diff --git a/.gitignore b/.gitignore index d46f692..a0a3277 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,12 @@ data/game_* data/windows* # Hardware Directories vivado_hls.log -./hls/ \ No newline at end of file +vitis_hls.log +hls_prj/ +vivado/ +vitis_include/ +./token + +# PYNQ +**/.ipynb_checkpoints +**/sds_trace_data.dat \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index c2d922e..43b6978 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,36 +1,53 @@ cmake_minimum_required(VERSION 3.10) # Set the project name project(Svd VERSION 1.0) -# Specify the C++ standard -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) -# To locate "custom"/manually added libraries +# To locate "custom", i.e. manually added, libraries list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules) -# Locate libraries and headers (see Files in ./cmake/Modules/) -# find_package(Vitis REQUIRED) -find_package(Vivado REQUIRED) -find_package(OpenCv REQUIRED) +# Locate external libraries and headers (see Files in ./cmake/Modules/) +# Search for HLS: if Vitis is found, use C++14, else fall back to C++11. +find_package(Vitis REQUIRED) +if (Vitis_FOUND) + # Specify the C++14 standard + message("[INFO] Vitis HLS FOUND.") + set(CMAKE_CXX_STANDARD 14) + set(CMAKE_CXX_STANDARD_REQUIRED True) + set(HLS_INCLUDE_DIRS ${VITIS_INCLUDE_DIRS}) + add_compile_definitions(__VITIS_HLS__) +else() + message("[INFO] Vivado HLS FOUND.") + find_package(Vivado REQUIRED) + # Specify the C++11 standard + set(CMAKE_CXX_STANDARD 11) + set(CMAKE_CXX_STANDARD_REQUIRED True) + set(HLS_INCLUDE_DIRS ${VIVADO_INCLUDE_DIRS}) +endif() +# find_package(OpenCv REQUIRED) -# set(HLS_INCLUDE_DIRS ${VITIS_INCLUDE_DIRS}) -# set(HLS_INCLUDE_DIRS ${VIVADO_INCLUDE_DIRS}) -# message(${HLS_INCLUDE_DIRS}) +message(${HLS_INCLUDE_DIRS}) # Add all definitions -if (WIN32) - add_compile_definitions(IMAGE_OUTPUT_PATH="C:/Users/ste/phd/hls_projects/hls_svd/data") -else() - add_compile_definitions(IMAGE_OUTPUT_PATH="/mnt/c/Users/ste/phd/hls_projects/hls_svd/data") -endif() # The following definitions is required for compiling half-precision numbers. add_compile_definitions(HLS_NO_XIL_FPO_LIB) # add_compile_definitions(USE_FLOAT) add_compile_definitions(DEBUG_LEVEL=2) +add_compile_definitions(INPUT_SIZE=1024) +add_compile_definitions(HIDDEN_SIZE=512) +add_compile_definitions(NUM_GATES=4) +add_compile_definitions(NUM_SAMPLES=2) +add_compile_definitions(NUM_TILES_U=4) +add_compile_definitions(NUM_ZERO_TILES_U=1) +add_compile_definitions(NUM_TILES_V=4) +add_compile_definitions(NUM_ZERO_TILES_V=1) +add_compile_definitions(NUM_TIMESTEPS=28) +add_compile_definitions(FIX_WIDTH=16) +add_compile_definitions(FIX_FRACT_WIDTH=5) + # Move executable in bin/, along side the DLLs (copied) set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin) -file(COPY ${OpenCv_LIBS} DESTINATION ${EXECUTABLE_OUTPUT_PATH}) +# file(COPY ${OpenCv_LIBS} DESTINATION ${EXECUTABLE_OUTPUT_PATH}) # NOTE: an object file becomes a library. All libraries/objects must be LINKED later! # Tell the application where to find the other CMake config files. diff --git a/README.md b/README.md index a287172..058ff64 100644 --- a/README.md +++ b/README.md @@ -47,17 +47,108 @@ cmake .. make all ``` +## Notes on Using Vitis + +### AXIS Interface and DMA + +Vitis to include the TLAST side channel if and only if TKEEP and TSTRB are also included. + +In order to attach the port to a Xilinx DMA, the TLAST signal must be properly set HIGH at the end of the data transmission. + +The TKEEP and TSTRB signals must be *always* set to HIGH, as indicated in the [AXIS documentation](https://developer.arm.com/documentation/ihi0051/a/Interface-Signals/Byte-qualifiers/TKEEP-and-TSTRB-combinations). + + +### Partitioning hls::vector Arrays + +A standard way of partitioning an array is: +```c++ + hls::stream > x_streams[M][N]; +#pragma HLS ARRAY_PARTITION variable=x_streams complete dim=0 +``` +However, since we are dealing with a `hls::vector` type, setting `dim=0` (all dimensions) will partition the array on the vector dimension too. + +In the example above, Vitis will create `M * N * 4` different streams (instead of just `M * N`). To fix it, manually specify the partitioning on the dimensions, like so: +```c++ + hls::stream > x_streams[M][N]; +#pragma HLS ARRAY_PARTITION variable=x_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=x_streams complete dim=2 +``` + +### Implementing AXIS Interfaces + +In order to implement AXIS interfaces, avoid using `depth` in the pragma, as follows: +```c++ +const int kAxiBitwidth = 128; + +void HlsVectorKernelU(hls::stream >& x_port, + hls::stream >& y_port) { +#pragma HLS INTERFACE axis port=x_port // depth=... <- DON'T SPECIFY THE DEPTH! +#pragma HLS INTERFACE axis port=y_port // depth=... <- DON'T SPECIFY THE DEPTH! + // ... +} +``` +The type `ap_axiu` must now be used to generate AXIS with side channels. Note: for using external DMAs, we need the TLAST, TKEEP and TSTRB signals. In particular, TKEEP and TSTRB must be all set (i.e. all ones) in order to signal data packets. + +#### AxiStreamInterface Class + +This repository contains a wrapper class for kernel arguments of type `hls::stream` named `AxiStreamInterface`. The class is implemented following a _Policy-based_ C++ paradigm, meaning that it accepts either a `AxiStreamPort` or `AxiStreamFifo` as possible policies (in practice, a template argument). + +The idea is to have a kernel argument, i.e. an HLS port, which can be either an AXIS interface with side-channels, or a bare FIFO interface connected to another kernel. In fact, Vitis HLS doesn't allow stream interfaces with side-channels within an IP. To overcome the issue, the `AxiStreamInterface` can be customized to be an IP port or a FIFO port, depending on the use of the kernel. + +An example of this can be seen in `HlsKernelU` and in `svd::SvdKernel`, which specialize the `svd::KernelU` function template. In the first case, the `svd::KernelU` has its output stream port `xu_port` connected to one of the IP's ports (with side-channels). In the latter case instead, `svd::KernelU` is connected to `svd::KernelS`, and so its `xu_port` argument is an internal FIFO (without side-channels). + +The `AxiStreamInterface` class in `axis_lib.h` can also be used with `hls::vector` types. + +### HLS Vector Patch + +If the project will be compiled with the Vitis HLS libraries, it needs a patch in the `hls::vector` class. + +Simply add the following line in the `vector` class after the `public:` statement: +```c++ +public: + static const int width = N; +``` + +In this way, one can access the number of elements in a `hls::vector` at compile/synthesis time by doing: + +```c++ +hls::vector a; +std::cout << "Number of elements in a: " << a::width << std::endl; + +// > Number of elements in a: 5 +``` + +## Notes on PYNQ Design + +### Vivado Project + +#### Xilinx DMA + +The DMA should be configured in the following way: + +* Max burst length to maximum +* Register buffer width to maximum + +#### HP Ports + +All HP ports should be set to 64bit width (to avoid receiving data interleaved by zeroes). + + ## TODOs List of TODOs: - * Import u, s, v new kernels - * Import (and clean up?) u, s, v old kernels - * Import DMA functions - * Import and clean up HLS SVD-model-Bouganis - * Import and clean up HLS SVD-model-2LSTM - * Import some testbenches to try compile something + + * ~Import u, s, v new kernels~ + * ~Import (and clean up?) u, s, v old kernels~ + * ~Import DMA functions~ + * ~Import and clean up HLS SVD-model-Bouganis~ + * ~Import and clean up HLS SVD-model-2LSTM~ + * ~Import some testbenches to try compile something~ ## Bugs List of possible bugs: -* Having not squared images in games generates distorted images. \ No newline at end of file + +* Constructing data handler storage might lead to segmentation faults. +* Having `R == 1` might trigger some asserts. +* Having `output_size == H` in HlsKernelV might break hardware runs. \ No newline at end of file diff --git a/cmake/Modules/FindVitis.cmake b/cmake/Modules/FindVitis.cmake index 8695d84..903adee 100644 --- a/cmake/Modules/FindVitis.cmake +++ b/cmake/Modules/FindVitis.cmake @@ -1,11 +1,13 @@ if (WIN32) - set(VITIS_INCLUDE_DIRS D:/Programs/Xilinx/Vitis_HLS/2020.2/include/) + # set(VITIS_INCLUDE_DIRS D:/Programs/Xilinx/Vitis_HLS/2021.1/include/) + set(VITIS_INCLUDE_DIRS C:/Users/ste/phd/hls_projects/hls_svd/vitis_include/2020.2/include/) + # set(VITIS_INCLUDE_DIRS C:/Users/ste/phd/hls_projects/hls_svd/vitis_include/2021.1/include/) else() - set(VITIS_INCLUDE_DIRS /mnt/d/Programs/Xilinx/Vitis_HLS/2020.2/include/) + set(VITIS_INCLUDE_DIRS /mnt/d/Programs/Xilinx/Vitis_HLS/2021.1/include/) endif() # NOTE: It handles the REQUIRED, QUIET and version-related arguments of find_package. # It also sets the _FOUND variable. The package is considered found # if all variables listed contain valid results, e.g. valid filepaths. include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(Vitis DEFAULT_MSG VITIS_INCLUDE_DIRS) +find_package_handle_standard_args(Vitis DEFAULT_MSG VITIS_INCLUDE_DIRS) \ No newline at end of file diff --git a/include/dma/axis_lib.h b/include/dma/axis_lib.h new file mode 100644 index 0000000..c2721bb --- /dev/null +++ b/include/dma/axis_lib.h @@ -0,0 +1,930 @@ +#ifndef DMA_AXIS_LIB_H_ +#define DMA_AXIS_LIB_H_ + +#include "hls_utils/hls_metaprogramming.h" + +#include "ap_axi_sdata.h" +#include "ap_int.h" +#include "hls_stream.h" + +#include +#include +#include +#include + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +namespace svd { + +template +struct AxiuPacketTlastOnlyType { + ap_uint data; + ap_uint<1> last = 0; + // ap_uint<4> keep = 0xF; +}; + +template +class AxiStreamFifo { +public: + typedef ap_int PacketType; + + AxiStreamFifo(hls::stream& port) : _port(port) { +#pragma HLS INLINE + } + + ~AxiStreamFifo() {}; + + template + inline void Push(const T &x, bool is_last = false) { +#pragma HLS INLINE + PacketType packet = *((PacketType*)&x); + this->_port.write(packet); + } + + /** + * @brief Pushes the last value. + * + * @param[in] x The value to push on the FIFO + * + * @tparam T The type of the value + */ + template + inline void PushLast(const T &x) { +#pragma HLS INLINE + PacketType packet = *((PacketType*)&x); + this->_port.write(packet); + } + + /** + * @brief Pushes a series of values from a buffer to the FIFO. + * + * @param[in] size The buffer size + * @param[in] x The buffer to read from + * + * @tparam T The type of the buffer + */ + template + inline void PushFromBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet = *((PacketType*)&x[i]); + this->_port.write(packet); + } + } + + template + inline void PushBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + assert(hlsutils::Bitwidth::value * size == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < size; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.range(kHi, kLo) = *((ap_uint*)&tmp); + } + this->_port.write(packet); + } + + /** + * @brief Pushes a series of values from a stream to the FIFO. + * + * @param[in] size The size + * @param[in] x The stream to read from + * + * @tparam T The type of the stream + */ + template + inline void PushFromStream(const int size, const hls::stream &x) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + T x_val = x.read(); + packet = *((PacketType*)&x_val); + this->_port.write(packet); + } + } + + /** + * @brief Pops a value from the FIFO and converts it. + * + * @tparam T The type of the returned value + * + * @return The value from the FIFO + */ + template + inline T Pop() { +#pragma HLS INLINE + PacketType packet = this->_port.read(); + return *((T*)&packet); + } + + /** + * @brief Read value and returns false (used for compatibility). + * + * @param y The value read from the FIFO + * + * @tparam T The type of the read value + * + * @return True if the specified y is the last value to pop, False + * otherwise. + */ + template + inline bool isLastPop(T &y) { +#pragma HLS INLINE + PacketType packet = this->_port.read(); + y = *((T*)&packet); + return false; + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * buffer. It also converts from ap_uint<> to T. + * + * @param[in] size The size + * @param y The output buffer + * + * @tparam T The type of the output buffer + */ + template + inline void PopToBuffer(const int size, T *y) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet = this->_port.read(); + y[i] = *((T*)&packet); + } + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * stream. It also converts from ap_uint<> to T. + * + * @param[in] size The stream size + * @param y The output stream + * + * @tparam T The type of the output stream + */ + template + inline void PopToStream(const int size, hls::stream &y) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet = this->_port.read(); + y.write(*((T*)&packet)); + } + } + +#ifdef __VITIS_HLS__ + /** + * @brief Push a vector into the FIFO with default TLAST set to low. + * From the AXIS specification: The following options are + * available: + * * Set TLAST LOW. This indicates that all transfers are within + * the same packet. This option provides maximum opportunity + * for merging and upsizing but means that transfers could be + * delayed in a stream with intermittent bursts. A permanently + * LOW TLAST signal might also affect the interleaving of + * streams across a shared channel because the interconnect + * can use the TLAST signal to influence the arbitration + * process. + * * Set TLAST HIGH. This indicates that all transfers are + * individual packets. This option ensures that transfers do + * not get delayed in the infrastructure. It also ensures that + * the stream does not unnecessarily block the use of a shared + * channel by influencing the arbitration scheme. This option + * prevents merging on streams from masters that have this + * default setting and prevents efficient upsizing. + * + * @param[in] x The vector to push + * @param[in] is_last Indicates if last packet to push. Default false. + * + * @tparam T The type of the vector, its type must be of the same + * size of the FIFO. + * @tparam N Number of elements in the vector + */ + template + inline void PushVector(const hls::vector& x, bool is_last = false) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.range(kHi, kLo) = *((ap_uint*)&tmp); + } + this->_port.write(packet); + } + + /** + * @brief Pushes the last vector, i.e. a packet with TLAST set to high. + * + * @param[in] x The vector to push on the FIFO + * + * @tparam T The type of the vector + * @tparam N Number of elements in the vector + */ + template + inline void PushLastVector(const hls::vector& x) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.range(kHi, kLo) = *((ap_uint*)&tmp); + } + this->_port.write(packet); + } + + /** + * @brief Pops a vector from the FIFO and converts it. + * + * @tparam T The type of the returned vector + * @tparam N The number of elements in the vector + * + * @return The vector from the FIFO + */ + template + inline hls::vector PopVector() { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + const PacketType packet = this->_port.read(); + hls::vector y; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + ap_uint tmp = packet.range(kHi, kLo); + y[i] = *((T*)&tmp); + } + return y; + } + + /** + * @brief Read vector and returns false (used for compatibility reasons). + * + * @param y The vector read from the FIFO + * + * @tparam T The type of the read vector + * @tparam N The number of elements in the vector. + * + * @return False + */ + template + inline bool isLastPopVector(hls::vector& y) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + const PacketType packet = this->_port.read(); + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + ap_uint tmp = packet.range(kHi, kLo); + y[i] = *((T*)&tmp); + } + return false; + } +#endif // __VITIS_HLS__ + + hls::stream& get_port() { + return this->_port; + } + +private: + hls::stream& _port; +}; + +/** + * @brief Wrapper class for an AXI stream interface port. + * + * The function instantiating this class must apply the respective + * HLS directive in order to synthesize a proper AXI stream + * interface. + * + * For documentation on TKEEP and TSTRB, please visit: + * https://developer.arm.com/documentation/ihi0051/a/Interface-Signals/Byte-qualifiers/TKEEP-and-TSTRB-combinations + * + * @tparam Bitwidth The bitwidth of the interface. + */ +template +class AxiStreamPort { +public: + static_assert(Bitwidth % 8 == 0, "ERROR. Bitwidth not byte aligned."); + typedef ap_axiu PacketType; + typedef ap_uint SideChannelsType; + // typedef ap_uint > > SideChannelsType; + + AxiStreamPort(hls::stream& port) : _port(port), + _all_ones(~(SideChannelsType(0))), _has_side_channels(true) { +#pragma HLS INLINE + }; + + ~AxiStreamPort() {}; + + inline void set_name(const std::string name) { +#ifndef __SYNTHESIS__ + _name = name; +#endif + } + + std::string name() { +#ifndef __SYNTHESIS__ + return this->_name; +#else + return ""; +#endif + } + + /** + * @brief Push a value into the FIFO with default TLAST set to low. From + * the AXIS specification: The following options are available: + * * Set TLAST LOW. This indicates that all transfers are within + * the same packet. This option provides maximum opportunity for + * merging and upsizing but means that transfers could be + * delayed in a stream with intermittent bursts. A permanently + * LOW TLAST signal might also affect the interleaving of + * streams across a shared channel because the interconnect can + * use the TLAST signal to influence the arbitration process. + * * Set TLAST HIGH. This indicates that all transfers are + * individual packets. This option ensures that transfers do not + * get delayed in the infrastructure. It also ensures that the + * stream does not unnecessarily block the use of a shared + * channel by influencing the arbitration scheme. This option + * prevents merging on streams from masters that have this + * default setting and prevents efficient upsizing. + * + * @param[in] x The value to push + * @param[in] is_last Indicates if last packet to push. Default false. + * + * @tparam T The type of the value, its type must be of the same + * size of the FIFO. + */ + template + inline void Push(const T &x, bool is_last = false) { +#pragma HLS INLINE + PacketType packet; + packet.data = *((ap_uint*)&x); + packet.last = is_last? 1 : 0; + // NOTE: If TKEEP and TSTRB both high, the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + + /** + * @brief Pushes the last value, i.e. a packet with TLAST set to high. + * + * @param[in] x The value to push on the FIFO + * + * @tparam T The type of the value + */ + template + inline void PushLast(const T &x) { +#pragma HLS INLINE + PacketType packet; + packet.data = *((ap_uint*)&x); + packet.last = 1; + // NOTE: If TKEEP and TSTRB both high, the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + + /** + * @brief Pushes a series of values from a buffer to the FIFO. + * + * @param[in] size The buffer size + * @param[in] x The buffer to read from + * + * @tparam T The type of the buffer + */ + template + inline void PushFromBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet.data = *((ap_uint*)&x[i]); + if (send_last && i == size - 1) { // The last packet needs special care. + packet.last = 1; + } + // NOTE: If TKEEP and TSTRB both high, the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + } + + template + inline void PushBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + assert(hlsutils::Bitwidth::value * size == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < size; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.data.range(kHi, kLo) = *((ap_uint*)&tmp); + } + packet.last = send_last? 1 : 0; + // NOTE: If TKEEP and TSTRB are both high, then the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + + /** + * @brief Pushes a series of values from a stream to the FIFO. + * + * @param[in] size The size + * @param[in] x The stream to read from + * + * @tparam T The type of the stream + */ + template + inline void PushFromStream(const int size, const hls::stream &x) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + T x_val = x.read(); + packet.data = *((ap_uint*)&x_val); + if (i == size - 1) { // The last packet needs special care. + packet.last = 1; + } + // NOTE: If TKEEP and TSTRB both high, the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + } + + /** + * @brief Pops a value from the FIFO and converts it. + * + * @tparam T The type of the returned value + * + * @return The value from the FIFO + */ + template + inline T Pop() { +#pragma HLS INLINE + PacketType packet; + packet = this->_port.read(); + return *((T*)&packet.data); + } + + /** + * @brief Read value and return true if the specified y is the last value + * to pop, i.e. with TLAST set high. It also converts the read + * value to the specified type. + * + * @param y The value read from the FIFO + * + * @tparam T The type of the read value + * + * @return True if the specified y is the last value to pop, False + * otherwise. + */ + template + inline bool isLastPop(T &y) { +#pragma HLS INLINE + PacketType packet; + packet = this->_port.read(); + y = *((T*)&packet.data); + return packet.last == 1 ? true : false; + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * buffer. It also converts from ap_uint<> to T. + * + * @param[in] size The size + * @param y The output buffer + * + * @tparam T The type of the output buffer + */ + template + inline void PopToBuffer(const int size, T *y) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet = this->_port.read(); + y[i] = *((T*)&packet.data); + } + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * stream. It also converts from ap_uint<> to T. + * + * @param[in] size The stream size + * @param y The output stream + * + * @tparam T The type of the output stream + */ + template + inline void PopToStream(const int size, hls::stream &y) { +#pragma HLS INLINE + PacketType packet; + for (int i = 0; i < size; ++i) { +#pragma HLS PIPELINE II=1 + packet = this->_port.read(); + y.write(*((T*)&packet.data)); + } + } + +#ifdef __VITIS_HLS__ + /** + * @brief Push a vector into the FIFO with default TLAST set to low. + * From the AXIS specification: The following options are + * available: + * * Set TLAST LOW. This indicates that all transfers are within + * the same packet. This option provides maximum opportunity + * for merging and upsizing but means that transfers could be + * delayed in a stream with intermittent bursts. A permanently + * LOW TLAST signal might also affect the interleaving of + * streams across a shared channel because the interconnect + * can use the TLAST signal to influence the arbitration + * process. + * * Set TLAST HIGH. This indicates that all transfers are + * individual packets. This option ensures that transfers do + * not get delayed in the infrastructure. It also ensures that + * the stream does not unnecessarily block the use of a shared + * channel by influencing the arbitration scheme. This option + * prevents merging on streams from masters that have this + * default setting and prevents efficient upsizing. + * + * @param[in] x The vector to push + * @param[in] is_last Indicates if last packet to push. Default false. + * + * @tparam T The type of the vector, its type must be of the same + * size of the FIFO. + * @tparam N Number of elements in the vector + */ + template + inline void PushVector(const hls::vector& x, bool is_last = false) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.data.range(kHi, kLo) = *((ap_uint*)&tmp); + } + packet.last = is_last? 1 : 0; + // NOTE: If TKEEP and TSTRB are both high, then the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + + /** + * @brief Pushes the last vector, i.e. a packet with TLAST set to high. + * + * @param[in] x The vector to push on the FIFO + * + * @tparam T The type of the vector + * @tparam N Number of elements in the vector + */ + template + inline void PushLastVector(const hls::vector& x) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + auto tmp = x[i]; + packet.data.range(kHi, kLo) = *((ap_uint*)&tmp); + } + packet.last = 1; + // NOTE: If TKEEP and TSTRB both high, the packet is a data type. + packet.keep = this->_all_ones; // Set TKEEP to all ones. + packet.strb = this->_all_ones; // Set TSTRB to all ones. + this->_port.write(packet); + } + + /** + * @brief Pops a vector from the FIFO and converts it. + * + * @tparam T The type of the returned vector + * @tparam N The number of elements in the vector + * + * @return The vector from the FIFO + */ + template + inline hls::vector PopVector() { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + const PacketType packet = this->_port.read(); + hls::vector y; + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + ap_uint tmp = packet.data.range(kHi, kLo); + y[i] = *((T*)&tmp); + } + return y; + } + + /** + * @brief Read vector and return true if the specified y is the last + * vector to pop, i.e. with TLAST set high. It also converts the + * read vector to the specified type. + * + * @param y The vector read from the FIFO + * + * @tparam T The type of the read vector + * @tparam N The number of elements in the vector. + * + * @return True if the specified y is the last vector to pop, False + * otherwise. + */ + template + inline bool isLastPopVector(hls::vector& y) { +#pragma HLS INLINE + static_assert(hlsutils::Bitwidth::value * N == Bitwidth, "AxiStreamPort must have same bitwidth as hls::vector"); + assert(hlsutils::Bitwidth::value * N == Bitwidth); + const int kElemBitwidth = hlsutils::Bitwidth::value; + PacketType packet; + packet = this->_port.read(); + for (int i = 0; i < N; ++i) { + const int kHi = (i + 1) * kElemBitwidth - 1; + const int kLo = i * kElemBitwidth; + ap_uint tmp = packet.data.range(kHi, kLo); + y[i] = *((T*)&tmp); + } + return packet.last == 1 ? true : false; + } +#endif // __VITIS_HLS__ + + hls::stream& get_port() { + return this->_port; + } + +private: + hls::stream& _port; + SideChannelsType _all_ones; + bool _has_side_channels; +#ifndef __SYNTHESIS__ + std::string _name; +#endif +}; + +/** + * @brief This class describes an AXI stream interface (Policy-based + * design). + * + * It has to be used as a "generic" interface whithin a kernel. The + * port of the kernel attached to this class can then be either a + * FIFO or a AXIS port. + * + * @tparam AxiClass The policy class. + */ +template +class AxiStreamInterface : private AxiClass { +public: + AxiStreamInterface(hls::stream& port): AxiClass(port) { +#pragma HLS INLINE + } + + ~AxiStreamInterface() {}; + + template + inline void Push(const T &x, bool is_last = false) { +#pragma HLS INLINE + AxiClass::template Push(x, is_last); + } + + /** + * @brief Pushes the last value, i.e. a packet with TLAST set to high. + * + * @param[in] x The value to push on the FIFO + * + * @tparam T The type of the value + */ + template + inline void PushLast(const T &x) { +#pragma HLS INLINE + AxiClass::template PushLast(x); + } + + /** + * @brief Pushes a series of values from a buffer to the FIFO. + * + * @param[in] size The buffer size + * @param[in] x The buffer to read from + * + * @tparam T The type of the buffer + */ + template + inline void PushFromBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + AxiClass::template PushFromBuffer(size, x, send_last); + } + + /** + * @brief Aggregates a buffer into a single packet and pushes it to the + * FIFO. + * + * @param[in] size The size of the buffer: assert(bitwidthElem * size + * == bitwidthStream) + * @param[in] x The buffer to read from + * @param[in] send_last Whether to send TLAST + * + * @tparam T The stream type + */ + template + inline void PushBuffer(const int size, const T *x, bool send_last = false) { +#pragma HLS INLINE + AxiClass::template PushBuffer(size, x, send_last); + } + + /** + * @brief Pushes a series of values from a stream to the FIFO. + * + * @param[in] size The size + * @param[in] x The stream to read from + * + * @tparam T The type of the stream + */ + template + inline void PushFromStream(const int size, const hls::stream &x) { +#pragma HLS INLINE + AxiClass::template PushFromStream(size, x); + } + + /** + * @brief Pops a value from the FIFO and converts it. + * + * @tparam T The type of the returned value + * + * @return The value from the FIFO + */ + template + inline T Pop() { +#pragma HLS INLINE + return AxiClass::template Pop(); + } + + /** + * @brief Read value and return true if the specified y is the last value + * to pop, i.e. with TLAST set high. It also converts the read + * value to the specified type. + * + * @param y The value read from the FIFO + * + * @tparam T The type of the read value + * + * @return True if the specified y is the last value to pop, False + * otherwise. + */ + template + inline bool isLastPop(T &y) { +#pragma HLS INLINE + return AxiClass::template isLastPop(y); + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * buffer. It also converts from ap_uint<> to T. + * + * @param[in] size The size + * @param y The output buffer + * + * @tparam T The type of the output buffer + */ + template + inline void PopToBuffer(const int size, T *y) { +#pragma HLS INLINE + AxiClass::template PopToBuffer(size, y); + } + + /** + * @brief Pops a series of values from the FIFO and writes them into a + * stream. It also converts from ap_uint<> to T. + * + * @param[in] size The stream size + * @param y The output stream + * + * @tparam T The type of the output stream + */ + template + inline void PopToStream(const int size, hls::stream &y) { +#pragma HLS INLINE + AxiClass::template PopToStream(size, y); + } + +#ifdef __VITIS_HLS__ + /** + * @brief Push a vector into the FIFO with default TLAST set to low. + * From the AXIS specification: The following options are + * available: + * * Set TLAST LOW. This indicates that all transfers are within + * the same packet. This option provides maximum opportunity + * for merging and upsizing but means that transfers could be + * delayed in a stream with intermittent bursts. A permanently + * LOW TLAST signal might also affect the interleaving of + * streams across a shared channel because the interconnect + * can use the TLAST signal to influence the arbitration + * process. + * * Set TLAST HIGH. This indicates that all transfers are + * individual packets. This option ensures that transfers do + * not get delayed in the infrastructure. It also ensures that + * the stream does not unnecessarily block the use of a shared + * channel by influencing the arbitration scheme. This option + * prevents merging on streams from masters that have this + * default setting and prevents efficient upsizing. + * + * @param[in] x The vector to push + * @param[in] is_last Indicates if last packet to push. Default false. + * + * @tparam T The type of the vector, its type must be of the same + * size of the FIFO. + * @tparam N Number of elements in the vector + */ + template + inline void PushVector(const hls::vector& x, bool is_last = false) { +#pragma HLS INLINE + AxiClass::template PushVector(x, is_last); + } + + /** + * @brief Pushes the last vector, i.e. a packet with TLAST set to high. + * + * @param[in] x The vector to push on the FIFO + * + * @tparam T The type of the vector + * @tparam N Number of elements in the vector + */ + template + inline void PushLastVector(const hls::vector& x) { +#pragma HLS INLINE + AxiClass::template PushLastVector(x); + } + + /** + * @brief Pops a vector from the FIFO and converts it. + * + * @tparam T The type of the returned vector + * @tparam N The number of elements in the vector + * + * @return The vector from the FIFO + */ + template + inline hls::vector PopVector() { +#pragma HLS INLINE + return AxiClass::template PopVector(); + } + + /** + * @brief Read vector and return true if the specified y is the last + * vector to pop, i.e. with TLAST set high. It also converts the + * read vector to the specified type. + * + * @param y The vector read from the FIFO + * + * @tparam T The type of the read vector + * @tparam N The number of elements in the vector. + * + * @return True if the specified y is the last vector to pop, False + * otherwise. + */ + template + inline bool isLastPopVector(hls::vector& y) { +#pragma HLS INLINE + return AxiClass::template isLastPopVector(y); + } +#endif // __VITIS_HLS__ +}; + +} // svd + +#endif // end DMA_AXIS_LIB_H_ \ No newline at end of file diff --git a/include/dma/svd_dma.h b/include/dma/svd_dma.h index de326bc..aa18d43 100644 --- a/include/dma/svd_dma.h +++ b/include/dma/svd_dma.h @@ -5,27 +5,33 @@ #include "hls_utils/hls_metaprogramming.h" #include "hls_utils/priority_encoder.h" #include "dma/width_converter.h" +#include "dma/axis_lib.h" #include "hls_stream.h" +#include "assert.h" + +#include + +namespace svd { template void StreamSplitter(const int output_size, const Din *x, - hls::stream (&y)[hls_utils::Bitwidth::value / hls_utils::Bitwidth::value]) { + hls::stream (&y)[hlsutils::Bitwidth::value / hlsutils::Bitwidth::value]) { #pragma HLS ARRAY_PARTITION variable=y complete dim=1 - const int kDivider = hls_utils::Bitwidth::value / hls_utils::Bitwidth::value; + const int kDivider = hlsutils::Bitwidth::value / hlsutils::Bitwidth::value; const int kInputSize = output_size / kDivider; - assert(hls_utils::Bitwidth::value % hls_utils::Bitwidth::value == 0); - assert(hls_utils::Bitwidth::value >= hls_utils::Bitwidth::value); + assert(hlsutils::Bitwidth::value % hlsutils::Bitwidth::value == 0); + assert(hlsutils::Bitwidth::value >= hlsutils::Bitwidth::value); assert(output_size % kDivider == 0); DMA_Loop: for (int i = 0; i < kInputSize; ++i) { #pragma HLS PIPELINE II=1 Parallel_Write_Loop: for (int j = 0; j < kDivider; ++j) { - const int kHi = (j + 1) * hls_utils::Bitwidth::value - 1; - const int kLo = j * hls_utils::Bitwidth::value; - ap_uint::value> x_val = x[i].range(kHi, kLo); + const int kHi = (j + 1) * hlsutils::Bitwidth::value - 1; + const int kLo = j * hlsutils::Bitwidth::value; + ap_uint::value> x_val = x[i].range(kHi, kLo); y[j].write(*((Dout*)&x_val)); } } @@ -57,17 +63,17 @@ void S_DMA(const typename params::SPortD s_port[params::N][params::R], } template -void U_Dispatcher(const typename params::UPortD u_port[params::PrunedSizeU], +void U_Dispatcher(const typename params::UPortD u_port[params::R * params::PrunedSizeU], svd::SvdStreams &streams) { U_Dispatcher: for (int i = 0; i < params::R; ++i) { for (int j = 0; j < params::PeU; ++j) { - for (int k = 0; k < params::PrunedSizeU / params::R / params::PeU; ++k) { + for (int k = 0; k < params::PrunedSizeU / params::PeU; ++k) { #pragma HLS PIPELINE II=1 #pragma HLS LOOP_FLATTEN for (int g = 0; g < params::G; ++g) { streams.u[g][j].write(streams.u_dma[g].read()); - } + } } } } @@ -102,11 +108,11 @@ void NzIdxConverter(svd::SvdStreams &streams) { } template -void InputDMA( +void InputDMA(const int num_refinements, const typename params::ActivationD x_port[params::N][params::I], svd::SvdStreams &streams, svd::SvdBuffers &buffers) { -// #pragma HLS INLINE +#pragma HLS INLINE typename params::UnzIdxD tile_idx[params::N][params::G][params::PeU]; #pragma HLS ARRAY_PARTITION variable=tile_idx complete dim=0 Store_X_Buffer: @@ -124,7 +130,8 @@ void InputDMA( Stream_X_Tiles: for (int ii = 0; ii < params::N; ++ii) { #pragma HLS UNROLL - for (int i = 0; i < params::R; ++i) { + Stream_X_Tiles_inner: + for (int i = 0; i < num_refinements; ++i) { for (int k = 0; k < params::I / params::Tu; ++k) { #pragma HLS PIPELINE II=1 for (int j = 0; j < params::PeU; ++j) { @@ -145,17 +152,17 @@ void InputDMA( } template -void V_Dispatcher(const typename params::VPortD v_port[params::PrunedSizeV], +void V_Dispatcher(const typename params::VPortD v_port[params::R * params::PrunedSizeV], svd::SvdStreams &streams) { V_Dispatcher: for (int i = 0; i < params::R; ++i) { for (int j = 0; j < params::PeV; ++j) { - for (int k = 0; k < params::PrunedSizeV / params::R / params::PeV; ++k) { + for (int k = 0; k < params::PrunedSizeV / params::PeV; ++k) { #pragma HLS PIPELINE II=1 #pragma HLS LOOP_FLATTEN for (int g = 0; g < params::G; ++g) { streams.v[g][j].write(streams.v_dma[g].read()); - } + } } } } @@ -164,9 +171,9 @@ void V_Dispatcher(const typename params::VPortD v_port[params::PrunedSizeV], template void SvdInDMA( const typename params::ActivationD x_port[params::N][params::I], - const typename params::UPortD u_port[params::PrunedSizeU], + const typename params::UPortD u_port[params::R * params::PrunedSizeU], const typename params::SPortD s_port[params::N][params::R], - const typename params::VPortD v_port[params::PrunedSizeV], + const typename params::VPortD v_port[params::R * params::PrunedSizeV], const typename params::UnzD nz_u_port[params::R * params::G], const typename params::VnzD nz_v_port[params::R * params::G], svd::SvdStreams &streams, @@ -176,15 +183,15 @@ void SvdInDMA( #pragma HLS DATAFLOW #endif S_DMA(s_port, streams); - U_DMA: StreamSplitter(params::G * params::PrunedSizeU, u_port, streams.u_dma); - V_DMA: StreamSplitter(params::G * params::PrunedSizeV, v_port, streams.v_dma); + U_DMA: StreamSplitter(params::G * params::R * params::PrunedSizeU, u_port, streams.u_dma); + V_DMA: StreamSplitter(params::G * params::R * params::PrunedSizeV, v_port, streams.v_dma); if (params::ZTu > 0) { NzDMA(nz_u_port, nz_v_port, streams); NzIdxConverter(streams); } U_Dispatcher(u_port, streams); V_Dispatcher(v_port, streams); - InputDMA(x_port, streams, buffers); + InputDMA(params::R, x_port, streams, buffers); } template @@ -203,54 +210,52 @@ void SvdOutDMA( } } -namespace svd { - template -void ZeroTileCombination2LstmDMA(const ap_uint *comb_port, - hls::stream > (&comb_stream1_current)[NumGates / 2], - hls::stream > (&comb_stream1_recurrent)[NumGates / 2], - hls::stream > (&comb_stream2_current)[NumGates / 2], - hls::stream > (&comb_stream2_recurrent)[NumGates / 2]) { +void NZIndex2LstmDMA(const ap_uint *nz_port, + hls::stream > (&nz_stream1_cur)[NumGates / 2], + hls::stream > (&nz_stream1_rec)[NumGates / 2], + hls::stream > (&nz_stream2_cur)[NumGates / 2], + hls::stream > (&nz_stream2_rec)[NumGates / 2]) { +#pragma HLS INLINE assert(NumGates % 2 == 0); assert(NumTiles % 2 == 0); - assert(NumTiles >= 8); - - ZeroTileCombination_Dma_Iter_Loop: + // assert(NumTiles >= 8); // Minimum port size requirement. + NZIndex_Dma_Iter_Loop: for (int i = 0; i < NumIter; ++i) { #pragma HLS PIPELINE II=1 - ZeroTileCombination_Dma_Current_Loop: + NZIndex_Dma_Current_Loop: for (int g = 0; g < NumGates / 2; ++g) { - ap_uint comb = comb_port[i * NumGates + g]; - comb_stream1_current[g].write(comb); - comb_stream2_current[g].write(comb); + ap_uint nz_idx = nz_port[i * NumGates + g]; + nz_stream1_cur[g].write(nz_idx); + nz_stream2_cur[g].write(nz_idx); } - ZeroTileCombination_Dma_Recurrent_Loop: + NZIndex_Dma_Recur_Loop: for (int g = 0; g < NumGates / 2; ++g) { - ap_uint comb = comb_port[i * NumGates + NumGates / 2 + g]; - comb_stream1_recurrent[g].write(comb); - comb_stream2_recurrent[g].write(comb); + ap_uint nz_idx = nz_port[i * NumGates + NumGates / 2 + g]; + nz_stream1_rec[g].write(nz_idx); + nz_stream2_rec[g].write(nz_idx); } } } template -void ZeroTileCombinationDMA(const ap_uint *comb_port, - hls::stream > (¤t_comb_stream)[NumGates / 2], - hls::stream > (&recurrent_comb_stream)[NumGates / 2]) { +void NZIndexDMA(const ap_uint *nz_port, + hls::stream > (&cur_nz_stream)[NumGates / 2], + hls::stream > (&rec_nz_stream)[NumGates / 2]) { +#pragma HLS INLINE assert(NumGates % 2 == 0); assert(NumTiles % 2 == 0); - assert(NumTiles >= 8); - - ZeroTileCombination_Dma_Iter_Loop: + // assert(NumTiles >= 8); // Minimum port size requirement. + NZIndex_Dma_Iter_Loop: for (int i = 0; i < NumIter; ++i) { #pragma HLS PIPELINE II=1 - ZeroTileCombination_Dma_Current_Loop: + NZIndex_Dma_Current_Loop: for (int g = 0; g < NumGates / 2; ++g) { - current_comb_stream[g].write(comb_port[i * NumGates + g]); + cur_nz_stream[g].write(nz_port[i * NumGates + g]); } - ZeroTileCombination_Dma_Recurrent_Loop: + NZIndex_Dma_Recur_Loop: for (int g = 0; g < NumGates / 2; ++g) { - recurrent_comb_stream[g].write(comb_port[i * NumGates + NumGates / 2 + g]); + rec_nz_stream[g].write(nz_port[i * NumGates + NumGates / 2 + g]); } } } @@ -278,19 +283,22 @@ void InputDMA(const svd::ActivationD *x_dmem, // Store the input onto an on-chip buffer for data reuse. The buffer is shared // by the LSTM gates and their U-units (which contain T - ZT MAC units each). // =========================================================================== +#ifdef __VITIS_HLS__ +#pragma HLS INLINE +#endif #pragma HLS DATAFLOW - const int kNumElemsTile = VectLength / NumTiles; + const int kTileSize = VectLength / NumTiles; const int kNumPEs = NumTiles - NumZeroTiles; - svd::ActivationD x_buffer[NumTiles][kNumElemsTile]; + svd::ActivationD x_buffer[NumTiles][kTileSize]; #pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=1 Write_Buffer: for (int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { + for (int j = 0; j < kTileSize; ++j) { #pragma HLS PIPELINE II=1 - x_buffer[i][j] = x_dmem[i * kNumElemsTile + j]; + x_buffer[i][j] = x_dmem[i * kTileSize + j]; } } - hls::stream::value> > tile_idx_stream[NumGates][kNumPEs]; + hls::stream::value> > tile_idx_stream[NumGates][kNumPEs]; #pragma HLS ARRAY_PARTITION variable=tile_idx_stream complete dim=0 NZ_to_Idx: for (int i = 0; i < NumIter; ++i) { @@ -302,7 +310,7 @@ void InputDMA(const svd::ActivationD *x_dmem, if (j == 0) { nz_idx[k] = comb_stream[k].read(); } - int set_idx = PriorityEncoderLSB(nz_idx[k]); + int set_idx = hlsutils::PriorityEncoderLSB(nz_idx[k]); assert(set_idx < NumTiles); tile_idx_stream[k][j].write(set_idx); nz_idx[k][set_idx] = 0; @@ -311,9 +319,9 @@ void InputDMA(const svd::ActivationD *x_dmem, } Stream_Tiles: for (int i = 0; i < NumIter; ++i) { - for (int k = 0; k < kNumElemsTile; ++k) { + for (int k = 0; k < kTileSize; ++k) { #pragma HLS PIPELINE II=1 - ap_uint::value> tile_idx[NumGates][kNumPEs]; + ap_uint::value> tile_idx[NumGates][kNumPEs]; #pragma HLS ARRAY_PARTITION variable=tile_idx complete dim=0 for (int j = 0; j < kNumPEs; ++j) { for (int g = 0; g < NumGates; ++g) { @@ -331,7 +339,9 @@ template (&y)[InWidth / OutWidth]) { #pragma HLS INLINE +#ifndef __VITIS_HLS__ #pragma HLS ARRAY_PARTITION variable=y complete dim=1 +#endif const int kDivider = InWidth / OutWidth; const int kInputSize = output_size / kDivider; assert(InWidth % OutWidth == 0); @@ -380,26 +392,25 @@ void StreamSplitter(const int output_size, * * @param[in] use_nz_dim If true, there are #num_non_zero_tiles different * PEs (for the U-unit), else there are - * #num_elems_per_tile different PEs (for the V-unit). + * #tile_size different PEs (for the V-unit). * @param[in] gate_port The gate port * @param gate_stream The gate PEs stream * * @tparam NumIter Number of refinement steps. * @tparam num_non_zero_tiles Number of non pruned tiles. - * @tparam num_elems_per_tile Number of elements per tile. + * @tparam tile_size Number of elements per tile. */ template -void GateDMA(const bool use_nz_dim, const int num_iter, - const int num_non_zero_tiles, const int num_elems_per_tile, - const T *gate_port, hls::stream *gate_streams) { +void DispatchGateFromArray(const bool use_nz_dim, const int num_iter, + const int num_non_zero_tiles, const int tile_size, + const T* gate_port, hls::stream* gate_streams) { #pragma HLS INLINE -#pragma HLS FUNCTION_INSTANTIATE vriable=num_iter -#pragma HLS FUNCTION_INSTANTIATE vriable=num_non_zero_tiles -#pragma HLS FUNCTION_INSTANTIATE vriable=num_elems_per_tile +#pragma HLS FUNCTION_INSTANTIATE variable=num_iter +#pragma HLS FUNCTION_INSTANTIATE variable=num_non_zero_tiles +#pragma HLS FUNCTION_INSTANTIATE variable=tile_size const int kI = num_iter; const int kNZ = num_non_zero_tiles; - const int kE = num_elems_per_tile; - + const int kE = tile_size; I : for (int i = 0; i < kI; ++i) { Z : for (int z = 0; z < kNZ; ++z) { E : for (int e = 0; e < kE; ++e) { @@ -415,6 +426,29 @@ void GateDMA(const bool use_nz_dim, const int num_iter, } } +template +void DispatchGateFromStream(const bool use_nz_dim, const int num_refinements, + const int num_non_zero_tiles, const int tile_size, + hls::stream* gate_port, hls::stream gate_streams[NumGates][NumStreams]) { +#pragma HLS INLINE +#pragma HLS FUNCTION_INSTANTIATE variable=num_refinements +#pragma HLS FUNCTION_INSTANTIATE variable=num_non_zero_tiles + I : for (int i = 0; i < num_refinements; ++i) { + Z : for (int z = 0; z < num_non_zero_tiles; ++z) { + E : for (int e = 0; e < tile_size; ++e) { +#pragma HLS PIPELINE II=1 + for (int g = 0; g < NumGates; ++g) { + if (use_nz_dim) { + gate_streams[g][z].write(gate_port[g].read()); // for U weights + } else { + gate_streams[g][e].write(gate_port[g].read()); // for V weights + } + } + } + } + } +} + /** * @brief Dispatch input elements to several PEs. All PEs receive the same * amount of elements and in the same clock cycle. @@ -533,6 +567,40 @@ void PipelinedDispatcher(const int input_size, } } + +#ifdef __VITIS_HLS__ +template +void VectorizedInputDMA(const int R, + hls::stream& x_port, + hls::stream x_streams[params::N]) { + + typedef typename params::ActivationD ActivationType; + const int kNumTilesU = params::I / params::Tu; + svd::AxiStreamPort x_axis = svd::AxiStreamPort(x_port); + typename params::VectTuType x_buffer[params::N][kNumTilesU]; +#pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=1 + + Store_X_Buffer: + for (int i = 0; i < params::N; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS LOOP_FLATTEN +#pragma HLS PIPELINE II=1 + // x_buffer[i][j] = x_axis.PopVector(); + } + } + Stream_X_Tiles: + for (int i = 0; i < R; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=params::R max=params::R + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 + for (int k = 0; k < params::N; ++k) { + x_streams[k] << x_buffer[k][j]; + } + } + } +} +#endif + } // end namespace svd #endif // end DMA_SVD_DMA_H_ \ No newline at end of file diff --git a/include/dma/width_converter.h b/include/dma/width_converter.h index 58ba6eb..2a65b73 100644 --- a/include/dma/width_converter.h +++ b/include/dma/width_converter.h @@ -2,6 +2,7 @@ #define DMA_WIDTH_CONVERTER_H_ #include "ap_int.h" +#include "assert.h" #include #include @@ -145,8 +146,6 @@ void Mem2MemDataWidthConverter(const int num_in_words, #pragma HLS PIPELINE II=1 const int kHi = ((i + 1) * InWidth) % OutWidth - 1; const int kLo = (i * InWidth) % OutWidth; - std::cout << "(" << kHi << ", " << kLo << ")\n"; - // if constexpr (std::is_same::value || std::is_same::value) { // elem_out(kHi, kLo) = in[i]; // } else { diff --git a/include/hls_utils/adder_tree.h b/include/hls_utils/adder_tree.h index 7b3c360..d6caf34 100644 --- a/include/hls_utils/adder_tree.h +++ b/include/hls_utils/adder_tree.h @@ -4,6 +4,12 @@ #include "hls_stream.h" #include "hls_utils/hls_metaprogramming.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +namespace hlsutils { + /** * @brief Given a static array, sum-reduce all its elements. * @@ -23,8 +29,8 @@ DataType adder_tree(DataType x[NumPE]) { // Determine the number of ranks for the adder tree and declare array: // - The adder_tree is larger than required as each rank only needs to be // half the size of the previous rank. - const unsigned kNumPEsLog2 = hls_utils::log2::value; - const unsigned kNumPEsSub1Log2 = hls_utils::log2::value; + const unsigned kNumPEsLog2 = hlsutils::log2::value; + const unsigned kNumPEsSub1Log2 = hlsutils::log2::value; const unsigned kNumRanks = kNumPEsLog2 != kNumPEsSub1Log2 ? kNumPEsLog2 : kNumPEsLog2 + 1; DataType adder_tree[kNumRanks][NumPE]; #pragma HLS ARRAY_PARTITION variable=adder_tree complete dim=0 @@ -96,8 +102,8 @@ DataType adder_tree(hls::stream x[NumPE]) { // Determine the number of ranks for the adder tree and declare array: // - The adder_tree is larger than required as each rank only needs to be // half the size of the previous rank. - const unsigned kNumPEsLog2 = hls_utils::log2::value; - const unsigned kNumPEsSub1Log2 = hls_utils::log2::value; + const unsigned kNumPEsLog2 = hlsutils::log2::value; + const unsigned kNumPEsSub1Log2 = hlsutils::log2::value; const unsigned kNumRanks = kNumPEsLog2 != kNumPEsSub1Log2 ? kNumPEsLog2 : kNumPEsLog2 + 1; DataType adder_tree[kNumRanks][NumPE]; #pragma HLS ARRAY_PARTITION variable=adder_tree complete dim=0 @@ -149,4 +155,68 @@ DataType adder_tree(hls::stream x[NumPE]) { return ret_val; } +#ifdef __VITIS_HLS__ +template +DataType adder_tree(hls::vector x) { +#pragma HLS ARRAY_PARTITION variable=x complete // to force II=1 +#pragma HLS PIPELINE II=1 + // Determine the number of ranks for the adder tree and declare array: + // - The adder_tree is larger than required as each rank only needs to be + // half the size of the previous rank. + const unsigned kNumPEsLog2 = hlsutils::log2::value; + const unsigned kNumPEsSub1Log2 = hlsutils::log2::value; + const unsigned kNumRanks = kNumPEsLog2 != kNumPEsSub1Log2 ? kNumPEsLog2 : kNumPEsLog2 + 1; + DataType adder_tree[kNumRanks][NumPE]; +#pragma HLS ARRAY_PARTITION variable=adder_tree complete dim=0 + + unsigned rank_size = NumPE; + DataType ret_val = 0; + + add_level_loop: + for(int adder_tree_rank = kNumRanks - 1; adder_tree_rank >= 0; --adder_tree_rank) { + const bool kLoopInit = adder_tree_rank == kNumRanks - 1 ? true : false; + const bool kLoopEpilog = adder_tree_rank == 0 ? true : false; + + if (kLoopInit) { + rank_size = NumPE; + } + + const bool prev_rank_is_odd = rank_size % 2 == 0 ? false : true; + rank_size = (rank_size + 1) / 2; + + add_col_loop: + for(int jj = 0; jj < (NumPE + 1) / 2; ++jj) { + if (jj < rank_size) { + if (prev_rank_is_odd && jj == rank_size - 1) { + // Bypass, no adder required. + if (kLoopInit) { + adder_tree[adder_tree_rank][jj] = x[jj * 2]; + // adder_tree[adder_tree_rank][jj] = x[jj * 2]; + } else { + adder_tree[adder_tree_rank][jj] = adder_tree[adder_tree_rank + 1][jj * 2]; + } + } else { + if (kLoopInit) { + auto y_acc = x[jj * 2] + x[jj * 2 + 1]; + // auto y_acc = x[jj * 2] + x[jj * 2 + 1]; +#pragma HLS RESOURCE variable=y_acc core=AddSub_DSP + adder_tree[adder_tree_rank][jj] = y_acc; + } else{ + auto y_acc = adder_tree[adder_tree_rank + 1][jj * 2] + adder_tree[adder_tree_rank + 1][jj * 2 + 1]; +#pragma HLS RESOURCE variable=y_acc core=AddSub_DSP + adder_tree[adder_tree_rank][jj] = y_acc; + } + } + } + } + if (kLoopEpilog) { + ret_val = adder_tree[0][0]; + } + } + return ret_val; +} +#endif + +} // hlsutils + #endif // end HLS_UTILS_ADDER_TREE_H_ \ No newline at end of file diff --git a/include/hls_utils/dot_prod_dsp.h b/include/hls_utils/dot_prod_dsp.h index 322c43b..79319e0 100644 --- a/include/hls_utils/dot_prod_dsp.h +++ b/include/hls_utils/dot_prod_dsp.h @@ -42,6 +42,8 @@ #include "ap_int.h" #include "assert.h" +namespace hlsutils { + /** * @brief Implements p0 += y_dsp * w_dsp + y_lut * w_lut; p1 += x_dsp * * w_dsp + x_lut * w_lut; @@ -149,4 +151,6 @@ void dot_prod_dsp_lut_generic(const T x_dsp, const T y_dsp, const T w_dsp, p1 += p1_tmp; } +} // hlsutils + #endif // end HLS_UTILS_DOT_PROD_DSP_H_ \ No newline at end of file diff --git a/include/hls_utils/hls_debugging.h b/include/hls_utils/hls_debugging.h index af9eaef..213f82b 100644 --- a/include/hls_utils/hls_debugging.h +++ b/include/hls_utils/hls_debugging.h @@ -2,6 +2,9 @@ #define HLS_UTILS_HLS_DEBUGGING #include "hls_utils/hw_timer.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif #include #include @@ -10,12 +13,12 @@ #define HLS_DEBUG_LEVEL 0 #endif -namespace hls_utils { +namespace hlsutils { static int hls_debug_level = HLS_DEBUG_LEVEL; -void Log(const int verbose_level, const std::string &str) { - std::cout << str << std::endl; +template +void Log(const int verbose_level, const T* str) { #ifndef __SYNTHESIS__ if (verbose_level < hls_debug_level) { std::cout << str << std::endl; @@ -23,7 +26,16 @@ void Log(const int verbose_level, const std::string &str) { #endif } +#ifdef __VITIS_HLS__ +template +void PrintVector(hls::vector &x) { + for (int i = 0; i < N; ++i) { + std::cout << x[i] << " "; + } + std::cout << std::endl; +} +#endif -} // hls_utils +} // hlsutils #endif // HLS_UTILS_HLS_DEBUGGING \ No newline at end of file diff --git a/include/hls_utils/hls_metaprogramming.h b/include/hls_utils/hls_metaprogramming.h index 252e1d9..156299d 100644 --- a/include/hls_utils/hls_metaprogramming.h +++ b/include/hls_utils/hls_metaprogramming.h @@ -1,11 +1,11 @@ #ifndef HLS_UTILS_HLS_METAPROGRAMMING_H_ #define HLS_UTILS_HLS_METAPROGRAMMING_H_ -namespace hls_utils { +namespace hlsutils { template struct log2 { - enum {value = 1 + hls_utils::log2::value}; + enum {value = 1 + hlsutils::log2::value}; }; template <> @@ -26,13 +26,13 @@ class GCDbase; template class GCD { public: - static const int value = hls_utils::GCDbase::value; + static const int value = hlsutils::GCDbase::value; }; template class GCDbase { public: - static const int value = hls_utils::GCDbase::value; + static const int value = hlsutils::GCDbase::value; }; template @@ -46,6 +46,46 @@ struct Bitwidth { static const int value = T::width; }; +template<> +struct Bitwidth { + static const int value = 8; +}; + +template<> +struct Bitwidth { + static const int value = 32; +}; + +template<> +struct Bitwidth { + static const int value = 16; +}; + +template<> +struct Bitwidth { + static const int value = 64; +}; + +template<> +struct Bitwidth { + static const int value = 8; +}; + +template<> +struct Bitwidth { + static const int value = 32; +}; + +template<> +struct Bitwidth { + static const int value = 16; +}; + +template<> +struct Bitwidth { + static const int value = 64; +}; + template<> struct Bitwidth { static const int value = 32; @@ -56,9 +96,16 @@ struct Bitwidth { static const int value = 64; }; -template +#ifdef __VITIS_HLS__ +template +struct VectBitwidth { + static const int value = N * Bitwidth::value; +}; +#endif + +template struct PrunedSize { - static const int value = N * X / T * (T - ZT); + static const int value = R * X / T * (T - ZT); }; @@ -71,6 +118,11 @@ struct is_pow2 { static const bool value = (N & (N - 1)) == 0; }; +template +struct round_up_div { + static const unsigned int value = (X + Y - 1) / Y; +}; + } // end namespace hls #endif // end HLS_UTILS_HLS_METAPROGRAMMING_H_ \ No newline at end of file diff --git a/include/hls_utils/hw_timer.h b/include/hls_utils/hw_timer.h index 94f11b9..58b1196 100644 --- a/include/hls_utils/hw_timer.h +++ b/include/hls_utils/hw_timer.h @@ -3,6 +3,8 @@ #include "hls_stream.h" +namespace hlsutils { + /** * @brief Synthesizeable HLS clock counter. Note: this module must be * placed in a DATAFLOW region and at the bottom of it (to avoid @@ -354,4 +356,9 @@ const int NUM_HW_TIMERS = 1; */ static unsigned long long hw_timers[NUM_HW_TIMERS]; +typedef long long CounterD; +typedef hls::stream ProbeStream; + +} // hlsutils + #endif // end HLS_UTILS_HW_TIMER_H_ \ No newline at end of file diff --git a/include/hls_utils/priority_encoder.h b/include/hls_utils/priority_encoder.h index 7805f7c..5a07fd1 100644 --- a/include/hls_utils/priority_encoder.h +++ b/include/hls_utils/priority_encoder.h @@ -3,7 +3,9 @@ #include "hls_utils/hls_metaprogramming.h" -namespace svd { +#include "assert.h" + +namespace hlsutils { /** * @brief Priority Encoder: returns the MSB set bit. @@ -64,7 +66,7 @@ int PriorityEncoderLSB(const T a) { } template -void PriorityEncoder(const int num_zero_tiles, const ap_uint a, hls::stream::value> > &idx_stream) { +void PriorityEncoder(const int num_zero_tiles, const ap_uint a, hls::stream::value> > &idx_stream) { ap_uint tmp = a; for (int i = 0; i < NumTiles - num_zero_tiles; ++i) { #pragma HLS PIPELINE II=1 @@ -76,7 +78,7 @@ void PriorityEncoder(const int num_zero_tiles, const ap_uint a, hls::s } template -void PriorityEncoder(const int num_zero_tiles, const T a, hls::stream::value> > &idx_stream) { +void PriorityEncoder(const int num_zero_tiles, const T a, hls::stream::value> > &idx_stream) { T tmp = a; for (int i = 0; i < T::width - num_zero_tiles; ++i) { #pragma HLS PIPELINE II=1 @@ -87,6 +89,6 @@ void PriorityEncoder(const int num_zero_tiles, const T a, hls::stream +void GemvKernel(const int num_rows, const int num_cols, + hls::stream > x_streams[N], + hls::stream > w_streams[N], + hls::stream y_streams[N]) { + assert(num_rows % T == 0); + const int kNumTiles = num_rows / T; + for (int i = 0; i < num_cols; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testgemv::R max=testgemv::R + hls::vector tmp[N] = {hls::vector(0)}; +#pragma HLS ARRAY_PARTITION variable=tmp complete + for (int j = 0; j < kNumTiles; ++j) { +#pragma HLS LOOP_TRIPCOUNT min=testgemv::I/T max=testgemv::I/T +#pragma HLS PIPELINE II=1 + for (int k = 0; k < N; ++k) { + tmp[k] += x_streams[k].read() * w_streams[k].read(); + if (j == kNumTiles - 1) { + y_streams[k] << tmp[k].reduce_add(); + } + } + } + } +} +#endif + +} // svd + +void HlsGemvKernel(const int num_rows, const int num_cols, + hls::stream >& x1_port, + hls::stream >& x2_port, + hls::stream >& w1_port, + hls::stream >& w2_port, + hls::stream& y1_port, + hls::stream& y2_port); + +#endif // end KERNEL_GEMV_KERNEL_H_ \ No newline at end of file diff --git a/include/kernel/s_kernel.h b/include/kernel/s_kernel.h index 9b7e7b8..dc105fc 100644 --- a/include/kernel/s_kernel.h +++ b/include/kernel/s_kernel.h @@ -3,15 +3,21 @@ #include "svd_params.h" #include "hls_utils/adder_tree.h" +#include "dma/axis_lib.h" +#include "hls_utils/hls_metaprogramming.h" + +#include "hls_stream.h" + +namespace svd { template -void KernelS(svd::SvdStreams &streams) { +void KernelS(const int num_refinements, svd::SvdStreams &streams) { typedef typename params::AccumulationD accum_t; - for (int i = 0; i < params::R; ++i) { + for (int i = 0; i < num_refinements; ++i) { #pragma HLS PIPELINE II=1 for (int j = 0; j < params::N; ++j) { for (int k = 0; k < params::G; ++k) { - auto sum = adder_tree(streams.xu[j][k]); + auto sum = hlsutils::adder_tree(streams.xu[j][k]); auto xs = sum * streams.s[j][k].read(); for (int ii = 0; ii < params::PeV; ++ii) { streams.xus[j][k][ii].write(xs); @@ -21,4 +27,98 @@ void KernelS(svd::SvdStreams &streams) { } } +template > +struct KernelS_Params { + static const int N = Ni; + static const int G = Gi; + static const int ActivationWidth = hlsutils::Bitwidth::value; + static const int VectG_AxiWidth = ActivationWidth * G; + typedef ActivationD_tp ActivationD; + typedef typename svd::AxiStreamPort::AxiuPacketType VectG_AxiPacketType; +#ifdef __VITIS_HLS__ + typedef hls::vector VectG_Type; +#endif +}; + +#ifndef __VITIS_HLS__ +#else +template < + typename params, + typename PortWrapper = svd::AxiStreamPort +> +void KernelS(const int num_active_inputs, + const int num_refinements[params::N], + hls::stream& xu_port, + hls::stream& s_port, + hls::stream& xus_port) { +#pragma HLS TOP name=KernelS +#pragma HLS DATAFLOW +#pragma HLS INLINE +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=xu_port +#pragma HLS STABLE variable=s_port +#pragma HLS STABLE variable=xus_port +#endif + assert(num_active_inputs <= params::N); + assert(num_active_inputs > 0); + int R_max = num_refinements[0]; + int R_total = num_refinements[0] * num_active_inputs; // Total elements. + Get_Total_R: + for (int i = 1; i < num_active_inputs; ++i) { +#pragma HLS PIPELINE II=1 + if (num_refinements[i] > R_max) { + R_max = num_refinements[i]; + } + assert(num_refinements[i] >= num_refinements[i - 1]); + R_total += (num_refinements[i] - num_refinements[i - 1]) * (num_active_inputs - i); + } + auto xu_axis = svd::AxiStreamInterface(xu_port); + auto s_axis = svd::AxiStreamPort(s_port); + auto xus_axis = svd::AxiStreamInterface(xus_port); + S_Kernel: + for (int i = 0; i < R_total; ++i) { +#pragma HLS PIPELINE II=1 style=frp + typedef typename params::ActivationD ActivationType; + auto xu_val = xu_axis.template PopVector(); + auto s_val = s_axis.template PopVector(); + auto xus_val = xu_val * s_val; + const bool kIsLast = i == R_total - 1; + xus_axis.template PushVector(xus_val, kIsLast); + } +} +#endif // __VITIS_HLS__ + +} // svd + +namespace tests { + +static const int kNumInputs = 2; +static const int kInputSize = 512; +static const int Tu = 4; +// NOTE: The rest of the parameters are unused for now. +static const int kDummySize = 1; +static const int R = 8; +static const int Tv = 1; +static const int ZTu = 0; +static const int ZTv = 0; +static const int G = 4; + +typedef svd::SvdParameters params; + short, short, short> params; + +} // tests + +#ifndef __VITIS_HLS__ +#else +void HlsKernelS( + const int num_refinements[tests::params::N], + // const hls::vector num_refinements, + hls::stream& xu_port, + hls::stream& s_port, + hls::stream& xus_port); +#endif + #endif // end KERNEL_S_KERNEL_H_ \ No newline at end of file diff --git a/include/kernel/svd_kernel.h b/include/kernel/svd_kernel.h index 7d5e24d..f782fae 100644 --- a/include/kernel/svd_kernel.h +++ b/include/kernel/svd_kernel.h @@ -3,19 +3,216 @@ #include "svd_params.h" #include "dma/svd_dma.h" +#include "dma/axis_lib.h" #include "kernel/u_kernel.h" #include "kernel/s_kernel.h" #include "kernel/v_kernel.h" +namespace svd { + template inline void SvdKernel(svd::SvdStreams &streams) { #pragma HLS INLINE #ifndef __VITIS_HLS__ #pragma HLS DATAFLOW #endif - KernelU(streams); - KernelS(streams); - KernelV(streams); + svd::KernelU(params::R, streams); + svd::KernelS(params::R, streams); + svd::KernelV(params::R, streams); +} + +template < + typename params, + typename WrapperAxisGTv = svd::AxiStreamPort +> +void SvdKernel(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& y_port) { +#pragma HLS TOP name=SvdKernel +#pragma HLS INLINE +#pragma HLS DATAFLOW +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=x_port +#pragma HLS STABLE variable=u_port +#pragma HLS STABLE variable=s_port +#pragma HLS STABLE variable=v_port +#pragma HLS STABLE variable=y_port +#endif +#pragma HLS ARRAY_PARTITION variable=num_refinements complete + const bool pad_output = false; + typedef svd::AxiStreamFifo WrapperFifoG; + hls::stream xu_port("xu_port"); + hls::stream xus_port("xus_port"); +#pragma HLS STREAM variable=xu_port depth=2 +#pragma HLS STREAM variable=xus_port depth=2 + int num_refinements_u[params::N]; + int num_refinements_s[params::N]; + int num_refinements_v[params::N]; +#pragma HLS ARRAY_PARTITION variable=num_refinements_u complete +#pragma HLS ARRAY_PARTITION variable=num_refinements_s complete +#pragma HLS ARRAY_PARTITION variable=num_refinements_v complete + Duplicate_R_Stream: + for (int i = 0; i < params::N; ++i) { +#pragma HLS UNROLL + num_refinements_u[i] = num_refinements[i]; + num_refinements_s[i] = num_refinements[i]; + num_refinements_v[i] = num_refinements[i]; + } + svd::KernelU(num_active_inputs, input_size, + num_refinements_u, pad_output, x_port, u_port, xu_port); + svd::KernelS(num_active_inputs, num_refinements_s, + xu_port, s_port, xus_port); + svd::KernelV(num_active_inputs, + output_size, num_refinements_v, xus_port, v_port, y_port); } +/** + * @brief Sets the SVD kernel inputs, i.e. streams from arrays into + * hls::streams. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param x_port The x port to be used as argument to SvdKernel + * @param u_port The u port to be used as argument to SvdKernel + * @param s_port The s port to be used as argument to SvdKernel + * @param v_port The v port to be used as argument to SvdKernel + * + * @tparam params Collection of SVD configuration params. + */ +#ifdef __VITIS_HLS__ +template +void SetSvdKernelInputs(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + const typename params::ActivationD* x, + const typename params::ActivationD* u, + const typename params::ActivationD* s, + const typename params::ActivationD* v, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port) { + typedef typename params::ActivationD ActivationType; + const int kG = params::G; + const int kTu = params::Tu; + const int kTv = params::Tv; + const int kGTv = kG * kTv; + const int kNumTilesU = input_size / kTu; + const int kNumTilesV = output_size / kTv; + auto x_axis = svd::AxiStreamPort(x_port); + auto u_axis = svd::AxiStreamPort(u_port); + auto s_axis = svd::AxiStreamPort(s_port); + auto v_axis = svd::AxiStreamPort(v_port); + int max_R = num_refinements[0]; + typename params::VectTuType x_val; + typename params::VectTuType u_val; + typename params::VectG_Type s_val; + typename params::VectTvType v_val; + for (int i = i; i < params::N; ++i) { + if (num_refinements[i] > max_R) { + max_R = num_refinements[i]; + } + } + for (int j = 0; j < kNumTilesU; ++j) { + for (int i = 0; i < num_active_inputs; ++i) { + for (int k = 0; k < kTu; ++k) { + x_val[k] = x[i * input_size + j * kTu + k]; + } + x_axis.template PushVector(x_val); + } + } + for (int i = 0; i < max_R; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < kG; ++k) { + for (int ii = 0; ii < kTu; ++ii) { + u_val[ii] = u[i * kNumTilesU * kTu * kG + (j * kTu + ii) * kG + k]; + } + u_axis.template PushVector(u_val); + } + } + } + for (int i = 0; i < max_R; ++i) { + for (int j = 0; j < num_active_inputs; ++j) { + if (i < num_refinements[j]) { + for (int k = 0; k < kG; ++k) { + s_val[k] = s[i * num_active_inputs * kG + j * kG + k]; + } + s_axis.template PushVector(s_val); + } + } + } + for (int i = 0; i < max_R; ++i) { + for (int j = 0; j < kNumTilesV; ++j) { + for (int k = 0; k < kG; ++k) { + for (int ii = 0; ii < kTv; ++ii) { + v_val[ii] = v[i * kNumTilesV * kTv * kG + (j * kTv + ii) * kG + k]; + } + v_axis.template PushVector(v_val); + } + } + } +} +#endif // __VITIS_HLS__ + +/** + * @brief Gets the svd kernel outputs, i.e. fills in an array from + * hls::streams. + * + * @param[in] num_active_inputs The number active inputs + * @param[in] output_size The output size (H) + * @param y_port The y port to be used as argument to SvdKernel + * @param y The output array. Shape: (N, G, H) + * + * @tparam params Collection of SVD configuration params. + */ +#ifdef __VITIS_HLS__ +template +void GetSvdKernelOutputs(const int num_active_inputs, const int output_size, + hls::stream& y_port, + typename params::ActivationD* y) { + typedef typename params::ActivationD ActivationType; + const int kG = params::G; + const int kTv = params::Tv; + const int kGTv = kG * kTv; + const int kNumTilesV = output_size / kTv; + auto y_axis = svd::AxiStreamPort(y_port); + for (int j = 0; j < kNumTilesV; ++j) { + for (int i = 0; i < num_active_inputs; ++i) { + auto y_val = y_axis.template PopVector(); + for (int k = 0; k < kTv; ++k) { + for (int ii = 0; ii < kG; ++ii) { + int y_idx = i * output_size * kG + ii * output_size + j * kTv + k; + y[y_idx] = y_val[k * kG + ii]; + } + } + } + } +} +#endif // __VITIS_HLS__ + +} // svd + +void HlsSvdKernel(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::svd_params::N], + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& y_port); + #endif // end KERNEL_SVD_KERNEL_H_ \ No newline at end of file diff --git a/include/kernel/u_kernel.h b/include/kernel/u_kernel.h index 71b566d..10f971b 100644 --- a/include/kernel/u_kernel.h +++ b/include/kernel/u_kernel.h @@ -3,24 +3,35 @@ #include "svd_params.h" #include "hls_utils/hls_metaprogramming.h" +#include "hls_utils/hls_debugging.h" +#include "hls_utils/adder_tree.h" +#include "dma/axis_lib.h" +#include "ap_axi_sdata.h" #include "hls_stream.h" +#include "assert.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +namespace svd { /** * @brief Kernel performing x @ U. * - * @param[in] size The size, ideally: params::R * params::PrunedSizeU / params::R / params::PeU * @param streams The streams group + * @param[in] size The size, ideally: params::R * params::PrunedSizeU / params::R + * / params::PeU * * @tparam params The algorithm characteristics */ template -void KernelU(svd::SvdStreams &streams) { +void KernelU(const int num_refinements, svd::SvdStreams &streams) { typename params::AccumulationD xu[params::N][params::G][params::PeU]; #pragma HLS ARRAY_PARTITION variable=xu complete dim=0 - for (int i = 0; i < params::R; ++i) { - for (int j = 0; j < params::PrunedSizeU / params::R / params::PeU; ++j) { -#pragma HLS PIPELINE II=1 + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < params::PrunedSizeU / params::PeU; ++j) { +#pragma HLS PIPELINE II=1 style=frp for (int k = 0; k < params::PeU; ++k) { for (int g = 0; g < params::G; ++g) { auto u = streams.u[g][k].read(); @@ -30,7 +41,7 @@ void KernelU(svd::SvdStreams &streams) { } xu[ii][g][k] += u * streams.x[ii][g][k].read(); #pragma HLS RESOURCE variable=xu[ii][g][k] core=DSP48 latency=3 - if (j == params::PrunedSizeU / params::R / params::PeU - 1) { + if (j == params::PrunedSizeU / params::PeU - 1) { streams.xu[ii][g][k].write(xu[ii][g][k]); } } @@ -40,8 +51,6 @@ void KernelU(svd::SvdStreams &streams) { } } -namespace svd { - /** * @brief Performs MAC operation. The weight values are read directly from * a port (which can be modeled as a FIFO). @@ -57,170 +66,47 @@ namespace svd { * @tparam NumIter The number of refinement steps * @tparam NumTimesteps The number of LSTM timesteps */ -template +template void UDotUnit2LstmPe(const int vect_length, const int num_tiles, - const int num_iter, const int num_timesteps, - hls::stream &x1_stream, - hls::stream &x2_stream, - hls::stream &gate_u_stream, - hls::stream &acc1_stream, - hls::stream &acc2_stream) { + const int num_iter, + hls::stream x1_stream[NumGates][NumPEs], + hls::stream x2_stream[NumGates][NumPEs], + hls::stream gate_u_stream[NumGates][NumPEs], + hls::stream acc1_stream[NumGates][NumPEs], + hls::stream acc2_stream[NumGates][NumPEs]) { #pragma HLS INLINE off #pragma HLS FUNCTION_INSTANTIATE variable=vect_length #pragma HLS FUNCTION_INSTANTIATE variable=num_iter #pragma HLS FUNCTION_INSTANTIATE variable=num_tiles -#pragma HLS FUNCTION_INSTANTIATE variable=num_timesteps -// #pragma HLS INTERFACE ap_ctrl_none port=return assert(vect_length % num_tiles == 0); - - const int kNumElemsPerTile = vect_length / num_tiles; - AccumType y1_mac = 0; - AccumType y2_mac = 0; - - ReduceProd_PE_IterTimesteps_Loop: - for (int i = 0; i < num_iter * num_timesteps; ++i) { - ReduceProd_PE_Loop: - for (int j = 0; j < kNumElemsPerTile; ++j) { -#pragma HLS PIPELINE II=1 - if (j == 0) { - y1_mac = 0; - y2_mac = 0; - } - auto u_val = gate_u_stream.read(); - auto mac1 = u_val * x1_stream.read(); - auto mac2 = u_val * x2_stream.read(); - mac1 += y1_mac; - mac2 += y2_mac; -#pragma HLS RESOURCE variable=mac1 core=DSP48 -#pragma HLS RESOURCE variable=mac2 core=DSP48 - y1_mac = mac1; - y2_mac = mac2; - if (j == kNumElemsPerTile - 1) { - acc1_stream.write(y1_mac); - acc2_stream.write(y2_mac); - } - } - } -} - -/** - * @brief Accumulate partial results from ReduceProd PEs. - * - * @param acc1_streams The acc 1 streams, each from a PE - * @param acc2_streams The acc 2 streams, each from a PE - * @param y1_stream The single y_1 stream - * @param y2_stream The single y_2 stream - * - * @tparam VectLength The input vector dimension - * @tparam NumTiles The number of used tiles (to determine the - * number of PEs) - * @tparam NumZeroTiles The number of pruned tiles (to determine the - * number of PEs) - * @tparam NumIter The number of refinement steps (to make the - * pipeline longer) - * @tparam NumTimesteps The number of LSTM timesteps (to make the - * pipeline longer) - * @tparam AdderTreeDesign Enable or disable AdderTree design. Default is - * active, i.e. true. - */ -template -void UDotUnit2LstmAccumulator(svd::AccumStream (&acc1_streams)[NumTiles-NumZeroTiles], - svd::AccumStream (&acc2_streams)[NumTiles-NumZeroTiles], - svd::ActivationStream &y1_stream, - svd::ActivationStream &y2_stream) { -#pragma HLS INLINE off -// #pragma HLS INTERFACE ap_ctrl_none port=return - const int kNumPEs = NumTiles - NumZeroTiles; - - if (AdderTreeDesign) { - // Determine the number of ranks for the adder tree and declare array - // - The adder_tree is larger than required as each rank only needs to be half the size of the previous rank - const unsigned kNumPEsLog2 = hls_utils::log2::value; - const unsigned kNumPEsSub1Log2 = hls_utils::log2::value; - const unsigned kNumRanks = kNumPEsLog2 != kNumPEsSub1Log2 ? kNumPEsLog2 : kNumPEsLog2 + 1; - svd::AccumD adder_tree1[kNumRanks][kNumPEs]; - svd::AccumD adder_tree2[kNumRanks][kNumPEs]; - - unsigned rank_size = kNumPEs; - - for (int i = 0; i < NumIter * NumTimesteps; ++i) { -#pragma HLS PIPELINE II=1 - add_level_loop: - for(int adder_tree_rank = kNumRanks - 1; adder_tree_rank >= 0; --adder_tree_rank) { - const bool kLoopInit = adder_tree_rank == kNumRanks - 1 ? true : false; - const bool kLoopEpilog = adder_tree_rank == 0 ? true : false; - - if (kLoopInit) { - rank_size = kNumPEs; - } - - const bool prev_rank_is_odd = rank_size % 2 == 0 ? false : true; - rank_size = (rank_size + 1) / 2; - // std::cout << "[" << adder_tree_rank << "] rank_size: " << rank_size << "\n"; - - add_col_loop: - for(int jj = 0; jj < (kNumPEs + 1) / 2; ++jj) { - if (jj < rank_size) { - if (prev_rank_is_odd && jj == rank_size - 1) { - // Bypass, no adder required. - if (kLoopInit) { - adder_tree1[adder_tree_rank][jj] = acc1_streams[jj * 2].read(); - adder_tree2[adder_tree_rank][jj] = acc2_streams[jj * 2].read(); - // std::cout << "\t\tstream[" << adder_tree_rank << "][" << jj * 2 << "] = [" << jj << "]\n"; - } else { - adder_tree1[adder_tree_rank][jj] = adder_tree1[adder_tree_rank + 1][jj * 2]; - adder_tree2[adder_tree_rank][jj] = adder_tree2[adder_tree_rank + 1][jj * 2]; - // std::cout << "\t\tbuffer[" << adder_tree_rank << "][" << jj * 2 << "] = [" << adder_tree_rank + 1 << "][" << jj << "]\n"; - } - } else { - if (kLoopInit) { - auto y1_acc = acc1_streams[jj * 2].read() + acc1_streams[jj * 2 + 1].read(); - auto y2_acc = acc2_streams[jj * 2].read() + acc2_streams[jj * 2 + 1].read(); -#pragma HLS RESOURCE variable=y1_acc core=AddSub_DSP -#pragma HLS RESOURCE variable=y2_acc core=AddSub_DSP - adder_tree1[adder_tree_rank][jj] = y1_acc; - adder_tree2[adder_tree_rank][jj] = y2_acc; - // std::cout << "\tstreams[" << adder_tree_rank << "][" << jj << "] = [" << jj * 2 << "] + [" << jj * 2 + 1 << "]\n"; - } else{ - auto y1_acc = adder_tree1[adder_tree_rank + 1][jj * 2] + adder_tree1[adder_tree_rank + 1][jj * 2 + 1]; - auto y2_acc = adder_tree2[adder_tree_rank + 1][jj * 2] + adder_tree2[adder_tree_rank + 1][jj * 2 + 1]; -#pragma HLS RESOURCE variable=y1_acc core=AddSub_DSP -#pragma HLS RESOURCE variable=y2_acc core=AddSub_DSP - adder_tree1[adder_tree_rank][jj] = y1_acc; - adder_tree2[adder_tree_rank][jj] = y2_acc; - // std::cout << "\tbuffer[" << adder_tree_rank << "][" << jj << "] = [" << adder_tree_rank + 1 << "][" << jj * 2 << "] + [" << adder_tree_rank + 1 << "][" << jj * 2 + 1 << "]\n"; - } + const int kNumInputs = 2; + const int kTileSize = vect_length / num_tiles; + AccumType y_mac[NumGates][NumPEs][kNumInputs] = {0}; + AccumType x_val[NumGates][NumPEs][kNumInputs] = {0}; +#pragma HLS ARRAY_PARTITION variable=y_mac complete dim=0 +#pragma HLS ARRAY_PARTITION variable=x_val complete dim=0 + U_Unit_PE: + for (int i = 0; i < num_iter; ++i) { + for (int j = 0; j < kTileSize; ++j) { +#pragma HLS PIPELINE II=1 style=frp + for (int k = 0; k < NumGates; ++k) { + for (int ii = 0; ii < NumPEs; ++ii) { + auto u_val = gate_u_stream[k][ii].read(); + x_val[k][ii][0] = x1_stream[k][ii].read(); + x_val[k][ii][1] = x2_stream[k][ii].read(); + for (int jj = 0; jj < kNumInputs; ++jj) { + if (j == 0) { + y_mac[k][ii][jj] = 0; } + auto mac = u_val * x_val[k][ii][jj]; + mac += y_mac[k][ii][jj]; +#pragma HLS RESOURCE variable=mac core=DSP48 + y_mac[k][ii][jj] = mac; + } + if (j == kTileSize - 1) { + acc1_stream[k][ii].write(y_mac[k][ii][0]); + acc2_stream[k][ii].write(y_mac[k][ii][1]); } - } - if (kLoopEpilog) { - y1_stream.write(adder_tree1[0][0]); - y2_stream.write(adder_tree2[0][0]); - // std::cout << "\n"; - } - } - } - } else { - svd::AccumD y1_acc = 0; - svd::AccumD y2_acc = 0; - for (int i = 0; i < NumIter * NumTimesteps; ++i) { - AdderTree_PE_Loop: - for (int j = 0; j < kNumPEs; ++j) { -#pragma HLS PIPELINE II=1 - if (j == 0) { - y1_acc = 0; - y2_acc = 0; - } - auto acc1 = y1_acc + acc1_streams[j].read(); - auto acc2 = y2_acc + acc2_streams[j].read(); -#pragma HLS RESOURCE variable=acc1 core=AddSub_DSP -#pragma HLS RESOURCE variable=acc2 core=AddSub_DSP - y1_acc = acc1; - y2_acc = acc2; - if (j == kNumPEs - 1) { - y1_stream.write(y1_acc); - y2_stream.write(y2_acc); } } } @@ -246,12 +132,12 @@ void UDotUnit2LstmAccumulator(svd::AccumStream (&acc1_streams)[NumTiles-NumZeroT * @tparam NumZeroTiles The number of zeroed, i.e. pruned, tiles */ template -void UDotUnit2Lstm(svd::ActivationStream (&x1_streams)[NumTiles-NumZeroTiles], - svd::ActivationStream (&x2_streams)[NumTiles-NumZeroTiles], - WeightStream (&gate_u_streams)[NumTiles-NumZeroTiles], - svd::ActivationStream &y1, - svd::ActivationStream &y2) { + int NumGates> +void UDotUnit2Lstm(svd::ActivationStream x1_streams[NumGates][NumTiles-NumZeroTiles], + svd::ActivationStream x2_streams[NumGates][NumTiles-NumZeroTiles], + WeightStream gate_u_streams[NumGates][NumTiles-NumZeroTiles], + svd::ActivationStream y1[NumGates], + svd::ActivationStream y2[NumGates]) { assert(VectLength % NumTiles == 0); assert(NumZeroTiles < NumTiles); assert(NumTiles >= 8); @@ -268,8 +154,8 @@ void UDotUnit2Lstm(svd::ActivationStream (&x1_streams)[NumTiles-NumZeroTiles], // =========================================================================== const int kNumNonZeroTiles = NumTiles - NumZeroTiles; const int kNumPEs = kNumNonZeroTiles; - const int kNumElemsPerTile = VectLength / NumTiles; - const int kStreamDepth = NumIter * kNumElemsPerTile; + const int kTileSize = VectLength / NumTiles; + const int kStreamDepth = NumIter * kTileSize; svd::AccumD y1_mul[kNumPEs]; svd::AccumD y2_mul[kNumPEs]; #pragma HLS ARRAY_PARTITION variable=y1_mul complete dim=1 @@ -294,8 +180,8 @@ void UDotUnit2Lstm(svd::ActivationStream (&x1_streams)[NumTiles-NumZeroTiles], y1_mul[i] = 0; y2_mul[i] = 0; ReduceProd_Tile_Loop: - for (int j = 0; j < kNumElemsPerTile / 2; ++j) { -#pragma HLS PIPELINE II=1 + for (int j = 0; j < kTileSize / 2; ++j) { +#pragma HLS PIPELINE II=1 style=frp // auto p0_tmp = y_dsp * w_dsp + y_lut * w_lut; // auto p1_tmp = x_dsp * w_dsp + x_lut * w_lut; // p0 += p0_tmp; @@ -332,7 +218,7 @@ void UDotUnit2Lstm(svd::ActivationStream (&x1_streams)[NumTiles-NumZeroTiles], ReduceProd_Accumulation_Loop: for (int i = 0; i < NumIter * NumTimesteps; ++i) { for (int j = 0; j < kNumPEs; ++j) { -#pragma HLS PIPELINE II=1 +#pragma HLS PIPELINE II=1 style=frp y1_acc += y1_mul[j]; y2_acc += y2_mul[j]; } @@ -343,40 +229,286 @@ void UDotUnit2Lstm(svd::ActivationStream (&x1_streams)[NumTiles-NumZeroTiles], // ============================================================================= // Implements #mac_PEs = NumTiles - NumZeroTiles & #Adder_Tree = 1 // ============================================================================= -// #pragma HLS INTERFACE ap_ctrl_none port=return #pragma HLS DATAFLOW -// #pragma HLS INLINE - - const unsigned kNumNonZeroTiles = NumTiles - NumZeroTiles; - const unsigned kNumPEs = kNumNonZeroTiles; +#pragma HLS INLINE + const int kNumNonZeroTiles = NumTiles - NumZeroTiles; + const int kNumInputs = 2; // NOTE: both PE and adder-tree have II=1, but the adder-tree reads in round // robin fashion from the PE queues. Hence, before the adder-tree reads again // from the same PE queue, kNumPEs cycles pass. This contrains the depth of // the queues to kNumPEs. (THIS WON'T WORK, TOO LOW CONSUMER RATE) // FIXED: Using an adder tree allows to use a stream of depth 1. - const unsigned kStreamDepth = 1; // VectLength / NumTiles; + const int kStreamDepth = 2; // VectLength / NumTiles; + hls::stream acc_streams[kNumInputs][NumGates][kNumNonZeroTiles]; +#pragma HLS ARRAY_PARTITION variable=acc_streams complete dim=0 +#pragma HLS STREAM variable=acc_streams depth=kStreamDepth + svd::UDotUnit2LstmPe(VectLength, + NumTiles, NumIter, x1_streams, x2_streams, gate_u_streams, + acc_streams[0], acc_streams[1]); + UAccumUnit: + for (int i = 0; i < NumIter; ++i) { +#pragma HLS PIPELINE II=1 style=frp + for (int j = 0; j < NumGates; ++j) { + auto y1_val = svd::ActivationD(hlsutils::adder_tree(acc_streams[0][j])); + auto y2_val = svd::ActivationD(hlsutils::adder_tree(acc_streams[1][j])); + y1[j].write(y1_val); + y2[j].write(y2_val); + } + } +#endif // end REDUCE_PROD_2LSTM_DATAFLOW_DESIGN +} - hls::stream acc1_streams[kNumNonZeroTiles]; - hls::stream acc2_streams[kNumNonZeroTiles]; -#pragma HLS ARRAY_PARTITION variable=acc1_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=acc1_streams complete dim=1 -#pragma HLS STREAM variable=acc1_streams depth=kStreamDepth -#pragma HLS STREAM variable=acc2_streams depth=kStreamDepth +#ifdef __VITIS_HLS__ +/** + * @brief Flexible Kernel-U. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] num_refinements The number of refinements steps (R) per input: + * the Rs must be positive, greater than zero and + * in ASCENDING ORDER. Their amount must be less + * or equal to num_active_inputs. There should be + * #num_active_inputs defined Rs (with no gaps), + * as only the first #num_active_inputs Rs will + * be considered. + * @param[in] pad_output Wether to pad output with zeroes + * @param x_port The input x port + * @param u_port The input u port + * @param xu_port The output xu port + * + * @tparam params The collection of fixed parameters and + * configurations. + */ +template < + typename params, + typename WrapperAxisG = svd::AxiStreamPort +> +void KernelU(const int num_active_inputs, + const int input_size, + const int num_refinements[params::N], + const bool pad_output, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port) { +#pragma HLS TOP name=KernelU +#pragma HLS DATAFLOW +#pragma HLS INLINE +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=x_port +#pragma HLS STABLE variable=u_port +#pragma HLS STABLE variable=xu_port +#endif + assert(num_active_inputs <= params::N); + assert(num_active_inputs > 0); + assert(params::I % params::Tu == 0); + assert(input_size % params::Tu == 0); + assert(input_size <= params::I); + const int kNumTilesU = input_size / params::Tu; + const int kMaxNumTilesU = params::I / params::Tu; + const int kStreamDepth_X = 2 + kMaxNumTilesU * params::N; + const int kStreamDepth_U = 8 + kMaxNumTilesU * params::N; + const int kStreamDepth_XU = 2 + params::G; + assert(kNumTilesU <= kMaxNumTilesU); + typedef typename params::ActivationD ActivationType; + auto x_axis = svd::AxiStreamPort(x_port); + auto u_axis = svd::AxiStreamPort(u_port); + auto xu_axis = svd::AxiStreamInterface(xu_port); + hls::stream x_stream("x_stream"); + hls::stream u_streams[params::G]; + hls::stream xu_streams[params::G]; + ActivationType x_buffer[params::N][params::Tu][kMaxNumTilesU]; +#pragma HLS STREAM variable=x_stream depth=kStreamDepth_X +#pragma HLS STREAM variable=u_streams depth=kStreamDepth_U +#pragma HLS STREAM variable=xu_streams depth=kStreamDepth_XU +#pragma HLS ARRAY_PARTITION variable=u_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=1 +#pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=2 +#pragma HLS BIND_STORAGE variable=x_buffer type=ram_t2p impl=bram latency=1 + /* + * Ideally, if the Rs are ordered, it would be: R0 * N + (R1-R0) * (N-1) + + * (R2-R1) * (N-2) + * + * Imagine we have: R0 = 2, R1 = 3, R2 = 6 + * + * This means: + * - till refinement 2 we have input 0 to process + * - till refinement 3 we have input 1 to process + * - till refinement 6 we have input 2 to process + * + * So it would become: + * + * R_total = 2 * 3 + (3-2) * (3-1) + (6-3) * (3-2) + */ + int R_max = num_refinements[0]; + int R_total = num_refinements[0] * num_active_inputs; // Total elements. + Get_Total_R: + for (int i = 1; i < num_active_inputs; ++i) { +#pragma HLS PIPELINE II=1 style=frp + if (num_refinements[i] > R_max) { + R_max = num_refinements[i]; + } + assert(num_refinements[i] >= num_refinements[i - 1]); + R_total += (num_refinements[i] - num_refinements[i - 1]) * (num_active_inputs - i); + } - PE_Loop: - for (int pe = 0; pe < kNumPEs; ++pe) { -#pragma HLS UNROLL - UDotUnit2LstmPe(VectLength, - NumTiles, NumIter, NumTimesteps, - x1_streams[pe], x2_streams[pe], gate_u_streams[pe], acc1_streams[pe], - acc2_streams[pe]); + int R_prev = 0; + X_DMA: + for (int ii = 0; ii < num_active_inputs; ++ii) { + Stream_X_Tiles: + for (int i = 0; i < num_refinements[ii] - R_prev; ++i) { + assert(num_refinements[ii] - R_prev >= 1); + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < num_active_inputs - ii; ++k) { +#pragma HLS PIPELINE II=1 style=frp + assert(num_active_inputs - ii >= 1); + if (ii == 0 && i == 0) { + auto x_val = x_axis.template PopVector(); + x_stream << x_val; + for (int jj = 0; jj < params::Tu; ++jj) { + x_buffer[k][jj][j] = x_val[jj]; + } + } else { + assert(k + ii < params::N); + typename params::VectTuType x_val; + for (int jj = 0; jj < params::Tu; ++jj) { + x_val[jj] = x_buffer[k + ii][jj][j]; + } + x_stream << x_val; + } + } + } + } + R_prev = num_refinements[ii]; + } + U_DMA: + for (int i = 0; i < R_max; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=params::R max=params::R + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < params::G; ++k) { + auto u_val = u_axis.template PopVector(); + for (int ii = 0; ii < num_active_inputs; ++ii) { +#pragma HLS PIPELINE II=1 style=frp + if (i < num_refinements[ii]) { + u_streams[k] << u_val; + } + } + } + } + } + U_Kernel: + for (int i = 0; i < R_total; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 style=frp + auto x_val = x_stream.read(); + for (int k = 0; k < params::G; ++k) { + xu_streams[k] << hlsutils::adder_tree(x_val * u_streams[k].read()); + // xu_streams[k] << (x_val * u_streams[k].read()).reduce_add(); + } + } + } + int iter_cnt = 0; + XU_DMA: + for (int i = 0; i < R_max; ++i) { + typename params::VectG_Type xu_out[params::N] = {typename params::VectG_Type(0)}; +#pragma HLS ARRAY_PARTITION variable=xu_out complete dim=1 + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < num_active_inputs; ++k) { +#pragma HLS PIPELINE II=1 style=frp + for (int ii = 0; ii < params::G; ++ii) { + if (i < num_refinements[k]) { + xu_out[k][ii] += xu_streams[ii].read(); +#pragma HLS BIND_OP variable=xu_out[k][ii] op=add impl=dsp + } + } + if (i < num_refinements[k] && j == kNumTilesU - 1) { + const bool kIsLast = (iter_cnt == R_total - 1 && !pad_output); + xu_axis.template PushVector(xu_out[k], kIsLast); + ++iter_cnt; + } else if (pad_output) { + const bool kIsLast = i == R_max - 1 && j == kNumTilesU - 1 && k == num_active_inputs - 1; + xu_axis.template PushVector(xu_out[k], kIsLast); + ++iter_cnt; + } + } + } } - UDotUnit2LstmAccumulator( - acc1_streams, acc2_streams, y1, y2); -#endif // end REDUCE_PROD_2LSTM_DATAFLOW_DESIGN } +#endif // end __VITIS_HLS__ } // svd +namespace testu { + +static const int kNumInputs = 4; +static const int kInputSize = 1024; +static const int Tu = 4; +// NOTE: The rest of the parameters are unused for now. +static const int kDummySize = 1; +static const int R = 8; +static const int Tv = 1; +static const int ZTu = 0; +static const int ZTv = 0; +static const int G = 4; + +typedef svd::SvdParameters params; + short, short, short> params; + +static const int VectTuAxiBitwidth = hlsutils::Bitwidth::value * params::Tu; +static const int VectN_AxiBitwidth = hlsutils::Bitwidth::value * params::N; +static const int VectGN_AxiBitwidth = hlsutils::Bitwidth::value * params::G * params::N; +#ifdef __VITIS_HLS__ +typedef hls::vector VectTuType; +typedef hls::vector VectN_Type; +typedef hls::vector VectGN_Type; +#endif +typedef svd::AxiStreamPort::PacketType VectTuAxiPacketType; +typedef svd::AxiStreamPort::PacketType VectN_AxiPacketType; +typedef svd::AxiStreamPort::PacketType VectGN_AxiPacketType; + +} // testu + +#ifndef __VITIS_HLS__ +void HlsKernelU(const int num_refinements, + const typename testu::params::ActivationD x_port[testu::params::N][testu::params::I], + const typename testu::params::UPortD u_port[testu::params::R * testu::params::PrunedSizeU], + typename testu::params::ActivationD xu_port[testu::params::N][testu::params::G * testu::params::R]); +#else +void HlsVectorKernelU(const int num_refinements, + hls::stream >& x_port, + hls::stream >& u_port, + hls::stream >& xu_port); + +void HlsAxisKernelU(const int num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port); + +/** + * @brief Synthesizeable flexible Kernel-U. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] num_refinements The number of refinements steps (R) per input: + * the Rs must be positive, greater than zero and + * in ASCENDING ORDER. Their amount must be less + * or equal to num_active_inputs. + * @param[in] pad_output Wether to pad output with zeroes + * @param x_port The input x port + * @param u_port The input u port + * @param xu_port The output xu port + */ +void HlsKernelU(const int num_active_inputs, + const int input_size, + const int num_refinements[testu::params::N], + // const hls::vector num_refinements, + const bool pad_output, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port); + +#endif // end __VITIS_HLS__ #endif // end KERNEL_U_KERNEL_H_ \ No newline at end of file diff --git a/include/kernel/v_kernel.h b/include/kernel/v_kernel.h index d07483d..b57abb1 100644 --- a/include/kernel/v_kernel.h +++ b/include/kernel/v_kernel.h @@ -3,8 +3,10 @@ #include "svd_params.h" +namespace svd { + template -void KernelV(svd::SvdStreams &streams) { +void KernelV(const int num_refinements, svd::SvdStreams &streams) { #pragma HLS INLINE #ifndef __VITIS_HLS__ #pragma HLS DATAFLOW @@ -34,8 +36,8 @@ void KernelV(svd::SvdStreams &streams) { #endif if (params::ZTv > 0) { // constexpr V_Nz_Converter: - for (int i = 0; i < params::R; ++i) { - for (int j = 0; j < params::PrunedSizeV / params::R / params::PeV; ++j) { + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < params::PrunedSizeV / params::PeV; ++j) { #pragma HLS PIPELINE II=1 #pragma HLS LOOP_FLATTEN for (int k = 0; k < params::G; ++k) { @@ -61,8 +63,8 @@ void KernelV(svd::SvdStreams &streams) { } } V_Unit: - for (int i = 0; i < params::R; ++i) { - for (int j = 0; j < params::PrunedSizeV / params::R / params::PeV; ++j) { + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < params::PrunedSizeV / params::PeV; ++j) { #pragma HLS PIPELINE II=1 #pragma HLS LOOP_FLATTEN for (int g = 0; g < params::G; ++g) { @@ -97,433 +99,388 @@ void KernelV(svd::SvdStreams &streams) { } } - -namespace svd { - -template +template void VDotUnit2LstmV2(const bool has_bias, svd::WeightStream *bias1, svd::WeightStream *bias2, - svd::ActivationStream &gate_dot1_streams, - svd::ActivationStream &gate_dot2_streams, - svd::WeightStream &gate_s1_streams, - svd::WeightStream &gate_s2_streams, - svd::WeightStream (&gate_v_streams)[VectLength / NumTiles], - hls::stream > &comb_stream_port, - svd::ActivationStream (&gate_out1_streams)[VectLength / NumTiles], - svd::ActivationStream (&gate_out2_streams)[VectLength / NumTiles], - bool debug_module = false, - ProbeStream *probe_ctrl = nullptr) { + svd::ActivationStream gate_dot1_streams[NumGates], + svd::ActivationStream gate_dot2_streams[NumGates], + svd::WeightStream gate_s1_streams[NumGates], + svd::WeightStream gate_s2_streams[NumGates], + svd::WeightStream gate_v_streams[NumGates][VectLength / NumTiles], + hls::stream > nz_port[NumGates], + svd::ActivationStream gate_out1_streams[NumGates][VectLength / NumTiles], + svd::ActivationStream gate_out2_streams[NumGates][VectLength / NumTiles]) { #pragma HLS INLINE #pragma HLS DATAFLOW - assert(VectLength % NumTiles == 0); assert(NumTiles > NumZeroTiles); assert(NumTiles % 2 == 0); assert(NumIter % 2 == 0); - + const int kNumInputs = 2; const int kFifoResizeFactor = 4; const int kNonZeroTiles = NumTiles - NumZeroTiles; - const int kNumTileElems = VectLength / NumTiles; + const int kTileSize = VectLength / NumTiles; // NOTE: By the time the dot products are available at the ports, the weight // values s1, s2 and v should be already at the FIFO ports. const int kStreamDepth = NumIter / kFifoResizeFactor; - hls::stream xs1_streams[kNumTileElems]; - hls::stream xs2_streams[kNumTileElems]; -#pragma HLS STREAM variable=xs1_streams depth=kStreamDepth dim=1 -#pragma HLS STREAM variable=xs2_streams depth=kStreamDepth dim=1 - - // svd::MultD xs1_val = 0; - // svd::MultD xs2_val = 0; - - ScalarMul: + hls::stream xus_streams[NumGates][kNumInputs][kTileSize]; +#pragma HLS STREAM variable=xus_streams depth=kStreamDepth dim=0 + S_Kernel: for (int i = 0; i < NumIter; ++i) { #pragma HLS INLINE off #pragma HLS PIPELINE II=1 - auto xs1_val = gate_s1_streams.read() * gate_dot1_streams.read(); - auto xs2_val = gate_s2_streams.read() * gate_dot2_streams.read(); -#pragma HLS RESOURCE variable=xs1_val core=DSP48 latency=3 -#pragma HLS RESOURCE variable=xs2_val core=DSP48 latency=3 - ScalarMulDispatcher: - for (int j = 0; j < kNumTileElems; ++j) { - xs1_streams[j].write(xs1_val); - xs2_streams[j].write(xs2_val); + for (int g = 0; g < NumGates; ++g) { + svd::MultD xus_val[kNumInputs]; + #pragma HLS ARRAY_PARTITION variable=xus_val complete dim=0 + xus_val[0] = gate_s1_streams[g].read() * gate_dot1_streams[g].read(); + xus_val[1] = gate_s2_streams[g].read() * gate_dot2_streams[g].read(); + #pragma HLS RESOURCE variable=xus_val[0] core=DSP48 latency=3 + #pragma HLS RESOURCE variable=xus_val[1] core=DSP48 latency=3 + for (int j = 0; j < kTileSize; ++j) { + for (int k = 0; k < kNumInputs; ++k) { + xus_streams[g][k][j].write(xus_val[k]); + } + } } } - - svd::WeightStream bias1_streams[kNumTileElems]; - svd::WeightStream bias2_streams[kNumTileElems]; - if (has_bias) { -#pragma HLS STREAM variable=bias1_streams depth=NumTiles dim=1 -#pragma HLS STREAM variable=bias2_streams depth=NumTiles dim=1 -#pragma HLS ARRAY_PARTITION variable=bias1_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=bias2_streams complete dim=1 - } - + svd::WeightStream bias_streams[NumGates][kNumInputs][kTileSize]; if (has_bias) { - BiasDispatcher_tiles: +#pragma HLS ARRAY_PARTITION variable=bias_streams complete dim=0 +#pragma HLS STREAM variable=bias_streams depth=NumTiles + Bias_DMA: for (int i = 0; i < NumTiles; ++i) { -#pragma HLS INLINE off - BiasDispatcher_elems: - for (int j = 0; j < kNumTileElems; ++j) { + for (int j = 0; j < kTileSize; ++j) { #pragma HLS PIPELINE II=1 - bias1_streams[j].write(bias1->read()); - bias2_streams[j].write(bias2->read()); + for (int k = 0; k < NumGates; ++k) { + bias_streams[k][0][j].write(bias1[k].read()); + bias_streams[k][1][j].write(bias2[k].read()); + } } } } - const int kCombStreamDepth = NumIter * NumZeroTiles / (kFifoResizeFactor * 2); - const int kNzBitLength = hls_utils::log2::value; - hls::stream > nz_idx_streams[kNumTileElems]; -#pragma HLS STREAM variable=nz_idx_streams depth=kCombStreamDepth dim=1 + const int kNzBitLength = hlsutils::log2::value; + hls::stream > nz_idx_streams[NumGates][kTileSize]; +#pragma HLS STREAM variable=nz_idx_streams depth=kCombStreamDepth dim=0 #pragma HLS RESOURCE variable=nz_idx_streams core=FIFO_SRL - -#if 0 // USE_PRIORITY_ENCODER +// #define V_UNIT_USE_PRIORITY_ENCODER +#ifdef V_UNIT_USE_PRIORITY_ENCODER // =========================================================================== // NOTE: The critical path is HUGE here. So we go for the other solution. // =========================================================================== - ap_uint zero_comb = 0; - - Convert_Iter: + ap_uint z_idx = 0; + ZIndex_Converter: for (int i = 0; i < NumIter; ++i) { for (int j = 0; j < NumTiles - NumZeroTiles; ++j) { #pragma HLS PIPELINE II=1 if (j == 0) { - zero_comb = comb_stream_port.read(); - int set_idx = PriorityEncoderLSB(zero_comb); + z_idx = nz_port.read(); + int set_idx = PriorityEncoderLSB(z_idx); assert(set_idx < NumTiles); - for (int k = 0; k < kNumTileElems; ++k) { + for (int k = 0; k < kTileSize; ++k) { nz_idx_streams[k].write(set_idx); } - zero_comb[set_idx] = 0; + z_idx[set_idx] = 0; } else { - int set_idx = PriorityEncoderLSB(zero_comb); + int set_idx = PriorityEncoderLSB(z_idx); assert(set_idx < NumTiles); - for (int k = 0; k < kNumTileElems; ++k) { + for (int k = 0; k < kTileSize; ++k) { nz_idx_streams[k].write(set_idx); } - zero_comb[set_idx] = 0; + z_idx[set_idx] = 0; } } } #else - ap_uint c; - int nz_cnt = 0; - assert(nz_cnt < kNonZeroTiles); - - CombConverter_iter: + ap_uint z_idx[NumGates]; + int nz_cnt[NumGates] = {0}; +#pragma HLS ARRAY_PARTITION variable=z_idx complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_cnt complete dim=0 + ZIndex_Converter: for (int i = 0; i < NumIter; ++i) { #pragma HLS INLINE off - CombConverter_tiles: for (int j = 0; j < NumTiles; ++j) { #pragma HLS LOOP_FLATTEN #pragma HLS PIPELINE II=1 #pragma HLS LOOP_TRIPCOUNT min=kNonZeroTiles max=kNonZeroTiles - if (j == 0) { - c = comb_stream_port.read(); - // std::cout << "nz[" << i << "] = " << c.to_string(2, false) << "\n"; - if (c[0] == 1) { - for (int k = 0; k < kNumTileElems; ++k) { - nz_idx_streams[k].write(0); - } - nz_cnt++; - } - } else { - if (c[j] == 1) { - CombConverter_elem: - for (int k = 0; k < kNumTileElems; ++k) { - nz_idx_streams[k].write(j); + for (int g = 0; g < NumGates; ++g) { + assert(nz_cnt[g] < kNonZeroTiles); + if (j == 0) { + z_idx[g] = nz_port[g].read(); + if (z_idx[g][0] == 1) { + for (int k = 0; k < kTileSize; ++k) { + nz_idx_streams[g][k].write(0); + } + ++nz_cnt[g]; } - if (nz_cnt == kNonZeroTiles - 1) { - nz_cnt = 0; - break; - } else { - nz_cnt++; + } else { + if (z_idx[g][j] == 1) { + for (int k = 0; k < kTileSize; ++k) { + nz_idx_streams[g][k].write(j); + } + if (nz_cnt[g] == kNonZeroTiles - 1) { + nz_cnt[g] = 0; + break; + } else { + ++nz_cnt[g]; + } } } } } } #endif - -#if 1 V_Kernel: { #pragma HLS INLINE off - if (debug_module) { - probe_ctrl->write(1); - } - - svd::AccumD acc_buffer1[kNumTileElems][NumTiles]; - svd::AccumD acc_buffer2[kNumTileElems][NumTiles]; -#pragma HLS ARRAY_PARTITION variable=acc_buffer1 complete dim=1 -#pragma HLS ARRAY_PARTITION variable=acc_buffer2 complete dim=1 -// #pragma HLS RESOURCE variable=acc_buffer1 core=RAM_T2P_BRAM latency=1 -// #pragma HLS RESOURCE variable=acc_buffer2 core=RAM_T2P_BRAM latency=1 -// #pragma HLS RESOURCE variable=acc_buffer1 core=RAM_T2P_URAM -// #pragma HLS RESOURCE variable=acc_buffer2 core=RAM_T2P_URAM - -// #pragma HLS RESOURCE variable=acc_buffer1 core=XPM_MEMORY uram -// #pragma HLS RESOURCE variable=acc_buffer2 core=XPM_MEMORY uram - - + svd::AccumD acc_buffer[NumGates][kNumInputs][kTileSize][NumTiles]; +#pragma HLS ARRAY_PARTITION variable=acc_buffer complete dim=1 +#pragma HLS ARRAY_PARTITION variable=acc_buffer complete dim=2 +#pragma HLS ARRAY_PARTITION variable=acc_buffer complete dim=3 Init_buffer: for (int i = 0; i < NumTiles; ++i) { #pragma HLS PIPELINE II=1 - for (int j = 0; j < kNumTileElems; ++j) { - acc_buffer1[j][i] = 0; - acc_buffer2[j][i] = 0; + for (int j = 0; j < kTileSize; ++j) { + for (int k = 0; k < kNumInputs; ++k) { + for (int g = 0; g < NumGates; ++g) { + acc_buffer[g][k][j][i] = 0; + } + } } } - - ap_uint nz_idx[kNumTileElems]; - svd::AccumD xs1[kNumTileElems]; - svd::AccumD xs2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=nz_idx complete -#pragma HLS ARRAY_PARTITION variable=xs1 complete -#pragma HLS ARRAY_PARTITION variable=xs2 complete - svd::AccumD mac_1[kNumTileElems]; - svd::AccumD mac_2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=mac_1 complete -#pragma HLS ARRAY_PARTITION variable=mac_2 complete - svd::AccumD acc_1[kNumTileElems]; - svd::AccumD acc_2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=acc_1 complete -#pragma HLS ARRAY_PARTITION variable=acc_2 complete - - svd::WeightD v[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=v complete - -#ifndef __SYNTHESIS__ - int nz_idx_buf[kNumTileElems][NumIter * kNonZeroTiles] = {-1}; - const int kPipelineDepth = 8; - const bool printout = false; -#endif - + ap_uint nz_idx[NumGates][kTileSize]; + svd::AccumD xus[NumGates][kNumInputs][kTileSize]; + svd::AccumD mac[NumGates][kNumInputs][kTileSize]; + svd::AccumD acc[NumGates][kNumInputs][kTileSize]; + svd::WeightD v[NumGates][kTileSize]; +#pragma HLS ARRAY_PARTITION variable=nz_idx complete dim=0 +#pragma HLS ARRAY_PARTITION variable=xus complete dim=0 +#pragma HLS ARRAY_PARTITION variable=mac complete dim=0 +#pragma HLS ARRAY_PARTITION variable=acc complete dim=0 +#pragma HLS ARRAY_PARTITION variable=v complete dim=0 for (int i = 0; i < NumIter; ++i) { for (int k = 0; k < kNonZeroTiles; ++k) { #pragma HLS LOOP_FLATTEN #pragma HLS PIPELINE II=1 - for (int j = 0; j < kNumTileElems; ++j) { - if (k == 0) { - xs1[j] = xs1_streams[j].read(); - xs2[j] = xs2_streams[j].read(); - } - nz_idx[j] = nz_idx_streams[j].read(); - -#ifndef __SYNTHESIS__ - // =================================================================== - // Naive dependency detection mechanism: - // =================================================================== - // std::cout << "\tPE n." << j << " accessing acc_buffer[" << j << "][" << nz_idx[j] << "]\n"; - const int idx = i * kNonZeroTiles + k; - nz_idx_buf[j][idx] = nz_idx[j]; - - if (idx > 0) { - int dependency_idx = -1; - if (j == 0 && printout) { - std::cout << "curr_idx: " << nz_idx[j] << "\nprev_idx: "; - } - for (int q = idx - 1; q > 0; --q) { - if (nz_idx_buf[j][idx] == nz_idx_buf[j][q]) { - dependency_idx = q; - break; - } - } - if (j == 0 && printout) { - for (int q = idx; q > 0; --q) { - if (q - 1 == dependency_idx && idx - dependency_idx < kPipelineDepth) { - std::cout << "<(("; - } - std::cout << nz_idx_buf[j][q - 1]; - if (q - 1 == dependency_idx && idx - dependency_idx < kPipelineDepth) { - std::cout << "))>"; - } - std::cout << " "; - if ((q - 1) % kNonZeroTiles == 0) { - std::cout << "| "; - } - } - std::cout << "\ndistance: " << idx - dependency_idx << "\n"; - } - // NOTE: The dependency will be the same for all PEs, i.e. j indexes. - if (j == 0 && dependency_idx != -1 && idx - dependency_idx < kPipelineDepth) { - //num_raw_hazards++; - if (printout) { - std::cout << "[WARNING] Possible dependecy detected: nz[" << idx << "] = " << nz_idx_buf[j][idx] - << " -> nz[" << dependency_idx << "] = " << nz_idx_buf[j][dependency_idx] - << ", distance: " << idx - dependency_idx << "\n"; + for (int g = 0; g < NumGates; ++g) { + for (int j = 0; j < kTileSize; ++j) { + if (k == 0) { + for (int ii = 0; ii < kNumInputs; ++ii) { + xus[g][ii][j] = xus_streams[g][ii][j].read(); } } - if (j == 0 && printout) { - std::cout << "\n"; + nz_idx[g][j] = nz_idx_streams[g][j].read(); + v[g][j] = gate_v_streams[g][j].read(); + for (int ii = 0; ii < kNumInputs; ++ii) { + mac[g][ii][j] = (xus[g][ii][j] * v[g][j]) + acc_buffer[g][ii][j][nz_idx[g][j]]; +#pragma HLS RESOURCE variable=mac[g][ii][j] core=DSP48 latency=3 +#pragma HLS DEPENDENCE variable=acc_buffer RAW false inter distance=kNonZeroTiles + acc_buffer[g][ii][j][nz_idx[g][j]] = mac[g][ii][j]; } } -#endif - v[j] = gate_v_streams[j].read(); - - mac_1[j] = (xs1[j] * v[j]) + acc_buffer1[j][nz_idx[j]]; - mac_2[j] = (xs2[j] * v[j]) + acc_buffer2[j][nz_idx[j]]; -#pragma HLS RESOURCE variable=mac_1[j] core=DSP48 latency=3 -#pragma HLS RESOURCE variable=mac_2[j] core=DSP48 latency=3 -#pragma HLS DEPENDENCE variable=acc_buffer1 RAW false inter -#pragma HLS DEPENDENCE variable=acc_buffer2 RAW false inter - - acc_buffer1[j][nz_idx[j]] = mac_1[j]; - acc_buffer2[j][nz_idx[j]] = mac_2[j]; - } // end kNumTileElems - } // end kNonZeroTiles - } // end NumIter - - WriteBack_tiles: + } + } + } + V_DMA: for (int i = 0; i < NumTiles; ++i) { #pragma HLS PIPELINE II=1 - WriteBack_elems: - for (int j = 0; j < kNumTileElems; ++j) { - if (has_bias) { - auto acc_1 = acc_buffer1[j][i] + bias1_streams[j].read(); - auto acc_2 = acc_buffer2[j][i] + bias2_streams[j].read(); + for (int j = 0; j < kTileSize; ++j) { + for (int k = 0; k < NumGates; ++k) { + if (has_bias) { + auto acc_1 = acc_buffer[k][0][j][i] + bias_streams[k][0][j].read(); + auto acc_2 = acc_buffer[k][1][j][i] + bias_streams[k][1][j].read(); #pragma HLS RESOURCE variable=acc_1 core=AddSub_DSP #pragma HLS RESOURCE variable=acc_2 core=AddSub_DSP - gate_out1_streams[j].write(acc_1); - gate_out2_streams[j].write(acc_2); - } else { - gate_out1_streams[j].write(acc_buffer1[j][i]); - gate_out2_streams[j].write(acc_buffer2[j][i]); + gate_out1_streams[k][j].write(acc_1); + gate_out2_streams[k][j].write(acc_2); + } else { + gate_out1_streams[k][j].write(acc_buffer[k][0][j][i]); + gate_out2_streams[k][j].write(acc_buffer[k][1][j][i]); + } } } } + } // end V_Function +} - if (debug_module) { - probe_ctrl->write(0); - } -#else - - svd::AccumD acc_buffer1[kNumTileElems][NumTiles]; - svd::AccumD acc_buffer2[kNumTileElems][NumTiles]; -#pragma HLS ARRAY_PARTITION variable=acc_buffer1 complete dim=1 -#pragma HLS ARRAY_PARTITION variable=acc_buffer2 complete dim=1 -#pragma HLS RESOURCE variable=acc_buffer1 core=RAM_T2P_BRAM latency=1 -#pragma HLS RESOURCE variable=acc_buffer2 core=RAM_T2P_BRAM latency=1 -// #pragma HLS STREAM variable=acc_buffer1 depth=1 -// #pragma HLS STREAM variable=acc_buffer2 depth=1 - - ap_uint nz_idx[kNumTileElems]; - svd::AccumD xs1[kNumTileElems]; - svd::AccumD xs2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=nz_idx complete -#pragma HLS ARRAY_PARTITION variable=xs1 complete -#pragma HLS ARRAY_PARTITION variable=xs2 complete - svd::AccumD mac_1[kNumTileElems]; - svd::AccumD mac_2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=mac_1 complete -#pragma HLS ARRAY_PARTITION variable=mac_2 complete - svd::AccumD acc_1[kNumTileElems]; - svd::AccumD acc_2[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=acc_1 complete -#pragma HLS ARRAY_PARTITION variable=acc_2 complete - - svd::WeightD v[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=v complete - - hls::stream xsv1_streams[kNumTileElems]; - hls::stream xsv2_streams[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=xsv1_streams complete -#pragma HLS ARRAY_PARTITION variable=xsv2_streams complete -#pragma HLS STREAM variable=xsv1_streams depth=kNonZeroTiles -#pragma HLS STREAM variable=xsv2_streams depth=kNonZeroTiles - hls::stream acc1_streams[kNumTileElems]; - hls::stream acc2_streams[kNumTileElems]; -#pragma HLS ARRAY_PARTITION variable=acc1_streams complete -#pragma HLS ARRAY_PARTITION variable=acc2_streams complete - const int kStreamDepthAcc = NumTiles; -#pragma HLS STREAM variable=acc1_streams depth=kStreamDepthAcc -#pragma HLS STREAM variable=acc2_streams depth=kStreamDepthAcc - for (int n = 0; n < NumIter; ++n) { - for (int nz = 0; nz < kNonZeroTiles; ++nz) { -#pragma HLS LOOP_FLATTEN +#ifndef __VITIS_HLS__ +#else +template < + typename params, + typename WrapperAxisG = svd::AxiStreamPort, + typename WrapperAxisGTv = svd::AxiStreamPort +> +void KernelV(const int num_active_inputs, + const int output_size, + const int num_refinements[params::N], + hls::stream& xus_port, + hls::stream& v_port, + hls::stream& y_port) { +#pragma HLS TOP name=KernelV +#pragma HLS DATAFLOW +#pragma HLS INLINE +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=xus_port +#pragma HLS STABLE variable=v_port +#pragma HLS STABLE variable=y_port +#endif + assert(num_active_inputs <= params::N); + assert(num_active_inputs > 0); + assert(params::H % params::Tv == 0); + assert(output_size % params::Tv == 0); + assert(output_size <= params::H); + typedef typename params::ActivationD ActivationType; + const int kMaxNumTilesV = params::H / params::Tv; + const int kNumTilesV = output_size / params::Tv; + const int kStreamDepth_V = 32 + kMaxNumTilesV * params::G; + assert(kNumTilesV <= kMaxNumTilesV); + auto xus_axis = svd::AxiStreamInterface(xus_port); + auto v_axis = svd::AxiStreamPort(v_port); + auto y_axis = svd::AxiStreamInterface(y_port); + hls::stream v_streams[params::G]; + // NOTE: Having y_buffer as static made cosim work in one-process configuration. + static ActivationType y_buffer[params::G][params::N][params::Tv][kMaxNumTilesV] = {0}; + typename params::VectTvType v_val; + typename params::VectG_Type xus_val[params::N]; + typename params::VectGTvType y_out; +// NOTE: I'm not accessing dimension N of y_buffer in parallel. +#pragma HLS ARRAY_PARTITION variable=v_streams complete +#pragma HLS ARRAY_PARTITION variable=y_buffer complete dim=1 +#pragma HLS ARRAY_PARTITION variable=y_buffer complete dim=3 +#pragma HLS BIND_STORAGE variable=y_buffer type=ram_t2p impl=bram latency=1 + int R_max = num_refinements[0]; + Get_Max_R: + for (int i = 1; i < num_active_inputs; ++i) { #pragma HLS PIPELINE II=1 - for (int i = 0; i < kNumTileElems; ++i) { - if (nz == 0) { - xs1[i] = xs1_streams[i].read(); - xs2[i] = xs2_streams[i].read(); - } - svd::WeightD v_val = gate_v_streams[i].read(); - svd::AccumD xvs1_val = xs1[i] * v_val; - svd::AccumD xvs2_val = xs2[i] * v_val; -#pragma HLS RESOURCE variable=xvs1_val core=DSP48 latency=3 -#pragma HLS RESOURCE variable=xvs2_val core=DSP48 latency=3 - xsv1_streams[i].write(xvs1_val); - xsv2_streams[i].write(xvs2_val); - } + if (num_refinements[i] > R_max) { + R_max = num_refinements[i]; } } - V_Kernel: { -#pragma HLS INLINE off - - Init_buffer: - for (int i = 0; i < NumTiles; ++i) { - #pragma HLS PIPELINE II=1 - for (int j = 0; j < kNumTileElems; ++j) { - acc_buffer1[j][i] = 0; - acc_buffer2[j][i] = 0; - } - } - for (int n = 0; n < NumIter; ++n) { - for (int t = 0; t < kNonZeroTiles; ++t) { -#pragma HLS LOOP_FLATTEN + V_DMA: + for (int i = 0; i < R_max; ++i) { + for (int j = 0; j < kNumTilesV; ++j) { + for (int k = 0; k < params::G; ++k) { + for (int ii = 0; ii < num_active_inputs; ++ii) { #pragma HLS PIPELINE II=1 - for (int i = 0; i < kNumTileElems; ++i) { - ActivationD operand_prev1 = 0; - ActivationD operand_curr1 = 0; - ActivationD operand_prev2 = 0; - ActivationD operand_curr2 = 0; - // =================================================================== - // Setup the internal stream - // =================================================================== - nz_idx[i] = nz_idx_streams[i].read(); - operand_prev1 = acc_buffer1[i][nz_idx[i]]; - operand_prev2 = acc_buffer2[i][nz_idx[i]]; - operand_curr1 = xsv1_streams[i].read(); - operand_curr2 = xsv2_streams[i].read(); - // =================================================================== - // Accumulate the incoming streams - // =================================================================== - svd::AccumD sum1 = operand_prev1 + operand_curr1; - svd::AccumD sum2 = operand_prev2 + operand_curr2; -#pragma HLS RESOURCE variable=sum1 core=AddSub_DSP -#pragma HLS RESOURCE variable=sum2 core=AddSub_DSP - acc_buffer1[i][nz_idx[i]] = sum1; - acc_buffer2[i][nz_idx[i]] = sum2; + if (ii == 0) { + v_val = v_axis.template PopVector(); + } + if (i < num_refinements[ii]) { + v_streams[k] << v_val; + } } } } - // =================================================================== - // Write the results to the output streams - // =================================================================== - WriteBack_tiles: - for (int i = 0; i < NumTiles; ++i) { + } + V_Kernel: + for (int i = 0; i < R_max; ++i) { + for (int j = 0; j < kNumTilesV; ++j) { + for (int k = 0; k < num_active_inputs; ++k) { #pragma HLS PIPELINE II=1 - WriteBack_elems: - for (int j = 0; j < kNumTileElems; ++j) { - if (has_bias) { - auto acc_1 = acc_buffer1[j][i] + bias1_streams[j].read(); - auto acc_2 = acc_buffer2[j][i] + bias2_streams[j].read(); -#pragma HLS RESOURCE variable=acc_1 core=AddSub_DSP -#pragma HLS RESOURCE variable=acc_2 core=AddSub_DSP - gate_out1_streams[j].write(acc_1); - gate_out2_streams[j].write(acc_2); - } else { - gate_out1_streams[j].write(acc_buffer1[j][i]); - gate_out2_streams[j].write(acc_buffer2[j][i]); + for (int ii = 0; ii < params::G; ++ii) { + assert(j < kMaxNumTilesV); + assert(k < params::N); + if (i < num_refinements[k]) { + assert(i < 512); + if (j == 0 && ii == 0) { + xus_val[k] = xus_axis.template PopVector(); + } + auto v_val = v_streams[ii].read(); + for (int jj = 0; jj < params::Tv; ++jj) { + ActivationType y_val; + if (i == 0) { + y_val = v_val[jj] * xus_val[k][ii]; + } else { + y_val = y_buffer[ii][k][jj][j] + v_val[jj] * xus_val[k][ii]; + } + y_buffer[ii][k][jj][j] = y_val; +// #pragma HLS DEPENDENCE inter variable=y_buffer false + } + } + } + if (i == R_max - 1) { + for (int jj = 0; jj < params::G; ++jj) { + for (int ii = 0; ii < params::Tv; ++ii) { + y_out[ii * params::G + jj] = y_buffer[jj][k][ii][j]; + } + } + const bool kIsLast = j == kNumTilesV-1 && k == num_active_inputs-1; + const int kGTv = params::G * params::Tv; + y_axis.template PushVector(y_out, kIsLast); } } } -#endif - } // end V_Function +// if (i == R_max - 1) { +// for (int j = 0; j < kNumTilesV; ++j) { +// for (int k = 0; k < num_active_inputs; ++k) { +// for (int jj = 0; jj < params::G; ++jj) { +// for (int ii = 0; ii < params::Tv; ++ii) { +// #pragma HLS PIPELINE II=1 +// y_out[ii * params::G + jj] = y_buffer[jj][k][ii][j]; +// } +// } +// const bool kIsLast = j == kNumTilesV-1 && k == num_active_inputs-1; +// const int kGTv = params::G * params::Tv; +// y_axis.template PushVector(y_out, kIsLast); +// } +// } +// } + } +// DMA_Out: +// for (int j = 0; j < kNumTilesV; ++j) { +// for (int k = 0; k < num_active_inputs; ++k) { +// #pragma HLS PIPELINE II=1 +// for (int jj = 0; jj < params::G; ++jj) { +// for (int ii = 0; ii < params::Tv; ++ii) { +// assert(ii * params::G + jj < params::G * params::Tv); +// y_out[ii * params::G + jj] = y_buffer[jj][k][ii][j]; +// // y_out[ii * params::G + jj] = y_val[jj][ii]; +// } +// } +// const bool kIsLast = j == kNumTilesV-1 && k == num_active_inputs-1; +// const int kGTv = params::G * params::Tv; +// y_axis.template PushVector(y_out, kIsLast); +// } +// } + } +#endif // end __VITIS_HLS__ } // svd -#endif // end KERNEL_V_KERNEL_H_ \ No newline at end of file +namespace testv { + +static const int kNumInputs = 2; +static const int kInputSize = 512; +static const int Tu = 4; +// NOTE: The rest of the parameters are unused for now. +static const int kOutputSize = 512; +static const int R = 64; +static const int Tv = 4; +static const int ZTu = 0; +static const int ZTv = 0; +static const int G = 4; + +typedef svd::SvdParameters params; + short, short, short> params; + // ap_fixed, ap_fixed, ap_fixed > params; + // float, float, float > params; + +} // testv + +#ifndef __VITIS_HLS__ +#else +void HlsKernelV(const int num_active_inputs, + const int output_size, + const int num_refinements[testv::params::N], + // const hls::vector num_refinements, + hls::stream& xus_port, + hls::stream& v_port, + hls::stream& y_port); +#endif // end __VITIS_HLS__ + +#endif // end KERNEL_V_KERNEL_H_ diff --git a/include/layers/dense/hls/dense_svd.h b/include/layers/dense/hls/dense_svd.h new file mode 100644 index 0000000..14d7183 --- /dev/null +++ b/include/layers/dense/hls/dense_svd.h @@ -0,0 +1,172 @@ +#ifndef LAYERS_DENSE_HLS_DENSE_SVD_H_ +#define LAYERS_DENSE_HLS_DENSE_SVD_H_ + +#include "svd_params.h" +#include "kernel/svd_kernel.h" + +#include "ap_int.h" + + +namespace svd { + +static const int kDenseNumGates = 1; + +typedef svd::SvdParameters, + ap_fixed, + ap_fixed > dense_params; + +#ifndef __VITIS_HLS__ +#else +template +void DenseSvdKernel(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + // const hls::vector num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& bias_port, + hls::stream& y_port) { +#pragma HLS TOP name=DenseSvdKernel +// #pragma HLS INLINE +#pragma HLS DATAFLOW +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=x_port +#pragma HLS STABLE variable=u_port +#pragma HLS STABLE variable=s_port +#pragma HLS STABLE variable=v_port +#pragma HLS STABLE variable=bias_port +#pragma HLS STABLE variable=y_port +#endif + static_assert(params::G == 1, "DenseSvdKernel must have params::G equal to one."); + assert(params::G == 1); + typedef typename params::ActivationD ActivationType; + typedef svd::AxiStreamFifo WrapperFifoGTv; + hls::stream y_fifo; +#pragma HLS STREAM variable=y_fifo depth=2 + auto y_axis = svd::AxiStreamFifo(y_fifo); + auto y_out_axis = svd::AxiStreamPort(y_port); + auto bias_axis = svd::AxiStreamPort(bias_port); + svd::SvdKernel(num_active_inputs, input_size, + output_size, num_refinements, x_port, u_port, s_port, v_port, y_fifo); + Apply_Bias: + for (int i = 0; i < output_size / params::Tv * num_active_inputs; ++i) { +#pragma HLS PIPELINE II=1 + const int kGTv = params::G * params::Tv; // NOTE: G is actually equal to 1. + const auto y_val = y_axis.template PopVector(); + const auto bias_val = bias_axis.template PopVector(); + const auto y_out = y_val + bias_val; +// #pragma HLS BIND_OP variable=y_out op=add impl=dsp latency=3 + const bool kIsLast = i == output_size / params::Tv * num_active_inputs - 1; + y_out_axis.template PushVector(y_out, kIsLast); + } +} +#endif // end __VITIS_HLS__ + +/** + * @brief Sets the DenseSvd kernel inputs, i.e. streams from arrays into + * hls::streams. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param[in] bias The bias array. Shape: (N, G, H) + * @param x_port The x port to be used as argument to SvdKernel + * @param u_port The u port to be used as argument to SvdKernel + * @param s_port The s port to be used as argument to SvdKernel + * @param v_port The v port to be used as argument to SvdKernel + * @param bias_port The bias port to be used as argument to + * SvdKernel + * + * @tparam params Collection of SVD configuration params. + */ +#ifdef __VITIS_HLS__ +template +void SetDenseSvdInputs(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + const typename params::ActivationD* x, + const typename params::ActivationD* u, + const typename params::ActivationD* s, + const typename params::ActivationD* v, + const typename params::ActivationD* bias, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& bias_port) { + typedef typename params::ActivationD ActivationType; + const int kG = params::G; // NOTE: G is actually equal to 1. + const int kTv = params::Tv; + const int kGTv = kG * kTv; + const int kNumTilesV = output_size / kTv; + auto bias_axis = svd::AxiStreamPort(bias_port); + typename params::VectGTvType bias_val; + for (int i = 0; i < kNumTilesV; ++i) { + for (int j = 0; j < num_active_inputs; ++j) { + for (int k = 0; k < kTv; ++k) { + for (int ii = 0; ii < kG; ++ii) { + int bias_idx = j * output_size * kG + ii * output_size + i * kTv + k; + bias_val[k * kG + ii] = bias[bias_idx]; + } + } + bias_axis.template PushVector(bias_val); + } + } + svd::SetSvdKernelInputs(num_active_inputs, input_size, + output_size, num_refinements, x, u, s, v, x_port, u_port, s_port, v_port); +} +#endif // __VITIS_HLS__ + +} // svd + +void HlsDenseSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::dense_params::N], + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& bias_port, + hls::stream& y_port); + + +/** + * @brief HLS Wrapper that calls a DenseSvd accelerator. + * + * Useful in Cosimulation. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param[in] bias The bias array. Shape: (N, G, H) + * @param y The y array. Shape: (N, G, H) + */ +void HlsWrapperDenseSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::dense_params::N], + const typename svd::dense_params::ActivationD* x, + const typename svd::dense_params::ActivationD* u, + const typename svd::dense_params::ActivationD* s, + const typename svd::dense_params::ActivationD* v, + const typename svd::dense_params::ActivationD* bias, + typename svd::dense_params::ActivationD* y); + +#endif // end DENSE_HLS_DENSE_SVD_H_); diff --git a/include/lstm/hls/lstm_hardware.h b/include/layers/lstm/hls/lstm_hardware.h similarity index 97% rename from include/lstm/hls/lstm_hardware.h rename to include/layers/lstm/hls/lstm_hardware.h index 1206d40..6757ad6 100644 --- a/include/lstm/hls/lstm_hardware.h +++ b/include/layers/lstm/hls/lstm_hardware.h @@ -36,15 +36,21 @@ * streams * *****************************************************************************/ -#ifndef LSTM_HARDWARE_H_ -#define LSTM_HARDWARE_H_ +#ifndef LSTM_HLS_LSTM_HARDWARE_H_ +#define LSTM_HLS_LSTM_HARDWARE_H_ #include "math_utils/activation_functions.h" +#include "svd_params.h" +#ifdef AP_INT_MAX_W +#undef AP_INT_MAX_W #define AP_INT_MAX_W 4096 +#endif #include "ap_int.h" -#include "hls_linear_algebra.h" #include "ap_axi_sdata.h" +#ifndef __VITIS_HLS__ +#include "hls_linear_algebra.h" +#endif #ifndef __SYNTHESIS__ #include @@ -71,6 +77,7 @@ namespace svd { +#ifndef __VITIS_HLS__ // struct MY_CONFIG: hls::matrix_multiply_traits { // static const int ARCH = 4; @@ -137,11 +144,7 @@ struct MatrixConfigFixRecurrent: hls::matrix_multiply_traits < static const int N = 1; static const int K = HIDDEN_TILE_SIZE; }; - -void svd_fpga_cur_gemm_axi(const AxiD *a, const AxiD *b, AxiD *c); - -template -void cur_gemm(const ActivationD *a, const ActivationD *b, ActivationD *c); +#endif typedef struct { ap_uint data; @@ -149,6 +152,11 @@ typedef struct { } AxisPacketD; typedef hls::stream DmaInterfaceD; +void svd_fpga_cur_gemm_axi(const AxiD *a, const AxiD *b, AxiD *c); + +template +void cur_gemm(const ActivationD *a, const ActivationD *b, ActivationD *c); + } // end namespace svd void svd_fpga_cur_gemm_gate(const svd::ActivationD *a, const svd::ActivationD *b, svd::ActivationD *c); @@ -224,4 +232,4 @@ void dummy_gemm_v0(const svd::ActivationD a[16][16], const svd::ActivationD b[16 void test_dispatcher(); -#endif // end LSTM_HARDWARE_H_ \ No newline at end of file +#endif // end LSTM_HLS_LSTM_HARDWARE_H_ \ No newline at end of file diff --git a/include/layers/lstm/hls/lstm_svd.h b/include/layers/lstm/hls/lstm_svd.h new file mode 100644 index 0000000..308ce42 --- /dev/null +++ b/include/layers/lstm/hls/lstm_svd.h @@ -0,0 +1,410 @@ +#ifndef LSTM_HLS_LSTM_SVD_H_ +#define LSTM_HLS_LSTM_SVD_H_ + +#include "svd_params.h" +#include "kernel/svd_kernel.h" +#include "math_utils/activation_functions.h" +#include "layers/dense/hls/dense_svd.h" +#include "dma/axis_lib.h" + +#include "ap_int.h" +#include "hls_stream.h" + +namespace svd { + +#ifdef SDS_DESIGN +// ============================================================================= +// Ports using DMAs +// ============================================================================= +#pragma SDS data copy(x1_port[0:INPUT_SIZE]) +#pragma SDS data copy(x2_port[0:INPUT_SIZE]) +#pragma SDS data copy(h_t1_prev_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(h_t2_prev_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(c_t1_prev_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(c_t2_prev_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(bias1_port[0:4*HIDDEN_SIZE]) +#pragma SDS data copy(bias2_port[0:4*HIDDEN_SIZE]) +#pragma SDS data copy(nz_v_port[0:NUM_ITERATIONS * 8]) +#pragma SDS data copy(nz_u_port[0:NUM_ITERATIONS * 8]) +#pragma SDS data copy(h_t1_curr_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(h_t2_curr_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(c_t1_curr_port[0:HIDDEN_SIZE]) +#pragma SDS data copy(c_t2_curr_port[0:HIDDEN_SIZE]) +// Data Movers +#pragma SDS data data_mover(x1_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(x2_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(h_t1_prev_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(h_t2_prev_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(c_t1_prev_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(c_t2_prev_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(bias1_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(bias2_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(nz_v_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(nz_u_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(h_t1_curr_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(h_t2_curr_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(c_t1_curr_port:AXIDMA_SIMPLE) +#pragma SDS data data_mover(c_t2_curr_port:AXIDMA_SIMPLE) +// Port mapping +// #pragma SDS data sys_port(x1_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(x2_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(h_t1_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(h_t2_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(c_t1_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(c_t2_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(bias1_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(bias2_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(nz_v_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(nz_u_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port +// #pragma SDS data sys_port(h_t1_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port +// #pragma SDS data sys_port(h_t2_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port +// #pragma SDS data sys_port(c_t1_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port +// #pragma SDS data sys_port(c_t2_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port +// ============================================================================= +// Weight ports not using DMAs +// ============================================================================= +// #pragma SDS data zero_copy(u_cur_port[0:NUM_ITERATIONS*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) +// #pragma SDS data zero_copy(u_rec_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) +// #pragma SDS data zero_copy(v_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)]) +// #pragma SDS data zero_copy(s1_port[0:NUM_ITERATIONS]) +// #pragma SDS data zero_copy(s2_port[0:NUM_ITERATIONS]) +// ============================================================================= +// Weight ports using DMAs +// ============================================================================= +#pragma SDS data copy(u_cur_port[0:NUM_ITERATIONS*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) +#pragma SDS data copy(u_rec_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) +#pragma SDS data copy(v_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)]) +#pragma SDS data copy(s1_port[0:NUM_ITERATIONS]) +#pragma SDS data copy(s2_port[0:NUM_ITERATIONS]) +// Platform Port Mapping, available options: +// - ACP Coherent ports: ps_e_S_AXI_HPC[0-1]_FPD +// - HP ports: ps_e_S_AXI_HP[0-3]_FPD +// #pragma SDS data sys_port(u_cur_port:ps_e_S_AXI_HP0_FPD) // HP2 +// #pragma SDS data sys_port(u_rec_port:ps_e_S_AXI_HP1_FPD) // HP3 +// #pragma SDS data sys_port(v_port:ps_e_S_AXI_HP2_FPD) // HP3 +// #pragma SDS data sys_port(s1_port:ps_e_S_AXI_HP3_FPD) // HP3 +// #pragma SDS data sys_port(s2_port:ps_e_S_AXI_HP3_FPD) // HP3 +// ============================================================================= +// Other Configurations +// ============================================================================= +// Compiler hint on allocation +#pragma SDS data mem_attribute(x1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(x2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(h_t1_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(h_t2_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(c_t1_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(c_t2_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(u_cur_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(u_rec_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(v_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(s1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(s2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(bias1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(bias2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(nz_v_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(nz_u_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(h_t1_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(h_t2_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(c_t1_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +#pragma SDS data mem_attribute(c_t2_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) +// NOTE: All ports are accessed sequentially. +#pragma SDS data access_pattern(x1_port:SEQUENTIAL) +#pragma SDS data access_pattern(x2_port:SEQUENTIAL) +#pragma SDS data access_pattern(h_t1_prev_port:SEQUENTIAL) +#pragma SDS data access_pattern(h_t2_prev_port:SEQUENTIAL) +#pragma SDS data access_pattern(c_t1_prev_port:SEQUENTIAL) +#pragma SDS data access_pattern(c_t2_prev_port:SEQUENTIAL) +#pragma SDS data access_pattern(u_cur_port:SEQUENTIAL) +#pragma SDS data access_pattern(u_rec_port:SEQUENTIAL) +#pragma SDS data access_pattern(v_port:SEQUENTIAL) +#pragma SDS data access_pattern(s1_port:SEQUENTIAL) +#pragma SDS data access_pattern(s2_port:SEQUENTIAL) +#pragma SDS data access_pattern(bias1_port:SEQUENTIAL) +#pragma SDS data access_pattern(bias2_port:SEQUENTIAL) +#pragma SDS data access_pattern(nz_v_port:SEQUENTIAL) +#pragma SDS data access_pattern(nz_u_port:SEQUENTIAL) +#pragma SDS data access_pattern(h_t1_curr_port:SEQUENTIAL) +#pragma SDS data access_pattern(h_t2_curr_port:SEQUENTIAL) +#pragma SDS data access_pattern(c_t1_curr_port:SEQUENTIAL) +#pragma SDS data access_pattern(c_t2_curr_port:SEQUENTIAL) +#endif // end SDS_DESIGN +void SvdModel2LstmSDSoCV2( + const svd::ActivationD x1_port[INPUT_SIZE], + const svd::ActivationD x2_port[INPUT_SIZE], + const svd::ActivationD h_t1_prev_port[HIDDEN_SIZE], + const svd::ActivationD h_t2_prev_port[HIDDEN_SIZE], + const svd::ActivationD c_t1_prev_port[HIDDEN_SIZE], + const svd::ActivationD c_t2_prev_port[HIDDEN_SIZE], + const ap_uint *u_cur_port, // [NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], + const ap_uint *u_rec_port, // [NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], + const ap_uint *v_port, // [NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)], + const ap_uint *s1_port, // [NUM_ITERATIONS*8], + const ap_uint *s2_port, // [NUM_ITERATIONS*8], + const svd::WeightD bias1_port[4 * HIDDEN_SIZE], + const svd::WeightD bias2_port[4 * HIDDEN_SIZE], + const ap_uint nz_v_port[NUM_ITERATIONS * 8], + const ap_uint nz_u_port[NUM_ITERATIONS * 8], + svd::ActivationD h_t1_curr_port[HIDDEN_SIZE], + svd::ActivationD h_t2_curr_port[HIDDEN_SIZE], + svd::ActivationD c_t1_curr_port[HIDDEN_SIZE], + svd::ActivationD c_t2_curr_port[HIDDEN_SIZE]); + +typedef svd::SvdParameters, + ap_fixed, + ap_fixed > lstm_params; + +#ifndef __VITIS_HLS__ +#else +template +void LstmSvdKernel(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + // Current Gates + hls::stream& x_port, + hls::stream& u_cur_port, + hls::stream& s_cur_port, + hls::stream& v_cur_port, + // Recurrent Gates + hls::stream& h_prev_port, + hls::stream& u_rec_port, + hls::stream& s_rec_port, + hls::stream& v_rec_port, + // Non-Linearities + hls::stream& bias_port, + hls::stream& c_prev_port, + hls::stream& h_curr_port, + hls::stream& c_curr_port) { +#pragma HLS TOP name=LstmSvdKernel +// #pragma HLS INLINE +#pragma HLS DATAFLOW +// Current Gates +#pragma HLS ARRAY_PARTITION variable=num_refinements complete +#ifndef __VITIS_HLS__ +#pragma HLS STABLE variable=x_port +#pragma HLS STABLE variable=u_cur_port +#pragma HLS STABLE variable=s_cur_port +#pragma HLS STABLE variable=v_cur_port +// Recurrent Gates +#pragma HLS STABLE variable=h_prev_port +#pragma HLS STABLE variable=u_rec_port +#pragma HLS STABLE variable=s_rec_port +#pragma HLS STABLE variable=v_rec_port +// Non-Linearities +#pragma HLS STABLE variable=bias_port +#pragma HLS STABLE variable=c_prev_port +#pragma HLS STABLE variable=h_curr_port +#pragma HLS STABLE variable=c_curr_port +#endif + int refinements[2][params::N]; +#pragma HLS ARRAY_PARTITION variable=refinements complete dim=0 + for (int i = 0; i < 2; ++i) { +#pragma HLS UNROLL region + for (int j = 0; j < params::N; ++j) { + refinements[i][j] = num_refinements[j]; + } + } + typedef typename params::ActivationD ActivationType; + typedef svd::AxiStreamFifo WrapperFifoGTv; + hls::stream y_cur_fifo; + hls::stream y_rec_fifo; +#pragma HLS STREAM variable=y_cur_fifo depth=2 +#pragma HLS STREAM variable=y_rec_fifo depth=2 + auto y_cur_axis = svd::AxiStreamFifo(y_cur_fifo); + auto y_rec_axis = svd::AxiStreamFifo(y_rec_fifo); + auto bias_axis = svd::AxiStreamPort(bias_port); + auto c_prev_axis = svd::AxiStreamPort(c_prev_port); + auto c_curr_axis = svd::AxiStreamPort(c_curr_port); + auto h_curr_axis = svd::AxiStreamPort(h_curr_port); + // Current Gates + svd::SvdKernel(num_active_inputs, input_size, + output_size, refinements[0], x_port, u_cur_port, s_cur_port, + v_cur_port, y_cur_fifo); + // Recurrent Gates + svd::SvdKernel(num_active_inputs, output_size, + output_size, refinements[1], h_prev_port, u_rec_port, s_rec_port, + v_rec_port, y_rec_fifo); + // Non-Linearities + const int kTypeBitwidth = hlsutils::Bitwidth::value; + const int kLutSize = (kTypeBitwidth > 16) ? 256 : 512; + const int kGTv = params::G * params::Tv; + const bool kApplyBias = true; + NonLinearities: + for (int i = 0; i < output_size / params::Tv * num_active_inputs; ++i) { +#pragma HLS PIPELINE II=1 + auto y_cur = y_cur_axis.template PopVector(); + auto y_rec = y_rec_axis.template PopVector(); + auto bias = bias_axis.template PopVector(); + auto c_prev = c_prev_axis.template PopVector(); + ActivationType c_curr[params::Tv]; + ActivationType h_curr[params::Tv]; +#pragma HLS ARRAY_PARTITION variable=c_curr complete dim=0 +#pragma HLS ARRAY_PARTITION variable=h_curr complete dim=0 + for (int j = 0; j < params::Tv; ++j) { + svd::LstmNonLinearFunctions( + kApplyBias, + y_cur[j * params::G + 0], y_cur[j * params::G + 1], + y_cur[j * params::G + 2], y_cur[j * params::G + 3], + y_rec[j * params::G + 0], y_rec[j * params::G + 1], + y_rec[j * params::G + 2], y_rec[j * params::G + 3], + bias[j * params::G + 0], bias[j * params::G + 1], + bias[j * params::G + 2], bias[j * params::G + 3], + c_prev[j], c_curr[j], h_curr[j]); + } + const bool kIsLast = i == output_size / params::Tv * num_active_inputs - 1; + c_curr_axis.template PushBuffer(params::Tv, c_curr, kIsLast); + h_curr_axis.template PushBuffer(params::Tv, h_curr, kIsLast); + } +} +#endif // end __VITIS_HLS__ + +/** + * @brief Sets the LstmSvd kernel inputs, i.e. streams from arrays into + * hls::streams. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param[in] bias The bias array. Shape: (N, G, H) + * @param x_port The x port to be used as argument to SvdKernel + * @param u_port The u port to be used as argument to SvdKernel + * @param s_port The s port to be used as argument to SvdKernel + * @param v_port The v port to be used as argument to SvdKernel + * @param bias_port The bias port to be used as argument to + * SvdKernel + * + * @tparam params Collection of SVD configuration params. + */ +#ifdef __VITIS_HLS__ +template +void SetLstmSvdInputs(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[params::N], + // Current Gates + const typename params::ActivationD* x, + const typename params::ActivationD* u_cur, + const typename params::ActivationD* s_cur, + const typename params::ActivationD* v_cur, + // Recurrent Gates + const typename params::ActivationD* h, + const typename params::ActivationD* u_rec, + const typename params::ActivationD* s_rec, + const typename params::ActivationD* v_rec, + // Non-Linearities + const typename params::ActivationD* bias, + const typename params::ActivationD* c_prev, + // Current Gates + hls::stream& x_port, + hls::stream& u_cur_port, + hls::stream& s_cur_port, + hls::stream& v_cur_port, + // Recurrent Gates + hls::stream& h_prev_port, + hls::stream& u_rec_port, + hls::stream& s_rec_port, + hls::stream& v_rec_port, + // Non-Linearities + hls::stream& bias_port, + hls::stream& c_prev_port) { + svd::SetDenseSvdInputs(num_active_inputs, input_size, output_size, + num_refinements, x, u_cur, s_cur, v_cur, bias, x_port, u_cur_port, + s_cur_port, v_cur_port, bias_port); + svd::SetSvdKernelInputs(num_active_inputs, output_size, output_size, + num_refinements, h, u_rec, s_rec, v_rec, h_prev_port, u_rec_port, + s_rec_port, v_rec_port); + auto c_prev_axis = svd::AxiStreamPort(c_prev_port); + typedef typename params::ActivationD ActivationType; + const int kTv = params::Tv; + const int kNumTilesV = output_size / kTv; + typename params::VectTvType c_prev_val; + for (int i = 0; i < kNumTilesV; ++i) { + for (int j = 0; j < num_active_inputs; ++j) { + for (int k = 0; k < kTv; ++k) { + c_prev_val[k] = c_prev[j * output_size + i * kTv + k]; + } + c_prev_axis.template PushVector(c_prev_val); + } + } +} +#endif // end __VITIS_HLS__ + +#ifdef __VITIS_HLS__ +template +void GetLstmSvdOutputs(const int num_active_inputs, const int output_size, + typename params::ActivationD* h_curr, + typename params::ActivationD* c_curr, + hls::stream& h_curr_port, + hls::stream& c_curr_port) { + typedef typename params::ActivationD ActivationType; + const int kTv = params::Tv; + const int kNumTilesV = output_size / kTv; + auto h_axis = svd::AxiStreamPort(h_curr_port); + auto c_axis = svd::AxiStreamPort(c_curr_port); + typename params::VectTvType h_val; + typename params::VectTvType c_val; + for (int i = 0; i < kNumTilesV; ++i) { + for (int j = 0; j < num_active_inputs; ++j) { + h_val = h_axis.template PopVector(); + c_val = c_axis.template PopVector(); + for (int k = 0; k < kTv; ++k) { + c_curr[j * output_size + i * kTv + k] = c_val[k]; + h_curr[j * output_size + i * kTv + k] = h_val[k]; + } + } + } +} +#endif // end __VITIS_HLS__ + +} // svd + +void HlsLstmSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::svd_params::N], + // const hls::vector num_refinements, + // Current Gates + hls::stream& x_port, + hls::stream& u_cur_port, + hls::stream& s_cur_port, + hls::stream& v_cur_port, + // Recurrent Gates + hls::stream& h_prev_port, + hls::stream& u_rec_port, + hls::stream& s_rec_port, + hls::stream& v_rec_port, + // Non-Linearities + hls::stream& bias_port, + hls::stream& c_prev_port, + hls::stream& h_curr_port, + hls::stream& c_curr_port); + +void HlsWrapperLstmSvd( + const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::lstm_params::N], + // Current Gates + const typename svd::lstm_params::ActivationD* x, + const typename svd::lstm_params::ActivationD* u_cur, + const typename svd::lstm_params::ActivationD* s_cur, + const typename svd::lstm_params::ActivationD* v_cur, + // Recurrent Gates + const typename svd::lstm_params::ActivationD* h, + const typename svd::lstm_params::ActivationD* u_rec, + const typename svd::lstm_params::ActivationD* s_rec, + const typename svd::lstm_params::ActivationD* v_rec, + // Non-Linearities + const typename svd::lstm_params::ActivationD* bias, + const typename svd::lstm_params::ActivationD* c_prev, + typename svd::lstm_params::ActivationD* h_curr, + typename svd::lstm_params::ActivationD* c_curr); + +#endif // end LSTM_HLS_LSTM_SVD_H_ \ No newline at end of file diff --git a/include/layers/lstm/hls/lstm_svd_emulator.h b/include/layers/lstm/hls/lstm_svd_emulator.h new file mode 100644 index 0000000..02cd1a5 --- /dev/null +++ b/include/layers/lstm/hls/lstm_svd_emulator.h @@ -0,0 +1,264 @@ +#ifndef LSTM_HLS_LSTM_SVD_EMULATOR_H_ +#define LSTM_HLS_LSTM_SVD_EMULATOR_H_ + +#include "math_utils/activation_functions.h" + +#include "hls_stream.h" + +#include +#include + +namespace svd { + +/** + * @brief Emulator used to test the accuracy of the HLS accelerator. It + * allows for testing different design points without recompiling. + * + * @param[in] InputSize The input size + * @param[in] HiddenSize The hidden size + * @param[in] NumIter The number of refinement steps + * @param[in] Tu The number of tiles of u + * @param[in] ZTu The number of pruned tiles of u + * @param[in] Tv The number of tiles of v + * @param[in] ZTv The number of pruned tiles of v + * @param[in] NumTimesteps The number timesteps (deprecated) + * @param[in] x The input data + * @param[in] cur_i_u The current i u + * @param[in] cur_i_s The current i s + * @param[in] cur_i_v The current i v + * @param[in] cur_i_unz The current i unz + * @param[in] cur_i_vnz The current i vnz + * @param[in] cur_f_u The current f u + * @param[in] cur_f_s The current f s + * @param[in] cur_f_v The current f v + * @param[in] cur_f_unz The current f unz + * @param[in] cur_f_vnz The current f vnz + * @param[in] cur_c_u The current c u + * @param[in] cur_c_s The current c s + * @param[in] cur_c_v The current c v + * @param[in] cur_c_unz The current c unz + * @param[in] cur_c_vnz The current c vnz + * @param[in] cur_o_u The current o u + * @param[in] cur_o_s The current o s + * @param[in] cur_o_v The current o v + * @param[in] cur_o_unz The current o unz + * @param[in] cur_o_vnz The current o vnz + * @param[in] rec_i_u The recurrent i u + * @param[in] rec_i_s The recurrent i s + * @param[in] rec_i_v The recurrent i v + * @param[in] rec_i_unz The recurrent i unz + * @param[in] rec_i_vnz The recurrent i vnz + * @param[in] rec_f_u The recurrent f u + * @param[in] rec_f_s The recurrent f s + * @param[in] rec_f_v The recurrent f v + * @param[in] rec_f_unz The recurrent f unz + * @param[in] rec_f_vnz The recurrent f vnz + * @param[in] rec_c_u The recurrent c u + * @param[in] rec_c_s The recurrent c s + * @param[in] rec_c_v The recurrent c v + * @param[in] rec_c_unz The recurrent c unz + * @param[in] rec_c_vnz The recurrent c vnz + * @param[in] rec_o_u The recurrent o u + * @param[in] rec_o_s The recurrent o s + * @param[in] rec_o_v The recurrent o v + * @param[in] rec_o_unz The recurrent o unz + * @param[in] rec_o_vnz The recurrent o vnz + * @param[in] bias The bias + * @param[in] c_prev The c previous + * @param[in] h_prev The h previous + * @param c_curr The c current + * @param h_curr The h current + * + * @tparam DataA Activation type + * @tparam DataW Weight type + * @tparam DataAcc Accumulation type + * @tparam DataMul Multiplication type + * @tparam TanhLutSize Size of the hard sigmoid LUT + */ +template +void LstmSvdSoftEmulator(const int InputSize, + const int HiddenSize, + const int NumIter, + const int Tu, + const int ZTu, + const int Tv, + const int ZTv, + const int NumTimesteps, + const DataA *x, + const DataW *cur_i_u, + const DataW *cur_i_s, + const DataW *cur_i_v, + const int *cur_i_unz, + const int *cur_i_vnz, + const DataW *cur_f_u, + const DataW *cur_f_s, + const DataW *cur_f_v, + const int *cur_f_unz, + const int *cur_f_vnz, + const DataW *cur_c_u, + const DataW *cur_c_s, + const DataW *cur_c_v, + const int *cur_c_unz, + const int *cur_c_vnz, + const DataW *cur_o_u, + const DataW *cur_o_s, + const DataW *cur_o_v, + const int *cur_o_unz, + const int *cur_o_vnz, + const DataW *rec_i_u, + const DataW *rec_i_s, + const DataW *rec_i_v, + const int *rec_i_unz, + const int *rec_i_vnz, + const DataW *rec_f_u, + const DataW *rec_f_s, + const DataW *rec_f_v, + const int *rec_f_unz, + const int *rec_f_vnz, + const DataW *rec_c_u, + const DataW *rec_c_s, + const DataW *rec_c_v, + const int *rec_c_unz, + const int *rec_c_vnz, + const DataW *rec_o_u, + const DataW *rec_o_s, + const DataW *rec_o_v, + const int *rec_o_unz, + const int *rec_o_vnz, + const DataW *bias, + DataA *c_prev, + DataA *h_prev, + DataA *c_curr, + DataA *h_curr) { + assert(Tu % 2 == 0); + assert(Tv % 2 == 0); + assert(Tu >= 8); + assert(Tv >= 8); + assert(Tu > ZTu); + assert(Tv > ZTv); + assert(NumIter % 2 == 0); + const DataW *u[8]; + const DataW *s[8]; + const DataW *v[8]; + const int *unz[8]; + const int *vnz[8]; + u[0] = cur_i_u; u[1] = cur_f_u; u[2] = cur_c_u; u[3] = cur_o_u; + u[4] = rec_i_u; u[5] = rec_f_u; u[6] = rec_c_u; u[7] = rec_o_u; + s[0] = cur_i_s; s[1] = cur_f_s; s[2] = cur_c_s; s[3] = cur_o_s; + s[4] = rec_i_s; s[5] = rec_f_s; s[6] = rec_c_s; s[7] = rec_o_s; + v[0] = cur_i_v; v[1] = cur_f_v; v[2] = cur_c_v; v[3] = cur_o_v; + v[4] = rec_i_v; v[5] = rec_f_v; v[6] = rec_c_v; v[7] = rec_o_v; + unz[0] = cur_i_unz; unz[1] = cur_f_unz; unz[2] = cur_c_unz; unz[3] = cur_o_unz; + unz[4] = rec_i_unz; unz[5] = rec_f_unz; unz[6] = rec_c_unz; unz[7] = rec_o_unz; + vnz[0] = cur_i_vnz; vnz[1] = cur_f_vnz; vnz[2] = cur_c_vnz; vnz[3] = cur_o_vnz; + vnz[4] = rec_i_vnz; vnz[5] = rec_f_vnz; vnz[6] = rec_c_vnz; vnz[7] = rec_o_vnz; + hls::stream **cur_out_fifo = new hls::stream*[4]; + hls::stream **rec_out_fifo = new hls::stream*[4]; + for (int i = 0; i < 4; ++i) { + cur_out_fifo[i] = new hls::stream[Tv]; + rec_out_fifo[i] = new hls::stream[Tv]; + } + DataAcc *u_acc[8]; + DataAcc **acc_buffer[8]; + DataMul xs_val[8] = {0}; + for (int i = 0; i < 8; ++i) { + u_acc[i] = new DataAcc[NumIter]; + } + DataA *h[2]; + DataA *c[2]; + if (NumTimesteps > 1) { + for (int i = 0; i < 2; ++i) { + h[i] = new DataA[HiddenSize]; + c[i] = new DataA[HiddenSize]; + std::memset(h[i], 0, HiddenSize * sizeof(DataA)); + std::memset(c[i], 0, HiddenSize * sizeof(DataA)); + } + } else { + c[0] = c_prev; + c[1] = c_curr; + h[0] = h_prev; + h[1] = h_curr; + } + for (int i = 0; i < 8; ++i) { + acc_buffer[i] = new DataAcc*[Tv]; + for (int j = 0; j < Tv; ++j) { + acc_buffer[i][j] = new DataAcc[HiddenSize / Tv]; + } + } + for (int t = 0; t < NumTimesteps; ++t) { + const int in_ptr = (t % 2) == 0 ? 0 : 1; + const int out_ptr = (t % 2) == 0 ? 1 : 0; + for (int i = 0; i < 8; ++i) { + std::memset(u_acc[i], 0, NumIter * sizeof(DataAcc)); + for (int j = 0; j < Tv; ++j) { + std::memset(acc_buffer[i][j], 0, HiddenSize / Tv * sizeof(DataAcc)); + } + } + for (int i = 0; i < NumIter; ++i) { + for (int q = 0; q < 4; ++q) { + for (int j = 0; j < Tu - ZTu; ++j) { + const int nz_idx = i * (Tu - ZTu) + j; + for (int k = 0; k < InputSize / Tu; ++k) { + int u_idx = i * InputSize / Tu * (Tu - ZTu) + j * InputSize / Tu + k; + u_acc[q][i] += x[t * InputSize + unz[q][nz_idx] * InputSize / Tu + k] * u[q][u_idx]; + } + for (int k = 0; k < HiddenSize / Tu; ++k) { + int u_idx = i * HiddenSize / Tu * (Tu - ZTu) + j * HiddenSize / Tu + k; + u_acc[q + 4][i] += h[in_ptr][unz[q + 4][nz_idx] * HiddenSize / Tu + k] * u[q + 4][u_idx]; + } + } + } + for (int q = 0; q < 8; ++q) { + xs_val[q] = s[q][i] * DataA(u_acc[q][i]); + for (int j = 0; j < Tv - ZTv; ++j) { + for (int k = 0; k < HiddenSize / Tv; ++k) { + const int v_idx = i * HiddenSize / Tv * (Tv - ZTv) + j * HiddenSize / Tv + k; + const int nz_idx = i * (Tv - ZTv) + j; + acc_buffer[q][vnz[q][nz_idx]][k] += xs_val[q] * v[q][v_idx]; + } + } + } + } + for (int i = 0; i < 4; ++i) { + for (int j = 0; j < Tv; ++j) { + for (int k = 0; k < HiddenSize / Tv; ++k) { + cur_out_fifo[i][j].write(acc_buffer[i][j][k]); + rec_out_fifo[i][j].write(acc_buffer[i + 4][j][k]); + } + } + } + NonLinearityUnitSoftware(HiddenSize, + Tv, 4, c[in_ptr], cur_out_fifo, rec_out_fifo, h[out_ptr], c[out_ptr], + true, bias); + } + if (NumTimesteps > 1) { + std::memcpy(h_curr, h[(NumTimesteps - 1) % 2 == 0 ? 1 : 0], HiddenSize * sizeof(DataA)); + } + for (int i = 0; i < 4; ++i) { + delete[] cur_out_fifo[i]; + delete[] rec_out_fifo[i]; + } + delete[] cur_out_fifo; + delete[] rec_out_fifo; + for (int i = 0; i < 8; ++i) { + delete[] u_acc[i]; + for (int j = 0; j < Tv; ++j) { + delete[] acc_buffer[i][j]; + } + delete[] acc_buffer[i]; + } + if (NumTimesteps > 1) { + for (int i = 0; i < 2; ++i) { + delete[] h[i]; + delete[] c[i]; + } + } +} + +} // svd + +#endif // LSTM_HLS_LSTM_SVD_EMULATOR_H_ \ No newline at end of file diff --git a/include/lstm/lstm_data_handler.h b/include/layers/lstm/lstm_data_handler.h similarity index 69% rename from include/lstm/lstm_data_handler.h rename to include/layers/lstm/lstm_data_handler.h index b927b60..811bf2b 100644 --- a/include/lstm/lstm_data_handler.h +++ b/include/layers/lstm/lstm_data_handler.h @@ -1,5 +1,5 @@ -#ifndef LSTM_DATA_HANDLER_H_ -#define LSTM_DATA_HANDLER_H_ +#ifndef LAYERS_LSTM_DATA_HANDLER_H_ +#define LAYERS_LSTM_DATA_HANDLER_H_ #include "math_utils/data_handler.h" #include "hls_utils/hls_metaprogramming.h" @@ -10,8 +10,10 @@ #include #include #include +#include +#include -namespace lstm { +namespace svd { template void ArrangeWeights(const int arrange_type, @@ -281,6 +283,7 @@ class AcceleratorBlob { int u_cur_size_; int u_rec_size_; int v_size_; + int s_size_; std::unordered_map cur_gates_; std::unordered_map rec_gates_; FixType* fix_u_cur_; @@ -289,38 +292,96 @@ class AcceleratorBlob { std::vector > x_; std::vector > h_; std::vector > c_; + std::vector > h_prev_; + std::vector > c_prev_; + std::vector > h_curr_; + std::vector > c_curr_; std::vector > bias_; std::vector fix_x_; std::vector fix_h_; std::vector fix_c_; + std::vector fix_h_prev_; + std::vector fix_c_prev_; + std::vector fix_h_curr_; + std::vector fix_c_curr_; std::vector fix_bias_; std::vector fix_s_; - ap_uint* fix_z_u_; - ap_uint* fix_z_v_; + ap_uint* fix_nz_u_; + ap_uint* fix_nz_v_; void InitVector(const bool init_random, const int num_inputs, const int size, std::vector& fix_y, std::vector >& y) { for (int i = 0; i < num_inputs; ++i) { fix_y[i] = svd::AllocateContiguously(size); for (int j = 0; j < size; ++j) { - FloatType tmp = init_random ? rand() : 0; + FloatType tmp = init_random ? 0.00001 * rand() : 0; y[i][j] = tmp; fix_y[i][j] = FixType(tmp); } } } + void ArrangeWeights(const int arrange_type, const int n_steps, + std::unordered_map& gates, + FixType* y) { + int idx = 0; + switch (arrange_type) { + case 0: + // NOTE: the following arrangement is: (N, G, E) + for (int i = 0; i < n_steps; ++i) { + for (auto g : gates) { + for (int j = 0; j < gates.get_u_pruned_size(); ++j) { + y[idx] = g.second->get_u()->fix_pruned_data()[j]; + ++idx; + } + } + } + break; + case 1: + // NOTE: the following arrangement is: (G, N, E) + for (auto g : gates) { + for (int i = 0; i < n_steps; ++i) { + for (int j = 0; j < gates.get_u_pruned_size(); ++j) { + y[idx] = g.second->get_u()->fix_pruned_data()[j]; + ++idx; + } + } + } + break; + case 2: + // NOTE: the following arrangement is: (N, E, G) + for (int i = 0; i < n_steps; ++i) { + for (int j = 0; j < gates.get_u_pruned_size(); ++j) { + for (auto g : gates) { + y[idx] = g.second->get_u()->fix_pruned_data()[j]; + ++idx; + } + } + } + break; + default: + // NOTE: the following arrangement is: (N, G, E) + for (int i = 0; i < n_steps; ++i) { + for (auto g : gates) { + for (int j = 0; j < gates.get_u_pruned_size(); ++j) { + y[idx] = g.second->get_u()->fix_pruned_data()[j]; + ++idx; + } + } + } + break; + } + } + public: AcceleratorBlob(const int num_inputs, const int refinement_steps, const int u_cur_size, const int u_rec_size, const int v_size, const int num_tiles_u, const int num_zero_tiles_u, const int num_tiles_v, const int num_zero_tiles_v) { + srand(time(NULL)); this->lstm_num_inputs_ = num_inputs; this->lstm_input_size_ = u_cur_size; this->lstm_output_size_ = v_size; - std::cout << this->lstm_num_inputs_ << std::endl; - std::cout << this->lstm_input_size_ << std::endl; - std::cout << this->lstm_output_size_ << std::endl; // NOTE: The following instantiation order is important and must be that. this->cur_gates_["o"] = new SvdVecType(num_inputs, refinement_steps, u_cur_size, v_size, num_tiles_u, num_zero_tiles_u, num_tiles_v, num_zero_tiles_v); this->cur_gates_["c"] = new SvdVecType(num_inputs, refinement_steps, u_cur_size, v_size, num_tiles_u, num_zero_tiles_u, num_tiles_v, num_zero_tiles_v); @@ -335,37 +396,34 @@ class AcceleratorBlob { const int kU_RecTotalSize = kNumGates / 2 * this->rec_gates_["i"]->get_u()->get_pruned_total_size(); const int kV_TotalSize = kNumGates * this->cur_gates_["i"]->get_v()->get_pruned_total_size(); const int kS_TotalSize = kNumGates * refinement_steps; - std::cout << "allocate stuff" << std::endl; this->fix_u_cur_ = svd::AllocateContiguously(kU_CurTotalSize); this->fix_u_rec_ = svd::AllocateContiguously(kU_RecTotalSize); this->fix_v_ = svd::AllocateContiguously(kV_TotalSize); this->u_cur_size_ = kU_CurTotalSize; this->u_rec_size_ = kU_RecTotalSize; this->v_size_ = kV_TotalSize; - this->fix_z_u_ = svd::AllocateContiguously>(kS_TotalSize); - this->fix_z_v_ = svd::AllocateContiguously>(kS_TotalSize); + this->s_size_ = kS_TotalSize; + this->fix_nz_u_ = svd::AllocateContiguously >(kS_TotalSize); + this->fix_nz_v_ = svd::AllocateContiguously >(kS_TotalSize); // NOTE: the following arrangement is: (R, E, G) const int kArrangementTypeREG = 2; const int kArrangementTypeRGE = 0; const int kU_CurLengthPruned = this->cur_gates_["i"]->get_u()->get_pruned_size(); const int kU_RecLengthPruned = this->rec_gates_["i"]->get_u()->get_pruned_size(); const int kV_LengthPruned = this->cur_gates_["i"]->get_v()->get_pruned_size(); - std::cout << "ArrangeWeights U cur" << std::endl; - lstm::ArrangeWeights(kArrangementTypeREG, refinement_steps, kU_CurLengthPruned, + svd::ArrangeWeights(kArrangementTypeREG, refinement_steps, kU_CurLengthPruned, this->cur_gates_["i"]->get_u()->fix_pruned_data(), this->cur_gates_["f"]->get_u()->fix_pruned_data(), this->cur_gates_["c"]->get_u()->fix_pruned_data(), this->cur_gates_["o"]->get_u()->fix_pruned_data(), this->fix_u_cur_); - std::cout << "ArrangeWeights U rec" << std::endl; - lstm::ArrangeWeights(kArrangementTypeREG, refinement_steps, kU_RecLengthPruned, + svd::ArrangeWeights(kArrangementTypeREG, refinement_steps, kU_RecLengthPruned, this->rec_gates_["i"]->get_u()->fix_pruned_data(), this->rec_gates_["f"]->get_u()->fix_pruned_data(), this->rec_gates_["c"]->get_u()->fix_pruned_data(), this->rec_gates_["o"]->get_u()->fix_pruned_data(), this->fix_u_rec_); - std::cout << "ArrangeWeights V" << std::endl; - lstm::ArrangeWeights(kArrangementTypeREG, refinement_steps, kV_LengthPruned, + svd::ArrangeWeights(kArrangementTypeREG, refinement_steps, kV_LengthPruned, kV_LengthPruned, this->cur_gates_["i"]->get_v()->fix_pruned_data(), this->cur_gates_["f"]->get_v()->fix_pruned_data(), @@ -376,45 +434,51 @@ class AcceleratorBlob { this->rec_gates_["c"]->get_v()->fix_pruned_data(), this->rec_gates_["o"]->get_v()->fix_pruned_data(), this->fix_v_); - std::cout << "arrange NZ" << std::endl; - lstm::ArrangeWeights(kArrangementTypeRGE, refinement_steps, 1, 1, - this->cur_gates_["i"]->get_u()->get_fix_z_idx(), - this->cur_gates_["f"]->get_u()->get_fix_z_idx(), - this->cur_gates_["c"]->get_u()->get_fix_z_idx(), - this->cur_gates_["o"]->get_u()->get_fix_z_idx(), - this->rec_gates_["i"]->get_u()->get_fix_z_idx(), - this->rec_gates_["f"]->get_u()->get_fix_z_idx(), - this->rec_gates_["c"]->get_u()->get_fix_z_idx(), - this->rec_gates_["o"]->get_u()->get_fix_z_idx(), - this->fix_z_u_); - lstm::ArrangeWeights(kArrangementTypeRGE, refinement_steps, 1, 1, - this->cur_gates_["i"]->get_v()->get_fix_z_idx(), - this->cur_gates_["f"]->get_v()->get_fix_z_idx(), - this->cur_gates_["c"]->get_v()->get_fix_z_idx(), - this->cur_gates_["o"]->get_v()->get_fix_z_idx(), - this->rec_gates_["i"]->get_v()->get_fix_z_idx(), - this->rec_gates_["f"]->get_v()->get_fix_z_idx(), - this->rec_gates_["c"]->get_v()->get_fix_z_idx(), - this->rec_gates_["o"]->get_v()->get_fix_z_idx(), - this->fix_z_v_); + svd::ArrangeWeights(kArrangementTypeRGE, refinement_steps, 1, 1, + this->cur_gates_["i"]->get_u()->get_fix_nz_idx(), + this->cur_gates_["f"]->get_u()->get_fix_nz_idx(), + this->cur_gates_["c"]->get_u()->get_fix_nz_idx(), + this->cur_gates_["o"]->get_u()->get_fix_nz_idx(), + this->rec_gates_["i"]->get_u()->get_fix_nz_idx(), + this->rec_gates_["f"]->get_u()->get_fix_nz_idx(), + this->rec_gates_["c"]->get_u()->get_fix_nz_idx(), + this->rec_gates_["o"]->get_u()->get_fix_nz_idx(), + this->fix_nz_u_); + svd::ArrangeWeights(kArrangementTypeRGE, refinement_steps, 1, 1, + this->cur_gates_["i"]->get_v()->get_fix_nz_idx(), + this->cur_gates_["f"]->get_v()->get_fix_nz_idx(), + this->cur_gates_["c"]->get_v()->get_fix_nz_idx(), + this->cur_gates_["o"]->get_v()->get_fix_nz_idx(), + this->rec_gates_["i"]->get_v()->get_fix_nz_idx(), + this->rec_gates_["f"]->get_v()->get_fix_nz_idx(), + this->rec_gates_["c"]->get_v()->get_fix_nz_idx(), + this->rec_gates_["o"]->get_v()->get_fix_nz_idx(), + this->fix_nz_v_); this->fix_x_.resize(num_inputs); this->fix_h_.resize(num_inputs); this->fix_c_.resize(num_inputs); + this->fix_h_curr_.resize(num_inputs); + this->fix_c_curr_.resize(num_inputs); + this->fix_h_prev_.resize(num_inputs); + this->fix_c_prev_.resize(num_inputs); this->fix_bias_.resize(num_inputs); - this->x_.resize(num_inputs, std::vector(this->lstm_input_size_)); this->h_.resize(num_inputs, std::vector(this->lstm_output_size_)); this->c_.resize(num_inputs, std::vector(this->lstm_output_size_)); + this->h_curr_.resize(num_inputs, std::vector(this->lstm_output_size_)); + this->c_curr_.resize(num_inputs, std::vector(this->lstm_output_size_)); + this->h_prev_.resize(num_inputs, std::vector(this->lstm_output_size_)); + this->c_prev_.resize(num_inputs, std::vector(this->lstm_output_size_)); this->bias_.resize(num_inputs, std::vector(kNumGates / 2 * this->lstm_output_size_)); - const bool init_random = true; this->InitVector(init_random, num_inputs, this->lstm_input_size_, this->fix_x_, this->x_); this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_h_, this->h_); this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_c_, this->c_); + this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_h_curr_, this->h_curr_); + this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_c_curr_, this->c_curr_); + this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_h_prev_, this->h_prev_); + this->InitVector(!init_random, num_inputs, this->lstm_output_size_, this->fix_c_prev_, this->c_prev_); this->InitVector(init_random, num_inputs, kNumGates / 2 * this->lstm_output_size_, this->fix_bias_, this->bias_); - - std::cout << "Arrange S" << std::endl; - for (int i = 0; i < num_inputs; ++i) { this->fix_s_.push_back(svd::AllocateContiguously(kS_TotalSize)); } @@ -442,10 +506,14 @@ class AcceleratorBlob { svd::FreeContiguously(this->fix_x_[i]); svd::FreeContiguously(this->fix_h_[i]); svd::FreeContiguously(this->fix_c_[i]); + svd::FreeContiguously(this->fix_h_curr_[i]); + svd::FreeContiguously(this->fix_c_curr_[i]); + svd::FreeContiguously(this->fix_h_prev_[i]); + svd::FreeContiguously(this->fix_c_prev_[i]); svd::FreeContiguously(this->fix_bias_[i]); } - svd::FreeContiguously(this->fix_z_u_); - svd::FreeContiguously(this->fix_z_v_); + svd::FreeContiguously(this->fix_nz_u_); + svd::FreeContiguously(this->fix_nz_v_); for (auto g : this->cur_gates_) { delete g.second; } @@ -454,17 +522,34 @@ class AcceleratorBlob { } } - void reset_lstm_outputs() { + void ResetLstmOutputs() { for (int i = 0; i < this->lstm_num_inputs_; ++i) { for (int j = 0; j < this->lstm_output_size_; ++j) { - h_[i][j] = 0; - c_[i][j] = 0; - fix_h_[i][j] = 0; - fix_c_[i][j] = 0; + this->h_[i][j] = 0; + this->c_[i][j] = 0; + this->h_curr_[i][j] = 0; + this->c_curr_[i][j] = 0; + this->h_prev_[i][j] = 0; + this->c_prev_[i][j] = 0; + this->fix_h_[i][j] = 0; + this->fix_c_[i][j] = 0; + this->fix_h_curr_[i][j] = 0; + this->fix_c_curr_[i][j] = 0; + this->fix_h_prev_[i][j] = 0; + this->fix_c_prev_[i][j] = 0; } } } + int get_lstm_input_size() { + return this->lstm_input_size_; + } + + int get_lstm_output_size() { + return this->lstm_output_size_; + } + + FixType* get_fix_u_cur() { return this->fix_u_cur_; } @@ -505,20 +590,44 @@ class AcceleratorBlob { return this->fix_h_[i]; } + FloatType* get_h(const int i) { + return this->h_[i].data(); + } + + FixType* get_fix_h_curr(const int i) { + return this->fix_h_curr_[i]; + } + + FixType* get_fix_h_prev(const int i) { + return this->fix_h_prev_[i]; + } + FixType* get_fix_c(const int i) { return this->fix_c_[i]; } + FixType* get_fix_c_curr(const int i) { + return this->fix_c_curr_[i]; + } + + FixType* get_fix_c_prev(const int i) { + return this->fix_c_prev_[i]; + } + FixType* get_fix_bias(const int i) { return this->fix_bias_[i]; } - ap_uint* get_fix_z_u() { - return this->fix_z_u_; + FloatType* get_bias(const int i) { + return this->bias_[i].data(); + } + + ap_uint* get_fix_nz_u() { + return this->fix_nz_u_; } - ap_uint* get_fix_z_v() { - return this->fix_z_v_; + ap_uint* get_fix_nz_v() { + return this->fix_nz_v_; } int get_u_cur_size() { @@ -533,8 +642,38 @@ class AcceleratorBlob { return this->v_size_; } + int get_s_size() { + return this->s_size_; + } + + FloatType* get_x(const int i) { + return this->x_[i].data(); + } + + int CountMismatches(FixType** x, const int verbose = 0) { + int num_errors = 0; + for (int i = 0; i < this->lstm_num_inputs_; ++i) { + for (int j = 0; j < this->lstm_output_size_; ++j) { + if (verbose > 0) { + std:: cout << j << ") hls/emulator: " << this->fix_h_curr_[i][j] << " / " << x[i][j]; + } + if (this->fix_h_curr_[i][j] != x[i][j]) { + ++num_errors; + if (verbose > 0) { + std:: cout << " <-- ERROR" << std::endl; + } + } else { + if (verbose > 0) { + std:: cout << std::endl; + } + } + } + } + return num_errors; + } + }; -} // lstm +} // svd -#endif // end LSTM_DATA_HANDLER_H_ \ No newline at end of file +#endif // end LAYERS_LSTM_DATA_HANDLER_H_ \ No newline at end of file diff --git a/include/lstm/sw/soft_lstm.h b/include/layers/lstm/sw/soft_lstm.h similarity index 96% rename from include/lstm/sw/soft_lstm.h rename to include/layers/lstm/sw/soft_lstm.h index 9104695..073a9ee 100644 --- a/include/lstm/sw/soft_lstm.h +++ b/include/layers/lstm/sw/soft_lstm.h @@ -36,8 +36,8 @@ * streams * *****************************************************************************/ -#ifndef LSTM_SW_LSTM_SOFTWARE_H_ -#define LSTM_SW_LSTM_SOFTWARE_H_ +#ifndef LAYERS_LSTM_SW_LSTM_SOFTWARE_H_ +#define LAYERS_LSTM_SW_LSTM_SOFTWARE_H_ #ifdef __cplusplus extern "C" @@ -85,4 +85,4 @@ void LstmUnbatched(const bool use_blas, const float *bias_o, float *out); -#endif // end LSTM_SW_LSTM_SOFTWARE_H_ \ No newline at end of file +#endif // end LAYERS_LSTM_SW_LSTM_SOFTWARE_H_ \ No newline at end of file diff --git a/include/lstm/sw/soft_lstm_svd.h b/include/layers/lstm/sw/soft_lstm_svd.h similarity index 68% rename from include/lstm/sw/soft_lstm_svd.h rename to include/layers/lstm/sw/soft_lstm_svd.h index e6927a2..46097e9 100644 --- a/include/lstm/sw/soft_lstm_svd.h +++ b/include/layers/lstm/sw/soft_lstm_svd.h @@ -1,5 +1,5 @@ -#ifndef LSTM_SW_SOFT_LSTM_SVD_H_ -#define LSTM_SW_SOFT_LSTM_SVD_H_ +#ifndef LAYERS_LSTM_SW_SOFT_LSTM_SVD_H_ +#define LAYERS_LSTM_SW_SOFT_LSTM_SVD_H_ #include "math_utils/blas_utils.h" #include "math_utils/activation_functions.h" @@ -17,7 +17,6 @@ #include #include #include -// using namespace Eigen; #endif #include @@ -29,29 +28,25 @@ #include #endif -#ifdef HLS_DESIGN #include "hls_math.h" +#ifdef AP_INT_MAX_W +#undef AP_INT_MAX_W #define AP_INT_MAX_W 4096 +#endif #include "ap_int.h" #define FIX8_INT_BIT 3 #define FIX16_INT_BIT 7 +namespace svd { + typedef half HalfD; typedef ap_fixed<8, FIX8_INT_BIT, AP_RND_ZERO, AP_SAT_SYM> Fix8D; typedef ap_fixed<16, FIX16_INT_BIT, AP_RND_ZERO, AP_SAT_SYM> Fix16D; typedef ap_fixed Accum8D; typedef ap_fixed Accum16D; typedef half AccumHalfD; -#else -typedef float HalfD; -typedef float Fix8D; -typedef float Fix16D; -typedef float Accum8D; -typedef float Accum16D; -typedef float AccumHalfD; -#endif // end HLS_DESIGN /* * @todo Using Eigen library is an attempt to using sparse matrixes @@ -64,22 +59,6 @@ typedef Eigen::Matrix Ma typedef Eigen::Triplet TripletD; #endif -#ifndef ALLOC - #ifdef SDS_DESIGN - #define ALLOC(x) sds_alloc(x) - #else - #define ALLOC(x) malloc(x) - #endif -#endif - -#ifndef FREE - #ifdef SDS_DESIGN - #define FREE(x) sds_free(x) - #else - #define FREE(x) free(x) - #endif -#endif - /** * @brief Used for performance comparisons against hardware designs. * @@ -370,7 +349,7 @@ void hls_copy_cast(const int n, const DtypeIn *a, DtypeOut *y) { } template -void SvdModel2LstmTemplatedLatencyCC(const int verbose, +void SvdModelLstmTemplatedLatencyCC(const int verbose, const T *x, const int num_samples, const int num_timesteps, @@ -512,7 +491,7 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, // TanH lookup table // =========================================================================== T tanh_table[TableSize]; - hls_init_tanh_table(tanh_table); + svd::hls_init_tanh_table(tanh_table); // =========================================================================== // NOTE: We need to 'transpose' u in order to generate the us matrix. This is @@ -521,52 +500,52 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, // BEFORE TRANSPOSE: s.shape = (n_steps) // BEFORE TRANSPOSE: u.shape = (n_steps, input_size) // BEFORE TRANSPOSE: us.shape = (n_steps, input_size) - hls_transpose(n_steps, input_size, cur_i_u, cur_i_u_T); - hls_transpose(n_steps, input_size, cur_f_u, cur_f_u_T); - hls_transpose(n_steps, input_size, cur_c_u, cur_c_u_T); - hls_transpose(n_steps, input_size, cur_o_u, cur_o_u_T); - hls_transpose(n_steps, hidden_size, rec_i_u, rec_i_u_T); - hls_transpose(n_steps, hidden_size, rec_f_u, rec_f_u_T); - hls_transpose(n_steps, hidden_size, rec_c_u, rec_c_u_T); - hls_transpose(n_steps, hidden_size, rec_o_u, rec_o_u_T); + svd::hls_transpose(n_steps, input_size, cur_i_u, cur_i_u_T); + svd::hls_transpose(n_steps, input_size, cur_f_u, cur_f_u_T); + svd::hls_transpose(n_steps, input_size, cur_c_u, cur_c_u_T); + svd::hls_transpose(n_steps, input_size, cur_o_u, cur_o_u_T); + svd::hls_transpose(n_steps, hidden_size, rec_i_u, rec_i_u_T); + svd::hls_transpose(n_steps, hidden_size, rec_f_u, rec_f_u_T); + svd::hls_transpose(n_steps, hidden_size, rec_c_u, rec_c_u_T); + svd::hls_transpose(n_steps, hidden_size, rec_o_u, rec_o_u_T); for (int i = 0; i < input_size; ++i) { - hls_mul(n_steps, &cur_i_u_T[i * n_steps], cur_i_s, &cur_i_us[i * n_steps]); - hls_mul(n_steps, &cur_f_u_T[i * n_steps], cur_f_s, &cur_f_us[i * n_steps]); - hls_mul(n_steps, &cur_c_u_T[i * n_steps], cur_c_s, &cur_c_us[i * n_steps]); - hls_mul(n_steps, &cur_o_u_T[i * n_steps], cur_o_s, &cur_o_us[i * n_steps]); + svd::hls_mul(n_steps, &cur_i_u_T[i * n_steps], cur_i_s, &cur_i_us[i * n_steps]); + svd::hls_mul(n_steps, &cur_f_u_T[i * n_steps], cur_f_s, &cur_f_us[i * n_steps]); + svd::hls_mul(n_steps, &cur_c_u_T[i * n_steps], cur_c_s, &cur_c_us[i * n_steps]); + svd::hls_mul(n_steps, &cur_o_u_T[i * n_steps], cur_o_s, &cur_o_us[i * n_steps]); } for (int i = 0; i < hidden_size; ++i) { - hls_mul(n_steps, &rec_i_u_T[i * n_steps], rec_i_s, &rec_i_us[i * n_steps]); - hls_mul(n_steps, &rec_f_u_T[i * n_steps], rec_f_s, &rec_f_us[i * n_steps]); - hls_mul(n_steps, &rec_c_u_T[i * n_steps], rec_c_s, &rec_c_us[i * n_steps]); - hls_mul(n_steps, &rec_o_u_T[i * n_steps], rec_o_s, &rec_o_us[i * n_steps]); + svd::hls_mul(n_steps, &rec_i_u_T[i * n_steps], rec_i_s, &rec_i_us[i * n_steps]); + svd::hls_mul(n_steps, &rec_f_u_T[i * n_steps], rec_f_s, &rec_f_us[i * n_steps]); + svd::hls_mul(n_steps, &rec_c_u_T[i * n_steps], rec_c_s, &rec_c_us[i * n_steps]); + svd::hls_mul(n_steps, &rec_o_u_T[i * n_steps], rec_o_s, &rec_o_us[i * n_steps]); } // =========================================================================== // Transpose back current v and current u vectors. // =========================================================================== // From (input_size, n_steps) to (n_steps, input_size) - hls_transpose(input_size, n_steps, cur_i_us, cur_i_u_T); - hls_transpose(input_size, n_steps, cur_f_us, cur_f_u_T); - hls_transpose(input_size, n_steps, cur_c_us, cur_c_u_T); - hls_transpose(input_size, n_steps, cur_o_us, cur_o_u_T); + svd::hls_transpose(input_size, n_steps, cur_i_us, cur_i_u_T); + svd::hls_transpose(input_size, n_steps, cur_f_us, cur_f_u_T); + svd::hls_transpose(input_size, n_steps, cur_c_us, cur_c_u_T); + svd::hls_transpose(input_size, n_steps, cur_o_us, cur_o_u_T); // From (n_steps, hidden_size) to (hidden_size, n_steps) - hls_transpose(n_steps, hidden_size, cur_i_v, cur_i_v_T); - hls_transpose(n_steps, hidden_size, cur_f_v, cur_f_v_T); - hls_transpose(n_steps, hidden_size, cur_c_v, cur_c_v_T); - hls_transpose(n_steps, hidden_size, cur_o_v, cur_o_v_T); + svd::hls_transpose(n_steps, hidden_size, cur_i_v, cur_i_v_T); + svd::hls_transpose(n_steps, hidden_size, cur_f_v, cur_f_v_T); + svd::hls_transpose(n_steps, hidden_size, cur_c_v, cur_c_v_T); + svd::hls_transpose(n_steps, hidden_size, cur_o_v, cur_o_v_T); // =========================================================================== // Transpose back recurrent v and recurrent u vectors. // =========================================================================== // From (hidden_size, n_steps) to (n_steps, hidden_size) - hls_transpose(hidden_size, n_steps, rec_i_us, rec_i_u_T); - hls_transpose(hidden_size, n_steps, rec_f_us, rec_f_u_T); - hls_transpose(hidden_size, n_steps, rec_c_us, rec_c_u_T); - hls_transpose(hidden_size, n_steps, rec_o_us, rec_o_u_T); + svd::hls_transpose(hidden_size, n_steps, rec_i_us, rec_i_u_T); + svd::hls_transpose(hidden_size, n_steps, rec_f_us, rec_f_u_T); + svd::hls_transpose(hidden_size, n_steps, rec_c_us, rec_c_u_T); + svd::hls_transpose(hidden_size, n_steps, rec_o_us, rec_o_u_T); // From (n_steps, hidden_size) to (hidden_size, n_steps) - hls_transpose(n_steps, hidden_size, rec_i_v, rec_i_v_T); - hls_transpose(n_steps, hidden_size, rec_f_v, rec_f_v_T); - hls_transpose(n_steps, hidden_size, rec_c_v, rec_c_v_T); - hls_transpose(n_steps, hidden_size, rec_o_v, rec_o_v_T); + svd::hls_transpose(n_steps, hidden_size, rec_i_v, rec_i_v_T); + svd::hls_transpose(n_steps, hidden_size, rec_f_v, rec_f_v_T); + svd::hls_transpose(n_steps, hidden_size, rec_c_v, rec_c_v_T); + svd::hls_transpose(n_steps, hidden_size, rec_o_v, rec_o_v_T); const int kSampleSize = num_timesteps * input_size; @@ -597,15 +576,15 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, for (int j = 0; j < num_timesteps; ++j) { #if defined(MULTITHREAD_DESIGN) && !defined(SDS_DESIGN) && !defined(__SYNTHESIS__) - std::thread cur_i_ux_thread(hls_gemv, n_steps, input_size, cur_i_u_T, &x[i * kSampleSize + j * input_size], cur_i_ux); - std::thread cur_f_ux_thread(hls_gemv, n_steps, input_size, cur_f_u_T, &x[i * kSampleSize + j * input_size], cur_f_ux); - std::thread cur_c_ux_thread(hls_gemv, n_steps, input_size, cur_c_u_T, &x[i * kSampleSize + j * input_size], cur_c_ux); - std::thread cur_o_ux_thread(hls_gemv, n_steps, input_size, cur_o_u_T, &x[i * kSampleSize + j * input_size], cur_o_ux); + std::thread cur_i_ux_thread(svd::hls_gemv, n_steps, input_size, cur_i_u_T, &x[i * kSampleSize + j * input_size], cur_i_ux); + std::thread cur_f_ux_thread(svd::hls_gemv, n_steps, input_size, cur_f_u_T, &x[i * kSampleSize + j * input_size], cur_f_ux); + std::thread cur_c_ux_thread(svd::hls_gemv, n_steps, input_size, cur_c_u_T, &x[i * kSampleSize + j * input_size], cur_c_ux); + std::thread cur_o_ux_thread(svd::hls_gemv, n_steps, input_size, cur_o_u_T, &x[i * kSampleSize + j * input_size], cur_o_ux); - std::thread rec_i_uh_thread(hls_gemv, n_steps, hidden_size, rec_i_u_T, &out[i * hidden_size], rec_i_uh); - std::thread rec_f_uh_thread(hls_gemv, n_steps, hidden_size, rec_f_u_T, &out[i * hidden_size], rec_f_uh); - std::thread rec_c_uh_thread(hls_gemv, n_steps, hidden_size, rec_c_u_T, &out[i * hidden_size], rec_c_uh); - std::thread rec_o_uh_thread(hls_gemv, n_steps, hidden_size, rec_o_u_T, &out[i * hidden_size], rec_o_uh); + std::thread rec_i_uh_thread(svd::hls_gemv, n_steps, hidden_size, rec_i_u_T, &out[i * hidden_size], rec_i_uh); + std::thread rec_f_uh_thread(svd::hls_gemv, n_steps, hidden_size, rec_f_u_T, &out[i * hidden_size], rec_f_uh); + std::thread rec_c_uh_thread(svd::hls_gemv, n_steps, hidden_size, rec_c_u_T, &out[i * hidden_size], rec_c_uh); + std::thread rec_o_uh_thread(svd::hls_gemv, n_steps, hidden_size, rec_o_u_T, &out[i * hidden_size], rec_o_uh); cur_i_ux_thread.join(); cur_f_ux_thread.join(); @@ -617,15 +596,15 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, rec_c_uh_thread.join(); rec_o_uh_thread.join(); - std::thread cur_i_y_thread(hls_gemv, hidden_size, n_steps, cur_i_v_T, cur_i_ux, cur_i_y); - std::thread cur_f_y_thread(hls_gemv, hidden_size, n_steps, cur_f_v_T, cur_f_ux, cur_f_y); - std::thread cur_c_y_thread(hls_gemv, hidden_size, n_steps, cur_c_v_T, cur_c_ux, cur_c_y); - std::thread cur_o_y_thread(hls_gemv, hidden_size, n_steps, cur_o_v_T, cur_o_ux, cur_o_y); + std::thread cur_i_y_thread(svd::hls_gemv, hidden_size, n_steps, cur_i_v_T, cur_i_ux, cur_i_y); + std::thread cur_f_y_thread(svd::hls_gemv, hidden_size, n_steps, cur_f_v_T, cur_f_ux, cur_f_y); + std::thread cur_c_y_thread(svd::hls_gemv, hidden_size, n_steps, cur_c_v_T, cur_c_ux, cur_c_y); + std::thread cur_o_y_thread(svd::hls_gemv, hidden_size, n_steps, cur_o_v_T, cur_o_ux, cur_o_y); - std::thread rec_i_y_thread(hls_gemv, hidden_size, n_steps, rec_i_v_T, rec_i_uh, rec_i_y); - std::thread rec_f_y_thread(hls_gemv, hidden_size, n_steps, rec_f_v_T, rec_f_uh, rec_f_y); - std::thread rec_c_y_thread(hls_gemv, hidden_size, n_steps, rec_c_v_T, rec_c_uh, rec_c_y); - std::thread rec_o_y_thread(hls_gemv, hidden_size, n_steps, rec_o_v_T, rec_o_uh, rec_o_y); + std::thread rec_i_y_thread(svd::hls_gemv, hidden_size, n_steps, rec_i_v_T, rec_i_uh, rec_i_y); + std::thread rec_f_y_thread(svd::hls_gemv, hidden_size, n_steps, rec_f_v_T, rec_f_uh, rec_f_y); + std::thread rec_c_y_thread(svd::hls_gemv, hidden_size, n_steps, rec_c_v_T, rec_c_uh, rec_c_y); + std::thread rec_o_y_thread(svd::hls_gemv, hidden_size, n_steps, rec_o_v_T, rec_o_uh, rec_o_y); cur_i_y_thread.join(); cur_f_y_thread.join(); @@ -644,54 +623,54 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, // is simmetrical, i.e. same transposed matrices logic. // ======================================================================= // us.T @ x - hls_gemv(n_steps, input_size, cur_i_u_T, &x[i * kSampleSize + j * input_size], cur_i_ux); - hls_gemv(n_steps, input_size, cur_f_u_T, &x[i * kSampleSize + j * input_size], cur_f_ux); - hls_gemv(n_steps, input_size, cur_c_u_T, &x[i * kSampleSize + j * input_size], cur_c_ux); - hls_gemv(n_steps, input_size, cur_o_u_T, &x[i * kSampleSize + j * input_size], cur_o_ux); + svd::hls_gemv(n_steps, input_size, cur_i_u_T, &x[i * kSampleSize + j * input_size], cur_i_ux); + svd::hls_gemv(n_steps, input_size, cur_f_u_T, &x[i * kSampleSize + j * input_size], cur_f_ux); + svd::hls_gemv(n_steps, input_size, cur_c_u_T, &x[i * kSampleSize + j * input_size], cur_c_ux); + svd::hls_gemv(n_steps, input_size, cur_o_u_T, &x[i * kSampleSize + j * input_size], cur_o_ux); // v.T @ xus - hls_gemv(hidden_size, n_steps, cur_i_v_T, cur_i_ux, cur_i_y); - hls_gemv(hidden_size, n_steps, cur_f_v_T, cur_f_ux, cur_f_y); - hls_gemv(hidden_size, n_steps, cur_c_v_T, cur_c_ux, cur_c_y); - hls_gemv(hidden_size, n_steps, cur_o_v_T, cur_o_ux, cur_o_y); + svd::hls_gemv(hidden_size, n_steps, cur_i_v_T, cur_i_ux, cur_i_y); + svd::hls_gemv(hidden_size, n_steps, cur_f_v_T, cur_f_ux, cur_f_y); + svd::hls_gemv(hidden_size, n_steps, cur_c_v_T, cur_c_ux, cur_c_y); + svd::hls_gemv(hidden_size, n_steps, cur_o_v_T, cur_o_ux, cur_o_y); // ======================================================================= // Recurrent LSTM gates // ======================================================================= // us.T @ h - hls_gemv(n_steps, hidden_size, rec_i_u_T, &out[i * hidden_size], rec_i_uh); - hls_gemv(n_steps, hidden_size, rec_f_u_T, &out[i * hidden_size], rec_f_uh); - hls_gemv(n_steps, hidden_size, rec_c_u_T, &out[i * hidden_size], rec_c_uh); - hls_gemv(n_steps, hidden_size, rec_o_u_T, &out[i * hidden_size], rec_o_uh); + svd::hls_gemv(n_steps, hidden_size, rec_i_u_T, &out[i * hidden_size], rec_i_uh); + svd::hls_gemv(n_steps, hidden_size, rec_f_u_T, &out[i * hidden_size], rec_f_uh); + svd::hls_gemv(n_steps, hidden_size, rec_c_u_T, &out[i * hidden_size], rec_c_uh); + svd::hls_gemv(n_steps, hidden_size, rec_o_u_T, &out[i * hidden_size], rec_o_uh); // v.T @ hus - hls_gemv(hidden_size, n_steps, rec_i_v_T, rec_i_uh, rec_i_y); - hls_gemv(hidden_size, n_steps, rec_f_v_T, rec_f_uh, rec_f_y); - hls_gemv(hidden_size, n_steps, rec_c_v_T, rec_c_uh, rec_c_y); - hls_gemv(hidden_size, n_steps, rec_o_v_T, rec_o_uh, rec_o_y); + svd::hls_gemv(hidden_size, n_steps, rec_i_v_T, rec_i_uh, rec_i_y); + svd::hls_gemv(hidden_size, n_steps, rec_f_v_T, rec_f_uh, rec_f_y); + svd::hls_gemv(hidden_size, n_steps, rec_c_v_T, rec_c_uh, rec_c_y); + svd::hls_gemv(hidden_size, n_steps, rec_o_v_T, rec_o_uh, rec_o_y); #endif // ======================================================================= // Non linearities // ======================================================================= - hls_add(hidden_size, cur_i_y, bias_i, i_cur_bias); - hls_add(hidden_size, cur_f_y, bias_f, f_cur_bias); - hls_add(hidden_size, cur_c_y, bias_c, c_cur_bias); - hls_add(hidden_size, cur_o_y, bias_o, o_cur_bias); - - hls_add(hidden_size, i_cur_bias, rec_i_y, i_sum); - hls_add(hidden_size, f_cur_bias, rec_f_y, f_sum); - hls_add(hidden_size, c_cur_bias, rec_c_y, c_sum); - hls_add(hidden_size, o_cur_bias, rec_o_y, o_sum); - - hls_hard_sigmoid(hidden_size, i_sum, i_gate); - hls_hard_sigmoid(hidden_size, f_sum, f_gate); - hls_hard_sigmoid(hidden_size, o_sum, o_gate); - hls_tanh(hidden_size, c_sum, tanh_table, c_sum_tanh); - hls_mul(hidden_size, c_sum_tanh, i_gate, c_lhs); - hls_mul(hidden_size, c, f_gate, c_rhs); - - hls_add(hidden_size, c_lhs, c_rhs, c); - hls_tanh(hidden_size, c, tanh_table, c_tanh); - hls_mul(hidden_size, c_tanh, o_gate, &out[i * hidden_size]); + svd::hls_add(hidden_size, cur_i_y, bias_i, i_cur_bias); + svd::hls_add(hidden_size, cur_f_y, bias_f, f_cur_bias); + svd::hls_add(hidden_size, cur_c_y, bias_c, c_cur_bias); + svd::hls_add(hidden_size, cur_o_y, bias_o, o_cur_bias); + + svd::hls_add(hidden_size, i_cur_bias, rec_i_y, i_sum); + svd::hls_add(hidden_size, f_cur_bias, rec_f_y, f_sum); + svd::hls_add(hidden_size, c_cur_bias, rec_c_y, c_sum); + svd::hls_add(hidden_size, o_cur_bias, rec_o_y, o_sum); + + svd::hls_hard_sigmoid(hidden_size, i_sum, i_gate); + svd::hls_hard_sigmoid(hidden_size, f_sum, f_gate); + svd::hls_hard_sigmoid(hidden_size, o_sum, o_gate); + svd::hls_tanh(hidden_size, c_sum, tanh_table, c_sum_tanh); + svd::hls_mul(hidden_size, c_sum_tanh, i_gate, c_lhs); + svd::hls_mul(hidden_size, c, f_gate, c_rhs); + + svd::hls_add(hidden_size, c_lhs, c_rhs, c); + svd::hls_tanh(hidden_size, c, tanh_table, c_tanh); + svd::hls_mul(hidden_size, c_tanh, o_gate, &out[i * hidden_size]); } } #ifdef SDS_DESIGN @@ -789,7 +768,7 @@ void SvdModel2LstmTemplatedLatencyCC(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmFix8(const int verbose, +void SvdModelLstmFix8(const int verbose, const Fix8D *x, const int num_samples, const int num_timesteps, @@ -829,7 +808,7 @@ void SvdModel2LstmFix8(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmFix16(const int verbose, +void SvdModelLstmFix16(const int verbose, const Fix16D *x, const int num_samples, const int num_timesteps, @@ -869,7 +848,7 @@ void SvdModel2LstmFix16(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmSoftware(const int verbose, +void SvdModelLstmSoftware(const int verbose, const bool use_blas, const int type, // 0:float, 1:fix8, 2:fix16 const float *x, @@ -998,7 +977,7 @@ void SvdModelEigenUnbatched(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmSoftwareBatched(const int verbose, +void SvdModelLstmSoftwareBatched(const int verbose, const bool use_blas, const float *x, // (num_samples, num_inputs, num_timesteps, input_size) const int num_inputs, @@ -1037,253 +1016,7 @@ void SvdModel2LstmSoftwareBatched(const int verbose, const float *bias_o, float *out); -/** - * @brief Emulator used to test the accuracy of the HLS accelerator. It - * allows for testing different design points without recompiling. - * - * @param[in] InputSize The input size - * @param[in] HiddenSize The hidden size - * @param[in] NumIter The number of refinement steps - * @param[in] Tu The number of tiles of u - * @param[in] ZTu The number of pruned tiles of u - * @param[in] Tv The number of tiles of v - * @param[in] ZTv The number of pruned tiles of v - * @param[in] NumTimesteps The number timesteps (deprecated) - * @param[in] x The input data - * @param[in] cur_i_u The current i u - * @param[in] cur_i_s The current i s - * @param[in] cur_i_v The current i v - * @param[in] cur_i_unz The current i unz - * @param[in] cur_i_vnz The current i vnz - * @param[in] cur_f_u The current f u - * @param[in] cur_f_s The current f s - * @param[in] cur_f_v The current f v - * @param[in] cur_f_unz The current f unz - * @param[in] cur_f_vnz The current f vnz - * @param[in] cur_c_u The current c u - * @param[in] cur_c_s The current c s - * @param[in] cur_c_v The current c v - * @param[in] cur_c_unz The current c unz - * @param[in] cur_c_vnz The current c vnz - * @param[in] cur_o_u The current o u - * @param[in] cur_o_s The current o s - * @param[in] cur_o_v The current o v - * @param[in] cur_o_unz The current o unz - * @param[in] cur_o_vnz The current o vnz - * @param[in] rec_i_u The recurrent i u - * @param[in] rec_i_s The recurrent i s - * @param[in] rec_i_v The recurrent i v - * @param[in] rec_i_unz The recurrent i unz - * @param[in] rec_i_vnz The recurrent i vnz - * @param[in] rec_f_u The recurrent f u - * @param[in] rec_f_s The recurrent f s - * @param[in] rec_f_v The recurrent f v - * @param[in] rec_f_unz The recurrent f unz - * @param[in] rec_f_vnz The recurrent f vnz - * @param[in] rec_c_u The recurrent c u - * @param[in] rec_c_s The recurrent c s - * @param[in] rec_c_v The recurrent c v - * @param[in] rec_c_unz The recurrent c unz - * @param[in] rec_c_vnz The recurrent c vnz - * @param[in] rec_o_u The recurrent o u - * @param[in] rec_o_s The recurrent o s - * @param[in] rec_o_v The recurrent o v - * @param[in] rec_o_unz The recurrent o unz - * @param[in] rec_o_vnz The recurrent o vnz - * @param[in] bias The bias - * @param[in] c_prev The c previous - * @param[in] h_prev The h previous - * @param c_curr The c current - * @param h_curr The h current - * - * @tparam DataA Activation type - * @tparam DataW Weight type - * @tparam DataAcc Accumulation type - * @tparam DataMul Multiplication type - * @tparam TanhLutSize Size of the hard sigmoid LUT - */ -template -void SoftSvdModel(const int InputSize, - const int HiddenSize, - const int NumIter, - const int Tu, - const int ZTu, - const int Tv, - const int ZTv, - const int NumTimesteps, - const DataA *x, - const DataW *cur_i_u, - const DataW *cur_i_s, - const DataW *cur_i_v, - const int *cur_i_unz, - const int *cur_i_vnz, - const DataW *cur_f_u, - const DataW *cur_f_s, - const DataW *cur_f_v, - const int *cur_f_unz, - const int *cur_f_vnz, - const DataW *cur_c_u, - const DataW *cur_c_s, - const DataW *cur_c_v, - const int *cur_c_unz, - const int *cur_c_vnz, - const DataW *cur_o_u, - const DataW *cur_o_s, - const DataW *cur_o_v, - const int *cur_o_unz, - const int *cur_o_vnz, - const DataW *rec_i_u, - const DataW *rec_i_s, - const DataW *rec_i_v, - const int *rec_i_unz, - const int *rec_i_vnz, - const DataW *rec_f_u, - const DataW *rec_f_s, - const DataW *rec_f_v, - const int *rec_f_unz, - const int *rec_f_vnz, - const DataW *rec_c_u, - const DataW *rec_c_s, - const DataW *rec_c_v, - const int *rec_c_unz, - const int *rec_c_vnz, - const DataW *rec_o_u, - const DataW *rec_o_s, - const DataW *rec_o_v, - const int *rec_o_unz, - const int *rec_o_vnz, - const DataW *bias, - DataA *c_prev, - DataA *h_prev, - DataA *c_curr, - DataA *h_curr) { - assert(Tu % 2 == 0); - assert(Tv % 2 == 0); - assert(Tu >= 8); - assert(Tv >= 8); - assert(Tu > ZTu); - assert(Tv > ZTv); - assert(NumIter % 2 == 0); - const DataW *u[8]; - const DataW *s[8]; - const DataW *v[8]; - const int *unz[8]; - const int *vnz[8]; - u[0] = cur_i_u; u[1] = cur_f_u; u[2] = cur_c_u; u[3] = cur_o_u; - u[4] = rec_i_u; u[5] = rec_f_u; u[6] = rec_c_u; u[7] = rec_o_u; - s[0] = cur_i_s; s[1] = cur_f_s; s[2] = cur_c_s; s[3] = cur_o_s; - s[4] = rec_i_s; s[5] = rec_f_s; s[6] = rec_c_s; s[7] = rec_o_s; - v[0] = cur_i_v; v[1] = cur_f_v; v[2] = cur_c_v; v[3] = cur_o_v; - v[4] = rec_i_v; v[5] = rec_f_v; v[6] = rec_c_v; v[7] = rec_o_v; - unz[0] = cur_i_unz; unz[1] = cur_f_unz; unz[2] = cur_c_unz; unz[3] = cur_o_unz; - unz[4] = rec_i_unz; unz[5] = rec_f_unz; unz[6] = rec_c_unz; unz[7] = rec_o_unz; - vnz[0] = cur_i_vnz; vnz[1] = cur_f_vnz; vnz[2] = cur_c_vnz; vnz[3] = cur_o_vnz; - vnz[4] = rec_i_vnz; vnz[5] = rec_f_vnz; vnz[6] = rec_c_vnz; vnz[7] = rec_o_vnz; - hls::stream **cur_out_fifo = new hls::stream*[4]; - hls::stream **rec_out_fifo = new hls::stream*[4]; - for (int i = 0; i < 4; ++i) { - cur_out_fifo[i] = new hls::stream[Tv]; - rec_out_fifo[i] = new hls::stream[Tv]; - } - DataAcc *u_acc[8]; - DataAcc **acc_buffer[8]; - DataMul xs_val[8] = {0}; - for (int i = 0; i < 8; ++i) { - u_acc[i] = new DataAcc[NumIter]; - } - DataA *h[2]; - DataA *c[2]; - if (NumTimesteps > 1) { - for (int i = 0; i < 2; ++i) { - h[i] = new DataA[HiddenSize]; - c[i] = new DataA[HiddenSize]; - std::memset(h[i], 0, HiddenSize * sizeof(DataA)); - std::memset(c[i], 0, HiddenSize * sizeof(DataA)); - } - } else { - c[0] = c_prev; - c[1] = c_curr; - h[0] = h_prev; - h[1] = h_curr; - } - for (int i = 0; i < 8; ++i) { - acc_buffer[i] = new DataAcc*[Tv]; - for (int j = 0; j < Tv; ++j) { - acc_buffer[i][j] = new DataAcc[HiddenSize / Tv]; - } - } - for (int t = 0; t < NumTimesteps; ++t) { - const int in_ptr = (t % 2) == 0 ? 0 : 1; - const int out_ptr = (t % 2) == 0 ? 1 : 0; - for (int i = 0; i < 8; ++i) { - std::memset(u_acc[i], 0, NumIter * sizeof(DataAcc)); - for (int j = 0; j < Tv; ++j) { - std::memset(acc_buffer[i][j], 0, HiddenSize / Tv * sizeof(DataAcc)); - } - } - for (int i = 0; i < NumIter; ++i) { - for (int q = 0; q < 4; ++q) { - for (int j = 0; j < Tu - ZTu; ++j) { - const int nz_idx = i * (Tu - ZTu) + j; - for (int k = 0; k < InputSize / Tu; ++k) { - int u_idx = i * InputSize / Tu * (Tu - ZTu) + j * InputSize / Tu + k; - u_acc[q][i] += x[t * InputSize + unz[q][nz_idx] * InputSize / Tu + k] * u[q][u_idx]; - } - for (int k = 0; k < HiddenSize / Tu; ++k) { - int u_idx = i * HiddenSize / Tu * (Tu - ZTu) + j * HiddenSize / Tu + k; - u_acc[q + 4][i] += h[in_ptr][unz[q + 4][nz_idx] * HiddenSize / Tu + k] * u[q + 4][u_idx]; - } - } - } - for (int q = 0; q < 8; ++q) { - xs_val[q] = s[q][i] * DataA(u_acc[q][i]); - for (int j = 0; j < Tv - ZTv; ++j) { - for (int k = 0; k < HiddenSize / Tv; ++k) { - const int v_idx = i * HiddenSize / Tv * (Tv - ZTv) + j * HiddenSize / Tv + k; - const int nz_idx = i * (Tv - ZTv) + j; - acc_buffer[q][vnz[q][nz_idx]][k] += xs_val[q] * v[q][v_idx]; - } - } - } - } - for (int i = 0; i < 4; ++i) { - for (int j = 0; j < Tv; ++j) { - for (int k = 0; k < HiddenSize / Tv; ++k) { - cur_out_fifo[i][j].write(acc_buffer[i][j][k]); - rec_out_fifo[i][j].write(acc_buffer[i + 4][j][k]); - } - } - } - NonLinearityUnitSoftware(HiddenSize, - Tv, 4, c[in_ptr], cur_out_fifo, rec_out_fifo, h[out_ptr], c[out_ptr], - true, bias); - } - if (NumTimesteps > 1) { - std::memcpy(h_curr, h[(NumTimesteps - 1) % 2 == 0 ? 1 : 0], HiddenSize * sizeof(DataA)); - } - for (int i = 0; i < 4; ++i) { - delete[] cur_out_fifo[i]; - delete[] rec_out_fifo[i]; - } - delete[] cur_out_fifo; - delete[] rec_out_fifo; - for (int i = 0; i < 8; ++i) { - delete[] u_acc[i]; - for (int j = 0; j < Tv; ++j) { - delete[] acc_buffer[i][j]; - } - delete[] acc_buffer[i]; - } - if (NumTimesteps > 1) { - for (int i = 0; i < 2; ++i) { - delete[] h[i]; - delete[] c[i]; - } - } -} -#endif // end LSTM_SW_SOFT_LSTM_SVD_H_ \ No newline at end of file +} // svd + +#endif // end LAYERS_LSTM_SW_SOFT_LSTM_SVD_H_ \ No newline at end of file diff --git a/include/lstm/hls/lstm_svd.h b/include/lstm/hls/lstm_svd.h deleted file mode 100644 index 0e8db4c..0000000 --- a/include/lstm/hls/lstm_svd.h +++ /dev/null @@ -1,143 +0,0 @@ -#ifndef LSTM_HLS_LSTM_SVD_H_ -#define LSTM_HLS_LSTM_SVD_H_ - -#include "svd_params.h" - -#ifdef SDS_DESIGN -// ============================================================================= -// Ports using DMAs -// ============================================================================= -#pragma SDS data copy(x1_port[0:INPUT_SIZE]) -#pragma SDS data copy(x2_port[0:INPUT_SIZE]) -#pragma SDS data copy(h_t1_prev_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(h_t2_prev_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(c_t1_prev_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(c_t2_prev_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(bias1_port[0:4*HIDDEN_SIZE]) -#pragma SDS data copy(bias2_port[0:4*HIDDEN_SIZE]) -#pragma SDS data copy(comb_v_port[0:NUM_ITERATIONS * 8]) -#pragma SDS data copy(comb_u_port[0:NUM_ITERATIONS * 8]) -#pragma SDS data copy(h_t1_curr_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(h_t2_curr_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(c_t1_curr_port[0:HIDDEN_SIZE]) -#pragma SDS data copy(c_t2_curr_port[0:HIDDEN_SIZE]) -// Data Movers -#pragma SDS data data_mover(x1_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(x2_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(h_t1_prev_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(h_t2_prev_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(c_t1_prev_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(c_t2_prev_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(bias1_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(bias2_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(comb_v_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(comb_u_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(h_t1_curr_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(h_t2_curr_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(c_t1_curr_port:AXIDMA_SIMPLE) -#pragma SDS data data_mover(c_t2_curr_port:AXIDMA_SIMPLE) -// Port mapping -// #pragma SDS data sys_port(x1_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(x2_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(h_t1_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(h_t2_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(c_t1_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(c_t2_prev_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(bias1_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(bias2_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(comb_v_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(comb_u_port:ps_e_S_AXI_HPC0_FPD) // Coherent HP port -// #pragma SDS data sys_port(h_t1_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port -// #pragma SDS data sys_port(h_t2_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port -// #pragma SDS data sys_port(c_t1_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port -// #pragma SDS data sys_port(c_t2_curr_port:ps_e_S_AXI_HPC1_FPD) // Coherent HP port -// ============================================================================= -// Weight ports not using DMAs -// ============================================================================= -// #pragma SDS data zero_copy(u_cur_port[0:NUM_ITERATIONS*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) -// #pragma SDS data zero_copy(u_rec_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) -// #pragma SDS data zero_copy(v_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)]) -// #pragma SDS data zero_copy(s1_port[0:NUM_ITERATIONS]) -// #pragma SDS data zero_copy(s2_port[0:NUM_ITERATIONS]) -// ============================================================================= -// Weight ports using DMAs -// ============================================================================= -#pragma SDS data copy(u_cur_port[0:NUM_ITERATIONS*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) -#pragma SDS data copy(u_rec_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)]) -#pragma SDS data copy(v_port[0:NUM_ITERATIONS*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)]) -#pragma SDS data copy(s1_port[0:NUM_ITERATIONS]) -#pragma SDS data copy(s2_port[0:NUM_ITERATIONS]) -// Platform Port Mapping, available options: -// - ACP Coherent ports: ps_e_S_AXI_HPC[0-1]_FPD -// - HP ports: ps_e_S_AXI_HP[0-3]_FPD -// #pragma SDS data sys_port(u_cur_port:ps_e_S_AXI_HP0_FPD) // HP2 -// #pragma SDS data sys_port(u_rec_port:ps_e_S_AXI_HP1_FPD) // HP3 -// #pragma SDS data sys_port(v_port:ps_e_S_AXI_HP2_FPD) // HP3 -// #pragma SDS data sys_port(s1_port:ps_e_S_AXI_HP3_FPD) // HP3 -// #pragma SDS data sys_port(s2_port:ps_e_S_AXI_HP3_FPD) // HP3 -// ============================================================================= -// Other Configurations -// ============================================================================= -// Compiler hint on allocation -#pragma SDS data mem_attribute(x1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(x2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(h_t1_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(h_t2_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(c_t1_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(c_t2_prev_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(u_cur_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(u_rec_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(v_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(s1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(s2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(bias1_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(bias2_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(comb_v_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(comb_u_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(h_t1_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(h_t2_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(c_t1_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -#pragma SDS data mem_attribute(c_t2_curr_port:PHYSICAL_CONTIGUOUS|NON_CACHEABLE) -// NOTE: All ports are accessed sequentially. -#pragma SDS data access_pattern(x1_port:SEQUENTIAL) -#pragma SDS data access_pattern(x2_port:SEQUENTIAL) -#pragma SDS data access_pattern(h_t1_prev_port:SEQUENTIAL) -#pragma SDS data access_pattern(h_t2_prev_port:SEQUENTIAL) -#pragma SDS data access_pattern(c_t1_prev_port:SEQUENTIAL) -#pragma SDS data access_pattern(c_t2_prev_port:SEQUENTIAL) -#pragma SDS data access_pattern(u_cur_port:SEQUENTIAL) -#pragma SDS data access_pattern(u_rec_port:SEQUENTIAL) -#pragma SDS data access_pattern(v_port:SEQUENTIAL) -#pragma SDS data access_pattern(s1_port:SEQUENTIAL) -#pragma SDS data access_pattern(s2_port:SEQUENTIAL) -#pragma SDS data access_pattern(bias1_port:SEQUENTIAL) -#pragma SDS data access_pattern(bias2_port:SEQUENTIAL) -#pragma SDS data access_pattern(comb_v_port:SEQUENTIAL) -#pragma SDS data access_pattern(comb_u_port:SEQUENTIAL) -#pragma SDS data access_pattern(h_t1_curr_port:SEQUENTIAL) -#pragma SDS data access_pattern(h_t2_curr_port:SEQUENTIAL) -#pragma SDS data access_pattern(c_t1_curr_port:SEQUENTIAL) -#pragma SDS data access_pattern(c_t2_curr_port:SEQUENTIAL) -#endif // end SDS_DESIGN -void SvdModel2LstmSDSoCV2( - const svd::ActivationD x1_port[INPUT_SIZE], - const svd::ActivationD x2_port[INPUT_SIZE], - const svd::ActivationD h_t1_prev_port[HIDDEN_SIZE], - const svd::ActivationD h_t2_prev_port[HIDDEN_SIZE], - const svd::ActivationD c_t1_prev_port[HIDDEN_SIZE], - const svd::ActivationD c_t2_prev_port[HIDDEN_SIZE], - const ap_uint *u_cur_port, // [NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], - const ap_uint *u_rec_port, // [NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], - const ap_uint *v_port, // [NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)], - const ap_uint *s1_port, // [NUM_ITERATIONS*8], - const ap_uint *s2_port, // [NUM_ITERATIONS*8], - const svd::WeightD bias1_port[4 * HIDDEN_SIZE], - const svd::WeightD bias2_port[4 * HIDDEN_SIZE], - const ap_uint comb_v_port[NUM_ITERATIONS * 8], - const ap_uint comb_u_port[NUM_ITERATIONS * 8], - svd::ActivationD h_t1_curr_port[HIDDEN_SIZE], - svd::ActivationD h_t2_curr_port[HIDDEN_SIZE], - svd::ActivationD c_t1_curr_port[HIDDEN_SIZE], - svd::ActivationD c_t2_curr_port[HIDDEN_SIZE]); - -#endif // end LSTM_HLS_LSTM_SVD_H_ \ No newline at end of file diff --git a/include/math_utils/activation_functions.h b/include/math_utils/activation_functions.h index 08c72bf..afa1dff 100644 --- a/include/math_utils/activation_functions.h +++ b/include/math_utils/activation_functions.h @@ -5,6 +5,9 @@ #include "hls_stream.h" #include "assert.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif #include @@ -144,9 +147,9 @@ void NonLinearityUnitSoftware(const int VectLength, assert(NumGates >= 4); DataW tanh_table[TableSize]; InitTanhTable(tanh_table); - const int kNumElemsTile = VectLength / NumTiles; + const int kTileSize = VectLength / NumTiles; for(int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { + for (int j = 0; j < kTileSize; ++j) { // ======================================================================= // Python (Keras) Implementation: // i = self.hard_sigm(x_i + K.dot(h_tm1_i, self.recurrent_kernel_i)) @@ -160,10 +163,10 @@ void NonLinearityUnitSoftware(const int VectLength, DataA c_gate = 0; DataA o_gate = 0; if (has_bias) { - i_gate = cur_gate_stream[0][i].read() + rec_gate_stream[0][i].read() + bias[0 * VectLength + i * kNumElemsTile + j]; - f_gate = cur_gate_stream[1][i].read() + rec_gate_stream[1][i].read() + bias[1 * VectLength + i * kNumElemsTile + j]; - c_gate = cur_gate_stream[2][i].read() + rec_gate_stream[2][i].read() + bias[2 * VectLength + i * kNumElemsTile + j]; - o_gate = cur_gate_stream[3][i].read() + rec_gate_stream[3][i].read() + bias[3 * VectLength + i * kNumElemsTile + j]; + i_gate = cur_gate_stream[0][i].read() + rec_gate_stream[0][i].read() + bias[0 * VectLength + i * kTileSize + j]; + f_gate = cur_gate_stream[1][i].read() + rec_gate_stream[1][i].read() + bias[1 * VectLength + i * kTileSize + j]; + c_gate = cur_gate_stream[2][i].read() + rec_gate_stream[2][i].read() + bias[2 * VectLength + i * kTileSize + j]; + o_gate = cur_gate_stream[3][i].read() + rec_gate_stream[3][i].read() + bias[3 * VectLength + i * kTileSize + j]; } else { i_gate = cur_gate_stream[0][i].read() + rec_gate_stream[0][i].read(); f_gate = cur_gate_stream[1][i].read() + rec_gate_stream[1][i].read(); @@ -174,12 +177,12 @@ void NonLinearityUnitSoftware(const int VectLength, const auto sigma_f = HardSigmoid(f_gate); const auto sigma_o = HardSigmoid(o_gate); const auto tanh_cell = TanH(c_gate, tanh_table); - const auto c_lhs = sigma_f * c_t_prev[i * kNumElemsTile + j]; + const auto c_lhs = sigma_f * c_t_prev[i * kTileSize + j]; const auto c_t_tile = c_lhs + sigma_i * tanh_cell; - c_t[i * kNumElemsTile + j] = c_t_tile; + c_t[i * kTileSize + j] = c_t_tile; const auto c_tanh = TanH(c_t_tile, tanh_table); const auto h_t_tile = sigma_o * c_tanh; - h[i * kNumElemsTile + j] = h_t_tile; + h[i * kTileSize + j] = h_t_tile; } } } @@ -239,6 +242,7 @@ void LstmNonLinearFunctions(const bool has_bias, const ActivationType c_prev, ActivationType &c_curr, ActivationType &h_curr) { +#pragma HLS FUNCTION_INSTANTIATE variable=has_bias #pragma HLS PIPELINE II=1 ActivationType i_gate = 0; ActivationType f_gate = 0; @@ -249,19 +253,19 @@ void LstmNonLinearFunctions(const bool has_bias, f_gate = cur_gate_f + rec_gate_f + bias_f; c_gate = cur_gate_c + rec_gate_c + bias_c; o_gate = cur_gate_o + rec_gate_o + bias_o; -#pragma HLS RESOURCE variable=i_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=f_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=c_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=o_gate core=AddSub_DSP latency=3 +#pragma HLS RESOURCE variable=i_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=f_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=c_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=o_gate core=AddSub_DSP // latency=3 } else { i_gate = cur_gate_i + rec_gate_i; f_gate = cur_gate_f + rec_gate_f; o_gate = cur_gate_c + rec_gate_c; c_gate = cur_gate_o + rec_gate_o; -#pragma HLS RESOURCE variable=i_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=f_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=c_gate core=AddSub_DSP latency=3 -#pragma HLS RESOURCE variable=o_gate core=AddSub_DSP latency=3 +#pragma HLS RESOURCE variable=i_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=f_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=c_gate core=AddSub_DSP // latency=3 +#pragma HLS RESOURCE variable=o_gate core=AddSub_DSP // latency=3 } const auto sigma_i = HardSigmoid(i_gate); @@ -281,6 +285,135 @@ void LstmNonLinearFunctions(const bool has_bias, h_curr = h_reg; } + +#ifdef __VITIS_HLS__ +/** + * @brief LSTM non-linearity function to be applied to each output element. + * It implements the following Python (Keras) implementation: + * + * i = self.recurrent_activation(x_i + K.dot(h_tm1_i, + * self.recurrent_kernel_i)) + * f = self.recurrent_activation(x_f + K.dot(h_tm1_f, + * self.recurrent_kernel_f)) + * c = f * c_tm1 + i * self.activation(x_c + K.dot(h_tm1_c, + * self.recurrent_kernel_c)) + * o = self.recurrent_activation(x_o + K.dot(h_tm1_o, + * self.recurrent_kernel_o)) + * h = o * self.activation(c) + * + * @param[in] has_bias Indicates if bias is present. + * @param[in] cur_gate_i The current gate i element + * @param[in] cur_gate_f The current gate f element + * @param[in] cur_gate_c The current gate c element + * @param[in] cur_gate_o The current gate o element + * @param[in] rec_gate_i The recurrent gate i element + * @param[in] rec_gate_f The recurrent gate f element + * @param[in] rec_gate_c The recurrent gate c element + * @param[in] rec_gate_o The recurrent gate o element + * @param[in] bias_i The bias i element + * @param[in] bias_f The bias f element + * @param[in] bias_c The bias c element + * @param[in] bias_o The bias o element + * @param[in] c_prev The previous c (cell) state + * @param c_curr The current c (cell) state + * @param h_curr The h current + * + * @tparam ActivationType The activation type + * @tparam WeightType The weight type + * @tparam LutSize The tanh LUT size: having it templated helps + * inferring a ROM + */ +template +void LstmVectNonLinearFunctions(const bool has_bias, + const hls::vector cur_gate_i, + const hls::vector cur_gate_f, + const hls::vector cur_gate_c, + const hls::vector cur_gate_o, + const hls::vector rec_gate_i, + const hls::vector rec_gate_f, + const hls::vector rec_gate_c, + const hls::vector rec_gate_o, + const hls::vector bias_i, + const hls::vector bias_f, + const hls::vector bias_c, + const hls::vector bias_o, + const hls::vector c_prev, + const hls::vector &c_curr, + const hls::vector &h_curr) { +#pragma HLS FUNCTION_INSTANTIATE variable=has_bias +#pragma HLS PIPELINE II=1 + const hls::vector i_gate; + const hls::vector f_gate; + const hls::vector c_gate; + const hls::vector o_gate; + if (has_bias) { + i_gate = cur_gate_i + rec_gate_i + bias_i; + f_gate = cur_gate_f + rec_gate_f + bias_f; + c_gate = cur_gate_c + rec_gate_c + bias_c; + o_gate = cur_gate_o + rec_gate_o + bias_o; + } else { + i_gate = cur_gate_i + rec_gate_i; + f_gate = cur_gate_f + rec_gate_f; + o_gate = cur_gate_c + rec_gate_c; + c_gate = cur_gate_o + rec_gate_o; + } +#pragma HLS BIND_OP variable=i_gate op=add impl=dsp +#pragma HLS BIND_OP variable=f_gate op=add impl=dsp +#pragma HLS BIND_OP variable=c_gate op=add impl=dsp +#pragma HLS BIND_OP variable=o_gate op=add impl=dsp + hls::vector sigma_i; + hls::vector sigma_f; + hls::vector sigma_o; + hls::vector tanh_cell; + hls::vector c_tanh; + for (int i = 0; i < N; ++i) { + sigma_i[i] = HardSigmoid(i_gate[i]); + sigma_f[i] = HardSigmoid(f_gate[i]); + sigma_o[i] = HardSigmoid(o_gate[i]); + tanh_cell[i] = TanH(c_gate[i]); + } + const auto c_lhs = sigma_f * c_prev; + const auto c_reg = c_lhs + sigma_i * tanh_cell; +#pragma HLS BIND_OP variable=c_lhs op=add impl=dsp +#pragma HLS BIND_OP variable=c_reg op=add impl=dsp + c_curr = c_reg; + for (int i = 0; i < N; ++i) { + c_tanh[i] = TanH(c_reg[i]); + } + const auto h_reg = sigma_o * c_tanh; +#pragma HLS BIND_OP variable=h_reg op=mul impl=dsp // latency=3 + h_curr = h_reg; +} +#endif // end __VITIS_HLS__ + + + +/** + * @brief Processing element used in SvdLstm. Deprecated. + * + * @deprecated Old inplementation, not flexible enough. + * + * @param[in] size The size + * @param[in] c_t_prev The c t previous + * @param[in] cur_gate_i The current gate i + * @param[in] cur_gate_f The current gate f + * @param[in] cur_gate_c The current gate c + * @param[in] cur_gate_o The current gate o + * @param[in] rec_gate_i The record gate i + * @param[in] rec_gate_f The record gate f + * @param[in] rec_gate_c The record gate c + * @param[in] rec_gate_o The record gate o + * @param h { parameter_description } + * @param c_t { parameter_description } + * @param[in] has_bias Indicates if bias + * @param[in] i_bias I bias + * @param[in] f_bias The f bias + * @param[in] c_bias The c bias + * @param[in] o_bias The o bias + * + * @tparam A { description } + * @tparam W { description } + */ template void NonLinearityUnitPE(const int size, const A *c_t_prev, @@ -328,8 +461,10 @@ void NonLinearityUnitPE(const int size, /** * @brief Sub module to apply non linearities in parallel. + * @deprecated This function has been included in NonLinearityUnit. * - * @param[in] c_t_prev The previous LSTM cell state (internal internal) + * @param[in] c_t_prev_stream The previous LSTM cell state (internal + * internal) * @param current_gate_i_stream The current gate i stream * @param current_gate_f_stream The current gate f stream * @param current_gate_c_stream The current gate c stream @@ -338,30 +473,42 @@ void NonLinearityUnitPE(const int size, * @param recurrent_gate_f_stream The recurrent gate f stream * @param recurrent_gate_c_stream The recurrent gate c stream * @param recurrent_gate_o_stream The recurrent gate o stream - * @param h The LSTM output - * @param c_t The current LSTM cell state t + * @param h_stream The h stream + * @param c_t_stream The c t stream + * @param[in] has_bias Indicates if bias + * @param i_bias_stream I bias stream + * @param f_bias_stream The f bias stream + * @param c_bias_stream The c bias stream + * @param o_bias_stream The o bias stream + * @param h The LSTM output + * @param c_t The current LSTM cell state t * - * @tparam VectLength The output dimension - * @tparam NumTiles The number of tiles the output is divided into. + * @tparam NumElemsTile The number of tiles the output is + * divided into. + * @tparam VectLength The output dimension */ template -void NonLinearityUnitTile(const svd::ActivationD *c_t_prev, - svd::ActivationStream ¤t_gate_i_stream, - svd::ActivationStream ¤t_gate_f_stream, - svd::ActivationStream ¤t_gate_c_stream, - svd::ActivationStream ¤t_gate_o_stream, - svd::ActivationStream &recurrent_gate_i_stream, - svd::ActivationStream &recurrent_gate_f_stream, - svd::ActivationStream &recurrent_gate_c_stream, - svd::ActivationStream &recurrent_gate_o_stream, - svd::ActivationD *h, - svd::ActivationD *c_t, +void NonLinearityUnitTile(svd::ActivationStream& c_t_prev_stream, + svd::ActivationStream& current_gate_i_stream, + svd::ActivationStream& current_gate_f_stream, + svd::ActivationStream& current_gate_c_stream, + svd::ActivationStream& current_gate_o_stream, + svd::ActivationStream& recurrent_gate_i_stream, + svd::ActivationStream& recurrent_gate_f_stream, + svd::ActivationStream& recurrent_gate_c_stream, + svd::ActivationStream& recurrent_gate_o_stream, + svd::ActivationStream& h_stream, + svd::ActivationStream& c_t_stream, const bool has_bias = false, svd::WeightStream *i_bias_stream = nullptr, svd::WeightStream *f_bias_stream = nullptr, svd::WeightStream *c_bias_stream = nullptr, svd::WeightStream *o_bias_stream = nullptr) { +#ifndef __VITIS_HLS__ #pragma HLS INLINE off +#else +#pragma HLS INLINE +#endif // =========================================================================== // Initialize the lookup table // =========================================================================== @@ -384,137 +531,127 @@ void NonLinearityUnitTile(const svd::ActivationD *c_t_prev, svd::ActivationD rec_f = recurrent_gate_f_stream.read(); svd::ActivationD rec_c = recurrent_gate_c_stream.read(); svd::ActivationD rec_o = recurrent_gate_o_stream.read(); - WeightD i_bias_reg = 0; - WeightD f_bias_reg = 0; - WeightD c_bias_reg = 0; - WeightD o_bias_reg = 0; + WeightD i_bias = 0; + WeightD f_bias = 0; + WeightD c_bias = 0; + WeightD o_bias = 0; if (has_bias) { - i_bias_reg = i_bias_stream->read(); - f_bias_reg = f_bias_stream->read(); - c_bias_reg = c_bias_stream->read(); - o_bias_reg = o_bias_stream->read(); + i_bias = i_bias_stream->read(); + f_bias = f_bias_stream->read(); + c_bias = c_bias_stream->read(); + o_bias = o_bias_stream->read(); } - LstmNonLinearFunctions(has_bias, + auto c_t_prev = c_t_prev_stream.read(); + svd::ActivationD c_t; + svd::ActivationD h; + svd::LstmNonLinearFunctions(has_bias, cur_i, cur_f, cur_c, cur_o, rec_i, rec_f, rec_c, rec_o, - i_bias_reg, f_bias_reg, c_bias_reg, o_bias_reg, - c_t_prev[i], c_t[i], h[i]); + i_bias, f_bias, c_bias, o_bias, + c_t_prev, c_t, h); + c_t_stream.write(c_t); + h_stream.write(h); } } template void NonLinearityUnit(const svd::ActivationD *c_t_prev, - svd::ActivationStream (¤t_gate_stream)[NumGates][VectLength / NumTiles], - svd::ActivationStream (&recurrent_gate_stream)[NumGates][VectLength / NumTiles], + svd::ActivationStream (&cur_gate_stream)[NumGates][VectLength / NumTiles], + svd::ActivationStream (&rec_gate_stream)[NumGates][VectLength / NumTiles], svd::ActivationD *h, svd::ActivationD *c_t, const bool has_bias = false, const WeightD *bias_port = nullptr) { +#pragma HLS FUNCTION_INSTANTIATE variable=has_bias #pragma HLS INLINE -// #pragma HLS INTERFACE ap_ctrl_none port=return #pragma HLS DATAFLOW assert(VectLength % NumTiles == 0); - assert(NumGates >= 4); - const int kNumElemsTile = VectLength / NumTiles; - // NOTE: There are kNumElemsTile different streams, which are read in round + assert(NumGates == 4); + const int kTileSize = VectLength / NumTiles; + // NOTE: There are kTileSize different streams, which are read in round // robin fashion. Their depth is then set as their number plus 50%. - const int kOutputStreamDepth = kNumElemsTile + kNumElemsTile / 2; - - svd::ActivationD h_t_curr_internal[kNumElemsTile][NumTiles]; - svd::ActivationD c_t_curr_internal[kNumElemsTile][NumTiles]; - svd::ActivationD c_t_prev_internal[kNumElemsTile][NumTiles]; + const int kOutputStreamDepth = kTileSize + kTileSize / 2; + svd::ActivationStream h_t_curr_internal[kTileSize]; + svd::ActivationStream c_t_curr_internal[kTileSize]; + svd::ActivationStream c_t_prev_internal[kTileSize]; + svd::WeightStream bias_streams[NumGates][kTileSize]; #pragma HLS ARRAY_PARTITION variable=h_t_curr_internal complete dim=1 #pragma HLS ARRAY_PARTITION variable=c_t_curr_internal complete dim=1 #pragma HLS ARRAY_PARTITION variable=c_t_prev_internal complete dim=1 #pragma HLS STREAM variable=h_t_curr_internal depth=NumTiles #pragma HLS STREAM variable=c_t_curr_internal depth=kOutputStreamDepth #pragma HLS STREAM variable=c_t_prev_internal depth=kOutputStreamDepth - - NonLinearityUnit_Read2_c_prev: + C_prev_DMA: for (int i = 0; i < NumTiles; ++i) { - NonLinearityUnit_Read_c_prev: - for (int j = 0; j < kNumElemsTile; ++j) { + for (int j = 0; j < kTileSize; ++j) { #pragma HLS PIPELINE II=1 - c_t_prev_internal[j][i] = c_t_prev[i * kNumElemsTile + j]; + c_t_prev_internal[j].write(c_t_prev[i * kTileSize + j]); } } - - svd::WeightStream i_bias_streams[kNumElemsTile]; - svd::WeightStream f_bias_streams[kNumElemsTile]; - svd::WeightStream c_bias_streams[kNumElemsTile]; - svd::WeightStream o_bias_streams[kNumElemsTile]; if (has_bias) { -#pragma HLS ARRAY_PARTITION variable=i_bias_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=f_bias_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=c_bias_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=o_bias_streams complete dim=1 -#pragma HLS STREAM variable=i_bias_streams depth=NumTiles -#pragma HLS STREAM variable=f_bias_streams depth=NumTiles -#pragma HLS STREAM variable=c_bias_streams depth=NumTiles -#pragma HLS STREAM variable=o_bias_streams depth=NumTiles - for (int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { -#pragma HLS PIPELINE II=1 - i_bias_streams[j].write(bias_port[i * kNumElemsTile + j]); - } - } - for (int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { -#pragma HLS PIPELINE II=1 - f_bias_streams[j].write(bias_port[VectLength + i * kNumElemsTile + j]); - } - } - for (int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { -#pragma HLS PIPELINE II=1 - c_bias_streams[j].write(bias_port[2 * VectLength + i * kNumElemsTile + j]); - } - } - for (int i = 0; i < NumTiles; ++i) { - for (int j = 0; j < kNumElemsTile; ++j) { +#pragma HLS ARRAY_PARTITION variable=bias_streams complete dim=0 +#pragma HLS STREAM variable=bias_streams depth=NumTiles + Bias_DMA: + for (int k = 0; k < NumGates; ++k) { // Expected in this order: i->f->c->o + for (int i = 0; i < NumTiles; ++i) { + for (int j = 0; j < kTileSize; ++j) { #pragma HLS PIPELINE II=1 - o_bias_streams[j].write(bias_port[3 * VectLength + i * kNumElemsTile + j]); - } + bias_streams[k][j].write(bias_port[k * VectLength + i * kTileSize + j]); + } + } } } - - NonLinearityUnit_Tile_Loop: - for(int i = 0; i < kNumElemsTile; ++i) { -#pragma HLS UNROLL - NonLinearityUnitTile(c_t_prev_internal[i], - current_gate_stream[0][i], - current_gate_stream[1][i], - current_gate_stream[2][i], - current_gate_stream[3][i], - recurrent_gate_stream[0][i], - recurrent_gate_stream[1][i], - recurrent_gate_stream[2][i], - recurrent_gate_stream[3][i], - h_t_curr_internal[i], - c_t_curr_internal[i], - has_bias, - &i_bias_streams[i], - &f_bias_streams[i], - &c_bias_streams[i], - &o_bias_streams[i]); - } - - NonLinearityUnit_Writeback2_h: - for (int i = 0; i < NumTiles; ++i) { - NonLinearityUnit_Writeback_h: - for (int j = 0; j < kNumElemsTile; ++j) { +// NonLinearityUnit_Tile_Loop: +// for(int i = 0; i < kTileSize; ++i) { +// #pragma HLS UNROLL +// svd::NonLinearityUnitTile(c_t_prev_internal[i], +// cur_gate_stream[0][i], cur_gate_stream[1][i], +// cur_gate_stream[2][i], cur_gate_stream[3][i], +// rec_gate_stream[0][i], rec_gate_stream[1][i], +// rec_gate_stream[2][i], rec_gate_stream[3][i], +// h_t_curr_internal[i], c_t_curr_internal[i], +// has_bias, &bias_streams[0][i], &bias_streams[1][i], +// &bias_streams[2][i], &bias_streams[3][i]); +// } + const int kTableSize = (FIX_WIDTH <= 16) ? 512 : 256; + // =========================================================================== + // Apply non-linearities to each vector element + // =========================================================================== + NonLinearityUnit_Elem_Loop: + for(int i = 0; i < NumTiles; ++i) { #pragma HLS PIPELINE II=1 - h[i * kNumElemsTile + j] = h_t_curr_internal[j][i]; + for(int j = 0; j < kTileSize; ++j) { + auto cur_i = cur_gate_stream[0][j].read(); + auto cur_f = cur_gate_stream[1][j].read(); + auto cur_c = cur_gate_stream[2][j].read(); + auto cur_o = cur_gate_stream[3][j].read(); + auto rec_i = rec_gate_stream[0][j].read(); + auto rec_f = rec_gate_stream[1][j].read(); + auto rec_c = rec_gate_stream[2][j].read(); + auto rec_o = rec_gate_stream[3][j].read(); + svd::WeightD i_bias, f_bias, c_bias, o_bias; + if (has_bias) { + i_bias = bias_streams[0][j].read(); + f_bias = bias_streams[1][j].read(); + c_bias = bias_streams[2][j].read(); + o_bias = bias_streams[3][j].read(); + } + auto c_t_prev = c_t_prev_internal[j].read(); + svd::ActivationD c_t, h; + svd::LstmNonLinearFunctions( + has_bias, cur_i, cur_f, cur_c, cur_o, rec_i, rec_f, rec_c, rec_o, + i_bias, f_bias, c_bias, o_bias, c_t_prev, c_t, h); + c_t_curr_internal[j].write(c_t); + h_t_curr_internal[j].write(h); } } - - NonLinearityUnit_Writeback2_c: + H_t_curr_DMA: for (int i = 0; i < NumTiles; ++i) { - NonLinearityUnit_Writeback_c: - for (int j = 0; j < kNumElemsTile; ++j) { + for (int j = 0; j < kTileSize; ++j) { #pragma HLS PIPELINE II=1 - c_t[i * kNumElemsTile + j] = c_t_curr_internal[j][i]; + h[i * kTileSize + j] = h_t_curr_internal[j].read(); + c_t[i * kTileSize + j] = c_t_curr_internal[j].read(); } } } diff --git a/include/math_utils/data_handler.h b/include/math_utils/data_handler.h index 30468c5..d3480d6 100644 --- a/include/math_utils/data_handler.h +++ b/include/math_utils/data_handler.h @@ -8,6 +8,9 @@ #include #include #include +#include +#include +#include #ifdef SDS_DESIGN #include @@ -36,6 +39,7 @@ namespace svd { template T* AllocateContiguously(const int size) { +#ifndef __SYNTHESIS__ T* tmp; try { tmp = (T*)ALLOC(size * sizeof(T)); @@ -49,6 +53,14 @@ T* AllocateContiguously(const int size) { throw except_alloc; } return tmp; +#else + T* tmp = (T*)ALLOC(size * sizeof(T)); + if (!tmp) { + std::cout << "[ERROR] Contiguous allocation failed." << std::endl; + exit(1); + } + return tmp; +#endif } template @@ -81,6 +93,9 @@ class VectorBlob { VectorBlob(const int refinement_steps, const int vector_size, const int num_tiles, const int num_zero_tiles) { assert(num_tiles >= 1); + assert(refinement_steps > 0); + assert(vector_size > 0); + assert(num_tiles > 0); this->num_tile_elems_ = vector_size / num_tiles; this->size_ = vector_size; this->pruned_size_ = this->num_tile_elems_ * (num_tiles - num_zero_tiles); @@ -121,7 +136,7 @@ class VectorBlob { this->z_idx_.push_back(j); } else { for (int k = 0; k < this->num_tile_elems_; ++k) { - FloatType tmp = rand(); + FloatType tmp = 0.00001 * rand(); this->data_.push_back(tmp); this->pruned_data_.push_back(tmp); this->fix_data_.push_back(FixType(tmp)); @@ -133,7 +148,7 @@ class VectorBlob { } } else { for (int i = 0; i < this->total_size_; ++i) { - FloatType tmp = rand(); + FloatType tmp = 0.00001 * rand(); this->data_.push_back(tmp); this->pruned_data_.push_back(tmp); this->fix_data_.push_back(FixType(tmp)); @@ -207,6 +222,10 @@ class VectorBlob { IdxType get_fix_nz_idx(const int refinement_step) { return this->fix_nz_idx_[refinement_step]; } + + int get_refinement_steps() { + return this->refinement_steps_; + } }; @@ -222,6 +241,7 @@ class SvdComponents { const int u_size, const int v_size, const int num_tiles_u, const int num_zero_tiles_u, const int num_tiles_v, const int num_zero_tiles_v) { + assert(num_inputs > 0); this->num_inputs_ = num_inputs; this->u_ = new VectorBlob(refinement_steps, u_size, num_tiles_u, num_zero_tiles_u); this->v_ = new VectorBlob(refinement_steps, v_size, num_tiles_v, num_zero_tiles_v); @@ -243,6 +263,22 @@ class SvdComponents { return this->v_; } + int get_u_size() { + return this->u_->get_size(); + } + + int get_v_size() { + return this->v_->get_size(); + } + + int get_u_pruned_size() { + return this->u_->get_pruned_size(); + } + + int get_v_pruned_size() { + return this->v_->get_pruned_size(); + } + std::vector > get_s() { return this->s_; } @@ -254,6 +290,10 @@ class SvdComponents { int get_num_inputs() { return this->num_inputs_; } + + int get_refinement_steps() { + return this->s_[0].get_refinement_steps(); + } }; } // svd diff --git a/include/svd_ip.h b/include/svd_ip.h index 32b9c90..4396134 100644 --- a/include/svd_ip.h +++ b/include/svd_ip.h @@ -4,14 +4,16 @@ #include "svd_params.h" #include "kernel/svd_kernel.h" +namespace svd { + template inline void SvdIP( const typename params::ActivationD x_port[params::N][params::I], - const typename params::UPortD u_port[params::PrunedSizeU], + const typename params::UPortD u_port[params::R * params::PrunedSizeU], const typename params::SPortD s_port[params::N][params::R], - const typename params::VPortD v_port[params::PrunedSizeV], - const typename params::UnzD nz_u_port[params::R * params::G], - const typename params::VnzD nz_v_port[params::R * params::G], + const typename params::VPortD v_port[params::R * params::PrunedSizeV], + const typename params::UnzD nz_u_port[params::G * params::R], + const typename params::VnzD nz_v_port[params::G * params::R], typename params::ActivationD y_port[params::N][params::G][params::H]) { #pragma HLS INLINE #pragma HLS DATAFLOW @@ -22,28 +24,19 @@ inline void SvdIP( svd::SvdStreams streams; svd::SvdBuffers buffers; SvdInDMA(x_port, u_port, s_port, v_port, nz_u_port, nz_v_port, streams, buffers); - SvdKernel(streams); + svd::SvdKernel(streams); SvdOutDMA(streams, y_port); } -const int N = 2; -const int I = 256; -const int H = 128; -const int R = 16; -const int Tu = 16; -const int Tv = 32; -const int ZTu = 8; -const int ZTv = 8; -const int G = 4; -typedef svd::SvdParameters svd_params; - void SvdIp2Inputs( const typename svd_params::ActivationD x_port[svd_params::N][svd_params::I], - const typename svd_params::UPortD u_port[svd_params::PrunedSizeU], + const typename svd_params::UPortD u_port[svd_params::R * svd_params::PrunedSizeU], const typename svd_params::SPortD s_port[svd_params::N][svd_params::R], - const typename svd_params::VPortD v_port[svd_params::PrunedSizeV], - const ap_uint nz_u_port[svd_params::N], - const ap_uint nz_v_port[svd_params::N], + const typename svd_params::VPortD v_port[svd_params::R * svd_params::PrunedSizeV], + const ap_uint nz_u_port[svd_params::G * svd_params::R], + const ap_uint nz_v_port[svd_params::G * svd_params::R], typename svd_params::ActivationD y_port[svd_params::N][svd_params::G][svd_params::H]); +} // svd + #endif // end SVD_IP_H_ \ No newline at end of file diff --git a/include/svd_params.h b/include/svd_params.h index ae77116..db408c2 100644 --- a/include/svd_params.h +++ b/include/svd_params.h @@ -2,12 +2,63 @@ #define SVD_PARAMS_H_ #include "hls_utils/hls_metaprogramming.h" +#include "dma/axis_lib.h" #include "ap_int.h" +#include "ap_axi_sdata.h" #include "hls_stream.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +#include namespace svd { +template +struct ParamsU { + static const int N = Ni; + static const int I = Ii; + static const int Tu = Tui; + static const int ZTu = ZTui; + static const int G = Gi; + static const int TuElems = I / Tu; + static const int TuBits = hlsutils::log2::value > 0 ? hlsutils::log2::value : 1; + typedef ap_uint UnzD; + typedef ap_uint UnzIdxD; + typedef Type ActivationD; + typedef Type WeightD; + typedef Type AccumulationD; + typedef hls::stream UnzS; + typedef hls::stream > UnzIdxS; + typedef hls::stream ActivationS; + typedef hls::stream WeightS; + typedef hls::stream AccumulationS; + typedef ap_uint::value * G> UPortD; + static const int PrunedSizeU = I / Tu * (Tu - ZTu); + static const int ActivationWidth = hlsutils::Bitwidth::value; + static const int WeightWidth = hlsutils::Bitwidth::value; + static const int AccumulationWidth = hlsutils::Bitwidth::value; + static const int VectTuAxiWidth = ActivationWidth * Tu; + static const int VectN_AxiWidth = ActivationWidth * N; + static const int VectG_AxiWidth = ActivationWidth * G; + static const int VectGN_AxiWidth = ActivationWidth * G * N; + typedef typename svd::AxiStreamPort::AxiuPacketType VectTuAxiPacketType; + typedef typename svd::AxiStreamPort::AxiuPacketType VectN_AxiPacketType; + typedef typename svd::AxiStreamPort::AxiuPacketType VectG_AxiPacketType; + typedef typename svd::AxiStreamPort::AxiuPacketType VectGN_AxiPacketType; + typedef typename svd::AxiStreamFifo::AxiuType VectTuAxiuType; + typedef typename svd::AxiStreamFifo::AxiuType VectN_AxiuType; + typedef typename svd::AxiStreamFifo::AxiuType VectG_AxiuType; + typedef typename svd::AxiStreamFifo::AxiuType VectGN_AxiuType; +#ifdef __VITIS_HLS__ + typedef hls::vector VectTuType; + typedef hls::vector VectN_Type; + typedef hls::vector VectG_Type; + typedef hls::vector VectGN_Type; +#endif +}; + template , @@ -27,8 +78,8 @@ struct SvdParameters { static const int PeV = H / Tv; static const int TuElems = I / Tu; static const int TvElems = H / Tv; - static const int TuBits = hls_utils::log2::value > 0 ? hls_utils::log2::value : 1; - static const int TvBits = hls_utils::log2::value > 0 ? hls_utils::log2::value : 1; + static const int TuBits = hlsutils::log2::value > 0 ? hlsutils::log2::value : 1; + static const int TvBits = hlsutils::log2::value > 0 ? hlsutils::log2::value : 1; typedef ap_uint UnzD; typedef ap_uint VnzD; typedef ap_uint UnzIdxD; @@ -43,15 +94,35 @@ struct SvdParameters { typedef hls::stream ActivationS; typedef hls::stream WeightS; typedef hls::stream AccumulationS; - typedef ap_uint::value * G> SPortD; - typedef ap_uint::value * G> UPortD; - typedef ap_uint::value * G> VPortD; - static const int PrunedSizeU = R * I / Tu * (Tu - ZTu); - static const int PrunedSizeV = R * H / Tv * (Tv - ZTv); + typedef ap_uint::value * G> SPortD; + typedef ap_uint::value * G> UPortD; + typedef ap_uint::value * G> VPortD; + static const int PrunedSizeU = I / Tu * (Tu - ZTu); + static const int PrunedSizeV = H / Tv * (Tv - ZTv); static const int SizeS = R * G; - static const int ActivationWidth = hls_utils::Bitwidth::value; - static const int WeightWidth = hls_utils::Bitwidth::value; - static const int AccumulationWidth = hls_utils::Bitwidth::value; + static const int ActivationWidth = hlsutils::Bitwidth::value; + static const int WeightWidth = hlsutils::Bitwidth::value; + static const int AccumulationWidth = hlsutils::Bitwidth::value; + static const int VectTuAxiWidth = ActivationWidth * Tu; + static const int VectTvAxiWidth = ActivationWidth * Tv; + static const int VectN_AxiWidth = ActivationWidth * N; + static const int VectG_AxiWidth = ActivationWidth * G; + static const int VectGN_AxiWidth = ActivationWidth * G * N; + static const int VectGTvAxiWidth = ActivationWidth * G * Tv; + typedef typename svd::AxiStreamPort::PacketType VectTuAxiPacketType; + typedef typename svd::AxiStreamPort::PacketType VectTvAxiPacketType; + typedef typename svd::AxiStreamPort::PacketType VectN_AxiPacketType; + typedef typename svd::AxiStreamPort::PacketType VectG_AxiPacketType; + typedef typename svd::AxiStreamPort::PacketType VectGN_AxiPacketType; + typedef typename svd::AxiStreamPort::PacketType VectGTvAxiPacketType; +#ifdef __VITIS_HLS__ + typedef hls::vector VectTuType; + typedef hls::vector VectTvType; + typedef hls::vector VectN_Type; + typedef hls::vector VectG_Type; + typedef hls::vector VectGN_Type; + typedef hls::vector VectGTvType; +#endif }; template @@ -74,34 +145,34 @@ class SvdStreams { typename params::UnzIdxS tile_idx_stream[params::N][params::G][params::PeU]; SvdStreams() { -#pragma HLS STREAM depth=2 variable=x -#pragma HLS STREAM depth=2 variable=nz_u -#pragma HLS STREAM depth=2 variable=nz_v -#pragma HLS STREAM depth=2 variable=u -#pragma HLS STREAM depth=2 variable=s -#pragma HLS STREAM depth=2 variable=v -#pragma HLS STREAM depth=2 variable=xu -#pragma HLS STREAM depth=2 variable=xus -#pragma HLS STREAM depth=2 variable=xusv -#pragma HLS STREAM depth=2 variable=nz_u_idx -#pragma HLS STREAM depth=2 variable=nz_v_idx -#pragma HLS STREAM depth=2 variable=u_dma -#pragma HLS STREAM depth=2 variable=v_dma -#pragma HLS STREAM depth=2 variable=tile_idx_stream -#pragma HLS ARRAY_PARTITION complete dim=0 variable=x -#pragma HLS ARRAY_PARTITION complete dim=0 variable=nz_u -#pragma HLS ARRAY_PARTITION complete dim=0 variable=nz_v -#pragma HLS ARRAY_PARTITION complete dim=0 variable=u -#pragma HLS ARRAY_PARTITION complete dim=0 variable=s -#pragma HLS ARRAY_PARTITION complete dim=0 variable=v -#pragma HLS ARRAY_PARTITION complete dim=0 variable=u_dma -#pragma HLS ARRAY_PARTITION complete dim=0 variable=v_dma -#pragma HLS ARRAY_PARTITION complete dim=0 variable=xu -#pragma HLS ARRAY_PARTITION complete dim=0 variable=xus -#pragma HLS ARRAY_PARTITION complete dim=0 variable=xusv -#pragma HLS ARRAY_PARTITION complete dim=0 variable=nz_u_idx -#pragma HLS ARRAY_PARTITION complete dim=0 variable=nz_v_idx -#pragma HLS ARRAY_PARTITION variable=tile_idx_stream complete dim=0 +#pragma HLS STREAM depth=2 variable=this->x +#pragma HLS STREAM depth=2 variable=this->nz_u +#pragma HLS STREAM depth=2 variable=this->nz_v +#pragma HLS STREAM depth=2 variable=this->u +#pragma HLS STREAM depth=2 variable=this->s +#pragma HLS STREAM depth=2 variable=this->v +#pragma HLS STREAM depth=2 variable=this->xu +#pragma HLS STREAM depth=2 variable=this->xus +#pragma HLS STREAM depth=2 variable=this->xusv +#pragma HLS STREAM depth=2 variable=this->nz_u_idx +#pragma HLS STREAM depth=2 variable=this->nz_v_idx +#pragma HLS STREAM depth=2 variable=this->u_dma +#pragma HLS STREAM depth=2 variable=this->v_dma +#pragma HLS STREAM depth=2 variable=this->tile_idx_stream +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->x +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->nz_u +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->nz_v +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->u +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->s +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->v +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->u_dma +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->v_dma +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->xu +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->xus +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->xusv +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->nz_u_idx +#pragma HLS ARRAY_PARTITION complete dim=0 variable=this->nz_v_idx +#pragma HLS ARRAY_PARTITION variable=this->tile_idx_stream complete dim=0 }; ~SvdStreams() {}; @@ -162,7 +233,7 @@ class SvdBuffers { #define NUM_TILES_V 64 #endif #ifndef NUM_ZERO_TILES_V -#define NUM_ZERO_TILES_V 21 +#define NUM_ZERO_TILES_V 8 #endif #ifndef TILE_SIZE_CUR_U #define TILE_SIZE_CUR_U (INPUT_SIZE / NUM_TILES_U) @@ -184,19 +255,6 @@ class SvdBuffers { #define NUM_TIMESTEPS 28 #endif -#ifndef PRUNED_SIZE_CUR_U -#define PRUNED_SIZE_CUR_U (NUM_ITERATIONS * (INPUT_SIZE - NUM_ZERO_TILES_U * INPUT_SIZE / NUM_TILES_U)) -#endif -#ifndef PRUNED_SIZE_REC_U -#define PRUNED_SIZE_REC_U (NUM_ITERATIONS * (HIDDEN_SIZE - NUM_ZERO_TILES_U * HIDDEN_SIZE / NUM_TILES_U)) -#endif -#ifndef PRUNED_SIZE_CUR_V -#define PRUNED_SIZE_CUR_V (NUM_ITERATIONS * (HIDDEN_SIZE - NUM_ZERO_TILES_V * HIDDEN_SIZE / NUM_TILES_V)) -#endif -#ifndef PRUNED_SIZE_REC_V -#define PRUNED_SIZE_REC_V (NUM_ITERATIONS * (HIDDEN_SIZE - NUM_ZERO_TILES_V * HIDDEN_SIZE / NUM_TILES_V)) -#endif - #if defined(USE_FIX) #define USE_FIX 1 #define USE_FLOAT 0 @@ -226,8 +284,6 @@ class SvdBuffers { #define AXI_PORT_WIDTH 128 #endif - - #if USE_FLOAT typedef float WeightD; typedef float ActivationD; @@ -239,9 +295,14 @@ typedef double ActivationD; typedef double AccumD; typedef double MultD; #else // USE_FIX + +// typedef short WeightD; +// typedef short ActivationD; +// typedef short AccumD; +// typedef short MultD; + typedef ap_fixed WeightD; typedef ap_fixed ActivationD; - #if FIX_WIDTH == 8 typedef ap_fixed AccumD; typedef ap_fixed MultD; @@ -264,36 +325,27 @@ typedef uint64_t AccelD; typedef ap_uint AxiD; // 64bit for ZedBoard HP and ACP ports (128bit for ZCU104) -// Used by software versions: -typedef ap_fixed<16, 2 * FIX_FRACT_WIDTH> Fix16D; -typedef ap_fixed<8, 2 * FIX_FRACT_WIDTH> Fix8D; - typedef hls::stream ActivationStream; typedef hls::stream WeightStream; typedef hls::stream AxiStream; typedef hls::stream AccumStream; -typedef long long CounterD; -typedef hls::stream ProbeStream; +// TODO: Remove CounterD and ProbeStream types from here. +// typedef long long CounterD; +// typedef hls::stream ProbeStream; -#ifndef X_PORT_WIDTH -#define X_PORT_WIDTH (FIX_WIDTH * NUM_TILES_U) -#endif -#ifndef U_PORT_WIDTH -#define U_PORT_WIDTH (FIX_WIDTH * (NUM_TILES_U - NUM_ZERO_TILES_U)) -#endif -#ifndef V_PORT_WIDTH -#define V_PORT_WIDTH (FIX_WIDTH * (HIDDEN_SIZE / NUM_TILES_V)) -#endif -#ifndef S_PORT_WIDTH -#define S_PORT_WIDTH (FIX_WIDTH * 8) -#endif - -typedef ap_uint XPortD; -typedef ap_uint UPortD; -typedef ap_uint VPortD; -typedef ap_uint SPortD; +typedef svd::SvdParameters, + ap_fixed, + ap_fixed > svd_params; + // ActivationD, WeightD, AccumD> svd_params; } // namespace svd + +namespace testsvd { + +} // end testsvd + #endif // end SVD_PARAMS_H_ \ No newline at end of file diff --git a/include/testbenches/test_dense_svd.h b/include/testbenches/test_dense_svd.h new file mode 100644 index 0000000..694c585 --- /dev/null +++ b/include/testbenches/test_dense_svd.h @@ -0,0 +1,6 @@ +#ifndef TESTBENCHES_TEST_DENSE_SVD_H_ +#define TESTBENCHES_TEST_DENSE_SVD_H_ + +#include "layers/dense/hls/dense_svd.h" + +#endif // end TESTBENCHES_TEST_DENSE_SVD_H_ \ No newline at end of file diff --git a/include/testbenches/test_lstm_svd.h b/include/testbenches/test_lstm_svd.h new file mode 100644 index 0000000..390899a --- /dev/null +++ b/include/testbenches/test_lstm_svd.h @@ -0,0 +1,6 @@ +#ifndef TESTBENCHES_TEST_LSTM_SVD_H_ +#define TESTBENCHES_TEST_LSTM_SVD_H_ + +#include "layers/lstm/hls/lstm_svd.h" + +#endif // end TESTBENCHES_TEST_LSTM_SVD_H_ \ No newline at end of file diff --git a/include/testbenches/test_svd_kernel.h b/include/testbenches/test_svd_kernel.h new file mode 100644 index 0000000..7fa3533 --- /dev/null +++ b/include/testbenches/test_svd_kernel.h @@ -0,0 +1,7 @@ +#ifndef TESTBENCHES_TEST_SVD_KERNEL_H_ +#define TESTBENCHES_TEST_SVD_KERNEL_H_ + +#include "svd_params.h" +#include "kernel/svd_kernel.h" + +#endif // end TESTBENCHES_TEST_SVD_KERNEL_H_ \ No newline at end of file diff --git a/include/testbenches/test_u_kernel.h b/include/testbenches/test_u_kernel.h new file mode 100644 index 0000000..cf28208 --- /dev/null +++ b/include/testbenches/test_u_kernel.h @@ -0,0 +1,7 @@ +#ifndef TESTBENCHES_TEST_U_KERNEL_H_ +#define TESTBENCHES_TEST_U_KERNEL_H_ + +#include "kernel/u_kernel.h" +#include "hls_utils/hls_debugging.h" + +#endif // end TESTBENCHES_TEST_U_KERNEL_H_ \ No newline at end of file diff --git a/include/testbenches/test_v_kernel.h b/include/testbenches/test_v_kernel.h new file mode 100644 index 0000000..7de11c0 --- /dev/null +++ b/include/testbenches/test_v_kernel.h @@ -0,0 +1,6 @@ +#ifndef TESTBENCHES_TEST_V_KERNEL_H_ +#define TESTBENCHES_TEST_V_KERNEL_H_ + +#include "kernel/v_kernel.h" + +#endif // end TESTBENCHES_TEST_V_KERNEL_H_ \ No newline at end of file diff --git a/pynq/dense_svd/dense_svd.ipynb b/pynq/dense_svd/dense_svd.ipynb new file mode 100644 index 0000000..b2d7fb7 --- /dev/null +++ b/pynq/dense_svd/dense_svd.ipynb @@ -0,0 +1,628 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing DenseSvd\n", + "\n", + "This notebook will test an IP written in Vivado HLS." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pynq import Overlay\n", + "import pynq.lib.dma\n", + "from pynq import allocate\n", + "import numpy as np\n", + "from pynq import DefaultIP\n", + "import timeit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Program FPGA and inspect Overlay." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "overlay = Overlay(\"overlay/dense_svd.bit\")\n", + "overlay?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the kernel register map." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_active_inputs = Register(num_active_inputs=0),\n", + " input_size = Register(input_size=0),\n", + " output_size = Register(output_size=0),\n", + " num_refinements_0 = Register(num_refinements_0=0),\n", + " num_refinements_1 = Register(num_refinements_1=0)\n", + "}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel = overlay.HlsDenseSvd_0\n", + "kernel.register_map\n", + "# print(\"stream size: \", adder.stream_size)\n", + "# accel_state = adder.get_state()\n", + "# print(\"accelerator state: \", accel_state)\n", + "# dma = overlay.axi_dma_0\n", + "# dma.register_map.MM2S_DMASR\n", + "# dma.register_map.S2MM_DMACR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel IP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The kernel IP can be automatically bound by first creating our Kernel class. Then, the overlay can be instantiated again." + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [], + "source": [ + "class KernelDriver(DefaultIP):\n", + " def __init__(self, description):\n", + " super().__init__(description=description)\n", + " self.max_G = 1\n", + " self.max_I = 1\n", + " self.max_H = 1\n", + " \n", + " bindto = ['xilinx.com:hls:HlsDenseSvd:1.0']\n", + "\n", + " def start_accel(self):\n", + " self.register_map.CTRL.AP_START = 1\n", + " self.write(0x0, 1)\n", + " self.write(0x0, 1)\n", + " while(self.read(0x0) % 2 == 0):\n", + " self.write(0x0, 1)\n", + " pass # Wait until start, i.e. bit 0, is set.\n", + "\n", + " def set_state(self, state):\n", + " # self.register_map.CTRL = state\n", + " # return self.register_map.CTRL\n", + " self.write(0x0, state)\n", + " return self.read(0x0)\n", + "\n", + " def get_state(self):\n", + " return self.register_map.CTRL\n", + " # return self.read(0x0)\n", + "\n", + " @property\n", + " def num_active_inputs(self):\n", + " return self.register_map.num_active_inputs\n", + "\n", + " @num_active_inputs.setter\n", + " def num_active_inputs(self, N):\n", + " self.register_map.num_active_inputs = N\n", + "\n", + " @property\n", + " def input_size(self):\n", + " return self.register_map.input_size\n", + "\n", + " @input_size.setter\n", + " def input_size(self, I):\n", + " self.register_map.input_size = I\n", + "\n", + " @property\n", + " def output_size(self):\n", + " return self.register_map.output_size\n", + "\n", + " @output_size.setter\n", + " def output_size(self, H):\n", + " self.register_map.output_size = H\n", + "\n", + " @property\n", + " def num_refinements(self):\n", + " return (self.register_map.num_refinements_0, self.register_map.num_refinements_1)\n", + "\n", + " @num_refinements.setter\n", + " def num_refinements(self, R):\n", + " self.register_map.num_refinements_0 = R[0]\n", + " self.register_map.num_refinements_1 = R[1]\n", + "\n", + "overlay = Overlay(\"overlay/dense_svd.bit\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check again the kernel:" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0)" + ] + }, + "execution_count": 192, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense_svd = overlay.HlsDenseSvd_0\n", + "dense_svd.get_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 193, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense_svd.read(0x10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the class is working, we setup the `num_refinements` using the setter method. We then read its corresponding register." + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Register(num_refinements_0=1), Register(num_refinements_1=1))" + ] + }, + "execution_count": 194, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense_svd.num_refinements = (1, 1)\n", + "dense_svd.num_refinements" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n" + ] + }, + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0)" + ] + }, + "execution_count": 195, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(dense_svd.get_state())\n", + "dense_svd.get_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Allocation and Run\n", + "\n", + "The data structures must be contiguosly allocated." + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Buffers setup completed.\n", + "x_buffer.shape: (2, 256) - Bytes: 1024\n" + ] + } + ], + "source": [ + "data_t = np.int16\n", + "G = dense_svd.max_G\n", + "N = 2\n", + "I = 256\n", + "H = 256\n", + "R = 64\n", + "x_buffer = pynq.allocate(shape=(N, I), dtype=data_t)\n", + "u_buffer = pynq.allocate(shape=(R, I, G), dtype=data_t)\n", + "s_buffer = pynq.allocate(shape=(R, N, G), dtype=data_t)\n", + "v_buffer = pynq.allocate(shape=(R, H, G), dtype=data_t)\n", + "bias_buffer = pynq.allocate(shape=(N, G, H), dtype=data_t)\n", + "y_buffer = pynq.allocate(shape=(N, G, H), dtype=data_t)\n", + "\n", + "# Generate random arrays\n", + "x_np = np.random.rand(N, I).astype(dtype=data_t)\n", + "u_np = np.random.rand(R, I, G).astype(dtype=data_t)\n", + "s_np = np.random.rand(R, N, G).astype(dtype=data_t)\n", + "v_np = np.random.rand(R, H, G).astype(dtype=data_t)\n", + "bias_np = np.random.rand(N, G, H).astype(dtype=data_t)\n", + "y_np = np.zeros((N, G, H)).astype(dtype=data_t)\n", + "\n", + "np.copyto(x_buffer, x_np, casting='no')\n", + "np.copyto(u_buffer, u_np, casting='no')\n", + "np.copyto(s_buffer, s_np, casting='no')\n", + "np.copyto(v_buffer, v_np, casting='no')\n", + "np.copyto(bias_buffer, bias_np, casting='no')\n", + "np.copyto(y_buffer, y_np, casting='no')\n", + "\n", + "print('Buffers setup completed.')\n", + "print(f'x_buffer.shape: {x_buffer.shape} - Bytes: {x_buffer.nbytes}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup the kernel and then send the data through the DMAs." + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n", + "0x1\n" + ] + }, + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=1, AP_DONE=0, AP_IDLE=0, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_active_inputs = Register(num_active_inputs=2),\n", + " input_size = Register(input_size=256),\n", + " output_size = Register(output_size=256),\n", + " num_refinements_0 = Register(num_refinements_0=64),\n", + " num_refinements_1 = Register(num_refinements_1=64)\n", + "}" + ] + }, + "execution_count": 197, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dense_svd.num_active_inputs = N\n", + "dense_svd.input_size = I\n", + "dense_svd.output_size = H\n", + "dense_svd.num_refinements = (R, R)\n", + "print(dense_svd.get_state())\n", + "dense_svd.start_accel()\n", + "print(dense_svd.get_state())\n", + "dense_svd.register_map" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting transfer:\n", + "Waiting transfer completion.\n", + "x_DMA done.\n", + "u_DMA done.\n", + "s_DMA done.\n", + "v_DMA done.\n", + "bias_DMA done.\n", + "y_DMA done.\n", + "Done.\n", + "\n", + "y_buffer.shape: (2, 1, 256)\n" + ] + } + ], + "source": [ + "# Transfer\n", + "print('Starting transfer:')\n", + "overlay.x_dma.sendchannel.transfer(x_buffer)\n", + "overlay.u_dma.sendchannel.transfer(u_buffer)\n", + "overlay.s_dma.sendchannel.transfer(s_buffer)\n", + "overlay.v_dma.sendchannel.transfer(v_buffer)\n", + "overlay.bias_dma.sendchannel.transfer(bias_buffer)\n", + "overlay.y_dma.recvchannel.transfer(y_buffer)\n", + "# Then wait\n", + "print('Waiting transfer completion.')\n", + "overlay.x_dma.sendchannel.wait()\n", + "print(f'x_DMA done.')\n", + "overlay.u_dma.sendchannel.wait()\n", + "print(f'u_DMA done.')\n", + "overlay.s_dma.sendchannel.wait()\n", + "print(f's_DMA done.')\n", + "overlay.v_dma.sendchannel.wait()\n", + "print(f'v_DMA done.')\n", + "overlay.bias_dma.sendchannel.wait()\n", + "print(f'bias_DMA done.')\n", + "overlay.y_dma.recvchannel.wait()\n", + "print(f'y_DMA done.')\n", + "print('Done.\\n')\n", + "\n", + "print(f'y_buffer.shape: {y_buffer.shape}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def run_kernel(R, x_buffer, u_buffer, xu_buffer):\n", + " kernel_u.num_refinements = R\n", + " kernel_u.start_accel()\n", + " # Transfer\n", + " overlay.x_dma.sendchannel.transfer(x_buffer)\n", + " overlay.u_dma.sendchannel.transfer(u_buffer)\n", + " overlay.xu_dma.recvchannel.transfer(xu_buffer)\n", + " # Then wait\n", + " overlay.x_dma.sendchannel.wait()\n", + " overlay.u_dma.sendchannel.wait()\n", + " overlay.xu_dma.recvchannel.wait()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 148 ms per loop\n" + ] + } + ], + "source": [ + "%timeit run_kernel(R, x_buffer, u_buffer, xu_buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Checking Correctness\n", + "\n", + "We first find the proper reshape mechanisms:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.25823639 1.03248304 -0.3389279 -0.26103506] [-1.25823639 1.03248304 -0.3389279 -0.26103506]\n", + "0.0\n", + "[ 0.38526848 -0.34712276 -0.39317614 0.77762274] [ 0.38526848 -0.34712276 -0.39317614 0.77762274]\n", + "0.0\n", + "(128, 4, 2)\n" + ] + } + ], + "source": [ + "# =============================================================================\n", + "# Reshape: (R, I, G) => (R, I // Tu, G, Tu)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I, G)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp.reshape(R, I // Tu, Tu, G), (0, 1, 3, 2))\n", + "print(u[0, 0:4, 0], u_tmp[0, 0, 0, 0:4])\n", + "print(u[0, 3, 0] - u_tmp[0, 0, 0, 3])\n", + "\n", + "# =============================================================================\n", + "# Reshape: (R, I // Tu, G, Tu) => (I, G, R)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I // Tu, G, Tu)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp, (1, 3, 2, 0)).reshape(I, G, R)\n", + "print(u[0, 0, 0, 0:4], u_tmp[0:4, 0, 0])\n", + "print(u[0, 0, 0, 3] - u_tmp[3, 0, 0])\n", + "\n", + "x = np.random.randn(N, I)\n", + "u = np.random.randn(I, G, R)\n", + "x = (x * 2).astype(np.int16)\n", + "u = (u * 2).astype(np.int16)\n", + "\n", + "xu = np.transpose(np.tensordot(x, u, axes=1), (2, 1, 0))\n", + "print(xu.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now check the Numpy computation against the FPGA result." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "All equal: True\n", + "gold[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n", + "fpga[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n" + ] + } + ], + "source": [ + "u_tmp = np.transpose(u_buffer, (1, 3, 2, 0)).reshape(I, G, R)\n", + "xu_gold = np.transpose(np.tensordot(x_buffer, u_tmp, axes=1), (2, 1, 0))\n", + "print('\\nAll equal:', np.allclose(xu_buffer, xu_gold))\n", + "print('gold[0]: ', xu_gold[0])\n", + "print('fpga[0]: ', xu_buffer[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pynq/dense_svd/overlay/dense_svd.bit b/pynq/dense_svd/overlay/dense_svd.bit new file mode 100644 index 0000000..8643112 Binary files /dev/null and b/pynq/dense_svd/overlay/dense_svd.bit differ diff --git a/pynq/dense_svd/overlay/dense_svd.hwh b/pynq/dense_svd/overlay/dense_svd.hwh new file mode 100644 index 0000000..9d7bb3f --- /dev/null +++ b/pynq/dense_svd/overlay/dense_svd.hwh @@ -0,0 +1,15028 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pynq/dense_svd/overlay/dense_svd.tcl b/pynq/dense_svd/overlay/dense_svd.tcl new file mode 100644 index 0000000..7657326 --- /dev/null +++ b/pynq/dense_svd/overlay/dense_svd.tcl @@ -0,0 +1,780 @@ + +################################################################ +# This is a generated script based on design: design_1 +# +# Though there are limitations about the generated script, +# the main purpose of this utility is to make learning +# IP Integrator Tcl commands easier. +################################################################ + +namespace eval _tcl { +proc get_script_folder {} { + set script_path [file normalize [info script]] + set script_folder [file dirname $script_path] + return $script_folder +} +} +variable script_folder +set script_folder [_tcl::get_script_folder] + +################################################################ +# Check if script is running in correct Vivado version. +################################################################ +set scripts_vivado_version 2020.2 +set current_vivado_version [version -short] + +if { [string first $scripts_vivado_version $current_vivado_version] == -1 } { + puts "" + catch {common::send_gid_msg -ssname BD::TCL -id 2041 -severity "ERROR" "This script was generated using Vivado <$scripts_vivado_version> and is being run in <$current_vivado_version> of Vivado. Please run the script in Vivado <$scripts_vivado_version> then open the design in Vivado <$current_vivado_version>. Upgrade the design by running \"Tools => Report => Report IP Status...\", then run write_bd_tcl to create an updated script."} + + return 1 +} + +################################################################ +# START +################################################################ + +# To test this script, run the following commands from Vivado Tcl console: +# source design_1_script.tcl + +# If there is no project opened, this script will create a +# project, but make sure you do not have an existing project +# <./myproj/project_1.xpr> in the current working folder. + +set list_projs [get_projects -quiet] +if { $list_projs eq "" } { + create_project project_1 myproj -part xc7z020clg484-1 + set_property BOARD_PART em.avnet.com:zed:part0:1.4 [current_project] +} + + +# CHANGE DESIGN NAME HERE +variable design_name +set design_name design_1 + +# If you do not already have an existing IP Integrator design open, +# you can create a design using the following command: +# create_bd_design $design_name + +# Creating design if needed +set errMsg "" +set nRet 0 + +set cur_design [current_bd_design -quiet] +set list_cells [get_bd_cells -quiet] + +if { ${design_name} eq "" } { + # USE CASES: + # 1) Design_name not set + + set errMsg "Please set the variable to a non-empty value." + set nRet 1 + +} elseif { ${cur_design} ne "" && ${list_cells} eq "" } { + # USE CASES: + # 2): Current design opened AND is empty AND names same. + # 3): Current design opened AND is empty AND names diff; design_name NOT in project. + # 4): Current design opened AND is empty AND names diff; design_name exists in project. + + if { $cur_design ne $design_name } { + common::send_gid_msg -ssname BD::TCL -id 2001 -severity "INFO" "Changing value of from <$design_name> to <$cur_design> since current design is empty." + set design_name [get_property NAME $cur_design] + } + common::send_gid_msg -ssname BD::TCL -id 2002 -severity "INFO" "Constructing design in IPI design <$cur_design>..." + +} elseif { ${cur_design} ne "" && $list_cells ne "" && $cur_design eq $design_name } { + # USE CASES: + # 5) Current design opened AND has components AND same names. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 1 +} elseif { [get_files -quiet ${design_name}.bd] ne "" } { + # USE CASES: + # 6) Current opened design, has components, but diff names, design_name exists in project. + # 7) No opened design, design_name exists in project. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 2 + +} else { + # USE CASES: + # 8) No opened design, design_name not in project. + # 9) Current opened design, has components, but diff names, design_name not in project. + + common::send_gid_msg -ssname BD::TCL -id 2003 -severity "INFO" "Currently there is no design <$design_name> in project, so creating one..." + + create_bd_design $design_name + + common::send_gid_msg -ssname BD::TCL -id 2004 -severity "INFO" "Making design <$design_name> as current_bd_design." + current_bd_design $design_name + +} + +common::send_gid_msg -ssname BD::TCL -id 2005 -severity "INFO" "Currently the variable is equal to \"$design_name\"." + +if { $nRet != 0 } { + catch {common::send_gid_msg -ssname BD::TCL -id 2006 -severity "ERROR" $errMsg} + return $nRet +} + +set bCheckIPsPassed 1 +################################################################## +# CHECK IPs +################################################################## +set bCheckIPs 1 +if { $bCheckIPs == 1 } { + set list_check_ips "\ +xilinx.com:hls:HlsDenseSvd:1.0\ +xilinx.com:ip:axi_dma:7.1\ +xilinx.com:ip:processing_system7:5.5\ +xilinx.com:ip:proc_sys_reset:5.0\ +" + + set list_ips_missing "" + common::send_gid_msg -ssname BD::TCL -id 2011 -severity "INFO" "Checking if the following IPs exist in the project's IP catalog: $list_check_ips ." + + foreach ip_vlnv $list_check_ips { + set ip_obj [get_ipdefs -all $ip_vlnv] + if { $ip_obj eq "" } { + lappend list_ips_missing $ip_vlnv + } + } + + if { $list_ips_missing ne "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2012 -severity "ERROR" "The following IPs are not found in the IP Catalog:\n $list_ips_missing\n\nResolution: Please add the repository containing the IP(s) to the project." } + set bCheckIPsPassed 0 + } + +} + +if { $bCheckIPsPassed != 1 } { + common::send_gid_msg -ssname BD::TCL -id 2023 -severity "WARNING" "Will not continue with creation of design due to the error(s) above." + return 3 +} + +################################################################## +# DESIGN PROCs +################################################################## + + + +# Procedure to create entire design; Provide argument to make +# procedure reusable. If parentCell is "", will use root. +proc create_root_design { parentCell } { + + variable script_folder + variable design_name + + if { $parentCell eq "" } { + set parentCell [get_bd_cells /] + } + + # Get object for parentCell + set parentObj [get_bd_cells $parentCell] + if { $parentObj == "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2090 -severity "ERROR" "Unable to find parent cell <$parentCell>!"} + return + } + + # Make sure parentObj is hier blk + set parentType [get_property TYPE $parentObj] + if { $parentType ne "hier" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2091 -severity "ERROR" "Parent <$parentObj> has TYPE = <$parentType>. Expected to be ."} + return + } + + # Save current instance; Restore later + set oldCurInst [current_bd_instance .] + + # Set parent object as current + current_bd_instance $parentObj + + + # Create interface ports + set DDR [ create_bd_intf_port -mode Master -vlnv xilinx.com:interface:ddrx_rtl:1.0 DDR ] + + set FIXED_IO [ create_bd_intf_port -mode Master -vlnv xilinx.com:display_processing_system7:fixedio_rtl:1.0 FIXED_IO ] + + + # Create ports + + # Create instance: HlsDenseSvd_0, and set properties + set HlsDenseSvd_0 [ create_bd_cell -type ip -vlnv xilinx.com:hls:HlsDenseSvd:1.0 HlsDenseSvd_0 ] + + # Create instance: axi_mem_intercon, and set properties + set axi_mem_intercon [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + CONFIG.NUM_SI {2} \ + ] $axi_mem_intercon + + # Create instance: axi_mem_intercon_1, and set properties + set axi_mem_intercon_1 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_1 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + CONFIG.NUM_SI {2} \ + ] $axi_mem_intercon_1 + + # Create instance: axi_mem_intercon_2, and set properties + set axi_mem_intercon_2 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_2 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_2 + + # Create instance: axi_mem_intercon_3, and set properties + set axi_mem_intercon_3 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_3 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_3 + + # Create instance: bias_dma, and set properties + set bias_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 bias_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $bias_dma + + # Create instance: processing_system7_0, and set properties + set processing_system7_0 [ create_bd_cell -type ip -vlnv xilinx.com:ip:processing_system7:5.5 processing_system7_0 ] + set_property -dict [ list \ + CONFIG.PCW_ACT_APU_PERIPHERAL_FREQMHZ {666.666687} \ + CONFIG.PCW_ACT_CAN_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_DCI_PERIPHERAL_FREQMHZ {10.158730} \ + CONFIG.PCW_ACT_ENET0_PERIPHERAL_FREQMHZ {125.000000} \ + CONFIG.PCW_ACT_ENET1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_ACT_FPGA1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA2_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA3_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_PCAP_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_QSPI_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_SDIO_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_SMC_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_SPI_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_TPIU_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_TTC0_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_UART_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_WDT_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_APU_PERIPHERAL_FREQMHZ {666.666667} \ + CONFIG.PCW_ARMPLL_CTRL_FBDIV {40} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_CLK0_FREQ {100000000} \ + CONFIG.PCW_CLK1_FREQ {10000000} \ + CONFIG.PCW_CLK2_FREQ {10000000} \ + CONFIG.PCW_CLK3_FREQ {10000000} \ + CONFIG.PCW_CPU_CPU_PLL_FREQMHZ {1333.333} \ + CONFIG.PCW_CPU_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR0 {15} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR1 {7} \ + CONFIG.PCW_DDRPLL_CTRL_FBDIV {32} \ + CONFIG.PCW_DDR_DDR_PLL_FREQMHZ {1066.667} \ + CONFIG.PCW_DDR_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DDR_RAM_HIGHADDR {0x1FFFFFFF} \ + CONFIG.PCW_ENET0_ENET0_IO {MIO 16 .. 27} \ + CONFIG.PCW_ENET0_GRP_MDIO_ENABLE {1} \ + CONFIG.PCW_ENET0_GRP_MDIO_IO {MIO 52 .. 53} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR0 {8} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_FREQMHZ {1000 Mbps} \ + CONFIG.PCW_ENET0_RESET_ENABLE {0} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET1_RESET_ENABLE {0} \ + CONFIG.PCW_ENET_RESET_ENABLE {1} \ + CONFIG.PCW_ENET_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_EN_EMIO_TTC0 {1} \ + CONFIG.PCW_EN_ENET0 {1} \ + CONFIG.PCW_EN_GPIO {1} \ + CONFIG.PCW_EN_QSPI {1} \ + CONFIG.PCW_EN_SDIO0 {1} \ + CONFIG.PCW_EN_TTC0 {1} \ + CONFIG.PCW_EN_UART1 {1} \ + CONFIG.PCW_EN_USB0 {1} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR1 {2} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_FPGA1_PERIPHERAL_FREQMHZ {150.000000} \ + CONFIG.PCW_FPGA2_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA_FCLK0_ENABLE {1} \ + CONFIG.PCW_FPGA_FCLK1_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK2_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK3_ENABLE {0} \ + CONFIG.PCW_GPIO_MIO_GPIO_ENABLE {1} \ + CONFIG.PCW_GPIO_MIO_GPIO_IO {MIO} \ + CONFIG.PCW_I2C0_GRP_INT_ENABLE {0} \ + CONFIG.PCW_I2C0_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_I2C0_RESET_ENABLE {0} \ + CONFIG.PCW_I2C1_RESET_ENABLE {0} \ + CONFIG.PCW_I2C_PERIPHERAL_FREQMHZ {25} \ + CONFIG.PCW_I2C_RESET_ENABLE {1} \ + CONFIG.PCW_IOPLL_CTRL_FBDIV {30} \ + CONFIG.PCW_IO_IO_PLL_FREQMHZ {1000.000} \ + CONFIG.PCW_MIO_0_DIRECTION {inout} \ + CONFIG.PCW_MIO_0_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_0_PULLUP {disabled} \ + CONFIG.PCW_MIO_0_SLEW {slow} \ + CONFIG.PCW_MIO_10_DIRECTION {inout} \ + CONFIG.PCW_MIO_10_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_10_PULLUP {disabled} \ + CONFIG.PCW_MIO_10_SLEW {slow} \ + CONFIG.PCW_MIO_11_DIRECTION {inout} \ + CONFIG.PCW_MIO_11_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_11_PULLUP {disabled} \ + CONFIG.PCW_MIO_11_SLEW {slow} \ + CONFIG.PCW_MIO_12_DIRECTION {inout} \ + CONFIG.PCW_MIO_12_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_12_PULLUP {disabled} \ + CONFIG.PCW_MIO_12_SLEW {slow} \ + CONFIG.PCW_MIO_13_DIRECTION {inout} \ + CONFIG.PCW_MIO_13_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_13_PULLUP {disabled} \ + CONFIG.PCW_MIO_13_SLEW {slow} \ + CONFIG.PCW_MIO_14_DIRECTION {inout} \ + CONFIG.PCW_MIO_14_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_14_PULLUP {disabled} \ + CONFIG.PCW_MIO_14_SLEW {slow} \ + CONFIG.PCW_MIO_15_DIRECTION {inout} \ + CONFIG.PCW_MIO_15_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_15_PULLUP {disabled} \ + CONFIG.PCW_MIO_15_SLEW {slow} \ + CONFIG.PCW_MIO_16_DIRECTION {out} \ + CONFIG.PCW_MIO_16_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_16_PULLUP {disabled} \ + CONFIG.PCW_MIO_16_SLEW {fast} \ + CONFIG.PCW_MIO_17_DIRECTION {out} \ + CONFIG.PCW_MIO_17_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_17_PULLUP {disabled} \ + CONFIG.PCW_MIO_17_SLEW {fast} \ + CONFIG.PCW_MIO_18_DIRECTION {out} \ + CONFIG.PCW_MIO_18_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_18_PULLUP {disabled} \ + CONFIG.PCW_MIO_18_SLEW {fast} \ + CONFIG.PCW_MIO_19_DIRECTION {out} \ + CONFIG.PCW_MIO_19_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_19_PULLUP {disabled} \ + CONFIG.PCW_MIO_19_SLEW {fast} \ + CONFIG.PCW_MIO_1_DIRECTION {out} \ + CONFIG.PCW_MIO_1_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_1_PULLUP {disabled} \ + CONFIG.PCW_MIO_1_SLEW {fast} \ + CONFIG.PCW_MIO_20_DIRECTION {out} \ + CONFIG.PCW_MIO_20_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_20_PULLUP {disabled} \ + CONFIG.PCW_MIO_20_SLEW {fast} \ + CONFIG.PCW_MIO_21_DIRECTION {out} \ + CONFIG.PCW_MIO_21_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_21_PULLUP {disabled} \ + CONFIG.PCW_MIO_21_SLEW {fast} \ + CONFIG.PCW_MIO_22_DIRECTION {in} \ + CONFIG.PCW_MIO_22_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_22_PULLUP {disabled} \ + CONFIG.PCW_MIO_22_SLEW {fast} \ + CONFIG.PCW_MIO_23_DIRECTION {in} \ + CONFIG.PCW_MIO_23_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_23_PULLUP {disabled} \ + CONFIG.PCW_MIO_23_SLEW {fast} \ + CONFIG.PCW_MIO_24_DIRECTION {in} \ + CONFIG.PCW_MIO_24_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_24_PULLUP {disabled} \ + CONFIG.PCW_MIO_24_SLEW {fast} \ + CONFIG.PCW_MIO_25_DIRECTION {in} \ + CONFIG.PCW_MIO_25_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_25_PULLUP {disabled} \ + CONFIG.PCW_MIO_25_SLEW {fast} \ + CONFIG.PCW_MIO_26_DIRECTION {in} \ + CONFIG.PCW_MIO_26_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_26_PULLUP {disabled} \ + CONFIG.PCW_MIO_26_SLEW {fast} \ + CONFIG.PCW_MIO_27_DIRECTION {in} \ + CONFIG.PCW_MIO_27_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_27_PULLUP {disabled} \ + CONFIG.PCW_MIO_27_SLEW {fast} \ + CONFIG.PCW_MIO_28_DIRECTION {inout} \ + CONFIG.PCW_MIO_28_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_28_PULLUP {disabled} \ + CONFIG.PCW_MIO_28_SLEW {fast} \ + CONFIG.PCW_MIO_29_DIRECTION {in} \ + CONFIG.PCW_MIO_29_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_29_PULLUP {disabled} \ + CONFIG.PCW_MIO_29_SLEW {fast} \ + CONFIG.PCW_MIO_2_DIRECTION {inout} \ + CONFIG.PCW_MIO_2_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_2_PULLUP {disabled} \ + CONFIG.PCW_MIO_2_SLEW {fast} \ + CONFIG.PCW_MIO_30_DIRECTION {out} \ + CONFIG.PCW_MIO_30_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_30_PULLUP {disabled} \ + CONFIG.PCW_MIO_30_SLEW {fast} \ + CONFIG.PCW_MIO_31_DIRECTION {in} \ + CONFIG.PCW_MIO_31_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_31_PULLUP {disabled} \ + CONFIG.PCW_MIO_31_SLEW {fast} \ + CONFIG.PCW_MIO_32_DIRECTION {inout} \ + CONFIG.PCW_MIO_32_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_32_PULLUP {disabled} \ + CONFIG.PCW_MIO_32_SLEW {fast} \ + CONFIG.PCW_MIO_33_DIRECTION {inout} \ + CONFIG.PCW_MIO_33_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_33_PULLUP {disabled} \ + CONFIG.PCW_MIO_33_SLEW {fast} \ + CONFIG.PCW_MIO_34_DIRECTION {inout} \ + CONFIG.PCW_MIO_34_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_34_PULLUP {disabled} \ + CONFIG.PCW_MIO_34_SLEW {fast} \ + CONFIG.PCW_MIO_35_DIRECTION {inout} \ + CONFIG.PCW_MIO_35_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_35_PULLUP {disabled} \ + CONFIG.PCW_MIO_35_SLEW {fast} \ + CONFIG.PCW_MIO_36_DIRECTION {in} \ + CONFIG.PCW_MIO_36_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_36_PULLUP {disabled} \ + CONFIG.PCW_MIO_36_SLEW {fast} \ + CONFIG.PCW_MIO_37_DIRECTION {inout} \ + CONFIG.PCW_MIO_37_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_37_PULLUP {disabled} \ + CONFIG.PCW_MIO_37_SLEW {fast} \ + CONFIG.PCW_MIO_38_DIRECTION {inout} \ + CONFIG.PCW_MIO_38_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_38_PULLUP {disabled} \ + CONFIG.PCW_MIO_38_SLEW {fast} \ + CONFIG.PCW_MIO_39_DIRECTION {inout} \ + CONFIG.PCW_MIO_39_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_39_PULLUP {disabled} \ + CONFIG.PCW_MIO_39_SLEW {fast} \ + CONFIG.PCW_MIO_3_DIRECTION {inout} \ + CONFIG.PCW_MIO_3_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_3_PULLUP {disabled} \ + CONFIG.PCW_MIO_3_SLEW {fast} \ + CONFIG.PCW_MIO_40_DIRECTION {inout} \ + CONFIG.PCW_MIO_40_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_40_PULLUP {disabled} \ + CONFIG.PCW_MIO_40_SLEW {fast} \ + CONFIG.PCW_MIO_41_DIRECTION {inout} \ + CONFIG.PCW_MIO_41_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_41_PULLUP {disabled} \ + CONFIG.PCW_MIO_41_SLEW {fast} \ + CONFIG.PCW_MIO_42_DIRECTION {inout} \ + CONFIG.PCW_MIO_42_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_42_PULLUP {disabled} \ + CONFIG.PCW_MIO_42_SLEW {fast} \ + CONFIG.PCW_MIO_43_DIRECTION {inout} \ + CONFIG.PCW_MIO_43_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_43_PULLUP {disabled} \ + CONFIG.PCW_MIO_43_SLEW {fast} \ + CONFIG.PCW_MIO_44_DIRECTION {inout} \ + CONFIG.PCW_MIO_44_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_44_PULLUP {disabled} \ + CONFIG.PCW_MIO_44_SLEW {fast} \ + CONFIG.PCW_MIO_45_DIRECTION {inout} \ + CONFIG.PCW_MIO_45_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_45_PULLUP {disabled} \ + CONFIG.PCW_MIO_45_SLEW {fast} \ + CONFIG.PCW_MIO_46_DIRECTION {in} \ + CONFIG.PCW_MIO_46_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_46_PULLUP {disabled} \ + CONFIG.PCW_MIO_46_SLEW {slow} \ + CONFIG.PCW_MIO_47_DIRECTION {in} \ + CONFIG.PCW_MIO_47_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_47_PULLUP {disabled} \ + CONFIG.PCW_MIO_47_SLEW {slow} \ + CONFIG.PCW_MIO_48_DIRECTION {out} \ + CONFIG.PCW_MIO_48_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_48_PULLUP {disabled} \ + CONFIG.PCW_MIO_48_SLEW {slow} \ + CONFIG.PCW_MIO_49_DIRECTION {in} \ + CONFIG.PCW_MIO_49_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_49_PULLUP {disabled} \ + CONFIG.PCW_MIO_49_SLEW {slow} \ + CONFIG.PCW_MIO_4_DIRECTION {inout} \ + CONFIG.PCW_MIO_4_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_4_PULLUP {disabled} \ + CONFIG.PCW_MIO_4_SLEW {fast} \ + CONFIG.PCW_MIO_50_DIRECTION {inout} \ + CONFIG.PCW_MIO_50_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_50_PULLUP {disabled} \ + CONFIG.PCW_MIO_50_SLEW {slow} \ + CONFIG.PCW_MIO_51_DIRECTION {inout} \ + CONFIG.PCW_MIO_51_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_51_PULLUP {disabled} \ + CONFIG.PCW_MIO_51_SLEW {slow} \ + CONFIG.PCW_MIO_52_DIRECTION {out} \ + CONFIG.PCW_MIO_52_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_52_PULLUP {disabled} \ + CONFIG.PCW_MIO_52_SLEW {slow} \ + CONFIG.PCW_MIO_53_DIRECTION {inout} \ + CONFIG.PCW_MIO_53_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_53_PULLUP {disabled} \ + CONFIG.PCW_MIO_53_SLEW {slow} \ + CONFIG.PCW_MIO_5_DIRECTION {inout} \ + CONFIG.PCW_MIO_5_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_5_PULLUP {disabled} \ + CONFIG.PCW_MIO_5_SLEW {fast} \ + CONFIG.PCW_MIO_6_DIRECTION {out} \ + CONFIG.PCW_MIO_6_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_6_PULLUP {disabled} \ + CONFIG.PCW_MIO_6_SLEW {fast} \ + CONFIG.PCW_MIO_7_DIRECTION {out} \ + CONFIG.PCW_MIO_7_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_7_PULLUP {disabled} \ + CONFIG.PCW_MIO_7_SLEW {slow} \ + CONFIG.PCW_MIO_8_DIRECTION {out} \ + CONFIG.PCW_MIO_8_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_8_PULLUP {disabled} \ + CONFIG.PCW_MIO_8_SLEW {fast} \ + CONFIG.PCW_MIO_9_DIRECTION {inout} \ + CONFIG.PCW_MIO_9_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_9_PULLUP {disabled} \ + CONFIG.PCW_MIO_9_SLEW {slow} \ + CONFIG.PCW_MIO_TREE_PERIPHERALS {GPIO#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#UART 1#UART 1#GPIO#GPIO#Enet 0#Enet 0} \ + CONFIG.PCW_MIO_TREE_SIGNALS {gpio[0]#qspi0_ss_b#qspi0_io[0]#qspi0_io[1]#qspi0_io[2]#qspi0_io[3]/HOLD_B#qspi0_sclk#gpio[7]#gpio[8]#gpio[9]#gpio[10]#gpio[11]#gpio[12]#gpio[13]#gpio[14]#gpio[15]#tx_clk#txd[0]#txd[1]#txd[2]#txd[3]#tx_ctl#rx_clk#rxd[0]#rxd[1]#rxd[2]#rxd[3]#rx_ctl#data[4]#dir#stp#nxt#data[0]#data[1]#data[2]#data[3]#clk#data[5]#data[6]#data[7]#clk#cmd#data[0]#data[1]#data[2]#data[3]#wp#cd#tx#rx#gpio[50]#gpio[51]#mdc#mdio} \ + CONFIG.PCW_NAND_GRP_D8_ENABLE {0} \ + CONFIG.PCW_NAND_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_A25_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_INT_ENABLE {0} \ + CONFIG.PCW_NOR_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PCAP_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_PJTAG_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PRESET_BANK0_VOLTAGE {LVCMOS 3.3V} \ + CONFIG.PCW_PRESET_BANK1_VOLTAGE {LVCMOS 1.8V} \ + CONFIG.PCW_QSPI_GRP_FBCLK_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_IO1_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_ENABLE {1} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_IO {MIO 1 .. 6} \ + CONFIG.PCW_QSPI_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_QSPI_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_QSPI_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_QSPI_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_QSPI_QSPI_IO {MIO 1 .. 6} \ + CONFIG.PCW_SD0_GRP_CD_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_CD_IO {MIO 47} \ + CONFIG.PCW_SD0_GRP_POW_ENABLE {0} \ + CONFIG.PCW_SD0_GRP_WP_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_WP_IO {MIO 46} \ + CONFIG.PCW_SD0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_SD0_SD0_IO {MIO 40 .. 45} \ + CONFIG.PCW_SDIO_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_SDIO_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_SDIO_PERIPHERAL_VALID {1} \ + CONFIG.PCW_SINGLE_QSPI_DATA_MODE {x4} \ + CONFIG.PCW_SMC_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_SPI_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_S_AXI_HP2_DATA_WIDTH {64} \ + CONFIG.PCW_TPIU_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_TTC0_TTC0_IO {EMIO} \ + CONFIG.PCW_TTC_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART1_GRP_FULL_ENABLE {0} \ + CONFIG.PCW_UART1_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_UART1_UART1_IO {MIO 48 .. 49} \ + CONFIG.PCW_UART_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_UART_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART_PERIPHERAL_VALID {1} \ + CONFIG.PCW_UIPARAM_ACT_DDR_FREQ_MHZ {533.333374} \ + CONFIG.PCW_UIPARAM_DDR_BANK_ADDR_COUNT {3} \ + CONFIG.PCW_UIPARAM_DDR_BL {8} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY0 {0.41} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY1 {0.411} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY2 {0.341} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY3 {0.358} \ + CONFIG.PCW_UIPARAM_DDR_CL {7} \ + CONFIG.PCW_UIPARAM_DDR_COL_ADDR_COUNT {10} \ + CONFIG.PCW_UIPARAM_DDR_CWL {6} \ + CONFIG.PCW_UIPARAM_DDR_DEVICE_CAPACITY {2048 MBits} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_0 {0.025} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_1 {0.028} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_2 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_3 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DRAM_WIDTH {16 Bits} \ + CONFIG.PCW_UIPARAM_DDR_FREQ_MHZ {533.333313} \ + CONFIG.PCW_UIPARAM_DDR_MEMORY_TYPE {DDR 3} \ + CONFIG.PCW_UIPARAM_DDR_PARTNO {MT41J128M16 HA-15E} \ + CONFIG.PCW_UIPARAM_DDR_ROW_ADDR_COUNT {14} \ + CONFIG.PCW_UIPARAM_DDR_SPEED_BIN {DDR3_1066F} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_DATA_EYE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_READ_GATE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_WRITE_LEVEL {1} \ + CONFIG.PCW_UIPARAM_DDR_T_FAW {45.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RAS_MIN {36.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RC {49.5} \ + CONFIG.PCW_UIPARAM_DDR_T_RCD {7} \ + CONFIG.PCW_UIPARAM_DDR_T_RP {7} \ + CONFIG.PCW_UIPARAM_DDR_USE_INTERNAL_VREF {1} \ + CONFIG.PCW_USB0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_USB0_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_USB0_RESET_ENABLE {0} \ + CONFIG.PCW_USB0_USB0_IO {MIO 28 .. 39} \ + CONFIG.PCW_USB1_RESET_ENABLE {0} \ + CONFIG.PCW_USB_RESET_ENABLE {1} \ + CONFIG.PCW_USB_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_USE_S_AXI_HP0 {1} \ + CONFIG.PCW_USE_S_AXI_HP1 {1} \ + CONFIG.PCW_USE_S_AXI_HP2 {1} \ + CONFIG.PCW_USE_S_AXI_HP3 {1} \ + CONFIG.preset {ZedBoard} \ + ] $processing_system7_0 + + # Create instance: ps7_0_axi_periph, and set properties + set ps7_0_axi_periph [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 ps7_0_axi_periph ] + set_property -dict [ list \ + CONFIG.NUM_MI {7} \ + ] $ps7_0_axi_periph + + # Create instance: rst_ps7_0_100M, and set properties + set rst_ps7_0_100M [ create_bd_cell -type ip -vlnv xilinx.com:ip:proc_sys_reset:5.0 rst_ps7_0_100M ] + + # Create instance: s_dma, and set properties + set s_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 s_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $s_dma + + # Create instance: u_dma, and set properties + set u_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 u_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $u_dma + + # Create instance: v_dma, and set properties + set v_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 v_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $v_dma + + # Create instance: x_dma, and set properties + set x_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 x_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $x_dma + + # Create instance: y_dma, and set properties + set y_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 y_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s {0} \ + CONFIG.c_include_s2mm_dre {1} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_micro_dma {0} \ + CONFIG.c_s2mm_burst_size {128} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $y_dma + + # Create interface connections + connect_bd_intf_net -intf_net HlsDenseSvd_0_y_port [get_bd_intf_pins HlsDenseSvd_0/y_port] [get_bd_intf_pins y_dma/S_AXIS_S2MM] + connect_bd_intf_net -intf_net axi_mem_intercon_1_M00_AXI [get_bd_intf_pins axi_mem_intercon_1/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP1] + connect_bd_intf_net -intf_net axi_mem_intercon_2_M00_AXI [get_bd_intf_pins axi_mem_intercon_2/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP2] + connect_bd_intf_net -intf_net axi_mem_intercon_3_M00_AXI [get_bd_intf_pins axi_mem_intercon_3/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP3] + connect_bd_intf_net -intf_net axi_mem_intercon_M00_AXI [get_bd_intf_pins axi_mem_intercon/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP0] + connect_bd_intf_net -intf_net bias_dma_M_AXIS_MM2S [get_bd_intf_pins HlsDenseSvd_0/bias_port] [get_bd_intf_pins bias_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net bias_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon/S01_AXI] [get_bd_intf_pins bias_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net processing_system7_0_DDR [get_bd_intf_ports DDR] [get_bd_intf_pins processing_system7_0/DDR] + connect_bd_intf_net -intf_net processing_system7_0_FIXED_IO [get_bd_intf_ports FIXED_IO] [get_bd_intf_pins processing_system7_0/FIXED_IO] + connect_bd_intf_net -intf_net processing_system7_0_M_AXI_GP0 [get_bd_intf_pins processing_system7_0/M_AXI_GP0] [get_bd_intf_pins ps7_0_axi_periph/S00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M00_AXI [get_bd_intf_pins bias_dma/S_AXI_LITE] [get_bd_intf_pins ps7_0_axi_periph/M00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M01_AXI [get_bd_intf_pins ps7_0_axi_periph/M01_AXI] [get_bd_intf_pins v_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M02_AXI [get_bd_intf_pins ps7_0_axi_periph/M02_AXI] [get_bd_intf_pins x_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M03_AXI [get_bd_intf_pins ps7_0_axi_periph/M03_AXI] [get_bd_intf_pins y_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M04_AXI [get_bd_intf_pins HlsDenseSvd_0/s_axi_ctrl] [get_bd_intf_pins ps7_0_axi_periph/M04_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M05_AXI [get_bd_intf_pins ps7_0_axi_periph/M05_AXI] [get_bd_intf_pins s_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M06_AXI [get_bd_intf_pins ps7_0_axi_periph/M06_AXI] [get_bd_intf_pins u_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net s_dma_M_AXIS_MM2S [get_bd_intf_pins HlsDenseSvd_0/s_port] [get_bd_intf_pins s_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net s_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S01_AXI] [get_bd_intf_pins s_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXIS_MM2S [get_bd_intf_pins HlsDenseSvd_0/u_port] [get_bd_intf_pins u_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S00_AXI] [get_bd_intf_pins v_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S1 [get_bd_intf_pins axi_mem_intercon_3/S00_AXI] [get_bd_intf_pins u_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net v_dma_M_AXIS_MM2S [get_bd_intf_pins HlsDenseSvd_0/v_port] [get_bd_intf_pins v_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXIS_MM2S [get_bd_intf_pins HlsDenseSvd_0/x_port] [get_bd_intf_pins x_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon/S00_AXI] [get_bd_intf_pins x_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net xu_dma_M_AXI_S2MM [get_bd_intf_pins axi_mem_intercon_2/S00_AXI] [get_bd_intf_pins y_dma/M_AXI_S2MM] + + # Create port connections + connect_bd_net -net processing_system7_0_FCLK_CLK0 [get_bd_pins HlsDenseSvd_0/ap_clk] [get_bd_pins axi_mem_intercon/ACLK] [get_bd_pins axi_mem_intercon/M00_ACLK] [get_bd_pins axi_mem_intercon/S00_ACLK] [get_bd_pins axi_mem_intercon/S01_ACLK] [get_bd_pins axi_mem_intercon_1/ACLK] [get_bd_pins axi_mem_intercon_1/M00_ACLK] [get_bd_pins axi_mem_intercon_1/S00_ACLK] [get_bd_pins axi_mem_intercon_1/S01_ACLK] [get_bd_pins axi_mem_intercon_2/ACLK] [get_bd_pins axi_mem_intercon_2/M00_ACLK] [get_bd_pins axi_mem_intercon_2/S00_ACLK] [get_bd_pins axi_mem_intercon_3/ACLK] [get_bd_pins axi_mem_intercon_3/M00_ACLK] [get_bd_pins axi_mem_intercon_3/S00_ACLK] [get_bd_pins bias_dma/m_axi_mm2s_aclk] [get_bd_pins bias_dma/s_axi_lite_aclk] [get_bd_pins processing_system7_0/FCLK_CLK0] [get_bd_pins processing_system7_0/M_AXI_GP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP1_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP2_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP3_ACLK] [get_bd_pins ps7_0_axi_periph/ACLK] [get_bd_pins ps7_0_axi_periph/M00_ACLK] [get_bd_pins ps7_0_axi_periph/M01_ACLK] [get_bd_pins ps7_0_axi_periph/M02_ACLK] [get_bd_pins ps7_0_axi_periph/M03_ACLK] [get_bd_pins ps7_0_axi_periph/M04_ACLK] [get_bd_pins ps7_0_axi_periph/M05_ACLK] [get_bd_pins ps7_0_axi_periph/M06_ACLK] [get_bd_pins ps7_0_axi_periph/S00_ACLK] [get_bd_pins rst_ps7_0_100M/slowest_sync_clk] [get_bd_pins s_dma/m_axi_mm2s_aclk] [get_bd_pins s_dma/s_axi_lite_aclk] [get_bd_pins u_dma/m_axi_mm2s_aclk] [get_bd_pins u_dma/s_axi_lite_aclk] [get_bd_pins v_dma/m_axi_mm2s_aclk] [get_bd_pins v_dma/s_axi_lite_aclk] [get_bd_pins x_dma/m_axi_mm2s_aclk] [get_bd_pins x_dma/s_axi_lite_aclk] [get_bd_pins y_dma/m_axi_s2mm_aclk] [get_bd_pins y_dma/s_axi_lite_aclk] + connect_bd_net -net processing_system7_0_FCLK_RESET0_N [get_bd_pins processing_system7_0/FCLK_RESET0_N] [get_bd_pins rst_ps7_0_100M/ext_reset_in] + connect_bd_net -net rst_ps7_0_100M_peripheral_aresetn [get_bd_pins HlsDenseSvd_0/ap_rst_n] [get_bd_pins axi_mem_intercon/ARESETN] [get_bd_pins axi_mem_intercon/M00_ARESETN] [get_bd_pins axi_mem_intercon/S00_ARESETN] [get_bd_pins axi_mem_intercon/S01_ARESETN] [get_bd_pins axi_mem_intercon_1/ARESETN] [get_bd_pins axi_mem_intercon_1/M00_ARESETN] [get_bd_pins axi_mem_intercon_1/S00_ARESETN] [get_bd_pins axi_mem_intercon_1/S01_ARESETN] [get_bd_pins axi_mem_intercon_2/ARESETN] [get_bd_pins axi_mem_intercon_2/M00_ARESETN] [get_bd_pins axi_mem_intercon_2/S00_ARESETN] [get_bd_pins axi_mem_intercon_3/ARESETN] [get_bd_pins axi_mem_intercon_3/M00_ARESETN] [get_bd_pins axi_mem_intercon_3/S00_ARESETN] [get_bd_pins bias_dma/axi_resetn] [get_bd_pins ps7_0_axi_periph/ARESETN] [get_bd_pins ps7_0_axi_periph/M00_ARESETN] [get_bd_pins ps7_0_axi_periph/M01_ARESETN] [get_bd_pins ps7_0_axi_periph/M02_ARESETN] [get_bd_pins ps7_0_axi_periph/M03_ARESETN] [get_bd_pins ps7_0_axi_periph/M04_ARESETN] [get_bd_pins ps7_0_axi_periph/M05_ARESETN] [get_bd_pins ps7_0_axi_periph/M06_ARESETN] [get_bd_pins ps7_0_axi_periph/S00_ARESETN] [get_bd_pins rst_ps7_0_100M/peripheral_aresetn] [get_bd_pins s_dma/axi_resetn] [get_bd_pins u_dma/axi_resetn] [get_bd_pins v_dma/axi_resetn] [get_bd_pins x_dma/axi_resetn] [get_bd_pins y_dma/axi_resetn] + + # Create address segments + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces bias_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP0/HP0_DDR_LOWOCM] -force + assign_bd_address -offset 0x40000000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs HlsDenseSvd_0/s_axi_ctrl/Reg] -force + assign_bd_address -offset 0x41E30000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs bias_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E40000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs s_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E00000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs v_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E50000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs u_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E10000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs x_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E20000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs y_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces s_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces u_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP3/HP3_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces v_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces x_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP0/HP0_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces y_dma/Data_S2MM] [get_bd_addr_segs processing_system7_0/S_AXI_HP2/HP2_DDR_LOWOCM] -force + + + # Restore current instance + current_bd_instance $oldCurInst + + validate_bd_design + save_bd_design +} +# End of create_root_design() + + +################################################################## +# MAIN FLOW +################################################################## + +create_root_design "" + + diff --git a/pynq/kernel_svd/kernel_svd.ipynb b/pynq/kernel_svd/kernel_svd.ipynb new file mode 100644 index 0000000..5d5cc3d --- /dev/null +++ b/pynq/kernel_svd/kernel_svd.ipynb @@ -0,0 +1,557 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing DenseSvd\n", + "\n", + "This notebook will test an IP written in Vivado HLS." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pynq import Overlay\n", + "import pynq.lib.dma\n", + "from pynq import allocate\n", + "import numpy as np\n", + "from pynq import DefaultIP\n", + "import timeit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Program FPGA and inspect Overlay." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "overlay = Overlay(\"overlay/kernel_svd.bit\")\n", + "overlay?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the kernel register map." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_active_inputs = Register(num_active_inputs=0),\n", + " input_size = Register(input_size=0),\n", + " output_size = Register(output_size=0),\n", + " num_refinements_0 = Register(num_refinements_0=0),\n", + " num_refinements_1 = Register(num_refinements_1=0)\n", + "}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel = overlay.HlsSvdKernel_0\n", + "kernel.register_map\n", + "# print(\"stream size: \", adder.stream_size)\n", + "# accel_state = adder.get_state()\n", + "# print(\"accelerator state: \", accel_state)\n", + "# dma = overlay.axi_dma_0\n", + "# dma.register_map.MM2S_DMASR\n", + "# dma.register_map.S2MM_DMACR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel IP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The kernel IP can be automatically bound by first creating our Kernel class. Then, the overlay can be instantiated again." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "class KernelDriver(DefaultIP):\n", + " def __init__(self, description):\n", + " super().__init__(description=description)\n", + " self.max_G = 4\n", + " self.max_I = 1\n", + " self.max_H = 1\n", + " \n", + " bindto = ['xilinx.com:hls:HlsSvdKernel:1.0']\n", + "\n", + " def start_accel(self):\n", + " self.register_map.CTRL.AP_START = 1\n", + " self.write(0x0, 1)\n", + " self.write(0x0, 1)\n", + " while(self.read(0x0) % 2 == 0):\n", + " self.write(0x0, 1)\n", + " pass # Wait until start, i.e. bit 0, is set.\n", + "\n", + " def set_state(self, state):\n", + " # self.register_map.CTRL = state\n", + " # return self.register_map.CTRL\n", + " self.write(0x0, state)\n", + " return self.read(0x0)\n", + "\n", + " def get_state(self):\n", + " return self.register_map.CTRL\n", + " # return self.read(0x0)\n", + "\n", + " @property\n", + " def num_active_inputs(self):\n", + " return self.register_map.num_active_inputs\n", + "\n", + " @num_active_inputs.setter\n", + " def num_active_inputs(self, N):\n", + " self.register_map.num_active_inputs = N\n", + "\n", + " @property\n", + " def input_size(self):\n", + " return self.register_map.input_size\n", + "\n", + " @input_size.setter\n", + " def input_size(self, I):\n", + " self.register_map.input_size = I\n", + "\n", + " @property\n", + " def output_size(self):\n", + " return self.register_map.output_size\n", + "\n", + " @output_size.setter\n", + " def output_size(self, H):\n", + " self.register_map.output_size = H\n", + "\n", + " @property\n", + " def num_refinements(self):\n", + " return (self.register_map.num_refinements_0, self.register_map.num_refinements_1)\n", + "\n", + " @num_refinements.setter\n", + " def num_refinements(self, R):\n", + " self.register_map.num_refinements_0 = R[0]\n", + " self.register_map.num_refinements_1 = R[1]\n", + "\n", + "overlay = Overlay(\"overlay/kernel_svd.bit\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the class is working, we setup the `num_refinements` using the setter method. We then read its corresponding register." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Register(num_refinements_0=1), Register(num_refinements_1=1))" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_svd.num_refinements = (1, 1)\n", + "kernel_svd.num_refinements" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Allocation and Run\n", + "\n", + "The data structures must be contiguosly allocated." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Buffers setup completed.\n", + "x_buffer.shape: (2, 8) - Bytes: 32\n", + "u_buffer.shape: (4, 8, 4) - Bytes: 256\n" + ] + } + ], + "source": [ + "data_t = np.int16\n", + "G = kernel_svd.max_G\n", + "N = 2\n", + "I = 8\n", + "H = 8\n", + "R = 4\n", + "x_buffer = pynq.allocate(shape=(N, I), dtype=data_t)\n", + "u_buffer = pynq.allocate(shape=(R, I, G), dtype=data_t)\n", + "s_buffer = pynq.allocate(shape=(R, N, G), dtype=data_t)\n", + "v_buffer = pynq.allocate(shape=(R, H, G), dtype=data_t)\n", + "y_buffer = pynq.allocate(shape=(N, G, H), dtype=data_t)\n", + "\n", + "# Generate random arrays\n", + "x_np = np.random.rand(N, I).astype(dtype=data_t)\n", + "u_np = np.random.rand(R, I, G).astype(dtype=data_t)\n", + "s_np = np.random.rand(R, N, G).astype(dtype=data_t)\n", + "v_np = np.random.rand(R, H, G).astype(dtype=data_t)\n", + "y_np = np.zeros((N, G, H)).astype(dtype=data_t)\n", + "\n", + "np.copyto(x_buffer, x_np, casting='no')\n", + "np.copyto(u_buffer, u_np, casting='no')\n", + "np.copyto(s_buffer, s_np, casting='no')\n", + "np.copyto(v_buffer, v_np, casting='no')\n", + "np.copyto(y_buffer, y_np, casting='no')\n", + "\n", + "print('Buffers setup completed.')\n", + "print(f'x_buffer.shape: {x_buffer.shape} - Bytes: {x_buffer.nbytes}')\n", + "print(f'u_buffer.shape: {u_buffer.shape} - Bytes: {u_buffer.nbytes}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup the kernel and then send the data through the DMAs." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n", + "0x1\n" + ] + }, + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=1, AP_DONE=0, AP_IDLE=0, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_active_inputs = Register(num_active_inputs=2),\n", + " input_size = Register(input_size=8),\n", + " output_size = Register(output_size=8),\n", + " num_refinements_0 = Register(num_refinements_0=4),\n", + " num_refinements_1 = Register(num_refinements_1=4)\n", + "}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_svd.num_active_inputs = N\n", + "kernel_svd.input_size = I\n", + "kernel_svd.output_size = H\n", + "kernel_svd.num_refinements = (R, R)\n", + "print(kernel_svd.get_state())\n", + "kernel_svd.start_accel()\n", + "print(kernel_svd.get_state())\n", + "kernel_svd.register_map" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting transfer:\n", + "Waiting transfer completion.\n", + "x_DMA done.\n", + "u_DMA done.\n", + "s_DMA done.\n", + "v_DMA done.\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0moverlay\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mv_dma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msendchannel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'v_DMA done.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0moverlay\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_dma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecvchannel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 19\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'y_DMA done.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Done.\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pynq/lib/dma.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 206\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 207\u001b[0m \u001b[0merror\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mmio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_offset\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 208\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merror\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 209\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0merror\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;36m0x10\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 210\u001b[0m raise RuntimeError(\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pynq/lib/dma.py\u001b[0m in \u001b[0;36merror\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 115\u001b[0m \"\"\"True if DMA engine is in an error state\n\u001b[1;32m 116\u001b[0m \"\"\"\n\u001b[0;32m--> 117\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mmio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_offset\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;36m0x70\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0x0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mstart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pynq/mmio.py\u001b[0m in \u001b[0;36mread\u001b[0;34m(self, offset, length, word_order)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Device does not have capabilities for MMIO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moffset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlength\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mword_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'little'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 111\u001b[0m \"\"\"The method to read data from MMIO.\n\u001b[1;32m 112\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "# Transfer\n", + "print('Starting transfer:')\n", + "overlay.x_dma.sendchannel.transfer(x_buffer)\n", + "overlay.u_dma.sendchannel.transfer(u_buffer)\n", + "overlay.s_dma.sendchannel.transfer(s_buffer)\n", + "overlay.v_dma.sendchannel.transfer(v_buffer)\n", + "overlay.y_dma.recvchannel.transfer(y_buffer)\n", + "# Then wait\n", + "print('Waiting transfer completion.')\n", + "overlay.x_dma.sendchannel.wait()\n", + "print(f'x_DMA done.')\n", + "overlay.u_dma.sendchannel.wait()\n", + "print(f'u_DMA done.')\n", + "overlay.s_dma.sendchannel.wait()\n", + "print(f's_DMA done.')\n", + "overlay.v_dma.sendchannel.wait()\n", + "print(f'v_DMA done.')\n", + "overlay.y_dma.recvchannel.wait()\n", + "print(f'y_DMA done.')\n", + "print('Done.\\n')\n", + "\n", + "print(f'y_buffer.shape: {y_buffer.shape}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def run_kernel(R, x_buffer, u_buffer, xu_buffer):\n", + " kernel_u.num_refinements = R\n", + " kernel_u.start_accel()\n", + " # Transfer\n", + " overlay.x_dma.sendchannel.transfer(x_buffer)\n", + " overlay.u_dma.sendchannel.transfer(u_buffer)\n", + " overlay.xu_dma.recvchannel.transfer(xu_buffer)\n", + " # Then wait\n", + " overlay.x_dma.sendchannel.wait()\n", + " overlay.u_dma.sendchannel.wait()\n", + " overlay.xu_dma.recvchannel.wait()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 148 ms per loop\n" + ] + } + ], + "source": [ + "%timeit run_kernel(R, x_buffer, u_buffer, xu_buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Checking Correctness\n", + "\n", + "We first find the proper reshape mechanisms:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.25823639 1.03248304 -0.3389279 -0.26103506] [-1.25823639 1.03248304 -0.3389279 -0.26103506]\n", + "0.0\n", + "[ 0.38526848 -0.34712276 -0.39317614 0.77762274] [ 0.38526848 -0.34712276 -0.39317614 0.77762274]\n", + "0.0\n", + "(128, 4, 2)\n" + ] + } + ], + "source": [ + "# =============================================================================\n", + "# Reshape: (R, I, G) => (R, I // Tu, G, Tu)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I, G)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp.reshape(R, I // Tu, Tu, G), (0, 1, 3, 2))\n", + "print(u[0, 0:4, 0], u_tmp[0, 0, 0, 0:4])\n", + "print(u[0, 3, 0] - u_tmp[0, 0, 0, 3])\n", + "\n", + "# =============================================================================\n", + "# Reshape: (R, I // Tu, G, Tu) => (I, G, R)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I // Tu, G, Tu)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp, (1, 3, 2, 0)).reshape(I, G, R)\n", + "print(u[0, 0, 0, 0:4], u_tmp[0:4, 0, 0])\n", + "print(u[0, 0, 0, 3] - u_tmp[3, 0, 0])\n", + "\n", + "x = np.random.randn(N, I)\n", + "u = np.random.randn(I, G, R)\n", + "x = (x * 2).astype(np.int16)\n", + "u = (u * 2).astype(np.int16)\n", + "\n", + "xu = np.transpose(np.tensordot(x, u, axes=1), (2, 1, 0))\n", + "print(xu.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now check the Numpy computation against the FPGA result." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "All equal: True\n", + "gold[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n", + "fpga[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n" + ] + } + ], + "source": [ + "u_tmp = np.transpose(u_buffer, (1, 3, 2, 0)).reshape(I, G, R)\n", + "xu_gold = np.transpose(np.tensordot(x_buffer, u_tmp, axes=1), (2, 1, 0))\n", + "print('\\nAll equal:', np.allclose(xu_buffer, xu_gold))\n", + "print('gold[0]: ', xu_gold[0])\n", + "print('fpga[0]: ', xu_buffer[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pynq/kernel_svd/overlay/kernel_svd.bit b/pynq/kernel_svd/overlay/kernel_svd.bit new file mode 100644 index 0000000..7860370 Binary files /dev/null and b/pynq/kernel_svd/overlay/kernel_svd.bit differ diff --git a/pynq/kernel_svd/overlay/kernel_svd.hwh b/pynq/kernel_svd/overlay/kernel_svd.hwh new file mode 100644 index 0000000..6397772 --- /dev/null +++ b/pynq/kernel_svd/overlay/kernel_svd.hwh @@ -0,0 +1,13430 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pynq/kernel_svd/overlay/kernel_svd.tcl b/pynq/kernel_svd/overlay/kernel_svd.tcl new file mode 100644 index 0000000..fbb7ef4 --- /dev/null +++ b/pynq/kernel_svd/overlay/kernel_svd.tcl @@ -0,0 +1,762 @@ + +################################################################ +# This is a generated script based on design: design_1 +# +# Though there are limitations about the generated script, +# the main purpose of this utility is to make learning +# IP Integrator Tcl commands easier. +################################################################ + +namespace eval _tcl { +proc get_script_folder {} { + set script_path [file normalize [info script]] + set script_folder [file dirname $script_path] + return $script_folder +} +} +variable script_folder +set script_folder [_tcl::get_script_folder] + +################################################################ +# Check if script is running in correct Vivado version. +################################################################ +set scripts_vivado_version 2020.2 +set current_vivado_version [version -short] + +if { [string first $scripts_vivado_version $current_vivado_version] == -1 } { + puts "" + catch {common::send_gid_msg -ssname BD::TCL -id 2041 -severity "ERROR" "This script was generated using Vivado <$scripts_vivado_version> and is being run in <$current_vivado_version> of Vivado. Please run the script in Vivado <$scripts_vivado_version> then open the design in Vivado <$current_vivado_version>. Upgrade the design by running \"Tools => Report => Report IP Status...\", then run write_bd_tcl to create an updated script."} + + return 1 +} + +################################################################ +# START +################################################################ + +# To test this script, run the following commands from Vivado Tcl console: +# source design_1_script.tcl + +# If there is no project opened, this script will create a +# project, but make sure you do not have an existing project +# <./myproj/project_1.xpr> in the current working folder. + +set list_projs [get_projects -quiet] +if { $list_projs eq "" } { + create_project project_1 myproj -part xc7z020clg484-1 + set_property BOARD_PART em.avnet.com:zed:part0:1.4 [current_project] +} + + +# CHANGE DESIGN NAME HERE +variable design_name +set design_name design_1 + +# If you do not already have an existing IP Integrator design open, +# you can create a design using the following command: +# create_bd_design $design_name + +# Creating design if needed +set errMsg "" +set nRet 0 + +set cur_design [current_bd_design -quiet] +set list_cells [get_bd_cells -quiet] + +if { ${design_name} eq "" } { + # USE CASES: + # 1) Design_name not set + + set errMsg "Please set the variable to a non-empty value." + set nRet 1 + +} elseif { ${cur_design} ne "" && ${list_cells} eq "" } { + # USE CASES: + # 2): Current design opened AND is empty AND names same. + # 3): Current design opened AND is empty AND names diff; design_name NOT in project. + # 4): Current design opened AND is empty AND names diff; design_name exists in project. + + if { $cur_design ne $design_name } { + common::send_gid_msg -ssname BD::TCL -id 2001 -severity "INFO" "Changing value of from <$design_name> to <$cur_design> since current design is empty." + set design_name [get_property NAME $cur_design] + } + common::send_gid_msg -ssname BD::TCL -id 2002 -severity "INFO" "Constructing design in IPI design <$cur_design>..." + +} elseif { ${cur_design} ne "" && $list_cells ne "" && $cur_design eq $design_name } { + # USE CASES: + # 5) Current design opened AND has components AND same names. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 1 +} elseif { [get_files -quiet ${design_name}.bd] ne "" } { + # USE CASES: + # 6) Current opened design, has components, but diff names, design_name exists in project. + # 7) No opened design, design_name exists in project. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 2 + +} else { + # USE CASES: + # 8) No opened design, design_name not in project. + # 9) Current opened design, has components, but diff names, design_name not in project. + + common::send_gid_msg -ssname BD::TCL -id 2003 -severity "INFO" "Currently there is no design <$design_name> in project, so creating one..." + + create_bd_design $design_name + + common::send_gid_msg -ssname BD::TCL -id 2004 -severity "INFO" "Making design <$design_name> as current_bd_design." + current_bd_design $design_name + +} + +common::send_gid_msg -ssname BD::TCL -id 2005 -severity "INFO" "Currently the variable is equal to \"$design_name\"." + +if { $nRet != 0 } { + catch {common::send_gid_msg -ssname BD::TCL -id 2006 -severity "ERROR" $errMsg} + return $nRet +} + +set bCheckIPsPassed 1 +################################################################## +# CHECK IPs +################################################################## +set bCheckIPs 1 +if { $bCheckIPs == 1 } { + set list_check_ips "\ +xilinx.com:hls:HlsSvdKernel:1.0\ +xilinx.com:ip:processing_system7:5.5\ +xilinx.com:ip:proc_sys_reset:5.0\ +xilinx.com:ip:axi_dma:7.1\ +" + + set list_ips_missing "" + common::send_gid_msg -ssname BD::TCL -id 2011 -severity "INFO" "Checking if the following IPs exist in the project's IP catalog: $list_check_ips ." + + foreach ip_vlnv $list_check_ips { + set ip_obj [get_ipdefs -all $ip_vlnv] + if { $ip_obj eq "" } { + lappend list_ips_missing $ip_vlnv + } + } + + if { $list_ips_missing ne "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2012 -severity "ERROR" "The following IPs are not found in the IP Catalog:\n $list_ips_missing\n\nResolution: Please add the repository containing the IP(s) to the project." } + set bCheckIPsPassed 0 + } + +} + +if { $bCheckIPsPassed != 1 } { + common::send_gid_msg -ssname BD::TCL -id 2023 -severity "WARNING" "Will not continue with creation of design due to the error(s) above." + return 3 +} + +################################################################## +# DESIGN PROCs +################################################################## + + + +# Procedure to create entire design; Provide argument to make +# procedure reusable. If parentCell is "", will use root. +proc create_root_design { parentCell } { + + variable script_folder + variable design_name + + if { $parentCell eq "" } { + set parentCell [get_bd_cells /] + } + + # Get object for parentCell + set parentObj [get_bd_cells $parentCell] + if { $parentObj == "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2090 -severity "ERROR" "Unable to find parent cell <$parentCell>!"} + return + } + + # Make sure parentObj is hier blk + set parentType [get_property TYPE $parentObj] + if { $parentType ne "hier" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2091 -severity "ERROR" "Parent <$parentObj> has TYPE = <$parentType>. Expected to be ."} + return + } + + # Save current instance; Restore later + set oldCurInst [current_bd_instance .] + + # Set parent object as current + current_bd_instance $parentObj + + + # Create interface ports + set DDR [ create_bd_intf_port -mode Master -vlnv xilinx.com:interface:ddrx_rtl:1.0 DDR ] + + set FIXED_IO [ create_bd_intf_port -mode Master -vlnv xilinx.com:display_processing_system7:fixedio_rtl:1.0 FIXED_IO ] + + + # Create ports + + # Create instance: HlsSvdKernel_0, and set properties + set HlsSvdKernel_0 [ create_bd_cell -type ip -vlnv xilinx.com:hls:HlsSvdKernel:1.0 HlsSvdKernel_0 ] + + # Create instance: axi_mem_intercon, and set properties + set axi_mem_intercon [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + CONFIG.NUM_SI {1} \ + ] $axi_mem_intercon + + # Create instance: axi_mem_intercon_1, and set properties + set axi_mem_intercon_1 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_1 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + CONFIG.NUM_SI {2} \ + ] $axi_mem_intercon_1 + + # Create instance: axi_mem_intercon_2, and set properties + set axi_mem_intercon_2 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_2 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_2 + + # Create instance: axi_mem_intercon_3, and set properties + set axi_mem_intercon_3 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_3 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_3 + + # Create instance: processing_system7_0, and set properties + set processing_system7_0 [ create_bd_cell -type ip -vlnv xilinx.com:ip:processing_system7:5.5 processing_system7_0 ] + set_property -dict [ list \ + CONFIG.PCW_ACT_APU_PERIPHERAL_FREQMHZ {666.666687} \ + CONFIG.PCW_ACT_CAN_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_DCI_PERIPHERAL_FREQMHZ {10.158730} \ + CONFIG.PCW_ACT_ENET0_PERIPHERAL_FREQMHZ {125.000000} \ + CONFIG.PCW_ACT_ENET1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_ACT_FPGA1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA2_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA3_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_PCAP_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_QSPI_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_SDIO_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_SMC_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_SPI_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_TPIU_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_TTC0_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_UART_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_WDT_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_APU_PERIPHERAL_FREQMHZ {666.666667} \ + CONFIG.PCW_ARMPLL_CTRL_FBDIV {40} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_CLK0_FREQ {100000000} \ + CONFIG.PCW_CLK1_FREQ {10000000} \ + CONFIG.PCW_CLK2_FREQ {10000000} \ + CONFIG.PCW_CLK3_FREQ {10000000} \ + CONFIG.PCW_CPU_CPU_PLL_FREQMHZ {1333.333} \ + CONFIG.PCW_CPU_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR0 {15} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR1 {7} \ + CONFIG.PCW_DDRPLL_CTRL_FBDIV {32} \ + CONFIG.PCW_DDR_DDR_PLL_FREQMHZ {1066.667} \ + CONFIG.PCW_DDR_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DDR_RAM_HIGHADDR {0x1FFFFFFF} \ + CONFIG.PCW_ENET0_ENET0_IO {MIO 16 .. 27} \ + CONFIG.PCW_ENET0_GRP_MDIO_ENABLE {1} \ + CONFIG.PCW_ENET0_GRP_MDIO_IO {MIO 52 .. 53} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR0 {8} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_FREQMHZ {1000 Mbps} \ + CONFIG.PCW_ENET0_RESET_ENABLE {0} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET1_RESET_ENABLE {0} \ + CONFIG.PCW_ENET_RESET_ENABLE {1} \ + CONFIG.PCW_ENET_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_EN_EMIO_TTC0 {1} \ + CONFIG.PCW_EN_ENET0 {1} \ + CONFIG.PCW_EN_GPIO {1} \ + CONFIG.PCW_EN_QSPI {1} \ + CONFIG.PCW_EN_SDIO0 {1} \ + CONFIG.PCW_EN_TTC0 {1} \ + CONFIG.PCW_EN_UART1 {1} \ + CONFIG.PCW_EN_USB0 {1} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR1 {2} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_FPGA1_PERIPHERAL_FREQMHZ {150.000000} \ + CONFIG.PCW_FPGA2_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA_FCLK0_ENABLE {1} \ + CONFIG.PCW_FPGA_FCLK1_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK2_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK3_ENABLE {0} \ + CONFIG.PCW_GPIO_MIO_GPIO_ENABLE {1} \ + CONFIG.PCW_GPIO_MIO_GPIO_IO {MIO} \ + CONFIG.PCW_I2C0_GRP_INT_ENABLE {0} \ + CONFIG.PCW_I2C0_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_I2C0_RESET_ENABLE {0} \ + CONFIG.PCW_I2C1_RESET_ENABLE {0} \ + CONFIG.PCW_I2C_PERIPHERAL_FREQMHZ {25} \ + CONFIG.PCW_I2C_RESET_ENABLE {1} \ + CONFIG.PCW_IOPLL_CTRL_FBDIV {30} \ + CONFIG.PCW_IO_IO_PLL_FREQMHZ {1000.000} \ + CONFIG.PCW_MIO_0_DIRECTION {inout} \ + CONFIG.PCW_MIO_0_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_0_PULLUP {disabled} \ + CONFIG.PCW_MIO_0_SLEW {slow} \ + CONFIG.PCW_MIO_10_DIRECTION {inout} \ + CONFIG.PCW_MIO_10_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_10_PULLUP {disabled} \ + CONFIG.PCW_MIO_10_SLEW {slow} \ + CONFIG.PCW_MIO_11_DIRECTION {inout} \ + CONFIG.PCW_MIO_11_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_11_PULLUP {disabled} \ + CONFIG.PCW_MIO_11_SLEW {slow} \ + CONFIG.PCW_MIO_12_DIRECTION {inout} \ + CONFIG.PCW_MIO_12_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_12_PULLUP {disabled} \ + CONFIG.PCW_MIO_12_SLEW {slow} \ + CONFIG.PCW_MIO_13_DIRECTION {inout} \ + CONFIG.PCW_MIO_13_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_13_PULLUP {disabled} \ + CONFIG.PCW_MIO_13_SLEW {slow} \ + CONFIG.PCW_MIO_14_DIRECTION {inout} \ + CONFIG.PCW_MIO_14_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_14_PULLUP {disabled} \ + CONFIG.PCW_MIO_14_SLEW {slow} \ + CONFIG.PCW_MIO_15_DIRECTION {inout} \ + CONFIG.PCW_MIO_15_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_15_PULLUP {disabled} \ + CONFIG.PCW_MIO_15_SLEW {slow} \ + CONFIG.PCW_MIO_16_DIRECTION {out} \ + CONFIG.PCW_MIO_16_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_16_PULLUP {disabled} \ + CONFIG.PCW_MIO_16_SLEW {fast} \ + CONFIG.PCW_MIO_17_DIRECTION {out} \ + CONFIG.PCW_MIO_17_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_17_PULLUP {disabled} \ + CONFIG.PCW_MIO_17_SLEW {fast} \ + CONFIG.PCW_MIO_18_DIRECTION {out} \ + CONFIG.PCW_MIO_18_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_18_PULLUP {disabled} \ + CONFIG.PCW_MIO_18_SLEW {fast} \ + CONFIG.PCW_MIO_19_DIRECTION {out} \ + CONFIG.PCW_MIO_19_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_19_PULLUP {disabled} \ + CONFIG.PCW_MIO_19_SLEW {fast} \ + CONFIG.PCW_MIO_1_DIRECTION {out} \ + CONFIG.PCW_MIO_1_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_1_PULLUP {disabled} \ + CONFIG.PCW_MIO_1_SLEW {fast} \ + CONFIG.PCW_MIO_20_DIRECTION {out} \ + CONFIG.PCW_MIO_20_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_20_PULLUP {disabled} \ + CONFIG.PCW_MIO_20_SLEW {fast} \ + CONFIG.PCW_MIO_21_DIRECTION {out} \ + CONFIG.PCW_MIO_21_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_21_PULLUP {disabled} \ + CONFIG.PCW_MIO_21_SLEW {fast} \ + CONFIG.PCW_MIO_22_DIRECTION {in} \ + CONFIG.PCW_MIO_22_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_22_PULLUP {disabled} \ + CONFIG.PCW_MIO_22_SLEW {fast} \ + CONFIG.PCW_MIO_23_DIRECTION {in} \ + CONFIG.PCW_MIO_23_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_23_PULLUP {disabled} \ + CONFIG.PCW_MIO_23_SLEW {fast} \ + CONFIG.PCW_MIO_24_DIRECTION {in} \ + CONFIG.PCW_MIO_24_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_24_PULLUP {disabled} \ + CONFIG.PCW_MIO_24_SLEW {fast} \ + CONFIG.PCW_MIO_25_DIRECTION {in} \ + CONFIG.PCW_MIO_25_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_25_PULLUP {disabled} \ + CONFIG.PCW_MIO_25_SLEW {fast} \ + CONFIG.PCW_MIO_26_DIRECTION {in} \ + CONFIG.PCW_MIO_26_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_26_PULLUP {disabled} \ + CONFIG.PCW_MIO_26_SLEW {fast} \ + CONFIG.PCW_MIO_27_DIRECTION {in} \ + CONFIG.PCW_MIO_27_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_27_PULLUP {disabled} \ + CONFIG.PCW_MIO_27_SLEW {fast} \ + CONFIG.PCW_MIO_28_DIRECTION {inout} \ + CONFIG.PCW_MIO_28_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_28_PULLUP {disabled} \ + CONFIG.PCW_MIO_28_SLEW {fast} \ + CONFIG.PCW_MIO_29_DIRECTION {in} \ + CONFIG.PCW_MIO_29_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_29_PULLUP {disabled} \ + CONFIG.PCW_MIO_29_SLEW {fast} \ + CONFIG.PCW_MIO_2_DIRECTION {inout} \ + CONFIG.PCW_MIO_2_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_2_PULLUP {disabled} \ + CONFIG.PCW_MIO_2_SLEW {fast} \ + CONFIG.PCW_MIO_30_DIRECTION {out} \ + CONFIG.PCW_MIO_30_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_30_PULLUP {disabled} \ + CONFIG.PCW_MIO_30_SLEW {fast} \ + CONFIG.PCW_MIO_31_DIRECTION {in} \ + CONFIG.PCW_MIO_31_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_31_PULLUP {disabled} \ + CONFIG.PCW_MIO_31_SLEW {fast} \ + CONFIG.PCW_MIO_32_DIRECTION {inout} \ + CONFIG.PCW_MIO_32_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_32_PULLUP {disabled} \ + CONFIG.PCW_MIO_32_SLEW {fast} \ + CONFIG.PCW_MIO_33_DIRECTION {inout} \ + CONFIG.PCW_MIO_33_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_33_PULLUP {disabled} \ + CONFIG.PCW_MIO_33_SLEW {fast} \ + CONFIG.PCW_MIO_34_DIRECTION {inout} \ + CONFIG.PCW_MIO_34_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_34_PULLUP {disabled} \ + CONFIG.PCW_MIO_34_SLEW {fast} \ + CONFIG.PCW_MIO_35_DIRECTION {inout} \ + CONFIG.PCW_MIO_35_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_35_PULLUP {disabled} \ + CONFIG.PCW_MIO_35_SLEW {fast} \ + CONFIG.PCW_MIO_36_DIRECTION {in} \ + CONFIG.PCW_MIO_36_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_36_PULLUP {disabled} \ + CONFIG.PCW_MIO_36_SLEW {fast} \ + CONFIG.PCW_MIO_37_DIRECTION {inout} \ + CONFIG.PCW_MIO_37_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_37_PULLUP {disabled} \ + CONFIG.PCW_MIO_37_SLEW {fast} \ + CONFIG.PCW_MIO_38_DIRECTION {inout} \ + CONFIG.PCW_MIO_38_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_38_PULLUP {disabled} \ + CONFIG.PCW_MIO_38_SLEW {fast} \ + CONFIG.PCW_MIO_39_DIRECTION {inout} \ + CONFIG.PCW_MIO_39_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_39_PULLUP {disabled} \ + CONFIG.PCW_MIO_39_SLEW {fast} \ + CONFIG.PCW_MIO_3_DIRECTION {inout} \ + CONFIG.PCW_MIO_3_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_3_PULLUP {disabled} \ + CONFIG.PCW_MIO_3_SLEW {fast} \ + CONFIG.PCW_MIO_40_DIRECTION {inout} \ + CONFIG.PCW_MIO_40_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_40_PULLUP {disabled} \ + CONFIG.PCW_MIO_40_SLEW {fast} \ + CONFIG.PCW_MIO_41_DIRECTION {inout} \ + CONFIG.PCW_MIO_41_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_41_PULLUP {disabled} \ + CONFIG.PCW_MIO_41_SLEW {fast} \ + CONFIG.PCW_MIO_42_DIRECTION {inout} \ + CONFIG.PCW_MIO_42_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_42_PULLUP {disabled} \ + CONFIG.PCW_MIO_42_SLEW {fast} \ + CONFIG.PCW_MIO_43_DIRECTION {inout} \ + CONFIG.PCW_MIO_43_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_43_PULLUP {disabled} \ + CONFIG.PCW_MIO_43_SLEW {fast} \ + CONFIG.PCW_MIO_44_DIRECTION {inout} \ + CONFIG.PCW_MIO_44_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_44_PULLUP {disabled} \ + CONFIG.PCW_MIO_44_SLEW {fast} \ + CONFIG.PCW_MIO_45_DIRECTION {inout} \ + CONFIG.PCW_MIO_45_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_45_PULLUP {disabled} \ + CONFIG.PCW_MIO_45_SLEW {fast} \ + CONFIG.PCW_MIO_46_DIRECTION {in} \ + CONFIG.PCW_MIO_46_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_46_PULLUP {disabled} \ + CONFIG.PCW_MIO_46_SLEW {slow} \ + CONFIG.PCW_MIO_47_DIRECTION {in} \ + CONFIG.PCW_MIO_47_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_47_PULLUP {disabled} \ + CONFIG.PCW_MIO_47_SLEW {slow} \ + CONFIG.PCW_MIO_48_DIRECTION {out} \ + CONFIG.PCW_MIO_48_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_48_PULLUP {disabled} \ + CONFIG.PCW_MIO_48_SLEW {slow} \ + CONFIG.PCW_MIO_49_DIRECTION {in} \ + CONFIG.PCW_MIO_49_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_49_PULLUP {disabled} \ + CONFIG.PCW_MIO_49_SLEW {slow} \ + CONFIG.PCW_MIO_4_DIRECTION {inout} \ + CONFIG.PCW_MIO_4_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_4_PULLUP {disabled} \ + CONFIG.PCW_MIO_4_SLEW {fast} \ + CONFIG.PCW_MIO_50_DIRECTION {inout} \ + CONFIG.PCW_MIO_50_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_50_PULLUP {disabled} \ + CONFIG.PCW_MIO_50_SLEW {slow} \ + CONFIG.PCW_MIO_51_DIRECTION {inout} \ + CONFIG.PCW_MIO_51_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_51_PULLUP {disabled} \ + CONFIG.PCW_MIO_51_SLEW {slow} \ + CONFIG.PCW_MIO_52_DIRECTION {out} \ + CONFIG.PCW_MIO_52_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_52_PULLUP {disabled} \ + CONFIG.PCW_MIO_52_SLEW {slow} \ + CONFIG.PCW_MIO_53_DIRECTION {inout} \ + CONFIG.PCW_MIO_53_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_53_PULLUP {disabled} \ + CONFIG.PCW_MIO_53_SLEW {slow} \ + CONFIG.PCW_MIO_5_DIRECTION {inout} \ + CONFIG.PCW_MIO_5_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_5_PULLUP {disabled} \ + CONFIG.PCW_MIO_5_SLEW {fast} \ + CONFIG.PCW_MIO_6_DIRECTION {out} \ + CONFIG.PCW_MIO_6_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_6_PULLUP {disabled} \ + CONFIG.PCW_MIO_6_SLEW {fast} \ + CONFIG.PCW_MIO_7_DIRECTION {out} \ + CONFIG.PCW_MIO_7_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_7_PULLUP {disabled} \ + CONFIG.PCW_MIO_7_SLEW {slow} \ + CONFIG.PCW_MIO_8_DIRECTION {out} \ + CONFIG.PCW_MIO_8_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_8_PULLUP {disabled} \ + CONFIG.PCW_MIO_8_SLEW {fast} \ + CONFIG.PCW_MIO_9_DIRECTION {inout} \ + CONFIG.PCW_MIO_9_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_9_PULLUP {disabled} \ + CONFIG.PCW_MIO_9_SLEW {slow} \ + CONFIG.PCW_MIO_TREE_PERIPHERALS {GPIO#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#UART 1#UART 1#GPIO#GPIO#Enet 0#Enet 0} \ + CONFIG.PCW_MIO_TREE_SIGNALS {gpio[0]#qspi0_ss_b#qspi0_io[0]#qspi0_io[1]#qspi0_io[2]#qspi0_io[3]/HOLD_B#qspi0_sclk#gpio[7]#gpio[8]#gpio[9]#gpio[10]#gpio[11]#gpio[12]#gpio[13]#gpio[14]#gpio[15]#tx_clk#txd[0]#txd[1]#txd[2]#txd[3]#tx_ctl#rx_clk#rxd[0]#rxd[1]#rxd[2]#rxd[3]#rx_ctl#data[4]#dir#stp#nxt#data[0]#data[1]#data[2]#data[3]#clk#data[5]#data[6]#data[7]#clk#cmd#data[0]#data[1]#data[2]#data[3]#wp#cd#tx#rx#gpio[50]#gpio[51]#mdc#mdio} \ + CONFIG.PCW_NAND_GRP_D8_ENABLE {0} \ + CONFIG.PCW_NAND_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_A25_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_INT_ENABLE {0} \ + CONFIG.PCW_NOR_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PCAP_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_PJTAG_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PRESET_BANK0_VOLTAGE {LVCMOS 3.3V} \ + CONFIG.PCW_PRESET_BANK1_VOLTAGE {LVCMOS 1.8V} \ + CONFIG.PCW_QSPI_GRP_FBCLK_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_IO1_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_ENABLE {1} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_IO {MIO 1 .. 6} \ + CONFIG.PCW_QSPI_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_QSPI_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_QSPI_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_QSPI_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_QSPI_QSPI_IO {MIO 1 .. 6} \ + CONFIG.PCW_SD0_GRP_CD_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_CD_IO {MIO 47} \ + CONFIG.PCW_SD0_GRP_POW_ENABLE {0} \ + CONFIG.PCW_SD0_GRP_WP_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_WP_IO {MIO 46} \ + CONFIG.PCW_SD0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_SD0_SD0_IO {MIO 40 .. 45} \ + CONFIG.PCW_SDIO_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_SDIO_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_SDIO_PERIPHERAL_VALID {1} \ + CONFIG.PCW_SINGLE_QSPI_DATA_MODE {x4} \ + CONFIG.PCW_SMC_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_SPI_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_S_AXI_HP2_DATA_WIDTH {64} \ + CONFIG.PCW_TPIU_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_TTC0_TTC0_IO {EMIO} \ + CONFIG.PCW_TTC_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART1_GRP_FULL_ENABLE {0} \ + CONFIG.PCW_UART1_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_UART1_UART1_IO {MIO 48 .. 49} \ + CONFIG.PCW_UART_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_UART_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART_PERIPHERAL_VALID {1} \ + CONFIG.PCW_UIPARAM_ACT_DDR_FREQ_MHZ {533.333374} \ + CONFIG.PCW_UIPARAM_DDR_BANK_ADDR_COUNT {3} \ + CONFIG.PCW_UIPARAM_DDR_BL {8} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY0 {0.41} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY1 {0.411} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY2 {0.341} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY3 {0.358} \ + CONFIG.PCW_UIPARAM_DDR_CL {7} \ + CONFIG.PCW_UIPARAM_DDR_COL_ADDR_COUNT {10} \ + CONFIG.PCW_UIPARAM_DDR_CWL {6} \ + CONFIG.PCW_UIPARAM_DDR_DEVICE_CAPACITY {2048 MBits} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_0 {0.025} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_1 {0.028} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_2 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_3 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DRAM_WIDTH {16 Bits} \ + CONFIG.PCW_UIPARAM_DDR_FREQ_MHZ {533.333313} \ + CONFIG.PCW_UIPARAM_DDR_MEMORY_TYPE {DDR 3} \ + CONFIG.PCW_UIPARAM_DDR_PARTNO {MT41J128M16 HA-15E} \ + CONFIG.PCW_UIPARAM_DDR_ROW_ADDR_COUNT {14} \ + CONFIG.PCW_UIPARAM_DDR_SPEED_BIN {DDR3_1066F} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_DATA_EYE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_READ_GATE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_WRITE_LEVEL {1} \ + CONFIG.PCW_UIPARAM_DDR_T_FAW {45.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RAS_MIN {36.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RC {49.5} \ + CONFIG.PCW_UIPARAM_DDR_T_RCD {7} \ + CONFIG.PCW_UIPARAM_DDR_T_RP {7} \ + CONFIG.PCW_UIPARAM_DDR_USE_INTERNAL_VREF {1} \ + CONFIG.PCW_USB0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_USB0_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_USB0_RESET_ENABLE {0} \ + CONFIG.PCW_USB0_USB0_IO {MIO 28 .. 39} \ + CONFIG.PCW_USB1_RESET_ENABLE {0} \ + CONFIG.PCW_USB_RESET_ENABLE {1} \ + CONFIG.PCW_USB_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_USE_S_AXI_HP0 {1} \ + CONFIG.PCW_USE_S_AXI_HP1 {1} \ + CONFIG.PCW_USE_S_AXI_HP2 {1} \ + CONFIG.PCW_USE_S_AXI_HP3 {1} \ + CONFIG.preset {ZedBoard} \ + ] $processing_system7_0 + + # Create instance: ps7_0_axi_periph, and set properties + set ps7_0_axi_periph [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 ps7_0_axi_periph ] + set_property -dict [ list \ + CONFIG.NUM_MI {7} \ + ] $ps7_0_axi_periph + + # Create instance: rst_ps7_0_100M, and set properties + set rst_ps7_0_100M [ create_bd_cell -type ip -vlnv xilinx.com:ip:proc_sys_reset:5.0 rst_ps7_0_100M ] + + # Create instance: s_dma, and set properties + set s_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 s_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $s_dma + + # Create instance: u_dma, and set properties + set u_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 u_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $u_dma + + # Create instance: v_dma, and set properties + set v_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 v_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $v_dma + + # Create instance: x_dma, and set properties + set x_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 x_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $x_dma + + # Create instance: y_dma, and set properties + set y_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 y_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s {0} \ + CONFIG.c_include_s2mm_dre {1} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_micro_dma {0} \ + CONFIG.c_s2mm_burst_size {128} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $y_dma + + # Create interface connections + connect_bd_intf_net -intf_net HlsSvdKernel_0_y_port [get_bd_intf_pins HlsSvdKernel_0/y_port] [get_bd_intf_pins y_dma/S_AXIS_S2MM] + connect_bd_intf_net -intf_net axi_mem_intercon_1_M00_AXI [get_bd_intf_pins axi_mem_intercon_1/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP1] + connect_bd_intf_net -intf_net axi_mem_intercon_2_M00_AXI [get_bd_intf_pins axi_mem_intercon_2/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP2] + connect_bd_intf_net -intf_net axi_mem_intercon_3_M00_AXI [get_bd_intf_pins axi_mem_intercon_3/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP3] + connect_bd_intf_net -intf_net axi_mem_intercon_M00_AXI [get_bd_intf_pins axi_mem_intercon/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP0] + connect_bd_intf_net -intf_net processing_system7_0_DDR [get_bd_intf_ports DDR] [get_bd_intf_pins processing_system7_0/DDR] + connect_bd_intf_net -intf_net processing_system7_0_FIXED_IO [get_bd_intf_ports FIXED_IO] [get_bd_intf_pins processing_system7_0/FIXED_IO] + connect_bd_intf_net -intf_net processing_system7_0_M_AXI_GP0 [get_bd_intf_pins processing_system7_0/M_AXI_GP0] [get_bd_intf_pins ps7_0_axi_periph/S00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M00_AXI [get_bd_intf_pins HlsSvdKernel_0/s_axi_control] [get_bd_intf_pins ps7_0_axi_periph/M00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M01_AXI [get_bd_intf_pins ps7_0_axi_periph/M01_AXI] [get_bd_intf_pins v_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M02_AXI [get_bd_intf_pins ps7_0_axi_periph/M02_AXI] [get_bd_intf_pins x_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M03_AXI [get_bd_intf_pins ps7_0_axi_periph/M03_AXI] [get_bd_intf_pins y_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M05_AXI [get_bd_intf_pins ps7_0_axi_periph/M05_AXI] [get_bd_intf_pins s_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M06_AXI [get_bd_intf_pins ps7_0_axi_periph/M06_AXI] [get_bd_intf_pins u_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net s_dma_M_AXIS_MM2S [get_bd_intf_pins HlsSvdKernel_0/s_port] [get_bd_intf_pins s_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net s_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S01_AXI] [get_bd_intf_pins s_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXIS_MM2S [get_bd_intf_pins HlsSvdKernel_0/u_port] [get_bd_intf_pins u_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S00_AXI] [get_bd_intf_pins v_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S1 [get_bd_intf_pins axi_mem_intercon_3/S00_AXI] [get_bd_intf_pins u_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net v_dma_M_AXIS_MM2S [get_bd_intf_pins HlsSvdKernel_0/v_port] [get_bd_intf_pins v_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXIS_MM2S [get_bd_intf_pins HlsSvdKernel_0/x_port] [get_bd_intf_pins x_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon/S00_AXI] [get_bd_intf_pins x_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net xu_dma_M_AXI_S2MM [get_bd_intf_pins axi_mem_intercon_2/S00_AXI] [get_bd_intf_pins y_dma/M_AXI_S2MM] + + # Create port connections + connect_bd_net -net processing_system7_0_FCLK_CLK0 [get_bd_pins HlsSvdKernel_0/ap_clk] [get_bd_pins axi_mem_intercon/ACLK] [get_bd_pins axi_mem_intercon/M00_ACLK] [get_bd_pins axi_mem_intercon/S00_ACLK] [get_bd_pins axi_mem_intercon_1/ACLK] [get_bd_pins axi_mem_intercon_1/M00_ACLK] [get_bd_pins axi_mem_intercon_1/S00_ACLK] [get_bd_pins axi_mem_intercon_1/S01_ACLK] [get_bd_pins axi_mem_intercon_2/ACLK] [get_bd_pins axi_mem_intercon_2/M00_ACLK] [get_bd_pins axi_mem_intercon_2/S00_ACLK] [get_bd_pins axi_mem_intercon_3/ACLK] [get_bd_pins axi_mem_intercon_3/M00_ACLK] [get_bd_pins axi_mem_intercon_3/S00_ACLK] [get_bd_pins processing_system7_0/FCLK_CLK0] [get_bd_pins processing_system7_0/M_AXI_GP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP1_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP2_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP3_ACLK] [get_bd_pins ps7_0_axi_periph/ACLK] [get_bd_pins ps7_0_axi_periph/M00_ACLK] [get_bd_pins ps7_0_axi_periph/M01_ACLK] [get_bd_pins ps7_0_axi_periph/M02_ACLK] [get_bd_pins ps7_0_axi_periph/M03_ACLK] [get_bd_pins ps7_0_axi_periph/M04_ACLK] [get_bd_pins ps7_0_axi_periph/M05_ACLK] [get_bd_pins ps7_0_axi_periph/M06_ACLK] [get_bd_pins ps7_0_axi_periph/S00_ACLK] [get_bd_pins rst_ps7_0_100M/slowest_sync_clk] [get_bd_pins s_dma/m_axi_mm2s_aclk] [get_bd_pins s_dma/s_axi_lite_aclk] [get_bd_pins u_dma/m_axi_mm2s_aclk] [get_bd_pins u_dma/s_axi_lite_aclk] [get_bd_pins v_dma/m_axi_mm2s_aclk] [get_bd_pins v_dma/s_axi_lite_aclk] [get_bd_pins x_dma/m_axi_mm2s_aclk] [get_bd_pins x_dma/s_axi_lite_aclk] [get_bd_pins y_dma/m_axi_s2mm_aclk] [get_bd_pins y_dma/s_axi_lite_aclk] + connect_bd_net -net processing_system7_0_FCLK_RESET0_N [get_bd_pins processing_system7_0/FCLK_RESET0_N] [get_bd_pins rst_ps7_0_100M/ext_reset_in] + connect_bd_net -net rst_ps7_0_100M_peripheral_aresetn [get_bd_pins HlsSvdKernel_0/ap_rst_n] [get_bd_pins axi_mem_intercon/ARESETN] [get_bd_pins axi_mem_intercon/M00_ARESETN] [get_bd_pins axi_mem_intercon/S00_ARESETN] [get_bd_pins axi_mem_intercon_1/ARESETN] [get_bd_pins axi_mem_intercon_1/M00_ARESETN] [get_bd_pins axi_mem_intercon_1/S00_ARESETN] [get_bd_pins axi_mem_intercon_1/S01_ARESETN] [get_bd_pins axi_mem_intercon_2/ARESETN] [get_bd_pins axi_mem_intercon_2/M00_ARESETN] [get_bd_pins axi_mem_intercon_2/S00_ARESETN] [get_bd_pins axi_mem_intercon_3/ARESETN] [get_bd_pins axi_mem_intercon_3/M00_ARESETN] [get_bd_pins axi_mem_intercon_3/S00_ARESETN] [get_bd_pins ps7_0_axi_periph/ARESETN] [get_bd_pins ps7_0_axi_periph/M00_ARESETN] [get_bd_pins ps7_0_axi_periph/M01_ARESETN] [get_bd_pins ps7_0_axi_periph/M02_ARESETN] [get_bd_pins ps7_0_axi_periph/M03_ARESETN] [get_bd_pins ps7_0_axi_periph/M04_ARESETN] [get_bd_pins ps7_0_axi_periph/M05_ARESETN] [get_bd_pins ps7_0_axi_periph/M06_ARESETN] [get_bd_pins ps7_0_axi_periph/S00_ARESETN] [get_bd_pins rst_ps7_0_100M/peripheral_aresetn] [get_bd_pins s_dma/axi_resetn] [get_bd_pins u_dma/axi_resetn] [get_bd_pins v_dma/axi_resetn] [get_bd_pins x_dma/axi_resetn] [get_bd_pins y_dma/axi_resetn] + + # Create address segments + assign_bd_address -offset 0x40000000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs HlsSvdKernel_0/s_axi_control/Reg] -force + assign_bd_address -offset 0x41E40000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs s_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E00000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs v_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E50000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs u_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E10000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs x_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E20000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs y_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces s_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces u_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP3/HP3_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces v_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces x_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP0/HP0_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces y_dma/Data_S2MM] [get_bd_addr_segs processing_system7_0/S_AXI_HP2/HP2_DDR_LOWOCM] -force + + + # Restore current instance + current_bd_instance $oldCurInst + + validate_bd_design + save_bd_design +} +# End of create_root_design() + + +################################################################## +# MAIN FLOW +################################################################## + +create_root_design "" + + diff --git a/pynq/kernel_u/kernel_u.ipynb b/pynq/kernel_u/kernel_u.ipynb new file mode 100644 index 0000000..51e133c --- /dev/null +++ b/pynq/kernel_u/kernel_u.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing Kernel-U\n", + "\n", + "This notebook will test an IP written in Vivado HLS." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pynq import Overlay\n", + "import pynq.lib.dma\n", + "from pynq import allocate\n", + "import numpy as np\n", + "from pynq import DefaultIP\n", + "import timeit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Program FPGA and inspect Overlay." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "overlay = Overlay(\"overlay/kernel_u.bit\")\n", + "overlay?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the kernel register map." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_refinements = Register(num_refinements=0)\n", + "}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel = overlay.HlsAxisKernelU_0\n", + "kernel.register_map\n", + "# print(\"stream size: \", adder.stream_size)\n", + "# accel_state = adder.get_state()\n", + "# print(\"accelerator state: \", accel_state)\n", + "# dma = overlay.axi_dma_0\n", + "# dma.register_map.MM2S_DMASR\n", + "# dma.register_map.S2MM_DMACR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel IP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The kernel IP can be automatically bound by first creating our Kernel class. Then, the overlay can be instantiated again." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class KernelDriver(DefaultIP):\n", + " def __init__(self, description):\n", + " super().__init__(description=description)\n", + " \n", + " bindto = ['xilinx.com:hls:HlsAxisKernelU:1.0']\n", + "\n", + " def start_accel(self):\n", + " self.register_map.CTRL.AP_START = 1\n", + " self.write(0x0, 1)\n", + " self.write(0x0, 1)\n", + " while(self.read(0x0) % 2 == 0):\n", + " self.write(0x0, 1)\n", + " pass # Wait until start, i.e. bit 0, is set.\n", + "\n", + " def set_state(self, state):\n", + " # self.register_map.CTRL = state\n", + " # return self.register_map.CTRL\n", + " self.write(0x0, state)\n", + " return self.read(0x0)\n", + "\n", + " def get_state(self):\n", + " return self.register_map.CTRL\n", + " # return self.read(0x0)\n", + "\n", + " @property\n", + " def num_refinements(self):\n", + " return self.register_map.num_refinements\n", + " # return self.read(0x10)\n", + "\n", + " @num_refinements.setter\n", + " def num_refinements(self, R):\n", + " # self.register_map.num_refinements = R\n", + " self.write(0x10, R)\n", + "\n", + "overlay = Overlay(\"overlay/kernel_u.bit\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check again the kernel:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_u = overlay.HlsAxisKernelU_0\n", + "kernel_u.get_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_u.read(0x10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the class is working, we setup the `num_refinements` using the setter method. We then read its corresponding register." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_u.num_refinements = 1\n", + "kernel_u.read(0x10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n", + "0x4\n" + ] + }, + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(kernel_u.get_state())\n", + "# kernel_u.start_accel()\n", + "print(kernel_u.get_state())\n", + "kernel_u.get_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Allocation and Run\n", + "\n", + "The data structures must be contiguosly allocated." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Buffers setup completed.\n", + "x_buffer.shape: (2, 512) - Bytes: 2048\n", + "u_buffer.shape: (128, 128, 4, 4) - Bytes: 524288\n", + "xu_buffer.shape: (128, 4, 2) - Bytes: 2048\n" + ] + } + ], + "source": [ + "# The following parameters are fixed in hardware and cannot be changed:\n", + "# - The number of inputs N\n", + "# - The input size I\n", + "# - The number of gates G\n", + "# - The tile size Tu\n", + "I = 512\n", + "G = 4\n", + "N = 2\n", + "Tu = 4\n", + "data_t = np.int16\n", + "# The number of refinements R can instead be adjusted.\n", + "R = 128\n", + "\n", + "x_buffer = pynq.allocate(shape=(N, I,), dtype=data_t)\n", + "u_buffer = pynq.allocate(shape=(R, I // Tu, G, Tu), dtype=data_t)\n", + "xu_buffer = pynq.allocate(shape=(R, G, N,), dtype=data_t)\n", + "\n", + "for i in range(N):\n", + " for j in range(I):\n", + " # for ii in range(R):\n", + " x_buffer[i, j] = data_t(np.random.uniform(low=-2**15, high=2**15))\n", + "\n", + "for i in range(R):\n", + " for j in range(I // Tu):\n", + " for k in range(G):\n", + " for ii in range(Tu):\n", + " u_buffer[i, j, k, ii] = data_t(np.random.uniform(low=-2**15, high=2**15))\n", + "\n", + "for i in range(R):\n", + " for j in range(G):\n", + " for k in range(N):\n", + " xu_buffer[i, j, k] = 0\n", + "\n", + "print('Buffers setup completed.')\n", + "print(f'x_buffer.shape: {x_buffer.shape} - Bytes: {x_buffer.nbytes}')\n", + "print(f'u_buffer.shape: {u_buffer.shape} - Bytes: {u_buffer.nbytes}')\n", + "print(f'xu_buffer.shape: {xu_buffer.shape} - Bytes: {xu_buffer.nbytes}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup the kernel and then send the data through the DMAs." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n", + "0x1\n", + "Starting transfer:\n", + "Wait x...DONE.\n", + "Wait u...DONE.\n", + "Wait xu...DONE.\n", + "\n", + "xu_buffer.shape: (128, 4, 2)\n" + ] + } + ], + "source": [ + "kernel_u.num_refinements = R\n", + "print(kernel_u.get_state())\n", + "kernel_u.start_accel()\n", + "print(kernel_u.get_state())\n", + "\n", + "# Transfer\n", + "print('Starting transfer:')\n", + "overlay.x_dma.sendchannel.transfer(x_buffer)\n", + "overlay.u_dma.sendchannel.transfer(u_buffer)\n", + "overlay.xu_dma.recvchannel.transfer(xu_buffer)\n", + "# Then wait\n", + "print('Wait x...', end='')\n", + "overlay.x_dma.sendchannel.wait()\n", + "print('DONE.\\nWait u...', end='')\n", + "overlay.u_dma.sendchannel.wait()\n", + "print('DONE.\\nWait xu...', end='')\n", + "overlay.xu_dma.recvchannel.wait()\n", + "print('DONE.\\n')\n", + "\n", + "print(f'xu_buffer.shape: {xu_buffer.shape}')\n", + "# print(f'xu_buffer: {xu_buffer}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def run_kernel(R, x_buffer, u_buffer, xu_buffer):\n", + " kernel_u.num_refinements = R\n", + " kernel_u.start_accel()\n", + " # Transfer\n", + " overlay.x_dma.sendchannel.transfer(x_buffer)\n", + " overlay.u_dma.sendchannel.transfer(u_buffer)\n", + " overlay.xu_dma.recvchannel.transfer(xu_buffer)\n", + " # Then wait\n", + " overlay.x_dma.sendchannel.wait()\n", + " overlay.u_dma.sendchannel.wait()\n", + " overlay.xu_dma.recvchannel.wait()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 148 ms per loop\n" + ] + } + ], + "source": [ + "%timeit run_kernel(R, x_buffer, u_buffer, xu_buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Checking Correctness\n", + "\n", + "We first find the proper reshape mechanisms:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.25823639 1.03248304 -0.3389279 -0.26103506] [-1.25823639 1.03248304 -0.3389279 -0.26103506]\n", + "0.0\n", + "[ 0.38526848 -0.34712276 -0.39317614 0.77762274] [ 0.38526848 -0.34712276 -0.39317614 0.77762274]\n", + "0.0\n", + "(128, 4, 2)\n" + ] + } + ], + "source": [ + "# =============================================================================\n", + "# Reshape: (R, I, G) => (R, I // Tu, G, Tu)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I, G)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp.reshape(R, I // Tu, Tu, G), (0, 1, 3, 2))\n", + "print(u[0, 0:4, 0], u_tmp[0, 0, 0, 0:4])\n", + "print(u[0, 3, 0] - u_tmp[0, 0, 0, 3])\n", + "\n", + "# =============================================================================\n", + "# Reshape: (R, I // Tu, G, Tu) => (I, G, R)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I // Tu, G, Tu)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp, (1, 3, 2, 0)).reshape(I, G, R)\n", + "print(u[0, 0, 0, 0:4], u_tmp[0:4, 0, 0])\n", + "print(u[0, 0, 0, 3] - u_tmp[3, 0, 0])\n", + "\n", + "x = np.random.randn(N, I)\n", + "u = np.random.randn(I, G, R)\n", + "x = (x * 2).astype(np.int16)\n", + "u = (u * 2).astype(np.int16)\n", + "\n", + "xu = np.transpose(np.tensordot(x, u, axes=1), (2, 1, 0))\n", + "print(xu.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now check the Numpy computation against the FPGA result." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "All equal: True\n", + "gold[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n", + "fpga[0]: [[ -3634 -22667]\n", + " [ 31065 15347]\n", + " [ 22140 -9595]\n", + " [ 9106 26136]]\n" + ] + } + ], + "source": [ + "u_tmp = np.transpose(u_buffer, (1, 3, 2, 0)).reshape(I, G, R)\n", + "xu_gold = np.transpose(np.tensordot(x_buffer, u_tmp, axes=1), (2, 1, 0))\n", + "print('\\nAll equal:', np.allclose(xu_buffer, xu_gold))\n", + "print('gold[0]: ', xu_gold[0])\n", + "print('fpga[0]: ', xu_buffer[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pynq/kernel_u/kernel_u_hier.ipynb b/pynq/kernel_u/kernel_u_hier.ipynb new file mode 100644 index 0000000..78cd282 --- /dev/null +++ b/pynq/kernel_u/kernel_u_hier.ipynb @@ -0,0 +1,197 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing an IP that adds 1 to a stream\n", + "\n", + "This notebook will test an IP written in Vivado HLS. The IP adds +1 to a buffer. The HP ports **must** be configured at 64bit, not 32bit." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from pynq import Overlay\n", + "import pynq.lib.dma\n", + "from pynq import allocate\n", + "import numpy as np\n", + "from pynq import DefaultIP\n", + "from pynq import DefaultHierarchy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to define our own class **before** istantiating the overlay. In this way it will be automatically bound. We can use an accelerator driver as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "class AdderDriver(DefaultIP):\n", + " def __init__(self, description):\n", + " super().__init__(description=description)\n", + " bindto = [\"xilinx.com:hls:hls_adder:1.0\"]\n", + "\n", + " def start_accel(self):\n", + " self.write(0x0, 1)\n", + "\n", + " def set_state(self, state):\n", + " self.write(0x0, state)\n", + " return self.read(0x0)\n", + "\n", + " def get_state(self):\n", + " return self.read(0x0)\n", + "\n", + " @property\n", + " def stream_size(self):\n", + " return self.read(0x10)\n", + "\n", + " @stream_size.setter\n", + " def stream_size(self, size):\n", + " self.write(0x10, size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But it comes more handy to use an Hierarchy class as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "class StreamAdderDriver(DefaultHierarchy):\n", + " def __init__(self, description):\n", + " super().__init__(description)\n", + "\n", + " def stream_add(self, stream):\n", + " in_buffer = allocate(shape=(len(stream),), dtype=np.float32)\n", + " out_buffer = allocate(shape=(len(stream),), dtype=np.float32)\n", + " for i, elem in enumerate(stream):\n", + " in_buffer[i] = elem\n", + " # NOTE: for managing the HLS accelerator, we exploit\n", + " # the driver that we defined above.\n", + " self.hls_adder.stream_size = len(stream)\n", + " self.hls_adder.start_accel() # NOTE: The start must be sent before setting the other arguments \n", + " self.dma.sendchannel.transfer(in_buffer)\n", + " self.dma.recvchannel.transfer(out_buffer)\n", + " self.dma.sendchannel.wait()\n", + " self.dma.recvchannel.wait()\n", + " result = out_buffer.view(dtype=np.float32).copy()\n", + " del in_buffer, out_buffer\n", + " return result\n", + "\n", + " @staticmethod\n", + " def checkhierarchy(description):\n", + " \"\"\"\n", + " An Hierarchy that meets these requirements will be\n", + " automatically registered to this driver.\n", + " \"\"\"\n", + " if \"dma\" in description[\"ip\"] and \"hls_adder\" in description[\"ip\"]:\n", + " return True\n", + " return False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can istantiate the overaly, so that the drivers above will be automatically registered." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "overlay = Overlay(\"overlay/streamed_add_hier.bit\", download=False)\n", + "# overlay.download()\n", + "# overlay?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Width of Buffer Length Register\n", + "This integer value specifies the number of valid bits used for the Control field buffer length and Status field bytes transferred in the Scatter/Gather descriptors. It also specifies the number of valid bits in the RX Length of the Status Stream App4 field when Use Rxlength is enabled. For Direct Register Mode, it specifies the number of valid bits in the MM2S_LENGTH and S2MM_LENGTH registers. The length width directly correlates to the number of bytes being specified in a Scatter/Gather descriptor or number of bytes being specified in App4.RxLength, MM2S_LENGTH, or S2MM_LENGTH. The number of bytes is equal to 2^Length Width. So a Length Width of 26 gives a byte count of 67,108,863 bytes. This value should be set to 23 for Multichannel mode." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1.00000000e+00 4.14159298e+00 7.28318548e+00 ..., 3.20856616e+03\n", + " 3.21170776e+03 3.21484937e+03]\n", + "[ True True True ..., True True True]\n", + "3.469756501941687e-05\n" + ] + } + ], + "source": [ + "stream = [i * np.pi for i in range(1024)]\n", + "# print(stream)\n", + "out_stream = overlay.adder.stream_add(stream)\n", + "print(out_stream)\n", + "print(np.isclose(np.array(stream) + 1, out_stream))\n", + "print(np.abs((np.array(stream) - (out_stream - 1))).mean())\n", + "\n", + "# # NOTE: The following is a neat way of printing the np.floats in HEX format. \n", + "# for orig, f32, u32 in zip(np.array(stream, dtype=np.float32).view(dtype=np.uint32), out_stream, out_stream.view(dtype=np.uint32)):\n", + "# print(\"{:x}\\t{:03.3}\\t{:x}\".format(orig, f32, u32))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pynq/kernel_u/overlay/kernel_u.bit b/pynq/kernel_u/overlay/kernel_u.bit new file mode 100644 index 0000000..06eadae Binary files /dev/null and b/pynq/kernel_u/overlay/kernel_u.bit differ diff --git a/pynq/kernel_u/overlay/kernel_u.hwh b/pynq/kernel_u/overlay/kernel_u.hwh new file mode 100644 index 0000000..4715498 --- /dev/null +++ b/pynq/kernel_u/overlay/kernel_u.hwh @@ -0,0 +1,9213 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pynq/kernel_u/overlay/kernel_u.tcl b/pynq/kernel_u/overlay/kernel_u.tcl new file mode 100644 index 0000000..bc90a73 --- /dev/null +++ b/pynq/kernel_u/overlay/kernel_u.tcl @@ -0,0 +1,1088 @@ + +################################################################ +# This is a generated script based on design: design_1 +# +# Though there are limitations about the generated script, +# the main purpose of this utility is to make learning +# IP Integrator Tcl commands easier. +################################################################ + +namespace eval _tcl { +proc get_script_folder {} { + set script_path [file normalize [info script]] + set script_folder [file dirname $script_path] + return $script_folder +} +} +variable script_folder +set script_folder [_tcl::get_script_folder] + +################################################################ +# Check if script is running in correct Vivado version. +################################################################ +set scripts_vivado_version 2018.3 +set current_vivado_version [version -short] + +if { [string first $scripts_vivado_version $current_vivado_version] == -1 } { + puts "" + catch {common::send_msg_id "BD_TCL-109" "ERROR" "This script was generated using Vivado <$scripts_vivado_version> and is being run in <$current_vivado_version> of Vivado. Please run the script in Vivado <$scripts_vivado_version> then open the design in Vivado <$current_vivado_version>. Upgrade the design by running \"Tools => Report => Report IP Status...\", then run write_bd_tcl to create an updated script."} + + return 1 +} + +################################################################ +# START +################################################################ + +# To test this script, run the following commands from Vivado Tcl console: +# source design_1_script.tcl + +# If there is no project opened, this script will create a +# project, but make sure you do not have an existing project +# <./myproj/project_1.xpr> in the current working folder. + +set list_projs [get_projects -quiet] +if { $list_projs eq "" } { + create_project project_1 myproj -part xc7z020clg400-1 + set_property BOARD_PART www.digilentinc.com:pynq-z1:part0:1.0 [current_project] +} + + +# CHANGE DESIGN NAME HERE +variable design_name +set design_name design_1 + +# If you do not already have an existing IP Integrator design open, +# you can create a design using the following command: +# create_bd_design $design_name + +# Creating design if needed +set errMsg "" +set nRet 0 + +set cur_design [current_bd_design -quiet] +set list_cells [get_bd_cells -quiet] + +if { ${design_name} eq "" } { + # USE CASES: + # 1) Design_name not set + + set errMsg "Please set the variable to a non-empty value." + set nRet 1 + +} elseif { ${cur_design} ne "" && ${list_cells} eq "" } { + # USE CASES: + # 2): Current design opened AND is empty AND names same. + # 3): Current design opened AND is empty AND names diff; design_name NOT in project. + # 4): Current design opened AND is empty AND names diff; design_name exists in project. + + if { $cur_design ne $design_name } { + common::send_msg_id "BD_TCL-001" "INFO" "Changing value of from <$design_name> to <$cur_design> since current design is empty." + set design_name [get_property NAME $cur_design] + } + common::send_msg_id "BD_TCL-002" "INFO" "Constructing design in IPI design <$cur_design>..." + +} elseif { ${cur_design} ne "" && $list_cells ne "" && $cur_design eq $design_name } { + # USE CASES: + # 5) Current design opened AND has components AND same names. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 1 +} elseif { [get_files -quiet ${design_name}.bd] ne "" } { + # USE CASES: + # 6) Current opened design, has components, but diff names, design_name exists in project. + # 7) No opened design, design_name exists in project. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 2 + +} else { + # USE CASES: + # 8) No opened design, design_name not in project. + # 9) Current opened design, has components, but diff names, design_name not in project. + + common::send_msg_id "BD_TCL-003" "INFO" "Currently there is no design <$design_name> in project, so creating one..." + + create_bd_design $design_name + + common::send_msg_id "BD_TCL-004" "INFO" "Making design <$design_name> as current_bd_design." + current_bd_design $design_name + +} + +common::send_msg_id "BD_TCL-005" "INFO" "Currently the variable is equal to \"$design_name\"." + +if { $nRet != 0 } { + catch {common::send_msg_id "BD_TCL-114" "ERROR" $errMsg} + return $nRet +} + +set bCheckIPsPassed 1 +################################################################## +# CHECK IPs +################################################################## +set bCheckIPs 1 +if { $bCheckIPs == 1 } { + set list_check_ips "\ +xilinx.com:hls:HlsAxisKernelU:1.0\ +xilinx.com:ip:processing_system7:5.5\ +xilinx.com:ip:proc_sys_reset:5.0\ +xilinx.com:ip:axi_dma:7.1\ +" + + set list_ips_missing "" + common::send_msg_id "BD_TCL-006" "INFO" "Checking if the following IPs exist in the project's IP catalog: $list_check_ips ." + + foreach ip_vlnv $list_check_ips { + set ip_obj [get_ipdefs -all $ip_vlnv] + if { $ip_obj eq "" } { + lappend list_ips_missing $ip_vlnv + } + } + + if { $list_ips_missing ne "" } { + catch {common::send_msg_id "BD_TCL-115" "ERROR" "The following IPs are not found in the IP Catalog:\n $list_ips_missing\n\nResolution: Please add the repository containing the IP(s) to the project." } + set bCheckIPsPassed 0 + } + +} + +if { $bCheckIPsPassed != 1 } { + common::send_msg_id "BD_TCL-1003" "WARNING" "Will not continue with creation of design due to the error(s) above." + return 3 +} + +################################################################## +# DESIGN PROCs +################################################################## + + + +# Procedure to create entire design; Provide argument to make +# procedure reusable. If parentCell is "", will use root. +proc create_root_design { parentCell } { + + variable script_folder + variable design_name + + if { $parentCell eq "" } { + set parentCell [get_bd_cells /] + } + + # Get object for parentCell + set parentObj [get_bd_cells $parentCell] + if { $parentObj == "" } { + catch {common::send_msg_id "BD_TCL-100" "ERROR" "Unable to find parent cell <$parentCell>!"} + return + } + + # Make sure parentObj is hier blk + set parentType [get_property TYPE $parentObj] + if { $parentType ne "hier" } { + catch {common::send_msg_id "BD_TCL-101" "ERROR" "Parent <$parentObj> has TYPE = <$parentType>. Expected to be ."} + return + } + + # Save current instance; Restore later + set oldCurInst [current_bd_instance .] + + # Set parent object as current + current_bd_instance $parentObj + + + # Create interface ports + set DDR [ create_bd_intf_port -mode Master -vlnv xilinx.com:interface:ddrx_rtl:1.0 DDR ] + set FIXED_IO [ create_bd_intf_port -mode Master -vlnv xilinx.com:display_processing_system7:fixedio_rtl:1.0 FIXED_IO ] + + # Create ports + + # Create instance: HlsAxisKernelU_0, and set properties + set HlsAxisKernelU_0 [ create_bd_cell -type ip -vlnv xilinx.com:hls:HlsAxisKernelU:1.0 HlsAxisKernelU_0 ] + + # Create instance: axi_mem_intercon, and set properties + set axi_mem_intercon [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon + + # Create instance: axi_mem_intercon_1, and set properties + set axi_mem_intercon_1 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_1 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_1 + + # Create instance: axi_mem_intercon_2, and set properties + set axi_mem_intercon_2 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_2 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_2 + + # Create instance: processing_system7_0, and set properties + set processing_system7_0 [ create_bd_cell -type ip -vlnv xilinx.com:ip:processing_system7:5.5 processing_system7_0 ] + set_property -dict [ list \ + CONFIG.PCW_ACT_APU_PERIPHERAL_FREQMHZ {650.000000} \ + CONFIG.PCW_ACT_CAN0_PERIPHERAL_FREQMHZ {23.8095} \ + CONFIG.PCW_ACT_CAN1_PERIPHERAL_FREQMHZ {23.8095} \ + CONFIG.PCW_ACT_CAN_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_DCI_PERIPHERAL_FREQMHZ {10.096154} \ + CONFIG.PCW_ACT_ENET0_PERIPHERAL_FREQMHZ {125.000000} \ + CONFIG.PCW_ACT_ENET1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_ACT_FPGA1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA2_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA3_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_I2C_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_ACT_PCAP_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_QSPI_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_SDIO_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_SMC_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_SPI_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_TPIU_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_TTC0_CLK0_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC0_CLK1_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC0_CLK2_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC1_CLK0_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC1_CLK1_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC1_CLK2_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_ACT_TTC_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_ACT_UART_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_ACT_USB0_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_ACT_USB1_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_ACT_WDT_PERIPHERAL_FREQMHZ {108.333336} \ + CONFIG.PCW_APU_CLK_RATIO_ENABLE {6:2:1} \ + CONFIG.PCW_APU_PERIPHERAL_FREQMHZ {650} \ + CONFIG.PCW_ARMPLL_CTRL_FBDIV {26} \ + CONFIG.PCW_CAN0_BASEADDR {0xE0008000} \ + CONFIG.PCW_CAN0_HIGHADDR {0xE0008FFF} \ + CONFIG.PCW_CAN0_PERIPHERAL_CLKSRC {External} \ + CONFIG.PCW_CAN0_PERIPHERAL_FREQMHZ {-1} \ + CONFIG.PCW_CAN1_BASEADDR {0xE0009000} \ + CONFIG.PCW_CAN1_HIGHADDR {0xE0009FFF} \ + CONFIG.PCW_CAN1_PERIPHERAL_CLKSRC {External} \ + CONFIG.PCW_CAN1_PERIPHERAL_FREQMHZ {-1} \ + CONFIG.PCW_CAN_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_CAN_PERIPHERAL_VALID {0} \ + CONFIG.PCW_CLK0_FREQ {100000000} \ + CONFIG.PCW_CLK1_FREQ {10000000} \ + CONFIG.PCW_CLK2_FREQ {10000000} \ + CONFIG.PCW_CLK3_FREQ {10000000} \ + CONFIG.PCW_CORE0_FIQ_INTR {0} \ + CONFIG.PCW_CORE0_IRQ_INTR {0} \ + CONFIG.PCW_CORE1_FIQ_INTR {0} \ + CONFIG.PCW_CORE1_IRQ_INTR {0} \ + CONFIG.PCW_CPU_CPU_6X4X_MAX_RANGE {667} \ + CONFIG.PCW_CPU_CPU_PLL_FREQMHZ {1300.000} \ + CONFIG.PCW_CPU_PERIPHERAL_CLKSRC {ARM PLL} \ + CONFIG.PCW_CPU_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_CRYSTAL_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_DCI_PERIPHERAL_CLKSRC {DDR PLL} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR0 {52} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR1 {2} \ + CONFIG.PCW_DCI_PERIPHERAL_FREQMHZ {10.159} \ + CONFIG.PCW_DDRPLL_CTRL_FBDIV {21} \ + CONFIG.PCW_DDR_DDR_PLL_FREQMHZ {1050.000} \ + CONFIG.PCW_DDR_HPRLPR_QUEUE_PARTITION {HPR(0)/LPR(32)} \ + CONFIG.PCW_DDR_HPR_TO_CRITICAL_PRIORITY_LEVEL {15} \ + CONFIG.PCW_DDR_LPR_TO_CRITICAL_PRIORITY_LEVEL {2} \ + CONFIG.PCW_DDR_PERIPHERAL_CLKSRC {DDR PLL} \ + CONFIG.PCW_DDR_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DDR_PORT0_HPR_ENABLE {0} \ + CONFIG.PCW_DDR_PORT1_HPR_ENABLE {0} \ + CONFIG.PCW_DDR_PORT2_HPR_ENABLE {0} \ + CONFIG.PCW_DDR_PORT3_HPR_ENABLE {0} \ + CONFIG.PCW_DDR_RAM_BASEADDR {0x00100000} \ + CONFIG.PCW_DDR_RAM_HIGHADDR {0x1FFFFFFF} \ + CONFIG.PCW_DDR_WRITE_TO_CRITICAL_PRIORITY_LEVEL {2} \ + CONFIG.PCW_DM_WIDTH {4} \ + CONFIG.PCW_DQS_WIDTH {4} \ + CONFIG.PCW_DQ_WIDTH {32} \ + CONFIG.PCW_ENET0_BASEADDR {0xE000B000} \ + CONFIG.PCW_ENET0_ENET0_IO {MIO 16 .. 27} \ + CONFIG.PCW_ENET0_GRP_MDIO_ENABLE {1} \ + CONFIG.PCW_ENET0_GRP_MDIO_IO {MIO 52 .. 53} \ + CONFIG.PCW_ENET0_HIGHADDR {0xE000BFFF} \ + CONFIG.PCW_ENET0_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR0 {8} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_FREQMHZ {1000 Mbps} \ + CONFIG.PCW_ENET0_RESET_ENABLE {1} \ + CONFIG.PCW_ENET0_RESET_IO {MIO 9} \ + CONFIG.PCW_ENET1_BASEADDR {0xE000C000} \ + CONFIG.PCW_ENET1_GRP_MDIO_ENABLE {0} \ + CONFIG.PCW_ENET1_HIGHADDR {0xE000CFFF} \ + CONFIG.PCW_ENET1_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET1_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_ENET1_PERIPHERAL_FREQMHZ {1000 Mbps} \ + CONFIG.PCW_ENET1_RESET_ENABLE {0} \ + CONFIG.PCW_ENET_RESET_ENABLE {1} \ + CONFIG.PCW_ENET_RESET_POLARITY {Active Low} \ + CONFIG.PCW_ENET_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_EN_4K_TIMER {0} \ + CONFIG.PCW_EN_CAN0 {0} \ + CONFIG.PCW_EN_CAN1 {0} \ + CONFIG.PCW_EN_CLK0_PORT {1} \ + CONFIG.PCW_EN_CLK1_PORT {0} \ + CONFIG.PCW_EN_CLK2_PORT {0} \ + CONFIG.PCW_EN_CLK3_PORT {0} \ + CONFIG.PCW_EN_CLKTRIG0_PORT {0} \ + CONFIG.PCW_EN_CLKTRIG1_PORT {0} \ + CONFIG.PCW_EN_CLKTRIG2_PORT {0} \ + CONFIG.PCW_EN_CLKTRIG3_PORT {0} \ + CONFIG.PCW_EN_DDR {1} \ + CONFIG.PCW_EN_EMIO_CAN0 {0} \ + CONFIG.PCW_EN_EMIO_CAN1 {0} \ + CONFIG.PCW_EN_EMIO_CD_SDIO0 {0} \ + CONFIG.PCW_EN_EMIO_CD_SDIO1 {0} \ + CONFIG.PCW_EN_EMIO_ENET0 {0} \ + CONFIG.PCW_EN_EMIO_ENET1 {0} \ + CONFIG.PCW_EN_EMIO_GPIO {0} \ + CONFIG.PCW_EN_EMIO_I2C0 {0} \ + CONFIG.PCW_EN_EMIO_I2C1 {0} \ + CONFIG.PCW_EN_EMIO_MODEM_UART0 {0} \ + CONFIG.PCW_EN_EMIO_MODEM_UART1 {0} \ + CONFIG.PCW_EN_EMIO_PJTAG {0} \ + CONFIG.PCW_EN_EMIO_SDIO0 {0} \ + CONFIG.PCW_EN_EMIO_SDIO1 {0} \ + CONFIG.PCW_EN_EMIO_SPI0 {0} \ + CONFIG.PCW_EN_EMIO_SPI1 {0} \ + CONFIG.PCW_EN_EMIO_SRAM_INT {0} \ + CONFIG.PCW_EN_EMIO_TRACE {0} \ + CONFIG.PCW_EN_EMIO_TTC0 {0} \ + CONFIG.PCW_EN_EMIO_TTC1 {0} \ + CONFIG.PCW_EN_EMIO_UART0 {0} \ + CONFIG.PCW_EN_EMIO_UART1 {0} \ + CONFIG.PCW_EN_EMIO_WDT {0} \ + CONFIG.PCW_EN_EMIO_WP_SDIO0 {0} \ + CONFIG.PCW_EN_EMIO_WP_SDIO1 {0} \ + CONFIG.PCW_EN_ENET0 {1} \ + CONFIG.PCW_EN_ENET1 {0} \ + CONFIG.PCW_EN_GPIO {1} \ + CONFIG.PCW_EN_I2C0 {0} \ + CONFIG.PCW_EN_I2C1 {0} \ + CONFIG.PCW_EN_MODEM_UART0 {0} \ + CONFIG.PCW_EN_MODEM_UART1 {0} \ + CONFIG.PCW_EN_PJTAG {0} \ + CONFIG.PCW_EN_PTP_ENET0 {0} \ + CONFIG.PCW_EN_PTP_ENET1 {0} \ + CONFIG.PCW_EN_QSPI {1} \ + CONFIG.PCW_EN_RST0_PORT {1} \ + CONFIG.PCW_EN_RST1_PORT {0} \ + CONFIG.PCW_EN_RST2_PORT {0} \ + CONFIG.PCW_EN_RST3_PORT {0} \ + CONFIG.PCW_EN_SDIO0 {1} \ + CONFIG.PCW_EN_SDIO1 {0} \ + CONFIG.PCW_EN_SMC {0} \ + CONFIG.PCW_EN_SPI0 {0} \ + CONFIG.PCW_EN_SPI1 {0} \ + CONFIG.PCW_EN_TRACE {0} \ + CONFIG.PCW_EN_TTC0 {0} \ + CONFIG.PCW_EN_TTC1 {0} \ + CONFIG.PCW_EN_UART0 {1} \ + CONFIG.PCW_EN_UART1 {0} \ + CONFIG.PCW_EN_USB0 {1} \ + CONFIG.PCW_EN_USB1 {0} \ + CONFIG.PCW_EN_WDT {0} \ + CONFIG.PCW_FCLK0_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR1 {2} \ + CONFIG.PCW_FCLK1_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK_CLK0_BUF {TRUE} \ + CONFIG.PCW_FCLK_CLK1_BUF {FALSE} \ + CONFIG.PCW_FCLK_CLK2_BUF {FALSE} \ + CONFIG.PCW_FCLK_CLK3_BUF {FALSE} \ + CONFIG.PCW_FPGA0_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_FPGA1_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA2_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA3_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA_FCLK0_ENABLE {1} \ + CONFIG.PCW_FPGA_FCLK1_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK2_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK3_ENABLE {0} \ + CONFIG.PCW_GPIO_BASEADDR {0xE000A000} \ + CONFIG.PCW_GPIO_EMIO_GPIO_ENABLE {0} \ + CONFIG.PCW_GPIO_EMIO_GPIO_WIDTH {64} \ + CONFIG.PCW_GPIO_HIGHADDR {0xE000AFFF} \ + CONFIG.PCW_GPIO_MIO_GPIO_ENABLE {1} \ + CONFIG.PCW_GPIO_MIO_GPIO_IO {MIO} \ + CONFIG.PCW_GPIO_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_I2C0_BASEADDR {0xE0004000} \ + CONFIG.PCW_I2C0_HIGHADDR {0xE0004FFF} \ + CONFIG.PCW_I2C0_RESET_ENABLE {0} \ + CONFIG.PCW_I2C1_BASEADDR {0xE0005000} \ + CONFIG.PCW_I2C1_HIGHADDR {0xE0005FFF} \ + CONFIG.PCW_I2C1_RESET_ENABLE {0} \ + CONFIG.PCW_I2C_PERIPHERAL_FREQMHZ {25} \ + CONFIG.PCW_I2C_RESET_ENABLE {1} \ + CONFIG.PCW_I2C_RESET_POLARITY {Active Low} \ + CONFIG.PCW_IMPORT_BOARD_PRESET {None} \ + CONFIG.PCW_INCLUDE_ACP_TRANS_CHECK {0} \ + CONFIG.PCW_INCLUDE_TRACE_BUFFER {0} \ + CONFIG.PCW_IOPLL_CTRL_FBDIV {20} \ + CONFIG.PCW_IO_IO_PLL_FREQMHZ {1000.000} \ + CONFIG.PCW_IRQ_F2P_INTR {0} \ + CONFIG.PCW_IRQ_F2P_MODE {DIRECT} \ + CONFIG.PCW_MIO_0_DIRECTION {inout} \ + CONFIG.PCW_MIO_0_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_0_PULLUP {enabled} \ + CONFIG.PCW_MIO_0_SLEW {slow} \ + CONFIG.PCW_MIO_10_DIRECTION {inout} \ + CONFIG.PCW_MIO_10_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_10_PULLUP {enabled} \ + CONFIG.PCW_MIO_10_SLEW {slow} \ + CONFIG.PCW_MIO_11_DIRECTION {inout} \ + CONFIG.PCW_MIO_11_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_11_PULLUP {enabled} \ + CONFIG.PCW_MIO_11_SLEW {slow} \ + CONFIG.PCW_MIO_12_DIRECTION {inout} \ + CONFIG.PCW_MIO_12_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_12_PULLUP {enabled} \ + CONFIG.PCW_MIO_12_SLEW {slow} \ + CONFIG.PCW_MIO_13_DIRECTION {inout} \ + CONFIG.PCW_MIO_13_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_13_PULLUP {enabled} \ + CONFIG.PCW_MIO_13_SLEW {slow} \ + CONFIG.PCW_MIO_14_DIRECTION {in} \ + CONFIG.PCW_MIO_14_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_14_PULLUP {enabled} \ + CONFIG.PCW_MIO_14_SLEW {slow} \ + CONFIG.PCW_MIO_15_DIRECTION {out} \ + CONFIG.PCW_MIO_15_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_15_PULLUP {enabled} \ + CONFIG.PCW_MIO_15_SLEW {slow} \ + CONFIG.PCW_MIO_16_DIRECTION {out} \ + CONFIG.PCW_MIO_16_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_16_PULLUP {enabled} \ + CONFIG.PCW_MIO_16_SLEW {slow} \ + CONFIG.PCW_MIO_17_DIRECTION {out} \ + CONFIG.PCW_MIO_17_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_17_PULLUP {enabled} \ + CONFIG.PCW_MIO_17_SLEW {slow} \ + CONFIG.PCW_MIO_18_DIRECTION {out} \ + CONFIG.PCW_MIO_18_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_18_PULLUP {enabled} \ + CONFIG.PCW_MIO_18_SLEW {slow} \ + CONFIG.PCW_MIO_19_DIRECTION {out} \ + CONFIG.PCW_MIO_19_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_19_PULLUP {enabled} \ + CONFIG.PCW_MIO_19_SLEW {slow} \ + CONFIG.PCW_MIO_1_DIRECTION {out} \ + CONFIG.PCW_MIO_1_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_1_PULLUP {enabled} \ + CONFIG.PCW_MIO_1_SLEW {slow} \ + CONFIG.PCW_MIO_20_DIRECTION {out} \ + CONFIG.PCW_MIO_20_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_20_PULLUP {enabled} \ + CONFIG.PCW_MIO_20_SLEW {slow} \ + CONFIG.PCW_MIO_21_DIRECTION {out} \ + CONFIG.PCW_MIO_21_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_21_PULLUP {enabled} \ + CONFIG.PCW_MIO_21_SLEW {slow} \ + CONFIG.PCW_MIO_22_DIRECTION {in} \ + CONFIG.PCW_MIO_22_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_22_PULLUP {enabled} \ + CONFIG.PCW_MIO_22_SLEW {slow} \ + CONFIG.PCW_MIO_23_DIRECTION {in} \ + CONFIG.PCW_MIO_23_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_23_PULLUP {enabled} \ + CONFIG.PCW_MIO_23_SLEW {slow} \ + CONFIG.PCW_MIO_24_DIRECTION {in} \ + CONFIG.PCW_MIO_24_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_24_PULLUP {enabled} \ + CONFIG.PCW_MIO_24_SLEW {slow} \ + CONFIG.PCW_MIO_25_DIRECTION {in} \ + CONFIG.PCW_MIO_25_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_25_PULLUP {enabled} \ + CONFIG.PCW_MIO_25_SLEW {slow} \ + CONFIG.PCW_MIO_26_DIRECTION {in} \ + CONFIG.PCW_MIO_26_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_26_PULLUP {enabled} \ + CONFIG.PCW_MIO_26_SLEW {slow} \ + CONFIG.PCW_MIO_27_DIRECTION {in} \ + CONFIG.PCW_MIO_27_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_27_PULLUP {enabled} \ + CONFIG.PCW_MIO_27_SLEW {slow} \ + CONFIG.PCW_MIO_28_DIRECTION {inout} \ + CONFIG.PCW_MIO_28_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_28_PULLUP {enabled} \ + CONFIG.PCW_MIO_28_SLEW {slow} \ + CONFIG.PCW_MIO_29_DIRECTION {in} \ + CONFIG.PCW_MIO_29_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_29_PULLUP {enabled} \ + CONFIG.PCW_MIO_29_SLEW {slow} \ + CONFIG.PCW_MIO_2_DIRECTION {inout} \ + CONFIG.PCW_MIO_2_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_2_PULLUP {disabled} \ + CONFIG.PCW_MIO_2_SLEW {slow} \ + CONFIG.PCW_MIO_30_DIRECTION {out} \ + CONFIG.PCW_MIO_30_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_30_PULLUP {enabled} \ + CONFIG.PCW_MIO_30_SLEW {slow} \ + CONFIG.PCW_MIO_31_DIRECTION {in} \ + CONFIG.PCW_MIO_31_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_31_PULLUP {enabled} \ + CONFIG.PCW_MIO_31_SLEW {slow} \ + CONFIG.PCW_MIO_32_DIRECTION {inout} \ + CONFIG.PCW_MIO_32_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_32_PULLUP {enabled} \ + CONFIG.PCW_MIO_32_SLEW {slow} \ + CONFIG.PCW_MIO_33_DIRECTION {inout} \ + CONFIG.PCW_MIO_33_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_33_PULLUP {enabled} \ + CONFIG.PCW_MIO_33_SLEW {slow} \ + CONFIG.PCW_MIO_34_DIRECTION {inout} \ + CONFIG.PCW_MIO_34_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_34_PULLUP {enabled} \ + CONFIG.PCW_MIO_34_SLEW {slow} \ + CONFIG.PCW_MIO_35_DIRECTION {inout} \ + CONFIG.PCW_MIO_35_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_35_PULLUP {enabled} \ + CONFIG.PCW_MIO_35_SLEW {slow} \ + CONFIG.PCW_MIO_36_DIRECTION {in} \ + CONFIG.PCW_MIO_36_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_36_PULLUP {enabled} \ + CONFIG.PCW_MIO_36_SLEW {slow} \ + CONFIG.PCW_MIO_37_DIRECTION {inout} \ + CONFIG.PCW_MIO_37_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_37_PULLUP {enabled} \ + CONFIG.PCW_MIO_37_SLEW {slow} \ + CONFIG.PCW_MIO_38_DIRECTION {inout} \ + CONFIG.PCW_MIO_38_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_38_PULLUP {enabled} \ + CONFIG.PCW_MIO_38_SLEW {slow} \ + CONFIG.PCW_MIO_39_DIRECTION {inout} \ + CONFIG.PCW_MIO_39_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_39_PULLUP {enabled} \ + CONFIG.PCW_MIO_39_SLEW {slow} \ + CONFIG.PCW_MIO_3_DIRECTION {inout} \ + CONFIG.PCW_MIO_3_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_3_PULLUP {disabled} \ + CONFIG.PCW_MIO_3_SLEW {slow} \ + CONFIG.PCW_MIO_40_DIRECTION {inout} \ + CONFIG.PCW_MIO_40_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_40_PULLUP {enabled} \ + CONFIG.PCW_MIO_40_SLEW {slow} \ + CONFIG.PCW_MIO_41_DIRECTION {inout} \ + CONFIG.PCW_MIO_41_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_41_PULLUP {enabled} \ + CONFIG.PCW_MIO_41_SLEW {slow} \ + CONFIG.PCW_MIO_42_DIRECTION {inout} \ + CONFIG.PCW_MIO_42_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_42_PULLUP {enabled} \ + CONFIG.PCW_MIO_42_SLEW {slow} \ + CONFIG.PCW_MIO_43_DIRECTION {inout} \ + CONFIG.PCW_MIO_43_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_43_PULLUP {enabled} \ + CONFIG.PCW_MIO_43_SLEW {slow} \ + CONFIG.PCW_MIO_44_DIRECTION {inout} \ + CONFIG.PCW_MIO_44_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_44_PULLUP {enabled} \ + CONFIG.PCW_MIO_44_SLEW {slow} \ + CONFIG.PCW_MIO_45_DIRECTION {inout} \ + CONFIG.PCW_MIO_45_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_45_PULLUP {enabled} \ + CONFIG.PCW_MIO_45_SLEW {slow} \ + CONFIG.PCW_MIO_46_DIRECTION {out} \ + CONFIG.PCW_MIO_46_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_46_PULLUP {enabled} \ + CONFIG.PCW_MIO_46_SLEW {slow} \ + CONFIG.PCW_MIO_47_DIRECTION {in} \ + CONFIG.PCW_MIO_47_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_47_PULLUP {enabled} \ + CONFIG.PCW_MIO_47_SLEW {slow} \ + CONFIG.PCW_MIO_48_DIRECTION {inout} \ + CONFIG.PCW_MIO_48_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_48_PULLUP {enabled} \ + CONFIG.PCW_MIO_48_SLEW {slow} \ + CONFIG.PCW_MIO_49_DIRECTION {inout} \ + CONFIG.PCW_MIO_49_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_49_PULLUP {enabled} \ + CONFIG.PCW_MIO_49_SLEW {slow} \ + CONFIG.PCW_MIO_4_DIRECTION {inout} \ + CONFIG.PCW_MIO_4_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_4_PULLUP {disabled} \ + CONFIG.PCW_MIO_4_SLEW {slow} \ + CONFIG.PCW_MIO_50_DIRECTION {inout} \ + CONFIG.PCW_MIO_50_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_50_PULLUP {enabled} \ + CONFIG.PCW_MIO_50_SLEW {slow} \ + CONFIG.PCW_MIO_51_DIRECTION {inout} \ + CONFIG.PCW_MIO_51_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_51_PULLUP {enabled} \ + CONFIG.PCW_MIO_51_SLEW {slow} \ + CONFIG.PCW_MIO_52_DIRECTION {out} \ + CONFIG.PCW_MIO_52_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_52_PULLUP {enabled} \ + CONFIG.PCW_MIO_52_SLEW {slow} \ + CONFIG.PCW_MIO_53_DIRECTION {inout} \ + CONFIG.PCW_MIO_53_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_53_PULLUP {enabled} \ + CONFIG.PCW_MIO_53_SLEW {slow} \ + CONFIG.PCW_MIO_5_DIRECTION {inout} \ + CONFIG.PCW_MIO_5_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_5_PULLUP {disabled} \ + CONFIG.PCW_MIO_5_SLEW {slow} \ + CONFIG.PCW_MIO_6_DIRECTION {out} \ + CONFIG.PCW_MIO_6_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_6_PULLUP {disabled} \ + CONFIG.PCW_MIO_6_SLEW {slow} \ + CONFIG.PCW_MIO_7_DIRECTION {out} \ + CONFIG.PCW_MIO_7_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_7_PULLUP {disabled} \ + CONFIG.PCW_MIO_7_SLEW {slow} \ + CONFIG.PCW_MIO_8_DIRECTION {out} \ + CONFIG.PCW_MIO_8_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_8_PULLUP {disabled} \ + CONFIG.PCW_MIO_8_SLEW {slow} \ + CONFIG.PCW_MIO_9_DIRECTION {out} \ + CONFIG.PCW_MIO_9_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_9_PULLUP {enabled} \ + CONFIG.PCW_MIO_9_SLEW {slow} \ + CONFIG.PCW_MIO_PRIMITIVE {54} \ + CONFIG.PCW_MIO_TREE_PERIPHERALS {GPIO#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#GPIO#Quad SPI Flash#ENET Reset#GPIO#GPIO#GPIO#GPIO#UART 0#UART 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#USB Reset#SD 0#GPIO#GPIO#GPIO#GPIO#Enet 0#Enet 0} \ + CONFIG.PCW_MIO_TREE_SIGNALS {gpio[0]#qspi0_ss_b#qspi0_io[0]#qspi0_io[1]#qspi0_io[2]#qspi0_io[3]/HOLD_B#qspi0_sclk#gpio[7]#qspi_fbclk#reset#gpio[10]#gpio[11]#gpio[12]#gpio[13]#rx#tx#tx_clk#txd[0]#txd[1]#txd[2]#txd[3]#tx_ctl#rx_clk#rxd[0]#rxd[1]#rxd[2]#rxd[3]#rx_ctl#data[4]#dir#stp#nxt#data[0]#data[1]#data[2]#data[3]#clk#data[5]#data[6]#data[7]#clk#cmd#data[0]#data[1]#data[2]#data[3]#reset#cd#gpio[48]#gpio[49]#gpio[50]#gpio[51]#mdc#mdio} \ + CONFIG.PCW_M_AXI_GP0_ENABLE_STATIC_REMAP {0} \ + CONFIG.PCW_M_AXI_GP0_ID_WIDTH {12} \ + CONFIG.PCW_M_AXI_GP0_SUPPORT_NARROW_BURST {0} \ + CONFIG.PCW_M_AXI_GP0_THREAD_ID_WIDTH {12} \ + CONFIG.PCW_M_AXI_GP1_ENABLE_STATIC_REMAP {0} \ + CONFIG.PCW_M_AXI_GP1_ID_WIDTH {12} \ + CONFIG.PCW_M_AXI_GP1_SUPPORT_NARROW_BURST {0} \ + CONFIG.PCW_M_AXI_GP1_THREAD_ID_WIDTH {12} \ + CONFIG.PCW_NAND_CYCLES_T_AR {1} \ + CONFIG.PCW_NAND_CYCLES_T_CLR {1} \ + CONFIG.PCW_NAND_CYCLES_T_RC {11} \ + CONFIG.PCW_NAND_CYCLES_T_REA {1} \ + CONFIG.PCW_NAND_CYCLES_T_RR {1} \ + CONFIG.PCW_NAND_CYCLES_T_WC {11} \ + CONFIG.PCW_NAND_CYCLES_T_WP {1} \ + CONFIG.PCW_NAND_GRP_D8_ENABLE {0} \ + CONFIG.PCW_NAND_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_NOR_CS0_T_CEOE {1} \ + CONFIG.PCW_NOR_CS0_T_PC {1} \ + CONFIG.PCW_NOR_CS0_T_RC {11} \ + CONFIG.PCW_NOR_CS0_T_TR {1} \ + CONFIG.PCW_NOR_CS0_T_WC {11} \ + CONFIG.PCW_NOR_CS0_T_WP {1} \ + CONFIG.PCW_NOR_CS0_WE_TIME {0} \ + CONFIG.PCW_NOR_CS1_T_CEOE {1} \ + CONFIG.PCW_NOR_CS1_T_PC {1} \ + CONFIG.PCW_NOR_CS1_T_RC {11} \ + CONFIG.PCW_NOR_CS1_T_TR {1} \ + CONFIG.PCW_NOR_CS1_T_WC {11} \ + CONFIG.PCW_NOR_CS1_T_WP {1} \ + CONFIG.PCW_NOR_CS1_WE_TIME {0} \ + CONFIG.PCW_NOR_GRP_A25_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_INT_ENABLE {0} \ + CONFIG.PCW_NOR_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_NOR_SRAM_CS0_T_CEOE {1} \ + CONFIG.PCW_NOR_SRAM_CS0_T_PC {1} \ + CONFIG.PCW_NOR_SRAM_CS0_T_RC {11} \ + CONFIG.PCW_NOR_SRAM_CS0_T_TR {1} \ + CONFIG.PCW_NOR_SRAM_CS0_T_WC {11} \ + CONFIG.PCW_NOR_SRAM_CS0_T_WP {1} \ + CONFIG.PCW_NOR_SRAM_CS0_WE_TIME {0} \ + CONFIG.PCW_NOR_SRAM_CS1_T_CEOE {1} \ + CONFIG.PCW_NOR_SRAM_CS1_T_PC {1} \ + CONFIG.PCW_NOR_SRAM_CS1_T_RC {11} \ + CONFIG.PCW_NOR_SRAM_CS1_T_TR {1} \ + CONFIG.PCW_NOR_SRAM_CS1_T_WC {11} \ + CONFIG.PCW_NOR_SRAM_CS1_T_WP {1} \ + CONFIG.PCW_NOR_SRAM_CS1_WE_TIME {0} \ + CONFIG.PCW_OVERRIDE_BASIC_CLOCK {0} \ + CONFIG.PCW_P2F_CAN0_INTR {0} \ + CONFIG.PCW_P2F_CAN1_INTR {0} \ + CONFIG.PCW_P2F_CTI_INTR {0} \ + CONFIG.PCW_P2F_DMAC0_INTR {0} \ + CONFIG.PCW_P2F_DMAC1_INTR {0} \ + CONFIG.PCW_P2F_DMAC2_INTR {0} \ + CONFIG.PCW_P2F_DMAC3_INTR {0} \ + CONFIG.PCW_P2F_DMAC4_INTR {0} \ + CONFIG.PCW_P2F_DMAC5_INTR {0} \ + CONFIG.PCW_P2F_DMAC6_INTR {0} \ + CONFIG.PCW_P2F_DMAC7_INTR {0} \ + CONFIG.PCW_P2F_DMAC_ABORT_INTR {0} \ + CONFIG.PCW_P2F_ENET0_INTR {0} \ + CONFIG.PCW_P2F_ENET1_INTR {0} \ + CONFIG.PCW_P2F_GPIO_INTR {0} \ + CONFIG.PCW_P2F_I2C0_INTR {0} \ + CONFIG.PCW_P2F_I2C1_INTR {0} \ + CONFIG.PCW_P2F_QSPI_INTR {0} \ + CONFIG.PCW_P2F_SDIO0_INTR {0} \ + CONFIG.PCW_P2F_SDIO1_INTR {0} \ + CONFIG.PCW_P2F_SMC_INTR {0} \ + CONFIG.PCW_P2F_SPI0_INTR {0} \ + CONFIG.PCW_P2F_SPI1_INTR {0} \ + CONFIG.PCW_P2F_UART0_INTR {0} \ + CONFIG.PCW_P2F_UART1_INTR {0} \ + CONFIG.PCW_P2F_USB0_INTR {0} \ + CONFIG.PCW_P2F_USB1_INTR {0} \ + CONFIG.PCW_PACKAGE_DDR_BOARD_DELAY0 {0.223} \ + CONFIG.PCW_PACKAGE_DDR_BOARD_DELAY1 {0.212} \ + CONFIG.PCW_PACKAGE_DDR_BOARD_DELAY2 {0.085} \ + CONFIG.PCW_PACKAGE_DDR_BOARD_DELAY3 {0.092} \ + CONFIG.PCW_PACKAGE_DDR_DQS_TO_CLK_DELAY_0 {0.040} \ + CONFIG.PCW_PACKAGE_DDR_DQS_TO_CLK_DELAY_1 {0.058} \ + CONFIG.PCW_PACKAGE_DDR_DQS_TO_CLK_DELAY_2 {-0.009} \ + CONFIG.PCW_PACKAGE_DDR_DQS_TO_CLK_DELAY_3 {-0.033} \ + CONFIG.PCW_PACKAGE_NAME {clg400} \ + CONFIG.PCW_PCAP_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_PCAP_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_PCAP_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_PERIPHERAL_BOARD_PRESET {None} \ + CONFIG.PCW_PLL_BYPASSMODE_ENABLE {0} \ + CONFIG.PCW_PRESET_BANK0_VOLTAGE {LVCMOS 3.3V} \ + CONFIG.PCW_PRESET_BANK1_VOLTAGE {LVCMOS 1.8V} \ + CONFIG.PCW_PS7_SI_REV {PRODUCTION} \ + CONFIG.PCW_QSPI_GRP_FBCLK_ENABLE {1} \ + CONFIG.PCW_QSPI_GRP_FBCLK_IO {MIO 8} \ + CONFIG.PCW_QSPI_GRP_IO1_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_ENABLE {1} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_IO {MIO 1 .. 6} \ + CONFIG.PCW_QSPI_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_QSPI_INTERNAL_HIGHADDRESS {0xFCFFFFFF} \ + CONFIG.PCW_QSPI_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_QSPI_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_QSPI_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_QSPI_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_QSPI_QSPI_IO {MIO 1 .. 6} \ + CONFIG.PCW_SD0_GRP_CD_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_CD_IO {MIO 47} \ + CONFIG.PCW_SD0_GRP_POW_ENABLE {0} \ + CONFIG.PCW_SD0_GRP_WP_ENABLE {0} \ + CONFIG.PCW_SD0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_SD0_SD0_IO {MIO 40 .. 45} \ + CONFIG.PCW_SD1_GRP_CD_ENABLE {0} \ + CONFIG.PCW_SD1_GRP_POW_ENABLE {0} \ + CONFIG.PCW_SD1_GRP_WP_ENABLE {0} \ + CONFIG.PCW_SD1_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_SDIO0_BASEADDR {0xE0100000} \ + CONFIG.PCW_SDIO0_HIGHADDR {0xE0100FFF} \ + CONFIG.PCW_SDIO1_BASEADDR {0xE0101000} \ + CONFIG.PCW_SDIO1_HIGHADDR {0xE0101FFF} \ + CONFIG.PCW_SDIO_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_SDIO_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_SDIO_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_SDIO_PERIPHERAL_VALID {1} \ + CONFIG.PCW_SINGLE_QSPI_DATA_MODE {x4} \ + CONFIG.PCW_SMC_CYCLE_T0 {NA} \ + CONFIG.PCW_SMC_CYCLE_T1 {NA} \ + CONFIG.PCW_SMC_CYCLE_T2 {NA} \ + CONFIG.PCW_SMC_CYCLE_T3 {NA} \ + CONFIG.PCW_SMC_CYCLE_T4 {NA} \ + CONFIG.PCW_SMC_CYCLE_T5 {NA} \ + CONFIG.PCW_SMC_CYCLE_T6 {NA} \ + CONFIG.PCW_SMC_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_SMC_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_SMC_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_SMC_PERIPHERAL_VALID {0} \ + CONFIG.PCW_SPI0_BASEADDR {0xE0006000} \ + CONFIG.PCW_SPI0_GRP_SS0_ENABLE {0} \ + CONFIG.PCW_SPI0_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_SPI0_GRP_SS2_ENABLE {0} \ + CONFIG.PCW_SPI0_HIGHADDR {0xE0006FFF} \ + CONFIG.PCW_SPI0_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_SPI1_BASEADDR {0xE0007000} \ + CONFIG.PCW_SPI1_GRP_SS0_ENABLE {0} \ + CONFIG.PCW_SPI1_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_SPI1_GRP_SS2_ENABLE {0} \ + CONFIG.PCW_SPI1_HIGHADDR {0xE0007FFF} \ + CONFIG.PCW_SPI1_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_SPI_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_SPI_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_SPI_PERIPHERAL_FREQMHZ {166.666666} \ + CONFIG.PCW_SPI_PERIPHERAL_VALID {0} \ + CONFIG.PCW_S_AXI_ACP_ARUSER_VAL {31} \ + CONFIG.PCW_S_AXI_ACP_AWUSER_VAL {31} \ + CONFIG.PCW_S_AXI_ACP_ID_WIDTH {3} \ + CONFIG.PCW_S_AXI_GP0_ID_WIDTH {6} \ + CONFIG.PCW_S_AXI_GP1_ID_WIDTH {6} \ + CONFIG.PCW_S_AXI_HP0_DATA_WIDTH {64} \ + CONFIG.PCW_S_AXI_HP0_ID_WIDTH {6} \ + CONFIG.PCW_S_AXI_HP1_DATA_WIDTH {64} \ + CONFIG.PCW_S_AXI_HP1_ID_WIDTH {6} \ + CONFIG.PCW_S_AXI_HP2_DATA_WIDTH {64} \ + CONFIG.PCW_S_AXI_HP2_ID_WIDTH {6} \ + CONFIG.PCW_S_AXI_HP3_DATA_WIDTH {64} \ + CONFIG.PCW_S_AXI_HP3_ID_WIDTH {6} \ + CONFIG.PCW_TPIU_PERIPHERAL_CLKSRC {External} \ + CONFIG.PCW_TPIU_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TPIU_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_TRACE_BUFFER_CLOCK_DELAY {12} \ + CONFIG.PCW_TRACE_BUFFER_FIFO_SIZE {128} \ + CONFIG.PCW_TRACE_PIPELINE_WIDTH {8} \ + CONFIG.PCW_TTC0_BASEADDR {0xE0104000} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_HIGHADDR {0xE0104fff} \ + CONFIG.PCW_TTC1_BASEADDR {0xE0105000} \ + CONFIG.PCW_TTC1_CLK0_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC1_CLK0_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC1_CLK0_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC1_CLK1_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC1_CLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC1_CLK1_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC1_CLK2_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_TTC1_CLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC1_CLK2_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC1_HIGHADDR {0xE0105fff} \ + CONFIG.PCW_TTC_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART0_BASEADDR {0xE0000000} \ + CONFIG.PCW_UART0_BAUD_RATE {115200} \ + CONFIG.PCW_UART0_GRP_FULL_ENABLE {0} \ + CONFIG.PCW_UART0_HIGHADDR {0xE0000FFF} \ + CONFIG.PCW_UART0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_UART0_UART0_IO {MIO 14 .. 15} \ + CONFIG.PCW_UART1_BASEADDR {0xE0001000} \ + CONFIG.PCW_UART1_BAUD_RATE {115200} \ + CONFIG.PCW_UART1_GRP_FULL_ENABLE {0} \ + CONFIG.PCW_UART1_HIGHADDR {0xE0001FFF} \ + CONFIG.PCW_UART1_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_UART_PERIPHERAL_CLKSRC {IO PLL} \ + CONFIG.PCW_UART_PERIPHERAL_DIVISOR0 {10} \ + CONFIG.PCW_UART_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_UART_PERIPHERAL_VALID {1} \ + CONFIG.PCW_UIPARAM_ACT_DDR_FREQ_MHZ {525.000000} \ + CONFIG.PCW_UIPARAM_DDR_ADV_ENABLE {0} \ + CONFIG.PCW_UIPARAM_DDR_AL {0} \ + CONFIG.PCW_UIPARAM_DDR_BANK_ADDR_COUNT {3} \ + CONFIG.PCW_UIPARAM_DDR_BL {8} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY0 {0.223} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY1 {0.212} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY2 {0.085} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY3 {0.092} \ + CONFIG.PCW_UIPARAM_DDR_BUS_WIDTH {16 Bit} \ + CONFIG.PCW_UIPARAM_DDR_CL {7} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_0_LENGTH_MM {25.8} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_0_PACKAGE_LENGTH {80.4535} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_0_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_1_LENGTH_MM {25.8} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_1_PACKAGE_LENGTH {80.4535} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_1_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_2_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_2_PACKAGE_LENGTH {80.4535} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_2_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_3_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_3_PACKAGE_LENGTH {80.4535} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_3_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_CLOCK_STOP_EN {0} \ + CONFIG.PCW_UIPARAM_DDR_COL_ADDR_COUNT {10} \ + CONFIG.PCW_UIPARAM_DDR_CWL {6} \ + CONFIG.PCW_UIPARAM_DDR_DEVICE_CAPACITY {4096 MBits} \ + CONFIG.PCW_UIPARAM_DDR_DQS_0_LENGTH_MM {15.6} \ + CONFIG.PCW_UIPARAM_DDR_DQS_0_PACKAGE_LENGTH {105.056} \ + CONFIG.PCW_UIPARAM_DDR_DQS_0_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQS_1_LENGTH_MM {18.8} \ + CONFIG.PCW_UIPARAM_DDR_DQS_1_PACKAGE_LENGTH {66.904} \ + CONFIG.PCW_UIPARAM_DDR_DQS_1_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQS_2_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_DQS_2_PACKAGE_LENGTH {89.1715} \ + CONFIG.PCW_UIPARAM_DDR_DQS_2_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQS_3_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_DQS_3_PACKAGE_LENGTH {113.63} \ + CONFIG.PCW_UIPARAM_DDR_DQS_3_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_0 {0.040} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_1 {0.058} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_2 {-0.009} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_3 {-0.033} \ + CONFIG.PCW_UIPARAM_DDR_DQ_0_LENGTH_MM {16.5} \ + CONFIG.PCW_UIPARAM_DDR_DQ_0_PACKAGE_LENGTH {98.503} \ + CONFIG.PCW_UIPARAM_DDR_DQ_0_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQ_1_LENGTH_MM {18} \ + CONFIG.PCW_UIPARAM_DDR_DQ_1_PACKAGE_LENGTH {68.5855} \ + CONFIG.PCW_UIPARAM_DDR_DQ_1_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQ_2_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_DQ_2_PACKAGE_LENGTH {90.295} \ + CONFIG.PCW_UIPARAM_DDR_DQ_2_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DQ_3_LENGTH_MM {0} \ + CONFIG.PCW_UIPARAM_DDR_DQ_3_PACKAGE_LENGTH {103.977} \ + CONFIG.PCW_UIPARAM_DDR_DQ_3_PROPOGATION_DELAY {160} \ + CONFIG.PCW_UIPARAM_DDR_DRAM_WIDTH {16 Bits} \ + CONFIG.PCW_UIPARAM_DDR_ECC {Disabled} \ + CONFIG.PCW_UIPARAM_DDR_ENABLE {1} \ + CONFIG.PCW_UIPARAM_DDR_FREQ_MHZ {525} \ + CONFIG.PCW_UIPARAM_DDR_HIGH_TEMP {Normal (0-85)} \ + CONFIG.PCW_UIPARAM_DDR_MEMORY_TYPE {DDR 3} \ + CONFIG.PCW_UIPARAM_DDR_PARTNO {MT41J256M16 RE-125} \ + CONFIG.PCW_UIPARAM_DDR_ROW_ADDR_COUNT {15} \ + CONFIG.PCW_UIPARAM_DDR_SPEED_BIN {DDR3_1066F} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_DATA_EYE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_READ_GATE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_WRITE_LEVEL {1} \ + CONFIG.PCW_UIPARAM_DDR_T_FAW {40.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RAS_MIN {35.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RC {48.91} \ + CONFIG.PCW_UIPARAM_DDR_T_RCD {7} \ + CONFIG.PCW_UIPARAM_DDR_T_RP {7} \ + CONFIG.PCW_UIPARAM_DDR_USE_INTERNAL_VREF {0} \ + CONFIG.PCW_UIPARAM_GENERATE_SUMMARY {NA} \ + CONFIG.PCW_USB0_BASEADDR {0xE0102000} \ + CONFIG.PCW_USB0_HIGHADDR {0xE0102fff} \ + CONFIG.PCW_USB0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_USB0_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_USB0_RESET_ENABLE {1} \ + CONFIG.PCW_USB0_RESET_IO {MIO 46} \ + CONFIG.PCW_USB0_USB0_IO {MIO 28 .. 39} \ + CONFIG.PCW_USB1_BASEADDR {0xE0103000} \ + CONFIG.PCW_USB1_HIGHADDR {0xE0103fff} \ + CONFIG.PCW_USB1_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_USB1_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_USB1_RESET_ENABLE {0} \ + CONFIG.PCW_USB_RESET_ENABLE {1} \ + CONFIG.PCW_USB_RESET_POLARITY {Active Low} \ + CONFIG.PCW_USB_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_USE_AXI_FABRIC_IDLE {0} \ + CONFIG.PCW_USE_AXI_NONSECURE {0} \ + CONFIG.PCW_USE_CORESIGHT {0} \ + CONFIG.PCW_USE_CROSS_TRIGGER {0} \ + CONFIG.PCW_USE_CR_FABRIC {1} \ + CONFIG.PCW_USE_DDR_BYPASS {0} \ + CONFIG.PCW_USE_DEBUG {0} \ + CONFIG.PCW_USE_DEFAULT_ACP_USER_VAL {0} \ + CONFIG.PCW_USE_DMA0 {0} \ + CONFIG.PCW_USE_DMA1 {0} \ + CONFIG.PCW_USE_DMA2 {0} \ + CONFIG.PCW_USE_DMA3 {0} \ + CONFIG.PCW_USE_EXPANDED_IOP {0} \ + CONFIG.PCW_USE_EXPANDED_PS_SLCR_REGISTERS {0} \ + CONFIG.PCW_USE_FABRIC_INTERRUPT {0} \ + CONFIG.PCW_USE_HIGH_OCM {0} \ + CONFIG.PCW_USE_M_AXI_GP0 {1} \ + CONFIG.PCW_USE_M_AXI_GP1 {0} \ + CONFIG.PCW_USE_PROC_EVENT_BUS {0} \ + CONFIG.PCW_USE_PS_SLCR_REGISTERS {0} \ + CONFIG.PCW_USE_S_AXI_ACP {0} \ + CONFIG.PCW_USE_S_AXI_GP0 {0} \ + CONFIG.PCW_USE_S_AXI_GP1 {0} \ + CONFIG.PCW_USE_S_AXI_HP0 {1} \ + CONFIG.PCW_USE_S_AXI_HP1 {1} \ + CONFIG.PCW_USE_S_AXI_HP2 {1} \ + CONFIG.PCW_USE_S_AXI_HP3 {0} \ + CONFIG.PCW_USE_TRACE {0} \ + CONFIG.PCW_USE_TRACE_DATA_EDGE_DETECTOR {0} \ + CONFIG.PCW_VALUE_SILVERSION {3} \ + CONFIG.PCW_WDT_PERIPHERAL_CLKSRC {CPU_1X} \ + CONFIG.PCW_WDT_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_WDT_PERIPHERAL_FREQMHZ {133.333333} \ + ] $processing_system7_0 + + # Create instance: ps7_0_axi_periph, and set properties + set ps7_0_axi_periph [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 ps7_0_axi_periph ] + set_property -dict [ list \ + CONFIG.NUM_MI {4} \ + ] $ps7_0_axi_periph + + # Create instance: rst_ps7_0_100M, and set properties + set rst_ps7_0_100M [ create_bd_cell -type ip -vlnv xilinx.com:ip:proc_sys_reset:5.0 rst_ps7_0_100M ] + + # Create instance: u_dma, and set properties + set u_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 u_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {26} \ + ] $u_dma + + # Create instance: x_dma, and set properties + set x_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 x_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {26} \ + ] $x_dma + + # Create instance: xu_dma, and set properties + set xu_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 xu_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s {0} \ + CONFIG.c_include_s2mm {1} \ + CONFIG.c_include_s2mm_dre {1} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_s2mm_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {26} \ + ] $xu_dma + + # Create interface connections + connect_bd_intf_net -intf_net HlsAxisKernelU_0_xu_port [get_bd_intf_pins HlsAxisKernelU_0/xu_port] [get_bd_intf_pins xu_dma/S_AXIS_S2MM] + connect_bd_intf_net -intf_net axi_mem_intercon_1_M00_AXI [get_bd_intf_pins axi_mem_intercon_1/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP1] + connect_bd_intf_net -intf_net axi_mem_intercon_2_M00_AXI [get_bd_intf_pins axi_mem_intercon_2/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP2] + connect_bd_intf_net -intf_net axi_mem_intercon_M00_AXI [get_bd_intf_pins axi_mem_intercon/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP0] + connect_bd_intf_net -intf_net processing_system7_0_DDR [get_bd_intf_ports DDR] [get_bd_intf_pins processing_system7_0/DDR] + connect_bd_intf_net -intf_net processing_system7_0_FIXED_IO [get_bd_intf_ports FIXED_IO] [get_bd_intf_pins processing_system7_0/FIXED_IO] + connect_bd_intf_net -intf_net processing_system7_0_M_AXI_GP0 [get_bd_intf_pins processing_system7_0/M_AXI_GP0] [get_bd_intf_pins ps7_0_axi_periph/S00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M00_AXI [get_bd_intf_pins HlsAxisKernelU_0/s_axi_control] [get_bd_intf_pins ps7_0_axi_periph/M00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M01_AXI [get_bd_intf_pins ps7_0_axi_periph/M01_AXI] [get_bd_intf_pins x_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M02_AXI [get_bd_intf_pins ps7_0_axi_periph/M02_AXI] [get_bd_intf_pins u_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M03_AXI [get_bd_intf_pins ps7_0_axi_periph/M03_AXI] [get_bd_intf_pins xu_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net u_dma_M_AXIS_MM2S [get_bd_intf_pins HlsAxisKernelU_0/u_port] [get_bd_intf_pins u_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S00_AXI] [get_bd_intf_pins u_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXIS_MM2S [get_bd_intf_pins HlsAxisKernelU_0/x_port] [get_bd_intf_pins x_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon/S00_AXI] [get_bd_intf_pins x_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net xu_dma_M_AXI_S2MM [get_bd_intf_pins axi_mem_intercon_2/S00_AXI] [get_bd_intf_pins xu_dma/M_AXI_S2MM] + + # Create port connections + connect_bd_net -net processing_system7_0_FCLK_CLK0 [get_bd_pins HlsAxisKernelU_0/ap_clk] [get_bd_pins axi_mem_intercon/ACLK] [get_bd_pins axi_mem_intercon/M00_ACLK] [get_bd_pins axi_mem_intercon/S00_ACLK] [get_bd_pins axi_mem_intercon_1/ACLK] [get_bd_pins axi_mem_intercon_1/M00_ACLK] [get_bd_pins axi_mem_intercon_1/S00_ACLK] [get_bd_pins axi_mem_intercon_2/ACLK] [get_bd_pins axi_mem_intercon_2/M00_ACLK] [get_bd_pins axi_mem_intercon_2/S00_ACLK] [get_bd_pins processing_system7_0/FCLK_CLK0] [get_bd_pins processing_system7_0/M_AXI_GP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP1_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP2_ACLK] [get_bd_pins ps7_0_axi_periph/ACLK] [get_bd_pins ps7_0_axi_periph/M00_ACLK] [get_bd_pins ps7_0_axi_periph/M01_ACLK] [get_bd_pins ps7_0_axi_periph/M02_ACLK] [get_bd_pins ps7_0_axi_periph/M03_ACLK] [get_bd_pins ps7_0_axi_periph/S00_ACLK] [get_bd_pins rst_ps7_0_100M/slowest_sync_clk] [get_bd_pins u_dma/m_axi_mm2s_aclk] [get_bd_pins u_dma/s_axi_lite_aclk] [get_bd_pins x_dma/m_axi_mm2s_aclk] [get_bd_pins x_dma/s_axi_lite_aclk] [get_bd_pins xu_dma/m_axi_s2mm_aclk] [get_bd_pins xu_dma/s_axi_lite_aclk] + connect_bd_net -net processing_system7_0_FCLK_RESET0_N [get_bd_pins processing_system7_0/FCLK_RESET0_N] [get_bd_pins rst_ps7_0_100M/ext_reset_in] + connect_bd_net -net rst_ps7_0_100M_peripheral_aresetn [get_bd_pins HlsAxisKernelU_0/ap_rst_n] [get_bd_pins axi_mem_intercon/ARESETN] [get_bd_pins axi_mem_intercon/M00_ARESETN] [get_bd_pins axi_mem_intercon/S00_ARESETN] [get_bd_pins axi_mem_intercon_1/ARESETN] [get_bd_pins axi_mem_intercon_1/M00_ARESETN] [get_bd_pins axi_mem_intercon_1/S00_ARESETN] [get_bd_pins axi_mem_intercon_2/ARESETN] [get_bd_pins axi_mem_intercon_2/M00_ARESETN] [get_bd_pins axi_mem_intercon_2/S00_ARESETN] [get_bd_pins ps7_0_axi_periph/ARESETN] [get_bd_pins ps7_0_axi_periph/M00_ARESETN] [get_bd_pins ps7_0_axi_periph/M01_ARESETN] [get_bd_pins ps7_0_axi_periph/M02_ARESETN] [get_bd_pins ps7_0_axi_periph/M03_ARESETN] [get_bd_pins ps7_0_axi_periph/S00_ARESETN] [get_bd_pins rst_ps7_0_100M/peripheral_aresetn] [get_bd_pins u_dma/axi_resetn] [get_bd_pins x_dma/axi_resetn] [get_bd_pins xu_dma/axi_resetn] + + # Create address segments + create_bd_addr_seg -range 0x00010000 -offset 0x40000000 [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs HlsAxisKernelU_0/s_axi_control/Reg] SEG_HlsAxisKernelU_0_Reg + create_bd_addr_seg -range 0x00010000 -offset 0x40410000 [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs u_dma/S_AXI_LITE/Reg] SEG_u_dma_Reg + create_bd_addr_seg -range 0x00010000 -offset 0x40400000 [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs x_dma/S_AXI_LITE/Reg] SEG_x_dma_Reg + create_bd_addr_seg -range 0x00010000 -offset 0x40420000 [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs xu_dma/S_AXI_LITE/Reg] SEG_xu_dma_Reg + create_bd_addr_seg -range 0x20000000 -offset 0x00000000 [get_bd_addr_spaces u_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] SEG_processing_system7_0_HP1_DDR_LOWOCM + create_bd_addr_seg -range 0x20000000 -offset 0x00000000 [get_bd_addr_spaces x_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP0/HP0_DDR_LOWOCM] SEG_processing_system7_0_HP0_DDR_LOWOCM + create_bd_addr_seg -range 0x20000000 -offset 0x00000000 [get_bd_addr_spaces xu_dma/Data_S2MM] [get_bd_addr_segs processing_system7_0/S_AXI_HP2/HP2_DDR_LOWOCM] SEG_processing_system7_0_HP2_DDR_LOWOCM + + + # Restore current instance + current_bd_instance $oldCurInst + + validate_bd_design + save_bd_design +} +# End of create_root_design() + + +################################################################## +# MAIN FLOW +################################################################## + +create_root_design "" + + diff --git a/pynq/kernel_v/binfile_example.bin b/pynq/kernel_v/binfile_example.bin new file mode 100644 index 0000000..8c01583 Binary files /dev/null and b/pynq/kernel_v/binfile_example.bin differ diff --git a/pynq/kernel_v/kernel_v.ipynb b/pynq/kernel_v/kernel_v.ipynb new file mode 100644 index 0000000..1c0e1f3 --- /dev/null +++ b/pynq/kernel_v/kernel_v.ipynb @@ -0,0 +1,794 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing Kernel-V\n", + "\n", + "This notebook will test an IP written in Vivado HLS." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "try {\n", + "require(['notebook/js/codecell'], function(codecell) {\n", + " codecell.CodeCell.options_default.highlight_modes[\n", + " 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n", + " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", + " Jupyter.notebook.get_cells().map(function(cell){\n", + " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", + " });\n", + "});\n", + "} catch (e) {};\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pynq import Overlay\n", + "import pynq.lib.dma\n", + "from pynq import allocate\n", + "import numpy as np\n", + "from pynq import DefaultIP\n", + "import timeit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Program FPGA and inspect Overlay." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "overlay = Overlay('overlay/kernel_v.bit')\n", + "print(overlay.device)\n", + "overlay?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the kernel register map." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RegisterMap {\n", + " CTRL = Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0),\n", + " GIER = Register(Enable=0, RESERVED=0),\n", + " IP_IER = Register(CHAN0_INT_EN=0, CHAN1_INT_EN=0, RESERVED=0),\n", + " IP_ISR = Register(CHAN0_INT_ST=0, CHAN1_INT_ST=0, RESERVED=0),\n", + " num_active_inputs = Register(num_active_inputs=0),\n", + " output_size = Register(output_size=0),\n", + " num_refinements_0 = Register(num_refinements_0=0),\n", + " num_refinements_1 = Register(num_refinements_1=0)\n", + "}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel = overlay.HlsKernelV_0\n", + "kernel.register_map\n", + "# print(\"stream size: \", adder.stream_size)\n", + "# accel_state = adder.get_state()\n", + "# print(\"accelerator state: \", accel_state)\n", + "# dma = overlay.axi_dma_0\n", + "# dma.register_map.MM2S_DMASR\n", + "# dma.register_map.S2MM_DMACR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kernel IP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The kernel IP can be automatically bound by first creating our Kernel class. Then, the overlay can be instantiated again." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "class KernelDriver(DefaultIP):\n", + " def __init__(self, description):\n", + " super().__init__(description=description)\n", + " \n", + " bindto = ['xilinx.com:hls:HlsKernelV:1.0']\n", + "\n", + " def start_accel(self):\n", + " self.register_map.CTRL.AP_START = 1\n", + " self.write(0x0, 1)\n", + " self.write(0x0, 1)\n", + " while(self.read(0x0) % 2 == 0):\n", + " self.write(0x0, 1)\n", + " pass # Wait until start, i.e. bit 0, is set.\n", + "\n", + " def set_state(self, state):\n", + " # self.register_map.CTRL = state\n", + " # return self.register_map.CTRL\n", + " self.write(0x0, state)\n", + " return self.read(0x0)\n", + "\n", + " def get_state(self):\n", + " return self.register_map.CTRL\n", + " # return self.read(0x0)\n", + "\n", + " @property\n", + " def num_refinements(self):\n", + " return (self.register_map.num_refinements_0, self.register_map.num_refinements_1)\n", + " # return self.read(0x10)\n", + "\n", + " @num_refinements.setter\n", + " def num_refinements(self, R):\n", + " self.register_map.num_refinements_0 = R[0]\n", + " self.register_map.num_refinements_1 = R[1]\n", + " # self.write(0x10, R)\n", + "\n", + " @property\n", + " def num_active_inputs(self):\n", + " return self.register_map.num_active_inputs\n", + " # return self.read(0x10)\n", + "\n", + " @num_active_inputs.setter\n", + " def num_active_inputs(self, N):\n", + " self.register_map.num_active_inputs = N\n", + " # self.write(0x10, R)\n", + "\n", + " @property\n", + " def output_size(self):\n", + " return self.register_map.output_size\n", + " # return self.read(0x10)\n", + "\n", + " @output_size.setter\n", + " def output_size(self, H):\n", + " self.register_map.output_size = H\n", + " # self.write(0x10, R)\n", + "\n", + "overlay = Overlay(\"overlay/kernel_v.bit\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check again the kernel:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_v = overlay.HlsKernelV_0\n", + "kernel_v.get_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kernel_v.read(0x10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the class is working, we setup the `num_refinements` using the setter method. We then read its corresponding register." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Register(num_refinements_0=0), Register(num_refinements_1=0))\n", + "(Register(num_refinements_0=1), Register(num_refinements_1=1))\n" + ] + } + ], + "source": [ + "print(kernel_v.num_refinements)\n", + "kernel_v.num_refinements = (1, 1)\n", + "print(kernel_v.num_refinements)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x4\n", + "0x4\n" + ] + }, + { + "data": { + "text/plain": [ + "Register(AP_START=0, AP_DONE=0, AP_IDLE=1, AP_READY=0, RESERVED_1=0, AUTO_RESTART=0, RESERVED_2=0, RESERVED_3=0, RESERVED_4=0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(kernel_v.get_state())\n", + "# kernel_u.start_accel()\n", + "print(kernel_v.get_state())\n", + "kernel_v.get_state()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x0\n", + "0x2\n" + ] + } + ], + "source": [ + "print(kernel_v.num_active_inputs)\n", + "kernel_v.num_active_inputs = 2\n", + "print(kernel_v.num_active_inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Allocation and Run\n", + "\n", + "The data structures must be contiguosly allocated." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Buffers setup completed.\n", + "xus_buffer.shape: (16, 1, 4) - Bytes: 128\n", + "v_buffer.shape: (16, 64, 4, 4) - Bytes: 32768\n", + "y_buffer.shape: (64, 1, 4, 4) - Bytes: 2048\n" + ] + } + ], + "source": [ + "# The following parameters are fixed in hardware and cannot be changed:\n", + "# - The maximum output size H\n", + "# - The number of gates G\n", + "# - The tile size Tv\n", + "H = 512\n", + "G = 4\n", + "Tv = 4\n", + "data_t = np.int16\n", + "# The following parameters are customizeable in hardware and can be changed:\n", + "# - The number of refinements R\n", + "# - The output_size <= H\n", + "# - The number of active_inputs <= N\n", + "R = 16\n", + "N = 1\n", + "output_size = 256 # % H\n", + "# NOTE: Working with (R, N, out) == (16, 2, 8) \n", + "\n", + "xus = np.random.randn(R, N, G).astype(dtype=data_t)\n", + "v = np.random.randn(R, output_size // Tv, G, Tv).astype(dtype=data_t)\n", + "y = np.zeros((output_size // Tv, N, Tv, G)).astype(dtype=data_t)\n", + "\n", + "xus_buffer = pynq.allocate(shape=(R, N, G), dtype=data_t)\n", + "v_buffer = pynq.allocate(shape=(R, output_size // Tv, G, Tv), dtype=data_t)\n", + "y_buffer = pynq.allocate(shape=(output_size // Tv, N, Tv, G), dtype=data_t)\n", + "\n", + "np.copyto(xus_buffer, xus, casting='no')\n", + "np.copyto(v_buffer, v, casting='no')\n", + "np.copyto(y_buffer, y, casting='no')\n", + "\n", + "print('Buffers setup completed.')\n", + "print(f'xus_buffer.shape: {xus_buffer.shape} - Bytes: {xus_buffer.nbytes}')\n", + "print(f'v_buffer.shape: {v_buffer.shape} - Bytes: {v_buffer.nbytes}')\n", + "print(f'y_buffer.shape: {y_buffer.shape} - Bytes: {y_buffer.nbytes}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup the kernel and then send the data through the DMAs." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0xa\n", + "0x1\n", + "Starting transfer:\n", + "Wait xus...DONE.\n", + "Wait v...DONE.\n", + "Wait y...DONE.\n", + "\n", + "y_buffer.shape: (64, 1, 4, 4)\n" + ] + } + ], + "source": [ + "kernel_v.num_refinements = (R, R // 4)\n", + "kernel_v.output_size = output_size\n", + "kernel_v.num_active_inputs = N\n", + "print(kernel_v.get_state())\n", + "kernel_v.start_accel()\n", + "print(kernel_v.get_state())\n", + "\n", + "# Transfer\n", + "print('Starting transfer:')\n", + "overlay.xus_dma.sendchannel.transfer(xus_buffer)\n", + "overlay.v_dma.sendchannel.transfer(v_buffer)\n", + "overlay.y_dma.recvchannel.transfer(y_buffer)\n", + "# Then wait\n", + "print('Wait xus...', end='')\n", + "overlay.xus_dma.sendchannel.wait()\n", + "print('DONE.\\nWait v...', end='')\n", + "overlay.v_dma.sendchannel.wait()\n", + "print('DONE.\\nWait y...', end='')\n", + "overlay.y_dma.recvchannel.wait()\n", + "print('DONE.\\n')\n", + "\n", + "print(f'y_buffer.shape: {y_buffer.shape}')\n", + "# print(f'xu_buffer: {xu_buffer}')" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [], + "source": [ + "def run_kernel(R, x_buffer, u_buffer, xu_buffer):\n", + " kernel_u.num_refinements = R\n", + " kernel_u.start_accel()\n", + " # Transfer\n", + " overlay.x_dma.sendchannel.transfer(x_buffer)\n", + " overlay.u_dma.sendchannel.transfer(u_buffer)\n", + " overlay.xu_dma.recvchannel.transfer(xu_buffer)\n", + " # Then wait\n", + " overlay.x_dma.sendchannel.wait()\n", + " overlay.u_dma.sendchannel.wait()\n", + " overlay.xu_dma.recvchannel.wait()" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 80.5 ms per loop\n" + ] + } + ], + "source": [ + "%timeit run_kernel(R, x_buffer, u_buffer, xu_buffer)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Checking Correctness\n", + "\n", + "We first find the proper reshape mechanisms:" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.36593539 -1.03844877 0.82985754 -0.82067175] [ 0.36593539 -1.03844877 0.82985754 -0.82067175]\n", + "0.0\n", + "[-0.07974188 0.01109454 -0.18120697 0.73842526] [-0.07974188 0.01109454 -0.18120697 0.73842526]\n", + "0.0\n", + "10 loops, best of 3: 24.1 ms per loop\n", + "(128, 4, 2)\n" + ] + } + ], + "source": [ + "# =============================================================================\n", + "# Reshape: (R, I, G) => (R, I // Tu, G, Tu)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I, G)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp.reshape(R, I // Tu, Tu, G), (0, 1, 3, 2))\n", + "print(u[0, 0:4, 0], u_tmp[0, 0, 0, 0:4])\n", + "print(u[0, 3, 0] - u_tmp[0, 0, 0, 3])\n", + "\n", + "# =============================================================================\n", + "# Reshape: (R, I // Tu, G, Tu) => (I, G, R)\n", + "# =============================================================================\n", + "u = np.random.randn(R, I // Tu, G, Tu)\n", + "u_tmp = u.copy()\n", + "u_tmp = np.transpose(u_tmp, (1, 3, 2, 0)).reshape(I, G, R)\n", + "print(u[0, 0, 0, 0:4], u_tmp[0:4, 0, 0])\n", + "print(u[0, 0, 0, 3] - u_tmp[3, 0, 0])\n", + "\n", + "x = np.random.randn(N, I)\n", + "u = np.random.randn(I, G, R)\n", + "x = (x * 2).astype(np.int16)\n", + "u = (u * 2).astype(np.int16)\n", + "\n", + "%timeit xu = np.transpose(np.tensordot(x, u, axes=1), (2, 1, 0))\n", + "print(xu.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now check the Numpy computation against the FPGA result." + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 loops, best of 3: 105 ms per loop\n", + "\n", + "All equal: True\n", + "gold[0]: [[ 8822 -32153]\n", + " [-17540 6635]\n", + " [ 6489 5700]\n", + " [ 11839 25184]]\n", + "fpga[0]: [[ 8822 -32153]\n", + " [-17540 6635]\n", + " [ 6489 5700]\n", + " [ 11839 25184]]\n" + ] + } + ], + "source": [ + "u_tmp = np.transpose(u_buffer, (1, 3, 2, 0)).reshape(I, G, R)\n", + "%timeit xu_gold = np.transpose(np.tensordot(x_buffer, u_tmp, axes=1), (2, 1, 0))\n", + "print('\\nAll equal:', np.allclose(xu_buffer, xu_gold))\n", + "print('gold[0]: ', xu_gold[0])\n", + "print('fpga[0]: ', xu_buffer[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading File into PYNQ Buffer" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "tmp = np.random.randn(R, N, G).astype(dtype=data_t)\n", + "tmp.tofile('binfile_example.bin')" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PynqBuffer([[[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, 0]]], dtype=int16)" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xus_buffer = pynq.allocate(shape=(R, N, G), dtype=data_t)\n", + "xus_buffer" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PynqBuffer([[[-1, 0, -1, 0]],\n", + "\n", + " [[ 0, -2, 0, -1]],\n", + "\n", + " [[ 0, 0, 2, 0]],\n", + "\n", + " [[ 0, -1, 0, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[ 0, 1, 0, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[-1, 0, 0, 0]],\n", + "\n", + " [[ 0, 0, -1, 0]],\n", + "\n", + " [[ 0, -1, 0, 0]],\n", + "\n", + " [[ 1, 0, 0, 0]],\n", + "\n", + " [[ 0, 0, -1, 0]],\n", + "\n", + " [[-1, 0, -1, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[ 0, -1, -1, -1]],\n", + "\n", + " [[-1, 0, 0, 0]]], dtype=int16)" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp = np.fromfile('binfile_example.bin', dtype=data_t).reshape(xus_buffer.shape)\n", + "np.copyto(xus_buffer, tmp, casting='no')\n", + "xus_buffer" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "def load_from_bin(binfile, shape, dtype):\n", + " tmp_buffer = pynq.allocate(shape=shape, dtype=dtype)\n", + " tmp = np.fromfile(binfile, dtype=data_t).reshape(tmp_buffer.shape)\n", + " np.copyto(tmp_buffer, tmp, casting='no')\n", + " return tmp_buffer" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PynqBuffer([[[-1, 0, -1, 0]],\n", + "\n", + " [[ 0, -2, 0, -1]],\n", + "\n", + " [[ 0, 0, 2, 0]],\n", + "\n", + " [[ 0, -1, 0, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[ 0, 1, 0, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[-1, 0, 0, 0]],\n", + "\n", + " [[ 0, 0, -1, 0]],\n", + "\n", + " [[ 0, -1, 0, 0]],\n", + "\n", + " [[ 1, 0, 0, 0]],\n", + "\n", + " [[ 0, 0, -1, 0]],\n", + "\n", + " [[-1, 0, -1, 0]],\n", + "\n", + " [[ 0, 0, 0, 0]],\n", + "\n", + " [[ 0, -1, -1, -1]],\n", + "\n", + " [[-1, 0, 0, 0]]], dtype=int16)" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xus_buffer = load_from_bin('binfile_example.bin', shape=(R, N, G), dtype=data_t)\n", + "xus_buffer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pynq/kernel_v/overlay/kernel_v.bit b/pynq/kernel_v/overlay/kernel_v.bit new file mode 100644 index 0000000..c391107 Binary files /dev/null and b/pynq/kernel_v/overlay/kernel_v.bit differ diff --git a/pynq/kernel_v/overlay/kernel_v.hwh b/pynq/kernel_v/overlay/kernel_v.hwh new file mode 100644 index 0000000..541a112 --- /dev/null +++ b/pynq/kernel_v/overlay/kernel_v.hwh @@ -0,0 +1,9180 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pynq/kernel_v/overlay/kernel_v.tcl b/pynq/kernel_v/overlay/kernel_v.tcl new file mode 100644 index 0000000..541d234 --- /dev/null +++ b/pynq/kernel_v/overlay/kernel_v.tcl @@ -0,0 +1,717 @@ + +################################################################ +# This is a generated script based on design: design_1 +# +# Though there are limitations about the generated script, +# the main purpose of this utility is to make learning +# IP Integrator Tcl commands easier. +################################################################ + +namespace eval _tcl { +proc get_script_folder {} { + set script_path [file normalize [info script]] + set script_folder [file dirname $script_path] + return $script_folder +} +} +variable script_folder +set script_folder [_tcl::get_script_folder] + +################################################################ +# Check if script is running in correct Vivado version. +################################################################ +set scripts_vivado_version 2020.2 +set current_vivado_version [version -short] + +if { [string first $scripts_vivado_version $current_vivado_version] == -1 } { + puts "" + catch {common::send_gid_msg -ssname BD::TCL -id 2041 -severity "ERROR" "This script was generated using Vivado <$scripts_vivado_version> and is being run in <$current_vivado_version> of Vivado. Please run the script in Vivado <$scripts_vivado_version> then open the design in Vivado <$current_vivado_version>. Upgrade the design by running \"Tools => Report => Report IP Status...\", then run write_bd_tcl to create an updated script."} + + return 1 +} + +################################################################ +# START +################################################################ + +# To test this script, run the following commands from Vivado Tcl console: +# source design_1_script.tcl + +# If there is no project opened, this script will create a +# project, but make sure you do not have an existing project +# <./myproj/project_1.xpr> in the current working folder. + +set list_projs [get_projects -quiet] +if { $list_projs eq "" } { + create_project project_1 myproj -part xc7z020clg484-1 + set_property BOARD_PART em.avnet.com:zed:part0:1.4 [current_project] +} + + +# CHANGE DESIGN NAME HERE +variable design_name +set design_name design_1 + +# If you do not already have an existing IP Integrator design open, +# you can create a design using the following command: +# create_bd_design $design_name + +# Creating design if needed +set errMsg "" +set nRet 0 + +set cur_design [current_bd_design -quiet] +set list_cells [get_bd_cells -quiet] + +if { ${design_name} eq "" } { + # USE CASES: + # 1) Design_name not set + + set errMsg "Please set the variable to a non-empty value." + set nRet 1 + +} elseif { ${cur_design} ne "" && ${list_cells} eq "" } { + # USE CASES: + # 2): Current design opened AND is empty AND names same. + # 3): Current design opened AND is empty AND names diff; design_name NOT in project. + # 4): Current design opened AND is empty AND names diff; design_name exists in project. + + if { $cur_design ne $design_name } { + common::send_gid_msg -ssname BD::TCL -id 2001 -severity "INFO" "Changing value of from <$design_name> to <$cur_design> since current design is empty." + set design_name [get_property NAME $cur_design] + } + common::send_gid_msg -ssname BD::TCL -id 2002 -severity "INFO" "Constructing design in IPI design <$cur_design>..." + +} elseif { ${cur_design} ne "" && $list_cells ne "" && $cur_design eq $design_name } { + # USE CASES: + # 5) Current design opened AND has components AND same names. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 1 +} elseif { [get_files -quiet ${design_name}.bd] ne "" } { + # USE CASES: + # 6) Current opened design, has components, but diff names, design_name exists in project. + # 7) No opened design, design_name exists in project. + + set errMsg "Design <$design_name> already exists in your project, please set the variable to another value." + set nRet 2 + +} else { + # USE CASES: + # 8) No opened design, design_name not in project. + # 9) Current opened design, has components, but diff names, design_name not in project. + + common::send_gid_msg -ssname BD::TCL -id 2003 -severity "INFO" "Currently there is no design <$design_name> in project, so creating one..." + + create_bd_design $design_name + + common::send_gid_msg -ssname BD::TCL -id 2004 -severity "INFO" "Making design <$design_name> as current_bd_design." + current_bd_design $design_name + +} + +common::send_gid_msg -ssname BD::TCL -id 2005 -severity "INFO" "Currently the variable is equal to \"$design_name\"." + +if { $nRet != 0 } { + catch {common::send_gid_msg -ssname BD::TCL -id 2006 -severity "ERROR" $errMsg} + return $nRet +} + +set bCheckIPsPassed 1 +################################################################## +# CHECK IPs +################################################################## +set bCheckIPs 1 +if { $bCheckIPs == 1 } { + set list_check_ips "\ +xilinx.com:hls:HlsKernelV:1.0\ +xilinx.com:ip:processing_system7:5.5\ +xilinx.com:ip:proc_sys_reset:5.0\ +xilinx.com:ip:axi_dma:7.1\ +" + + set list_ips_missing "" + common::send_gid_msg -ssname BD::TCL -id 2011 -severity "INFO" "Checking if the following IPs exist in the project's IP catalog: $list_check_ips ." + + foreach ip_vlnv $list_check_ips { + set ip_obj [get_ipdefs -all $ip_vlnv] + if { $ip_obj eq "" } { + lappend list_ips_missing $ip_vlnv + } + } + + if { $list_ips_missing ne "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2012 -severity "ERROR" "The following IPs are not found in the IP Catalog:\n $list_ips_missing\n\nResolution: Please add the repository containing the IP(s) to the project." } + set bCheckIPsPassed 0 + } + +} + +if { $bCheckIPsPassed != 1 } { + common::send_gid_msg -ssname BD::TCL -id 2023 -severity "WARNING" "Will not continue with creation of design due to the error(s) above." + return 3 +} + +################################################################## +# DESIGN PROCs +################################################################## + + + +# Procedure to create entire design; Provide argument to make +# procedure reusable. If parentCell is "", will use root. +proc create_root_design { parentCell } { + + variable script_folder + variable design_name + + if { $parentCell eq "" } { + set parentCell [get_bd_cells /] + } + + # Get object for parentCell + set parentObj [get_bd_cells $parentCell] + if { $parentObj == "" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2090 -severity "ERROR" "Unable to find parent cell <$parentCell>!"} + return + } + + # Make sure parentObj is hier blk + set parentType [get_property TYPE $parentObj] + if { $parentType ne "hier" } { + catch {common::send_gid_msg -ssname BD::TCL -id 2091 -severity "ERROR" "Parent <$parentObj> has TYPE = <$parentType>. Expected to be ."} + return + } + + # Save current instance; Restore later + set oldCurInst [current_bd_instance .] + + # Set parent object as current + current_bd_instance $parentObj + + + # Create interface ports + set DDR [ create_bd_intf_port -mode Master -vlnv xilinx.com:interface:ddrx_rtl:1.0 DDR ] + + set FIXED_IO [ create_bd_intf_port -mode Master -vlnv xilinx.com:display_processing_system7:fixedio_rtl:1.0 FIXED_IO ] + + + # Create ports + + # Create instance: HlsKernelV_0, and set properties + set HlsKernelV_0 [ create_bd_cell -type ip -vlnv xilinx.com:hls:HlsKernelV:1.0 HlsKernelV_0 ] + + # Create instance: axi_mem_intercon, and set properties + set axi_mem_intercon [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon + + # Create instance: axi_mem_intercon_1, and set properties + set axi_mem_intercon_1 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_1 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_1 + + # Create instance: axi_mem_intercon_2, and set properties + set axi_mem_intercon_2 [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 axi_mem_intercon_2 ] + set_property -dict [ list \ + CONFIG.NUM_MI {1} \ + ] $axi_mem_intercon_2 + + # Create instance: processing_system7_0, and set properties + set processing_system7_0 [ create_bd_cell -type ip -vlnv xilinx.com:ip:processing_system7:5.5 processing_system7_0 ] + set_property -dict [ list \ + CONFIG.PCW_ACT_APU_PERIPHERAL_FREQMHZ {666.666687} \ + CONFIG.PCW_ACT_CAN_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_DCI_PERIPHERAL_FREQMHZ {10.158730} \ + CONFIG.PCW_ACT_ENET0_PERIPHERAL_FREQMHZ {125.000000} \ + CONFIG.PCW_ACT_ENET1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_ACT_FPGA1_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA2_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_FPGA3_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_PCAP_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_QSPI_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_SDIO_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_SMC_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_SPI_PERIPHERAL_FREQMHZ {10.000000} \ + CONFIG.PCW_ACT_TPIU_PERIPHERAL_FREQMHZ {200.000000} \ + CONFIG.PCW_ACT_TTC0_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC0_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK0_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK1_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_TTC1_CLK2_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_ACT_UART_PERIPHERAL_FREQMHZ {50.000000} \ + CONFIG.PCW_ACT_WDT_PERIPHERAL_FREQMHZ {111.111115} \ + CONFIG.PCW_APU_PERIPHERAL_FREQMHZ {666.666667} \ + CONFIG.PCW_ARMPLL_CTRL_FBDIV {40} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_CAN_PERIPHERAL_FREQMHZ {100} \ + CONFIG.PCW_CLK0_FREQ {100000000} \ + CONFIG.PCW_CLK1_FREQ {10000000} \ + CONFIG.PCW_CLK2_FREQ {10000000} \ + CONFIG.PCW_CLK3_FREQ {10000000} \ + CONFIG.PCW_CPU_CPU_PLL_FREQMHZ {1333.333} \ + CONFIG.PCW_CPU_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR0 {15} \ + CONFIG.PCW_DCI_PERIPHERAL_DIVISOR1 {7} \ + CONFIG.PCW_DDRPLL_CTRL_FBDIV {32} \ + CONFIG.PCW_DDR_DDR_PLL_FREQMHZ {1066.667} \ + CONFIG.PCW_DDR_PERIPHERAL_DIVISOR0 {2} \ + CONFIG.PCW_DDR_RAM_HIGHADDR {0x1FFFFFFF} \ + CONFIG.PCW_ENET0_ENET0_IO {MIO 16 .. 27} \ + CONFIG.PCW_ENET0_GRP_MDIO_ENABLE {1} \ + CONFIG.PCW_ENET0_GRP_MDIO_IO {MIO 52 .. 53} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR0 {8} \ + CONFIG.PCW_ENET0_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_ENET0_PERIPHERAL_FREQMHZ {1000 Mbps} \ + CONFIG.PCW_ENET0_RESET_ENABLE {0} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_ENET1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_ENET1_RESET_ENABLE {0} \ + CONFIG.PCW_ENET_RESET_ENABLE {1} \ + CONFIG.PCW_ENET_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_EN_EMIO_TTC0 {1} \ + CONFIG.PCW_EN_ENET0 {1} \ + CONFIG.PCW_EN_GPIO {1} \ + CONFIG.PCW_EN_QSPI {1} \ + CONFIG.PCW_EN_SDIO0 {1} \ + CONFIG.PCW_EN_TTC0 {1} \ + CONFIG.PCW_EN_UART1 {1} \ + CONFIG.PCW_EN_USB0 {1} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_FCLK0_PERIPHERAL_DIVISOR1 {2} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK1_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK2_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_FCLK3_PERIPHERAL_DIVISOR1 {1} \ + CONFIG.PCW_FPGA0_PERIPHERAL_FREQMHZ {100.000000} \ + CONFIG.PCW_FPGA1_PERIPHERAL_FREQMHZ {150.000000} \ + CONFIG.PCW_FPGA2_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_FPGA_FCLK0_ENABLE {1} \ + CONFIG.PCW_FPGA_FCLK1_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK2_ENABLE {0} \ + CONFIG.PCW_FPGA_FCLK3_ENABLE {0} \ + CONFIG.PCW_GPIO_MIO_GPIO_ENABLE {1} \ + CONFIG.PCW_GPIO_MIO_GPIO_IO {MIO} \ + CONFIG.PCW_I2C0_GRP_INT_ENABLE {0} \ + CONFIG.PCW_I2C0_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_I2C0_RESET_ENABLE {0} \ + CONFIG.PCW_I2C1_RESET_ENABLE {0} \ + CONFIG.PCW_I2C_PERIPHERAL_FREQMHZ {25} \ + CONFIG.PCW_I2C_RESET_ENABLE {1} \ + CONFIG.PCW_IOPLL_CTRL_FBDIV {30} \ + CONFIG.PCW_IO_IO_PLL_FREQMHZ {1000.000} \ + CONFIG.PCW_MIO_0_DIRECTION {inout} \ + CONFIG.PCW_MIO_0_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_0_PULLUP {disabled} \ + CONFIG.PCW_MIO_0_SLEW {slow} \ + CONFIG.PCW_MIO_10_DIRECTION {inout} \ + CONFIG.PCW_MIO_10_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_10_PULLUP {disabled} \ + CONFIG.PCW_MIO_10_SLEW {slow} \ + CONFIG.PCW_MIO_11_DIRECTION {inout} \ + CONFIG.PCW_MIO_11_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_11_PULLUP {disabled} \ + CONFIG.PCW_MIO_11_SLEW {slow} \ + CONFIG.PCW_MIO_12_DIRECTION {inout} \ + CONFIG.PCW_MIO_12_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_12_PULLUP {disabled} \ + CONFIG.PCW_MIO_12_SLEW {slow} \ + CONFIG.PCW_MIO_13_DIRECTION {inout} \ + CONFIG.PCW_MIO_13_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_13_PULLUP {disabled} \ + CONFIG.PCW_MIO_13_SLEW {slow} \ + CONFIG.PCW_MIO_14_DIRECTION {inout} \ + CONFIG.PCW_MIO_14_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_14_PULLUP {disabled} \ + CONFIG.PCW_MIO_14_SLEW {slow} \ + CONFIG.PCW_MIO_15_DIRECTION {inout} \ + CONFIG.PCW_MIO_15_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_15_PULLUP {disabled} \ + CONFIG.PCW_MIO_15_SLEW {slow} \ + CONFIG.PCW_MIO_16_DIRECTION {out} \ + CONFIG.PCW_MIO_16_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_16_PULLUP {disabled} \ + CONFIG.PCW_MIO_16_SLEW {fast} \ + CONFIG.PCW_MIO_17_DIRECTION {out} \ + CONFIG.PCW_MIO_17_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_17_PULLUP {disabled} \ + CONFIG.PCW_MIO_17_SLEW {fast} \ + CONFIG.PCW_MIO_18_DIRECTION {out} \ + CONFIG.PCW_MIO_18_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_18_PULLUP {disabled} \ + CONFIG.PCW_MIO_18_SLEW {fast} \ + CONFIG.PCW_MIO_19_DIRECTION {out} \ + CONFIG.PCW_MIO_19_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_19_PULLUP {disabled} \ + CONFIG.PCW_MIO_19_SLEW {fast} \ + CONFIG.PCW_MIO_1_DIRECTION {out} \ + CONFIG.PCW_MIO_1_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_1_PULLUP {disabled} \ + CONFIG.PCW_MIO_1_SLEW {fast} \ + CONFIG.PCW_MIO_20_DIRECTION {out} \ + CONFIG.PCW_MIO_20_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_20_PULLUP {disabled} \ + CONFIG.PCW_MIO_20_SLEW {fast} \ + CONFIG.PCW_MIO_21_DIRECTION {out} \ + CONFIG.PCW_MIO_21_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_21_PULLUP {disabled} \ + CONFIG.PCW_MIO_21_SLEW {fast} \ + CONFIG.PCW_MIO_22_DIRECTION {in} \ + CONFIG.PCW_MIO_22_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_22_PULLUP {disabled} \ + CONFIG.PCW_MIO_22_SLEW {fast} \ + CONFIG.PCW_MIO_23_DIRECTION {in} \ + CONFIG.PCW_MIO_23_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_23_PULLUP {disabled} \ + CONFIG.PCW_MIO_23_SLEW {fast} \ + CONFIG.PCW_MIO_24_DIRECTION {in} \ + CONFIG.PCW_MIO_24_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_24_PULLUP {disabled} \ + CONFIG.PCW_MIO_24_SLEW {fast} \ + CONFIG.PCW_MIO_25_DIRECTION {in} \ + CONFIG.PCW_MIO_25_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_25_PULLUP {disabled} \ + CONFIG.PCW_MIO_25_SLEW {fast} \ + CONFIG.PCW_MIO_26_DIRECTION {in} \ + CONFIG.PCW_MIO_26_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_26_PULLUP {disabled} \ + CONFIG.PCW_MIO_26_SLEW {fast} \ + CONFIG.PCW_MIO_27_DIRECTION {in} \ + CONFIG.PCW_MIO_27_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_27_PULLUP {disabled} \ + CONFIG.PCW_MIO_27_SLEW {fast} \ + CONFIG.PCW_MIO_28_DIRECTION {inout} \ + CONFIG.PCW_MIO_28_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_28_PULLUP {disabled} \ + CONFIG.PCW_MIO_28_SLEW {fast} \ + CONFIG.PCW_MIO_29_DIRECTION {in} \ + CONFIG.PCW_MIO_29_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_29_PULLUP {disabled} \ + CONFIG.PCW_MIO_29_SLEW {fast} \ + CONFIG.PCW_MIO_2_DIRECTION {inout} \ + CONFIG.PCW_MIO_2_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_2_PULLUP {disabled} \ + CONFIG.PCW_MIO_2_SLEW {fast} \ + CONFIG.PCW_MIO_30_DIRECTION {out} \ + CONFIG.PCW_MIO_30_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_30_PULLUP {disabled} \ + CONFIG.PCW_MIO_30_SLEW {fast} \ + CONFIG.PCW_MIO_31_DIRECTION {in} \ + CONFIG.PCW_MIO_31_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_31_PULLUP {disabled} \ + CONFIG.PCW_MIO_31_SLEW {fast} \ + CONFIG.PCW_MIO_32_DIRECTION {inout} \ + CONFIG.PCW_MIO_32_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_32_PULLUP {disabled} \ + CONFIG.PCW_MIO_32_SLEW {fast} \ + CONFIG.PCW_MIO_33_DIRECTION {inout} \ + CONFIG.PCW_MIO_33_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_33_PULLUP {disabled} \ + CONFIG.PCW_MIO_33_SLEW {fast} \ + CONFIG.PCW_MIO_34_DIRECTION {inout} \ + CONFIG.PCW_MIO_34_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_34_PULLUP {disabled} \ + CONFIG.PCW_MIO_34_SLEW {fast} \ + CONFIG.PCW_MIO_35_DIRECTION {inout} \ + CONFIG.PCW_MIO_35_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_35_PULLUP {disabled} \ + CONFIG.PCW_MIO_35_SLEW {fast} \ + CONFIG.PCW_MIO_36_DIRECTION {in} \ + CONFIG.PCW_MIO_36_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_36_PULLUP {disabled} \ + CONFIG.PCW_MIO_36_SLEW {fast} \ + CONFIG.PCW_MIO_37_DIRECTION {inout} \ + CONFIG.PCW_MIO_37_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_37_PULLUP {disabled} \ + CONFIG.PCW_MIO_37_SLEW {fast} \ + CONFIG.PCW_MIO_38_DIRECTION {inout} \ + CONFIG.PCW_MIO_38_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_38_PULLUP {disabled} \ + CONFIG.PCW_MIO_38_SLEW {fast} \ + CONFIG.PCW_MIO_39_DIRECTION {inout} \ + CONFIG.PCW_MIO_39_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_39_PULLUP {disabled} \ + CONFIG.PCW_MIO_39_SLEW {fast} \ + CONFIG.PCW_MIO_3_DIRECTION {inout} \ + CONFIG.PCW_MIO_3_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_3_PULLUP {disabled} \ + CONFIG.PCW_MIO_3_SLEW {fast} \ + CONFIG.PCW_MIO_40_DIRECTION {inout} \ + CONFIG.PCW_MIO_40_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_40_PULLUP {disabled} \ + CONFIG.PCW_MIO_40_SLEW {fast} \ + CONFIG.PCW_MIO_41_DIRECTION {inout} \ + CONFIG.PCW_MIO_41_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_41_PULLUP {disabled} \ + CONFIG.PCW_MIO_41_SLEW {fast} \ + CONFIG.PCW_MIO_42_DIRECTION {inout} \ + CONFIG.PCW_MIO_42_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_42_PULLUP {disabled} \ + CONFIG.PCW_MIO_42_SLEW {fast} \ + CONFIG.PCW_MIO_43_DIRECTION {inout} \ + CONFIG.PCW_MIO_43_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_43_PULLUP {disabled} \ + CONFIG.PCW_MIO_43_SLEW {fast} \ + CONFIG.PCW_MIO_44_DIRECTION {inout} \ + CONFIG.PCW_MIO_44_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_44_PULLUP {disabled} \ + CONFIG.PCW_MIO_44_SLEW {fast} \ + CONFIG.PCW_MIO_45_DIRECTION {inout} \ + CONFIG.PCW_MIO_45_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_45_PULLUP {disabled} \ + CONFIG.PCW_MIO_45_SLEW {fast} \ + CONFIG.PCW_MIO_46_DIRECTION {in} \ + CONFIG.PCW_MIO_46_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_46_PULLUP {disabled} \ + CONFIG.PCW_MIO_46_SLEW {slow} \ + CONFIG.PCW_MIO_47_DIRECTION {in} \ + CONFIG.PCW_MIO_47_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_47_PULLUP {disabled} \ + CONFIG.PCW_MIO_47_SLEW {slow} \ + CONFIG.PCW_MIO_48_DIRECTION {out} \ + CONFIG.PCW_MIO_48_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_48_PULLUP {disabled} \ + CONFIG.PCW_MIO_48_SLEW {slow} \ + CONFIG.PCW_MIO_49_DIRECTION {in} \ + CONFIG.PCW_MIO_49_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_49_PULLUP {disabled} \ + CONFIG.PCW_MIO_49_SLEW {slow} \ + CONFIG.PCW_MIO_4_DIRECTION {inout} \ + CONFIG.PCW_MIO_4_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_4_PULLUP {disabled} \ + CONFIG.PCW_MIO_4_SLEW {fast} \ + CONFIG.PCW_MIO_50_DIRECTION {inout} \ + CONFIG.PCW_MIO_50_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_50_PULLUP {disabled} \ + CONFIG.PCW_MIO_50_SLEW {slow} \ + CONFIG.PCW_MIO_51_DIRECTION {inout} \ + CONFIG.PCW_MIO_51_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_51_PULLUP {disabled} \ + CONFIG.PCW_MIO_51_SLEW {slow} \ + CONFIG.PCW_MIO_52_DIRECTION {out} \ + CONFIG.PCW_MIO_52_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_52_PULLUP {disabled} \ + CONFIG.PCW_MIO_52_SLEW {slow} \ + CONFIG.PCW_MIO_53_DIRECTION {inout} \ + CONFIG.PCW_MIO_53_IOTYPE {LVCMOS 1.8V} \ + CONFIG.PCW_MIO_53_PULLUP {disabled} \ + CONFIG.PCW_MIO_53_SLEW {slow} \ + CONFIG.PCW_MIO_5_DIRECTION {inout} \ + CONFIG.PCW_MIO_5_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_5_PULLUP {disabled} \ + CONFIG.PCW_MIO_5_SLEW {fast} \ + CONFIG.PCW_MIO_6_DIRECTION {out} \ + CONFIG.PCW_MIO_6_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_6_PULLUP {disabled} \ + CONFIG.PCW_MIO_6_SLEW {fast} \ + CONFIG.PCW_MIO_7_DIRECTION {out} \ + CONFIG.PCW_MIO_7_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_7_PULLUP {disabled} \ + CONFIG.PCW_MIO_7_SLEW {slow} \ + CONFIG.PCW_MIO_8_DIRECTION {out} \ + CONFIG.PCW_MIO_8_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_8_PULLUP {disabled} \ + CONFIG.PCW_MIO_8_SLEW {fast} \ + CONFIG.PCW_MIO_9_DIRECTION {inout} \ + CONFIG.PCW_MIO_9_IOTYPE {LVCMOS 3.3V} \ + CONFIG.PCW_MIO_9_PULLUP {disabled} \ + CONFIG.PCW_MIO_9_SLEW {slow} \ + CONFIG.PCW_MIO_TREE_PERIPHERALS {GPIO#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#Quad SPI Flash#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#GPIO#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#Enet 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#USB 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#SD 0#UART 1#UART 1#GPIO#GPIO#Enet 0#Enet 0} \ + CONFIG.PCW_MIO_TREE_SIGNALS {gpio[0]#qspi0_ss_b#qspi0_io[0]#qspi0_io[1]#qspi0_io[2]#qspi0_io[3]/HOLD_B#qspi0_sclk#gpio[7]#gpio[8]#gpio[9]#gpio[10]#gpio[11]#gpio[12]#gpio[13]#gpio[14]#gpio[15]#tx_clk#txd[0]#txd[1]#txd[2]#txd[3]#tx_ctl#rx_clk#rxd[0]#rxd[1]#rxd[2]#rxd[3]#rx_ctl#data[4]#dir#stp#nxt#data[0]#data[1]#data[2]#data[3]#clk#data[5]#data[6]#data[7]#clk#cmd#data[0]#data[1]#data[2]#data[3]#wp#cd#tx#rx#gpio[50]#gpio[51]#mdc#mdio} \ + CONFIG.PCW_NAND_GRP_D8_ENABLE {0} \ + CONFIG.PCW_NAND_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_A25_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS0_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_CS1_ENABLE {0} \ + CONFIG.PCW_NOR_GRP_SRAM_INT_ENABLE {0} \ + CONFIG.PCW_NOR_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PCAP_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_PJTAG_PERIPHERAL_ENABLE {0} \ + CONFIG.PCW_PRESET_BANK0_VOLTAGE {LVCMOS 3.3V} \ + CONFIG.PCW_PRESET_BANK1_VOLTAGE {LVCMOS 1.8V} \ + CONFIG.PCW_QSPI_GRP_FBCLK_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_IO1_ENABLE {0} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_ENABLE {1} \ + CONFIG.PCW_QSPI_GRP_SINGLE_SS_IO {MIO 1 .. 6} \ + CONFIG.PCW_QSPI_GRP_SS1_ENABLE {0} \ + CONFIG.PCW_QSPI_PERIPHERAL_DIVISOR0 {5} \ + CONFIG.PCW_QSPI_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_QSPI_PERIPHERAL_FREQMHZ {200} \ + CONFIG.PCW_QSPI_QSPI_IO {MIO 1 .. 6} \ + CONFIG.PCW_SD0_GRP_CD_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_CD_IO {MIO 47} \ + CONFIG.PCW_SD0_GRP_POW_ENABLE {0} \ + CONFIG.PCW_SD0_GRP_WP_ENABLE {1} \ + CONFIG.PCW_SD0_GRP_WP_IO {MIO 46} \ + CONFIG.PCW_SD0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_SD0_SD0_IO {MIO 40 .. 45} \ + CONFIG.PCW_SDIO_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_SDIO_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_SDIO_PERIPHERAL_VALID {1} \ + CONFIG.PCW_SINGLE_QSPI_DATA_MODE {x4} \ + CONFIG.PCW_SMC_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_SPI_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_S_AXI_HP2_DATA_WIDTH {64} \ + CONFIG.PCW_TPIU_PERIPHERAL_DIVISOR0 {1} \ + CONFIG.PCW_TTC0_CLK0_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK1_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_CLK2_PERIPHERAL_FREQMHZ {133.333333} \ + CONFIG.PCW_TTC0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_TTC0_TTC0_IO {EMIO} \ + CONFIG.PCW_TTC_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART1_GRP_FULL_ENABLE {0} \ + CONFIG.PCW_UART1_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_UART1_UART1_IO {MIO 48 .. 49} \ + CONFIG.PCW_UART_PERIPHERAL_DIVISOR0 {20} \ + CONFIG.PCW_UART_PERIPHERAL_FREQMHZ {50} \ + CONFIG.PCW_UART_PERIPHERAL_VALID {1} \ + CONFIG.PCW_UIPARAM_ACT_DDR_FREQ_MHZ {533.333374} \ + CONFIG.PCW_UIPARAM_DDR_BANK_ADDR_COUNT {3} \ + CONFIG.PCW_UIPARAM_DDR_BL {8} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY0 {0.41} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY1 {0.411} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY2 {0.341} \ + CONFIG.PCW_UIPARAM_DDR_BOARD_DELAY3 {0.358} \ + CONFIG.PCW_UIPARAM_DDR_CL {7} \ + CONFIG.PCW_UIPARAM_DDR_COL_ADDR_COUNT {10} \ + CONFIG.PCW_UIPARAM_DDR_CWL {6} \ + CONFIG.PCW_UIPARAM_DDR_DEVICE_CAPACITY {2048 MBits} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_0 {0.025} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_1 {0.028} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_2 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DQS_TO_CLK_DELAY_3 {0.001} \ + CONFIG.PCW_UIPARAM_DDR_DRAM_WIDTH {16 Bits} \ + CONFIG.PCW_UIPARAM_DDR_FREQ_MHZ {533.333313} \ + CONFIG.PCW_UIPARAM_DDR_MEMORY_TYPE {DDR 3} \ + CONFIG.PCW_UIPARAM_DDR_PARTNO {MT41J128M16 HA-15E} \ + CONFIG.PCW_UIPARAM_DDR_ROW_ADDR_COUNT {14} \ + CONFIG.PCW_UIPARAM_DDR_SPEED_BIN {DDR3_1066F} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_DATA_EYE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_READ_GATE {1} \ + CONFIG.PCW_UIPARAM_DDR_TRAIN_WRITE_LEVEL {1} \ + CONFIG.PCW_UIPARAM_DDR_T_FAW {45.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RAS_MIN {36.0} \ + CONFIG.PCW_UIPARAM_DDR_T_RC {49.5} \ + CONFIG.PCW_UIPARAM_DDR_T_RCD {7} \ + CONFIG.PCW_UIPARAM_DDR_T_RP {7} \ + CONFIG.PCW_UIPARAM_DDR_USE_INTERNAL_VREF {1} \ + CONFIG.PCW_USB0_PERIPHERAL_ENABLE {1} \ + CONFIG.PCW_USB0_PERIPHERAL_FREQMHZ {60} \ + CONFIG.PCW_USB0_RESET_ENABLE {0} \ + CONFIG.PCW_USB0_USB0_IO {MIO 28 .. 39} \ + CONFIG.PCW_USB1_RESET_ENABLE {0} \ + CONFIG.PCW_USB_RESET_ENABLE {1} \ + CONFIG.PCW_USB_RESET_SELECT {Share reset pin} \ + CONFIG.PCW_USE_S_AXI_HP0 {1} \ + CONFIG.PCW_USE_S_AXI_HP1 {1} \ + CONFIG.PCW_USE_S_AXI_HP2 {1} \ + CONFIG.preset {ZedBoard} \ + ] $processing_system7_0 + + # Create instance: ps7_0_axi_periph, and set properties + set ps7_0_axi_periph [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_interconnect:2.1 ps7_0_axi_periph ] + set_property -dict [ list \ + CONFIG.NUM_MI {4} \ + ] $ps7_0_axi_periph + + # Create instance: rst_ps7_0_100M, and set properties + set rst_ps7_0_100M [ create_bd_cell -type ip -vlnv xilinx.com:ip:proc_sys_reset:5.0 rst_ps7_0_100M ] + + # Create instance: v_dma, and set properties + set v_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 v_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $v_dma + + # Create instance: xus_dma, and set properties + set xus_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 xus_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s_dre {1} \ + CONFIG.c_include_s2mm {0} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_m_axi_mm2s_data_width {64} \ + CONFIG.c_m_axis_mm2s_tdata_width {64} \ + CONFIG.c_mm2s_burst_size {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $xus_dma + + # Create instance: y_dma, and set properties + set y_dma [ create_bd_cell -type ip -vlnv xilinx.com:ip:axi_dma:7.1 y_dma ] + set_property -dict [ list \ + CONFIG.c_include_mm2s {0} \ + CONFIG.c_include_s2mm_dre {1} \ + CONFIG.c_include_sg {0} \ + CONFIG.c_micro_dma {0} \ + CONFIG.c_s2mm_burst_size {128} \ + CONFIG.c_s_axis_s2mm_tdata_width {256} \ + CONFIG.c_sg_include_stscntrl_strm {0} \ + CONFIG.c_sg_length_width {16} \ + ] $y_dma + + # Create interface connections + connect_bd_intf_net -intf_net HlsKernelV_0_y_port [get_bd_intf_pins HlsKernelV_0/y_port] [get_bd_intf_pins y_dma/S_AXIS_S2MM] + connect_bd_intf_net -intf_net axi_mem_intercon_1_M00_AXI [get_bd_intf_pins axi_mem_intercon_1/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP1] + connect_bd_intf_net -intf_net axi_mem_intercon_2_M00_AXI [get_bd_intf_pins axi_mem_intercon_2/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP2] + connect_bd_intf_net -intf_net axi_mem_intercon_M00_AXI [get_bd_intf_pins axi_mem_intercon/M00_AXI] [get_bd_intf_pins processing_system7_0/S_AXI_HP0] + connect_bd_intf_net -intf_net processing_system7_0_DDR [get_bd_intf_ports DDR] [get_bd_intf_pins processing_system7_0/DDR] + connect_bd_intf_net -intf_net processing_system7_0_FIXED_IO [get_bd_intf_ports FIXED_IO] [get_bd_intf_pins processing_system7_0/FIXED_IO] + connect_bd_intf_net -intf_net processing_system7_0_M_AXI_GP0 [get_bd_intf_pins processing_system7_0/M_AXI_GP0] [get_bd_intf_pins ps7_0_axi_periph/S00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M00_AXI [get_bd_intf_pins HlsKernelV_0/s_axi_control] [get_bd_intf_pins ps7_0_axi_periph/M00_AXI] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M01_AXI [get_bd_intf_pins ps7_0_axi_periph/M01_AXI] [get_bd_intf_pins v_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M02_AXI [get_bd_intf_pins ps7_0_axi_periph/M02_AXI] [get_bd_intf_pins xus_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net ps7_0_axi_periph_M03_AXI [get_bd_intf_pins ps7_0_axi_periph/M03_AXI] [get_bd_intf_pins y_dma/S_AXI_LITE] + connect_bd_intf_net -intf_net u_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon_1/S00_AXI] [get_bd_intf_pins v_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net v_dma_M_AXIS_MM2S [get_bd_intf_pins HlsKernelV_0/v_port] [get_bd_intf_pins v_dma/M_AXIS_MM2S] + connect_bd_intf_net -intf_net x_dma_M_AXI_MM2S [get_bd_intf_pins axi_mem_intercon/S00_AXI] [get_bd_intf_pins xus_dma/M_AXI_MM2S] + connect_bd_intf_net -intf_net xu_dma_M_AXI_S2MM [get_bd_intf_pins axi_mem_intercon_2/S00_AXI] [get_bd_intf_pins y_dma/M_AXI_S2MM] + connect_bd_intf_net -intf_net xus_dma_M_AXIS_MM2S [get_bd_intf_pins HlsKernelV_0/xus_port] [get_bd_intf_pins xus_dma/M_AXIS_MM2S] + + # Create port connections + connect_bd_net -net processing_system7_0_FCLK_CLK0 [get_bd_pins HlsKernelV_0/ap_clk] [get_bd_pins axi_mem_intercon/ACLK] [get_bd_pins axi_mem_intercon/M00_ACLK] [get_bd_pins axi_mem_intercon/S00_ACLK] [get_bd_pins axi_mem_intercon_1/ACLK] [get_bd_pins axi_mem_intercon_1/M00_ACLK] [get_bd_pins axi_mem_intercon_1/S00_ACLK] [get_bd_pins axi_mem_intercon_2/ACLK] [get_bd_pins axi_mem_intercon_2/M00_ACLK] [get_bd_pins axi_mem_intercon_2/S00_ACLK] [get_bd_pins processing_system7_0/FCLK_CLK0] [get_bd_pins processing_system7_0/M_AXI_GP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP0_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP1_ACLK] [get_bd_pins processing_system7_0/S_AXI_HP2_ACLK] [get_bd_pins ps7_0_axi_periph/ACLK] [get_bd_pins ps7_0_axi_periph/M00_ACLK] [get_bd_pins ps7_0_axi_periph/M01_ACLK] [get_bd_pins ps7_0_axi_periph/M02_ACLK] [get_bd_pins ps7_0_axi_periph/M03_ACLK] [get_bd_pins ps7_0_axi_periph/S00_ACLK] [get_bd_pins rst_ps7_0_100M/slowest_sync_clk] [get_bd_pins v_dma/m_axi_mm2s_aclk] [get_bd_pins v_dma/s_axi_lite_aclk] [get_bd_pins xus_dma/m_axi_mm2s_aclk] [get_bd_pins xus_dma/s_axi_lite_aclk] [get_bd_pins y_dma/m_axi_s2mm_aclk] [get_bd_pins y_dma/s_axi_lite_aclk] + connect_bd_net -net processing_system7_0_FCLK_RESET0_N [get_bd_pins processing_system7_0/FCLK_RESET0_N] [get_bd_pins rst_ps7_0_100M/ext_reset_in] + connect_bd_net -net rst_ps7_0_100M_peripheral_aresetn [get_bd_pins HlsKernelV_0/ap_rst_n] [get_bd_pins axi_mem_intercon/ARESETN] [get_bd_pins axi_mem_intercon/M00_ARESETN] [get_bd_pins axi_mem_intercon/S00_ARESETN] [get_bd_pins axi_mem_intercon_1/ARESETN] [get_bd_pins axi_mem_intercon_1/M00_ARESETN] [get_bd_pins axi_mem_intercon_1/S00_ARESETN] [get_bd_pins axi_mem_intercon_2/ARESETN] [get_bd_pins axi_mem_intercon_2/M00_ARESETN] [get_bd_pins axi_mem_intercon_2/S00_ARESETN] [get_bd_pins ps7_0_axi_periph/ARESETN] [get_bd_pins ps7_0_axi_periph/M00_ARESETN] [get_bd_pins ps7_0_axi_periph/M01_ARESETN] [get_bd_pins ps7_0_axi_periph/M02_ARESETN] [get_bd_pins ps7_0_axi_periph/M03_ARESETN] [get_bd_pins ps7_0_axi_periph/S00_ARESETN] [get_bd_pins rst_ps7_0_100M/peripheral_aresetn] [get_bd_pins v_dma/axi_resetn] [get_bd_pins xus_dma/axi_resetn] [get_bd_pins y_dma/axi_resetn] + + # Create address segments + assign_bd_address -offset 0x40000000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs HlsKernelV_0/s_axi_control/Reg] -force + assign_bd_address -offset 0x41E00000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs v_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E10000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs xus_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x41E20000 -range 0x00010000 -target_address_space [get_bd_addr_spaces processing_system7_0/Data] [get_bd_addr_segs y_dma/S_AXI_LITE/Reg] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces v_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP1/HP1_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces xus_dma/Data_MM2S] [get_bd_addr_segs processing_system7_0/S_AXI_HP0/HP0_DDR_LOWOCM] -force + assign_bd_address -offset 0x00000000 -range 0x20000000 -target_address_space [get_bd_addr_spaces y_dma/Data_S2MM] [get_bd_addr_segs processing_system7_0/S_AXI_HP2/HP2_DDR_LOWOCM] -force + + + # Restore current instance + current_bd_instance $oldCurInst + + validate_bd_design + save_bd_design +} +# End of create_root_design() + + +################################################################## +# MAIN FLOW +################################################################## + +create_root_design "" + + diff --git a/python/SVD_Approximation.ipynb b/python/SVD_Approximation.ipynb new file mode 100644 index 0000000..3cb4bcd --- /dev/null +++ b/python/SVD_Approximation.ipynb @@ -0,0 +1,4235 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "SVD Approximation", + "provenance": [], + "collapsed_sections": [ + "_trp6sx3J3RR", + "9EWRUuxXkzxh", + "9qAJGTrJxCUl", + "Fxd8syuH4WeS", + "L3OA-HB7gExG", + "pjtqPfHpFOpE", + "WpYSOigtTVxh", + "Ya5FeHCMTips", + "xKKBt8IfsoZx", + "rhuPyqNv5Pxk", + "zY1BfLH75W2l", + "ukjOI4iC-uZq", + "euTcBc3P_aoN", + "ykQbfnSia2rf", + "IvprTTb8vXiM", + "95vRr_e-z4k3" + ], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "oHvAGHE5Ya6_" + }, + "source": [ + "# SVD Approximation" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MGO1yyCnXtbR", + "outputId": "09da0a50-9663-4638-a515-84f956046399" + }, + "source": [ + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from PIL import Image, ImageOps\n", + "from google.colab import drive\n", + "import re\n", + "from datetime import datetime\n", + "import os\n", + "\n", + "# Load the TensorBoard notebook extension\n", + "%load_ext tensorboard\n", + "%tensorflow_version 2.x\n", + "from tensorboard.plugins.hparams import api as hp\n", + "# Clear any logs from previous tensorboard runs\n", + "!rm -rf /tmp/mylogs\n", + "writer = tf.summary.create_file_writer('/tmp/mylogs')\n", + "\n", + "drive.mount('/gdrive', force_remount=True)" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Mounted at /gdrive\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zMLle_8oZIh5" + }, + "source": [ + "## Algorithm 1 - Stardard SVD Decomposition" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8mPVVvxkYN5T" + }, + "source": [ + "def svd1(x_in, Verbose=False, correction_factor=1e-12):\n", + " \"\"\"\n", + " @brief Short-hand for applying SVD and dealing with non-converging SVD.\n", + " \n", + " @param x input matrix\n", + " \n", + " @return the U, s, V first components\n", + " \"\"\"\n", + " x = x_in.copy()\n", + " m, n = x.shape\n", + " not_converged = True\n", + " max_tries = 1000\n", + " i = 0\n", + " while not_converged:\n", + " try:\n", + " u, s, v = np.linalg.svd(x, full_matrices=False)\n", + " except np.linalg.linalg.LinAlgError as e:\n", + " # ==================================================================\n", + " # If SVD didn't converge, add a small error to the matrix and\n", + " # repeat, otherwise the heuristic will always generate zero\n", + " # components.\n", + " # ==================================================================\n", + " if Verbose:\n", + " print(\"[WARNING] Exception caught: {}\". format(e))\n", + " if np.isnan(x).any():\n", + " print(\"[WARNING] The provided matrix contains NaNs.\")\n", + " if np.isinf(x).any():\n", + " print(\"[WARNING] The provided matrix contains Infs.\")\n", + " u = np.zeros((m, m))\n", + " s = np.zeros((n,))\n", + " v = np.zeros((n, n))\n", + " x -= correction_factor\n", + " if np.any(s): # not all zeros\n", + " not_converged = False\n", + " # If still not converging and max tries reached, return svd components\n", + " # that are close to zero.\n", + " if not_converged and i == max_tries:\n", + " not_converge = False\n", + " u = np.zeros((m, m))\n", + " s = np.zeros((n,))\n", + " v = np.zeros((n, n))\n", + " u += 1e-15\n", + " s += 1e-15\n", + " v += 1e-15\n", + " i += 1\n", + " return u.T[0], s[0], v[0]" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7b4e1BohX4uy", + "outputId": "63d3669e-3dbe-4a46-9e9c-ad9b6b776893" + }, + "source": [ + "x = np.random.randn(32, 16)\n", + "svd1(x)" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(array([-0.23517926, -0.22266451, -0.04113012, 0.12105154, 0.09157681,\n", + " 0.31938436, 0.06855524, -0.09182536, 0.1314608 , -0.09691401,\n", + " -0.18813444, -0.03940004, 0.11687518, 0.12699954, 0.06467241,\n", + " -0.33720879, -0.08737761, -0.01283995, 0.01086322, 0.32436626,\n", + " -0.15699125, -0.23119637, 0.02632368, 0.02199429, -0.10579826,\n", + " 0.3113676 , 0.26651324, 0.22477058, 0.17408367, -0.03829521,\n", + " 0.14641498, 0.2619741 ]),\n", + " 8.688512368755092,\n", + " array([-0.17232688, -0.50307578, 0.04739223, -0.25651778, 0.02782118,\n", + " -0.33456374, -0.36638351, -0.35588306, -0.24278886, 0.0009277 ,\n", + " 0.17219074, 0.20284928, 0.12503761, 0.21298591, 0.14851794,\n", + " -0.25054842]))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VX2I2QK0a7b2" + }, + "source": [ + "## Algorithm 2 - Joshua Paper\n", + "\n", + "Decompose `k` matrices into `r` sub-matrices." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "NIsZsVlEgfVl" + }, + "source": [ + "def mse(a, b):\n", + " return ((a - b)**2).mean()\n", + "\n", + "def avg_abs_diff(a, b):\n", + " return np.absolute(a - b).mean()\n", + "\n", + "def frobenius_norm(a, b):\n", + " return np.sqrt(np.absolute(np.linalg.norm(a - b)))\n", + "\n", + "def frobenius(x):\n", + " return (x**2).sum()\n", + "\n", + "def check_threshold(U, U_step, V, V_step, stop_threshold=0.00005,\n", + " config='mse'):\n", + " \"\"\"\n", + " @brief Determines the threshold for stopping vectors refinements\n", + " \n", + " @param U []\n", + " @param U_step []\n", + " @param V []\n", + " @param V_step []\n", + " \n", + " @return whether to stop refinement process\n", + " \"\"\"\n", + " if config == 'mse':\n", + " diff_u = mse(U, U_step)\n", + " diff_v = mse(V, V_step)\n", + " elif config == 'avg':\n", + " diff_u = avg_abs_diff(U, U_step)\n", + " diff_v = avg_abs_diff(V, V_step)\n", + " elif config == 'frobenius-norm':\n", + " diff_u = frobenius_norm(U, U_step)\n", + " diff_v = frobenius_norm(V, V_step)\n", + " elif config == 'norm':\n", + " diff_u = np.linalg.norm(U - U_step)\n", + " diff_v = np.linalg.norm(V - V_step)\n", + " if diff_v < stop_threshold and diff_u < stop_threshold:\n", + " return True, diff_u, diff_v\n", + " else:\n", + " return False, diff_u, diff_v" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "DWb7XVTzithU" + }, + "source": [ + "def get_vec_from_largest_eig(x):\n", + " w, vr = np.linalg.eigh(x)\n", + " return vr[:, np.argmax(w)]" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Q-QkFZOwagdX" + }, + "source": [ + "def update_F(F, U, V):\n", + " FT = np.transpose(F, axes=(0, 2, 1))\n", + " S = V.T @ FT @ U\n", + " A = np.outer(U, V)\n", + " F_tmp = np.zeros(F.shape)\n", + " for i in range(F.shape[0]):\n", + " F_tmp[i] = F[i] - S[i] * A\n", + " return F_tmp, S\n", + "\n", + "def algorithm2(F_in, r=1, stop_threshold=0.0001, hard_stop=100,\n", + " decomposition='eigen', truncate=False, metric='mse',\n", + " report_writer=None, report_step=0, scaler=None, Verbose=False):\n", + " \"\"\"\n", + " @brief Algorithm from \"Synthesis and Optimization\n", + " of 2D Filter Designs for Heterogeneous FPGAs\"\n", + " \n", + " @param F_in List or array of matrixes to approximate \n", + " (they must have same shape)\n", + " @param r The number of sub-matrices\n", + " @param Verbose Verbose\n", + " \n", + " @return the eigenvalues lambda_ij and vectors u and v\n", + " \"\"\"\n", + " if isinstance(F_in, (list,)):\n", + " k = len(F_in)\n", + " m, n = F_in[0].shape\n", + " F = np.zeros((k, m, n))\n", + " for i in range(k):\n", + " F[i] = F_in[i].copy()\n", + " else:\n", + " k, m, n = F_in.shape\n", + " F = np.array(F_in, copy=True)\n", + " # hard_stop = 100\n", + " # stop_threshold = 0.0001 # F.std()\n", + " if truncate:\n", + " tot_elem = k * (m * n)\n", + " appr_elem = k * (m + n + r)\n", + " if appr_elem >= tot_elem:\n", + " print('[WARNING] The r value ({}) is too high and will be truncated.'.format(r))\n", + " while appr_elem >= tot_elem:\n", + " r -= 1\n", + " appr_elem = k * (m + n + r)\n", + " print('[WARNING] r set to {}.'. format(r))\n", + " if scaler is None:\n", + " scaler = np.ones((k))\n", + " u_array = np.zeros((r, m))\n", + " s_array = np.zeros((r, k))\n", + " v_array = np.zeros((r, n))\n", + " # NOTE: Given a matrix A, we have that: A @ A.T is symmetrical! Meaning\n", + " # that, for the spectral theorem, A has real eigenvalues!\n", + " for j in range(r):\n", + " # Form the (m x m) matrix Fn: sum[0,k-1](F[i] @ F[i].T)\n", + " Fn = np.zeros((m, m))\n", + " for i in range(k):\n", + " Fn += scaler[i] * F[i] @ F[i].T # SQUARED\n", + " # Calculate the eigenvector u that corresponds to the largest eigenvalue \n", + " if decomposition == 'eigen':\n", + " u = get_vec_from_largest_eig(Fn)\n", + " else:\n", + " u, _, _ = svd1(Fn)\n", + " # Form the (n x k) matrix: Fb = [F[0].T @ u, F[1].T @ u, ..., F[k-1].T @ u]\n", + " Fb = np.zeros((n, k))\n", + " for i in range(k):\n", + " Fb[:,i] = scaler[i] * F[i].T @ u\n", + " # Calculate the eigenvector v that corresponds to the largest \n", + " # eigenvalue of the (n x n) matrix: Fb @ Fb.T\n", + " Fb = Fb @ Fb.T\n", + " if decomposition == 'eigen':\n", + " v = get_vec_from_largest_eig(Fb)\n", + " else:\n", + " _, _, v = svd1(Fb)\n", + " U = u\n", + " V = v\n", + " for t in range(hard_stop):\n", + " # Form the (k x m) matrix Fb = [F[0] @ v, F[1] @ v, ..., F[k-1] @ v].T\n", + " FbT = np.zeros((m, k))\n", + " for i in range(k):\n", + " FbT[:, i] = scaler[i] * F[i] @ v\n", + " Fb = FbT.T\n", + " # Calculate the eigenvector u that corresponds to the largest \n", + " # eigenvalue of the (m x m) matrix\n", + " Fb = FbT @ Fb\n", + " if decomposition == 'eigen':\n", + " u = get_vec_from_largest_eig(Fb)\n", + " else:\n", + " u, _, _ = svd1(Fb)\n", + " # Form the (n x k) matrix Fb = [F[0].T @ u, F[1].T @ u, ..., F[k-1].T @ u].T\n", + " FbT = np.zeros((k, n))\n", + " for i in range(k):\n", + " FbT[i] = scaler[i] * F[i].T @ u\n", + " Fb = FbT.T\n", + " # Calculate the eigenvector v that corresponds to the largest \n", + " # eigenvalue of the (n x n) matrix\n", + " Fb = Fb @ FbT\n", + " if decomposition == 'eigen':\n", + " v = get_vec_from_largest_eig(Fb)\n", + " else:\n", + " _, _, v = svd1(Fb)\n", + " # Until u and v vectors change less than a pre-specified\n", + " # value that is set by the user\n", + " stop_refinement, diff_u, diff_v = check_threshold(u, U, v, V, stop_threshold, metric)\n", + " if report_writer is not None:\n", + " with report_writer.as_default():\n", + " F_tmp, _ = update_F(F, U, V)\n", + " for p, (f_in, f_tmp) in enumerate(zip(F_in, F_tmp)):\n", + " tf.summary.scalar(f'Alg2 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), report_step, description=f'Algorithm2 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg2 - Mean {p}-th sub-matrix',f_tmp.mean(), report_step, description=f'Algorithm2 Mean(x_approx) of the {p}-th sub-matrix.')\n", + " report_writer.flush()\n", + " # tf.summary.scalar('Alg2 - MSE refining', mse(F_in, F_tmp), report_step, description='Algorithm2 MSE(F, F_approx) at refining steps.')\n", + " # tf.summary.scalar('Alg2 - diff(U)', diff_u, report_step, description='Algorithm2 MSE(u(i), u(i-1)) at refining steps.')\n", + " # tf.summary.scalar('Alg2 - diff(V)', diff_v, report_step, description='Algorithm2 MSE(v(i), v(i-1)) at refining steps.')\n", + " # NOTE: The u and v norms are always equal to 1.\n", + " # tf.summary.scalar('Alg2 - norm(U)', np.linalg.norm(u), report_step, description='Algorithm2 norm(u(i)) at refining steps.')\n", + " # tf.summary.scalar('Alg2 - norm(V)', np.linalg.norm(v), report_step, description='Algorithm2 norm(v(i)) at refining steps.')\n", + " # tf.summary.scalar('Alg2 - ', np.dot(U, u), report_step, description='Algorithm2 : inner-product (orthogonal if 0).')\n", + " # tf.summary.scalar('Alg2 - ', np.dot(V, v), report_step, description='Algorithm2 : inner-product (orthogonal if 0).')\n", + " report_writer.flush()\n", + " report_step += 1\n", + " if stop_refinement:\n", + " V, U = v, u\n", + " break\n", + " V = v #* (1 + 1e-12)\n", + " U = u #* (1 + 1e-12)\n", + " if report_writer is not None and r > 1:\n", + " with report_writer.as_default():\n", + " F_tmp, _ = update_F(F, U, V)\n", + " for p, (f_in, f_tmp) in enumerate(zip(F_in, F_tmp)):\n", + " tf.summary.scalar(f'Alg2 - Final MSE {p}-th sub-matrix', mse(f_in, f_tmp), report_step, description=f'Algorithm2 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " report_writer.flush()\n", + " report_step += 1\n", + " # F, S = update_F(F, U, V)\n", + " FT = np.transpose(F, axes=(0, 2, 1))\n", + " S = V.T @ FT @ U\n", + " A = np.outer(U, V)\n", + " for i in range(k):\n", + " F[i] = F[i] - S[i] * A\n", + " u_array[j] = U\n", + " s_array[j] = S\n", + " v_array[j] = V\n", + " return u_array, s_array, v_array" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "wlnmJleegNWF" + }, + "source": [ + "x = np.random.rand(3, 1024, 512)" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TKy8_OKSqldK", + "outputId": "f10faf56-09af-42ce-81cc-215b8b32dab3" + }, + "source": [ + "%time u_eig, s_eig, v_eig = algorithm2(x, decomposition='eigen', stop_threshold=1e-5)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 1.42 s, sys: 478 ms, total: 1.89 s\n", + "Wall time: 1.04 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yypholslqoF9", + "outputId": "93441043-dd46-41ef-e018-7bbd9bae15a3" + }, + "source": [ + "%time u_svd, s_svd, v_svd = algorithm2(x, decomposition='svd', stop_threshold=1e-5)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 3.29 s, sys: 591 ms, total: 3.88 s\n", + "Wall time: 2 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Uf6DAtgPgYWU", + "outputId": "d4efe923-8d50-4967-ae20-7aab3f9b17d9" + }, + "source": [ + "print(mse(u_eig, u_svd))\n", + "print(mse(s_eig, s_svd))\n", + "print(mse(v_eig, v_svd))" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.003906249999999999\n", + "4.52364397489937e-26\n", + "0.007812499999999998\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qbtEIi3orE7O" + }, + "source": [ + "Get approximation error." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "EN892KfYq6pw" + }, + "source": [ + "def algorithm2_inverse(U, S, V, F=None):\n", + " F_tmp = np.einsum('rk, rm, rn->kmn', S, U, V)\n", + " if F is None:\n", + " F = F_tmp\n", + " elif type(F) == list:\n", + " k = S.shape[1]\n", + " for i in range(k):\n", + " F.append(F_tmp[i])\n", + " return F_tmp" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NcZa2sZErOgD", + "outputId": "31c7ec2d-5b45-4a95-92ba-a4d700f5ddc1" + }, + "source": [ + "x_svd = algorithm2_inverse(u_svd, s_svd, v_svd)\n", + "x_eig = algorithm2_inverse(u_eig, s_eig, v_eig)\n", + "print(mse(x, x_svd))\n", + "print(mse(x, x_eig))" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.08324823102157376\n", + "0.08324823102157376\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cLnD6VD1sIc2" + }, + "source": [ + "## Algortihm 3 - SVD and Refinement Steps" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "83mTyjgJrdB1" + }, + "source": [ + "def algorithm3(x_in, num_refinements=1, num_sub_matrix=1, truncate=False,\n", + " stop_threshold=0.0001, hard_stop=100, decomposition='eigen',\n", + " metric='mse', scaler=None, report_writer=None,\n", + " apply_scaling_at_alg2=True, plotdata=None):\n", + " if type(x_in) == list:\n", + " x = np.concatenate([a[np.newaxis,:] for a in x_in], axis=0)\n", + " else:\n", + " x = x_in\n", + " k, m, n = x.shape\n", + " if truncate:\n", + " tot_elem = 2 * (m * n)\n", + " appr_elem = num_refinements * (m + n + x.shape[0])\n", + " if appr_elem >= tot_elem:\n", + " print(f'[WARNING] The num_refinements value ({num_refinements}) is too high and will be truncated.')\n", + " while appr_elem >= tot_elem:\n", + " num_refinements -= 1\n", + " appr_elem = num_refinements * (m + n + x.shape[0])\n", + " print(f'[WARNING] num_refinements set to {num_refinements}.')\n", + " u = np.zeros((num_refinements, num_sub_matrix, m))\n", + " s = np.zeros((num_refinements, num_sub_matrix, k))\n", + " v = np.zeros((num_refinements, num_sub_matrix, n))\n", + " report_steps = 0\n", + " if apply_scaling_at_alg2:\n", + " # ======================================================================\n", + " # Apply scaling at Alogirthm 2 (Default)\n", + " # ======================================================================\n", + " x_approx = np.zeros(x.shape)\n", + " for i in range(num_refinements):\n", + " u[i], s[i], v[i] = algorithm2(x - x_approx, num_sub_matrix,\n", + " stop_threshold, hard_stop, decomposition,\n", + " truncate, metric, report_writer,\n", + " report_steps, scaler)\n", + " x_approx += algorithm2_inverse(u[i], s[i], v[i])\n", + " if report_writer is not None:\n", + " with report_writer.as_default():\n", + " tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).')\n", + " for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.')\n", + " report_writer.flush()\n", + " if plotdata is not None:\n", + " if not plotdata: # If empty, initialize it\n", + " for p in range(k):\n", + " plotdata[f'MSE(matrix[{p}])'] = []\n", + " for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " plotdata[f'MSE(matrix[{p}])'].append(mse(f_in, f_tmp))\n", + " else:\n", + " # ======================================================================\n", + " # Apply scaling at Alogirthm 3 (To be checked)\n", + " # ======================================================================\n", + " x_approx = np.zeros(x.shape)\n", + " x_scaled = x.copy()\n", + " error = x - x_approx\n", + " if scaler is None:\n", + " scaler = [1.] * k\n", + " for j in range(k):\n", + " x_scaled[j] *= scaler[j]\n", + " error[j] = x_scaled[j]\n", + " for i in range(num_refinements):\n", + " u[i], s[i], v[i] = algorithm2(error, num_sub_matrix,\n", + " stop_threshold, hard_stop, decomposition,\n", + " truncate, metric, report_writer,\n", + " report_steps, scaler=None)\n", + " for j in range(k):\n", + " s[j] /= scaler[j]\n", + " x_approx += algorithm2_inverse(u[i], s[i], v[i])\n", + " # for j in range(k):\n", + " # x_approx[j] *= scaler[j]\n", + " error = x_scaled - x_approx\n", + " # for j in range(k):\n", + " # error[j] *= scaler[j]\n", + " if report_writer is not None:\n", + " with report_writer.as_default():\n", + " tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).')\n", + " for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.')\n", + " report_writer.flush()\n", + " if plotdata is not None:\n", + " if not plotdata: # If empty, initialize it\n", + " for p in range(k):\n", + " plotdata[f'MSE(matrix[{p}])'] = []\n", + " for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " plotdata[f'MSE(matrix[{p}])'].append(mse(f_in, f_tmp))\n", + " return u, s, v" + ], + "execution_count": 57, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Gix3Fnhgs39E" + }, + "source": [ + "def algorithm3_inverse(U, S, V):\n", + " \"\"\"\n", + " @brief Given a list of u, s, v vectors, reconstruct \n", + " the two approximated matrixes.\n", + " \n", + " @param U list of u vectr\n", + " @param S list of s vectr\n", + " @param V list of v vectr\n", + " \n", + " @return the reconstructed approximated matrix (concatened)\n", + " \"\"\"\n", + " # NOTE: The shape variables are:\n", + " # r := number of refinement steps\n", + " # k := number of merged matrixes\n", + " # m := \"input\" dimension of the matrixes\n", + " # n := \"output\" dimension of the matrixes\n", + " u, s, v = np.array(U), np.array(S), np.array(V)\n", + " F = np.einsum('...rk, ...rm, ...rn', s, u, v)\n", + " F = np.einsum('rkmn->kmn', F)\n", + " return F" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fO1tncBVsbgv", + "outputId": "c750ab88-6ff5-4755-a0ec-bfcd52b82c26" + }, + "source": [ + "x = np.random.rand(3, 1024, 512)\n", + "%time u_eig, s_eig, v_eig = algorithm3(x, 4, decomposition='eigen', stop_threshold=1e-3)" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 7.58 s, sys: 1.92 s, total: 9.5 s\n", + "Wall time: 4.94 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TB3sjDCLuY9I", + "outputId": "66dc43e0-4ad7-43f5-9ea3-8fb5b8771c92" + }, + "source": [ + "%time u_svd, s_svd, v_svd = algorithm3(x, 4, decomposition='svd', stop_threshold=1e-3)" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 16.4 s, sys: 3.08 s, total: 19.4 s\n", + "Wall time: 9.97 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1d-WkM-7uG2s", + "outputId": "0dec5105-0d35-4900-d57f-f7e8e4b3a08b" + }, + "source": [ + "x_svd = algorithm3_inverse(u_svd, s_svd, v_svd)\n", + "x_eig = algorithm3_inverse(u_eig, s_eig, v_eig)\n", + "print(mse(x, x_svd))\n", + "print(mse(x, x_eig))" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.08266490425610987\n", + "0.0826586846848718\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wE1hyhqU3cZ9" + }, + "source": [ + "### Algorithm 3 - Extra Refinements" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7w2n71uA3hmv" + }, + "source": [ + "def algorithm3_extra_refinements(x_in, u_in, s_in, v_in, num_refinements=1, num_sub_matrix=1, truncate=False,\n", + " stop_threshold=0.0001, hard_stop=100, decomposition='eigen',\n", + " metric='mse', scaler=None,\n", + " report_writer=None):\n", + " previous_num_refinements = u_in.shape[0]\n", + " assert previous_num_refinements <= num_refinements, f'Previous #Refinements ({previous_num_refinements}) must be less then num_refinements ({num_refinements}).'\n", + " if type(x_in) == list:\n", + " x = np.concatenate([a[np.newaxis,:] for a in x_in], axis=0)\n", + " else:\n", + " x = x_in\n", + " k, m, n = x.shape\n", + " if truncate:\n", + " tot_elem = 2 * (m * n)\n", + " appr_elem = num_refinements * (m + n + x.shape[0])\n", + " if appr_elem >= tot_elem:\n", + " print(f'[WARNING] The num_refinements value ({num_refinements}) is too high and will be truncated.')\n", + " while appr_elem >= tot_elem:\n", + " num_refinements -= 1\n", + " appr_elem = num_refinements * (m + n + x.shape[0])\n", + " print(f'[WARNING] num_refinements set to {num_refinements}.')\n", + " u = np.zeros((num_refinements, num_sub_matrix, m))\n", + " s = np.zeros((num_refinements, num_sub_matrix, k))\n", + " v = np.zeros((num_refinements, num_sub_matrix, n))\n", + "\n", + " u[:previous_num_refinements] = u_in\n", + " s[:previous_num_refinements] = s_in\n", + " v[:previous_num_refinements] = v_in\n", + "\n", + " report_steps = 0\n", + " # ==========================================================================\n", + " # Scaler version\n", + " # ==========================================================================\n", + " x_approx = algorithm3_inverse(u_in, s_in, v_in)\n", + " x_scaled = x.copy()\n", + " error = x - x_approx\n", + " if scaler is None:\n", + " scaler = [1.] * k\n", + " for j in range(k):\n", + " x_scaled[j] *= scaler[j]\n", + " error[j] = x_scaled[j]\n", + " for i in range(previous_num_refinements, num_refinements):\n", + " u[i], s[i], v[i] = algorithm2(error, num_sub_matrix,\n", + " stop_threshold, hard_stop, decomposition,\n", + " truncate, metric, report_writer,\n", + " report_steps, scaler=None)\n", + " for j in range(k):\n", + " s[j] /= scaler[j]\n", + " x_approx += algorithm2_inverse(u[i], s[i], v[i])\n", + " for j in range(k):\n", + " x_approx[j] *= scaler[j]\n", + " error = x_scaled - x_approx\n", + " # for j in range(k):\n", + " # error[j] *= scaler[j]\n", + " if report_writer is not None:\n", + " with report_writer.as_default():\n", + " tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).')\n", + " for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.')\n", + " tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.')\n", + " report_writer.flush()\n", + " # ==========================================================================\n", + " # Original version\n", + " # ==========================================================================\n", + " # x_approx = np.zeros(x.shape)\n", + " # for i in range(num_refinements):\n", + " # u[i], s[i], v[i] = algorithm2(x - x_approx, num_sub_matrix,\n", + " # stop_threshold, hard_stop, decomposition,\n", + " # truncate, metric, report_writer,\n", + " # report_steps, scaler)\n", + " # x_approx += algorithm2_inverse(u[i], s[i], v[i])\n", + " # if report_writer is not None:\n", + " # with report_writer.as_default():\n", + " # tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).')\n", + " # for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)):\n", + " # tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.')\n", + " # tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.')\n", + " # tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.')\n", + " # report_writer.flush()\n", + " return u, s, v" + ], + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_trp6sx3J3RR" + }, + "source": [ + "## Setup TensorBoard" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "resources": { + "https://localhost:6006/?tensorboardColab=true": { + "data": "<!doctype html><meta name="tb-relative-root" content="./"><!doctype html><!--
@license
Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--><html><head><meta charset="utf-8">
<title>TensorBoard</title>
<link rel="shortcut icon" href="data:image/png;base64,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">
<link rel="apple-touch-icon" href="data:image/png;base64,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">

<style>
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/uYECMKoHcO9x1wdmbyHIm3-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/sTdaA6j0Psb920Vjv-mrzH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/_VYFx-s824kXq_Ul2BHqYH-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/tnj4SB6DNbdaQnsM8CFqBX-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/Ks_cVxiCiwUWVsFWFA3Bjn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto'), local('Roboto-Regular'), url(/font-roboto/NJ4vxlgWwWbEsv18dAhqnn-_kf6ByYO6CLYdB4HQE-Y.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/isZ-wbCXNKAbnjo6_TwHToX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/77FXFjRbGzN4aCrSFhlh3oX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/jSN2CGVDbcVyCnfJfjSdfIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/UX6i4JxQDm3fVTc1CPuwqoX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/d-6IYplOFocCacKzxwXSOJBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/97uahxiqZRoncBaCEI3aW4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Bold'), local('Roboto-Bold'), url(/font-roboto/PwZc-YbIL414wB9rB1IAPYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcCwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 700;
  src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(/font-roboto/t6Nd4cfPRhZP44Q5QAjcC9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/OpXUqTo0UgQQhGj_SFdLWBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/WxrXJa0C3KdtC7lMafG4dRkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/cDKhRaXnQTOVbaoxwdOr9xkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/1hZf02POANh32k2VkgEoUBkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vPcynSL0qHq_6dX7lKVByXYhjbSpvc47ee6xR_80Hnw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/vSzulfKSK0LLjjfeaxcREhkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 400;
  src: local('Roboto Italic'), local('Roboto-Italic'), url(/font-roboto/K23cxWVTrIFD6DJsEVi07RkAz4rYn47Zy2rvigWQf6w.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Fl4y0QdOxyyTHEGMXX8kcYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/0eC6fl06luXEYWpBSJvXCIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/I3S1wsgSg9YCurV6PUkTOYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/-L14Jk06m6pUHB-5mXQQnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Hgo13k-tfSpn0qi1SFdUfZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/Pru33qjShpZSmG3z6VYwnYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 300;
  src: local('Roboto Light'), local('Roboto-Light'), url(/font-roboto/NYDWBdD4gIq26G5XYbHsFIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0atwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 300;
  src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(/font-roboto/7m8l7TlFO-S3VkhHuR0at9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oHi30kwQWvpCWqAhzHcCSIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/ZLqKeelYbATG60EpZBSDy4X0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mx9Uck6uB63VIKFYnEMXrYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/rGvHdJnr2l75qb0YND9NyIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/RxZJdnzeo3R5zSexge8UUZBw1xU1rKptJj_0jans920.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/oOeFwZNlrTefzLYmlVV1UIX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: normal;
  font-weight: 500;
  src: local('Roboto Medium'), local('Roboto-Medium'), url(/font-roboto/mbmhprMH69Zi6eEPBYVFhYX0hVgzZQUfRDuZrPvH3D8.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0V4sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0fZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Qt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0VBW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0Ygp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0aE8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto';
  font-style: italic;
  font-weight: 500;
  src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(/font-roboto/OLffGBTaF0XFOW1gnuHF0dDiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY14sYYdJg5dU2qzJEVSuta0.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY_ZraR2Tg8w2lzm7kLNL0-w.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpYwt_Rm691LTebKfY2ZkKSmI.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY1BW26QxpSj-_ZKm_xT4hWw.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY4gp9Q8gbYrhqGlRav_IXfk.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY6E8kM4xWR1_1bYURRojRGc.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 400;
  src: local('Roboto Mono'), local('RobotoMono-Regular'), url(/font-roboto/hMqPNLsu_dywMa4C_DEpY9DiNsR5a-9Oe_Ivpu8XWlY.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1x-M1I1w5OMiqnVF8xBLhU.woff2) format('woff2');
  unicode-range: U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59FzwXaAXup5mZlfK6xRLrhsco.woff2) format('woff2');
  unicode-range: U+0460-052F, U+20B4, U+2DE0-2DFF, U+A640-A69F;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fzwn6Wqxo-xwxilDXPU8chVU.woff2) format('woff2');
  unicode-range: U+0370-03FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz1T7aJLK6nKpn36IMwTcMMc.woff2) format('woff2');
  unicode-range: U+1F00-1FFF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz_79_ZuUxCigM2DespTnFaw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz4gd9OEPUCN3AdYW0e8tat4.woff2) format('woff2');
  unicode-range: U+0100-024F, U+1E00-1EFF, U+20A0-20AB, U+20AD-20CF, U+2C60-2C7F, U+A720-A7FF;
}
@font-face {
  font-family: 'Roboto Mono';
  font-style: normal;
  font-weight: 700;
  src: local('Roboto Mono Bold'), local('RobotoMono-Bold'), url(/font-roboto/N4duVc9C58uwPiY8_59Fz8bIQSYZnWLaWC9QNCpTK_U.woff2) format('woff2');
  unicode-range: U+0102-0103, U+1EA0-1EF9, U+20AB;
}
</style>



<style>.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline,.mat-typography h1{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography h2{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography h3{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography h4{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-dialog-title{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}input.mat-input-element{margin-top:-0.0625em}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop,.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator{position:relative}.mat-mdc-focus-indicator{position:relative}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox{color:#616161}.mat-pseudo-checkbox::after{color:#fafafa}.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked,.mat-primary .mat-pseudo-checkbox-indeterminate{background:#f57c00}.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-indeterminate,.mat-accent .mat-pseudo-checkbox-checked,.mat-accent .mat-pseudo-checkbox-indeterminate{background:#ff9800}.mat-warn .mat-pseudo-checkbox-checked,.mat-warn .mat-pseudo-checkbox-indeterminate{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled{background:#b0b0b0}.mat-app-background{background-color:#fafafa;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge{position:relative}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-disabled .mat-badge-content{background:#b9b9b9;color:#757575}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:transparent}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:transparent}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone,.mat-button-toggle-group{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fafafa}.mat-checkbox-checkmark-path{stroke:#fafafa !important}.mat-checkbox-mixedmark{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:#616161}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-calendar-arrow{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:transparent}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:transparent}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-item-disabled{background-color:#eee}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:transparent;color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled]::after{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-item-submenu-trigger::after{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-progress-bar-background{fill:#ff9800}.mat-progress-bar-buffer{background-color:#ff9800}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ff9800}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ff9800}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#ffcdd2}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#ffcdd2}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-drawer-container{background-color:#fafafa;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-primary .mat-slider-track-fill,.mat-primary .mat-slider-thumb,.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-accent .mat-slider-track-fill,.mat-accent .mat-slider-thumb,.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-warn .mat-slider-track-fill,.mat-warn .mat-slider-thumb,.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider-disabled .mat-slider-track-background,.mat-slider-disabled .mat-slider-track-fill,.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:transparent;color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-] .mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary .mat-tab-header,.mat-tab-group.mat-background-primary .mat-tab-links,.mat-tab-group.mat-background-primary .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary .mat-tab-header,.mat-tab-nav-bar.mat-background-primary .mat-tab-links,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary .mat-tab-label,.mat-tab-group.mat-background-primary .mat-tab-link,.mat-tab-nav-bar.mat-background-primary .mat-tab-label,.mat-tab-nav-bar.mat-background-primary .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent .mat-tab-header,.mat-tab-group.mat-background-accent .mat-tab-links,.mat-tab-group.mat-background-accent .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent .mat-tab-header,.mat-tab-nav-bar.mat-background-accent .mat-tab-links,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent .mat-tab-label,.mat-tab-group.mat-background-accent .mat-tab-link,.mat-tab-nav-bar.mat-background-accent .mat-tab-label,.mat-tab-nav-bar.mat-background-accent .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-accent .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn .mat-tab-header,.mat-tab-group.mat-background-warn .mat-tab-links,.mat-tab-group.mat-background-warn .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn .mat-tab-header,.mat-tab-nav-bar.mat-background-warn .mat-tab-links,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn .mat-tab-label,.mat-tab-group.mat-background-warn .mat-tab-link,.mat-tab-nav-bar.mat-background-warn .mat-tab-label,.mat-tab-nav-bar.mat-background-warn .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-warn .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-toolbar{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}
</style>

<style>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
    color: var(--primary-text-color);

    /* Legacy mechanism to avoid issues with subpixel anti-aliasing on macOS.
     *
     * In the past [1], macOS subpixel AA caused excessive bolding for light-on-dark text; this rule
     * avoids that by requesting non-subpixel AA always, rather than the default behavior, which is
     * to use subpixel AA when available. The original issue was "fixed" by removing subpixel AA in
     * macOS 14 (Mojave), but for legacy reasons they preserved the bolding effect as an option.
     * Chrome then in turn updated its font rendering to apply that bolding effect [2], which means
     * that even though the `-webkit-font-smoothing` docs [3] suggest that setting `antialiased`
     * would have no effect for recent versions of macOS, it still is needed to avoid the bolding.
     *
     * [1]: http://www.lighterra.com/articles/macosxtextaabug/
     * [2]: https://bugs.chromium.org/p/chromium/issues/detail?id=858861
     * [3]: https://developer.mozilla.org/en-US/docs/Web/CSS/font-smooth
     *
     */

    -webkit-font-smoothing: antialiased;
  }
  noscript {
    display: block;
    margin: 0 auto;
    max-width: 600px;
    padding: 10px;
  }
</style>

</head><body><noscript>
    <h1>TensorBoard requires JavaScript</h1>
    <p>Please enable JavaScript and reload this page.</p>
  </noscript><tb-webapp></tb-webapp><script src="index.js?_file_hash=8bbeb739"></script></body></html>", + "ok": true, + "headers": [ + [ + "content-type", + "text/html; charset=utf-8" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/index.js?_file_hash=8bbeb739": { + "data": "var CLOSURE_NO_DEPS = true;
// Copyright 2006 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @fileoverview Bootstrap for the Google JS Library (Closure).
 *
 * In uncompiled mode base.js will attempt to load Closure's deps file, unless
 * the global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects
 * to include their own deps file(s) from different locations.
 *
 * Avoid including base.js more than once. This is strictly discouraged and not
 * supported. goog.require(...) won't work properly in that case.
 *
 * @provideGoog
 */


/**
 * @define {boolean} Overridden to true by the compiler.
 */
var COMPILED = false;


/**
 * Base namespace for the Closure library.  Checks to see goog is already
 * defined in the current scope before assigning to prevent clobbering if
 * base.js is loaded more than once.
 *
 * @const
 */
var goog = goog || {};

/**
 * Reference to the global object.
 * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object
 *
 * More info on this implementation here:
 * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
 *
 * @const
 * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.
 * @type {!Global}
 */
goog.global =
    // Check `this` first for backwards compatibility.
    // Valid unless running as an ES module or in a function wrapper called
    //   without setting `this` properly.
    // Note that base.js can't usefully be imported as an ES module, but it may
    // be compiled into bundles that are loadable as ES modules.
    this ||
    // https://developer.mozilla.org/en-US/docs/Web/API/Window/self
    // For in-page browser environments and workers.
    self;


/**
 * A hook for overriding the define values in uncompiled mode.
 *
 * In uncompiled mode, `CLOSURE_UNCOMPILED_DEFINES` may be defined before
 * loading base.js.  If a key is defined in `CLOSURE_UNCOMPILED_DEFINES`,
 * `goog.define` will use the value instead of the default value.  This
 * allows flags to be overwritten without compilation (this is normally
 * accomplished with the compiler's "define" flag).
 *
 * Example:
 * <pre>
 *   var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_UNCOMPILED_DEFINES;


/**
 * A hook for overriding the define values in uncompiled or compiled mode,
 * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code.  In
 * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
 *
 * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
 * string literals or the compiler will emit an error.
 *
 * While any @define value may be set, only those set with goog.define will be
 * effective for uncompiled code.
 *
 * Example:
 * <pre>
 *   var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_DEFINES;


/**
 * Returns true if the specified value is not undefined.
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined.
 * @deprecated Use `val !== undefined` instead.
 */
goog.isDef = function(val) {
  // void 0 always evaluates to undefined and hence we do not need to depend on
  // the definition of the global variable named 'undefined'.
  return val !== void 0;
};

/**
 * Returns true if the specified value is a string.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a string.
 * @deprecated Use `typeof val === 'string'` instead.
 */
goog.isString = function(val) {
  return typeof val == 'string';
};


/**
 * Returns true if the specified value is a boolean.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is boolean.
 * @deprecated Use `typeof val === 'boolean'` instead.
 */
goog.isBoolean = function(val) {
  return typeof val == 'boolean';
};


/**
 * Returns true if the specified value is a number.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a number.
 * @deprecated Use `typeof val === 'number'` instead.
 */
goog.isNumber = function(val) {
  return typeof val == 'number';
};


/**
 * Builds an object structure for the provided namespace path, ensuring that
 * names that already exist are not overwritten. For example:
 * "a.b.c" -> a = {};a.b={};a.b.c={};
 * Used by goog.provide and goog.exportSymbol.
 * @param {string} name name of the object that this file defines.
 * @param {*=} opt_object the object to expose at the end of the path.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is `goog.global`.
 * @private
 */
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split('.');
  var cur = opt_objectToExportTo || goog.global;

  // Internet Explorer exhibits strange behavior when throwing errors from
  // methods externed in this manner.  See the testExportSymbolExceptions in
  // base_test.html for an example.
  if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {
    cur.execScript('var ' + parts[0]);
  }

  for (var part; parts.length && (part = parts.shift());) {
    if (!parts.length && opt_object !== undefined) {
      // last part and we have an object; use it
      cur[part] = opt_object;
    } else if (cur[part] && cur[part] !== Object.prototype[part]) {
      cur = cur[part];
    } else {
      cur = cur[part] = {};
    }
  }
};


/**
 * Defines a named value. In uncompiled mode, the value is retrieved from
 * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
 * has the property specified, and otherwise used the defined defaultValue.
 * When compiled the default can be overridden using the compiler options or the
 * value set in the CLOSURE_DEFINES object. Returns the defined value so that it
 * can be used safely in modules. Note that the value type MUST be either
 * boolean, number, or string.
 *
 * @param {string} name The distinguished name to provide.
 * @param {T} defaultValue
 * @return {T} The defined value.
 * @template T
 */
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED) {
    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;
    var defines = goog.global.CLOSURE_DEFINES;
    if (uncompiledDefines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (uncompiledDefines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {
      value = uncompiledDefines[name];
    } else if (
        defines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (defines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(defines, name)) {
      value = defines[name];
    }
  }
  return value;
};


/**
 * @define {number} Integer year indicating the set of browser features that are
 * guaranteed to be present.  This is defined to include exactly features that
 * work correctly on all "modern" browsers that are stable on January 1 of the
 * specified year.  For example,
 * ```js
 * if (goog.FEATURESET_YEAR >= 2019) {
 *   // use APIs known to be available on all major stable browsers Jan 1, 2019
 * } else {
 *   // polyfill for older browsers
 * }
 * ```
 * This is intended to be the primary define for removing
 * unnecessary browser compatibility code (such as ponyfills and workarounds),
 * and should inform the default value for most other defines:
 * ```js
 * const ASSUME_NATIVE_PROMISE =
 *     goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);
 * ```
 *
 * The default assumption is that IE9 is the lowest supported browser, which was
 * first available Jan 1, 2012.
 *
 * TODO(user): Reference more thorough documentation when it's available.
 */
goog.FEATURESET_YEAR = goog.define('goog.FEATURESET_YEAR', 2012);


/**
 * @define {boolean} DEBUG is provided as a convenience so that debugging code
 * that should not be included in a production. It can be easily stripped
 * by specifying --define goog.DEBUG=false to the Closure Compiler aka
 * JSCompiler. For example, most toString() methods should be declared inside an
 * "if (goog.DEBUG)" conditional because they are generally used for debugging
 * purposes and it is difficult for the JSCompiler to statically determine
 * whether they are used.
 */
goog.DEBUG = goog.define('goog.DEBUG', true);


/**
 * @define {string} LOCALE defines the locale being used for compilation. It is
 * used to select locale specific data to be compiled in js binary. BUILD rule
 * can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler
 * option.
 *
 * Take into account that the locale code format is important. You should use
 * the canonical Unicode format with hyphen as a delimiter. Language must be
 * lowercase, Language Script - Capitalized, Region - UPPERCASE.
 * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
 *
 * See more info about locale codes here:
 * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
 *
 * For language codes you should use values defined by ISO 693-1. See it here
 * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
 * this rule: the Hebrew language. For legacy reasons the old code (iw) should
 * be used instead of the new code (he).
 *
 */
goog.LOCALE = goog.define('goog.LOCALE', 'en');  // default to en


/**
 * @define {boolean} Whether this code is running on trusted sites.
 *
 * On untrusted sites, several native functions can be defined or overridden by
 * external libraries like Prototype, Datejs, and JQuery and setting this flag
 * to false forces closure to use its own implementations when possible.
 *
 * If your JavaScript can be loaded by a third party site and you are wary about
 * relying on non-standard implementations, specify
 * "--define goog.TRUSTED_SITE=false" to the compiler.
 */
goog.TRUSTED_SITE = goog.define('goog.TRUSTED_SITE', true);


/**
 * @define {boolean} Whether a project is expected to be running in strict mode.
 *
 * This define can be used to trigger alternate implementations compatible with
 * running in EcmaScript Strict mode or warn about unavailable functionality.
 * @see https://goo.gl/PudQ4y
 *
 */
goog.STRICT_MODE_COMPATIBLE = goog.define('goog.STRICT_MODE_COMPATIBLE', false);


/**
 * @define {boolean} Whether code that calls {@link goog.setTestOnly} should
 *     be disallowed in the compilation unit.
 */
goog.DISALLOW_TEST_ONLY_CODE =
    goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);


/**
 * @define {boolean} Whether to use a Chrome app CSP-compliant method for
 *     loading scripts via goog.require. @see appendScriptSrcNode_.
 */
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING =
    goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);


/**
 * Defines a namespace in Closure.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * The presence of one or more goog.provide() calls in a file indicates
 * that the file defines the given objects/namespaces.
 * Provided symbols must not be null or undefined.
 *
 * In addition, goog.provide() creates the object stubs for a namespace
 * (for example, goog.provide("goog.foo.bar") will create the object
 * goog.foo.bar if it does not already exist).
 *
 * Build tools also scan for provide/require/module statements
 * to discern dependencies, build dependency files (see deps.js), etc.
 *
 * @see goog.require
 * @see goog.module
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 */
goog.provide = function(name) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.provide cannot be used within a module.');
  }
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
  }

  goog.constructNamespace_(name);
};


/**
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 * @param {Object=} opt_obj The object to embed in the namespace.
 * @private
 */
goog.constructNamespace_ = function(name, opt_obj) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];

    var namespace = name;
    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
      if (goog.getObjectByName(namespace)) {
        break;
      }
      goog.implicitNamespaces_[namespace] = true;
    }
  }

  goog.exportPath_(name, opt_obj);
};


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {?Window=} opt_window The window context used to retrieve the nonce.
 *     Defaults to global context.
 * @return {string} CSP nonce or empty string if no nonce is present.
 */
goog.getScriptNonce = function(opt_window) {
  if (opt_window && opt_window != goog.global) {
    return goog.getScriptNonce_(opt_window.document);
  }
  if (goog.cspNonce_ === null) {
    goog.cspNonce_ = goog.getScriptNonce_(goog.global.document);
  }
  return goog.cspNonce_;
};


/**
 * According to the CSP3 spec a nonce must be a valid base64 string.
 * @see https://www.w3.org/TR/CSP3/#grammardef-base64-value
 * @private @const
 */
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;


/**
 * @private {?string}
 */
goog.cspNonce_ = null;


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {!Document} doc
 * @return {string} CSP nonce or empty string if no nonce is present.
 * @private
 */
goog.getScriptNonce_ = function(doc) {
  var script = doc.querySelector && doc.querySelector('script[nonce]');
  if (script) {
    // Try to get the nonce from the IDL property first, because browsers that
    // implement additional nonce protection features (currently only Chrome) to
    // prevent nonce stealing via CSS do not expose the nonce via attributes.
    // See https://github.com/whatwg/html/issues/2369
    var nonce = script['nonce'] || script.getAttribute('nonce');
    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
      return nonce;
    }
  }
  return '';
};


/**
 * Module identifier validation regexp.
 * Note: This is a conservative check, it is very possible to be more lenient,
 *   the primary exclusion here is "/" and "\" and a leading ".", these
 *   restrictions are intended to leave the door open for using goog.require
 *   with relative file paths rather than module identifiers.
 * @private
 */
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;


/**
 * Defines a module in Closure.
 *
 * Marks that this file must be loaded as a module and claims the namespace.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * goog.module() has three requirements:
 * - goog.module may not be used in the same file as goog.provide.
 * - goog.module must be the first statement in the file.
 * - only one goog.module is allowed per file.
 *
 * When a goog.module annotated file is loaded, it is enclosed in
 * a strict function closure. This means that:
 * - any variables declared in a goog.module file are private to the file
 * (not global), though the compiler is expected to inline the module.
 * - The code must obey all the rules of "strict" JavaScript.
 * - the file will be marked as "use strict"
 *
 * NOTE: unlike goog.provide, goog.module does not declare any symbols by
 * itself. If declared symbols are desired, use
 * goog.module.declareLegacyNamespace().
 *
 *
 * See the public goog.module proposal: http://goo.gl/Va1hin
 *
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part", is expected but not required.
 * @return {void}
 */
goog.module = function(name) {
  if (typeof name !== 'string' || !name ||
      name.search(goog.VALID_MODULE_RE_) == -1) {
    throw new Error('Invalid module identifier');
  }
  if (!goog.isInGoogModuleLoader_()) {
    throw new Error(
        'Module ' + name + ' has been loaded incorrectly. Note, ' +
        'modules cannot be loaded as normal scripts. They require some kind of ' +
        'pre-processing step. You\'re likely trying to load a module via a ' +
        'script tag or as a part of a concatenated bundle without rewriting the ' +
        'module. For more info see: ' +
        'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');
  }
  if (goog.moduleLoaderState_.moduleName) {
    throw new Error('goog.module may only be called once per module.');
  }

  // Store the module name for the loader.
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
    delete goog.implicitNamespaces_[name];
  }
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 *
 * Note: This is not an alternative to goog.require, it does not
 * indicate a hard dependency, instead it is used to indicate
 * an optional dependency or to access the exports of a module
 * that has already been loaded.
 * @suppress {missingProvide}
 */
goog.module.get = function(name) {
  return goog.module.getInternal_(name);
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 * @private
 */
goog.module.getInternal_ = function(name) {
  if (!COMPILED) {
    if (name in goog.loadedModules_) {
      return goog.loadedModules_[name].exports;
    } else if (!goog.implicitNamespaces_[name]) {
      var ns = goog.getObjectByName(name);
      return ns != null ? ns : null;
    }
  }
  return null;
};


/**
 * Types of modules the debug loader can load.
 * @enum {string}
 */
goog.ModuleType = {
  ES6: 'es6',
  GOOG: 'goog'
};


/**
 * @private {?{
 *   moduleName: (string|undefined),
 *   declareLegacyNamespace:boolean,
 *   type: ?goog.ModuleType
 * }}
 */
goog.moduleLoaderState_ = null;


/**
 * @private
 * @return {boolean} Whether a goog.module or an es6 module is currently being
 *     initialized.
 */
goog.isInModuleLoader_ = function() {
  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};


/**
 * @private
 * @return {boolean} Whether a goog.module is currently being initialized.
 */
goog.isInGoogModuleLoader_ = function() {
  return !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};


/**
 * @private
 * @return {boolean} Whether an es6 module is currently being initialized.
 */
goog.isInEs6ModuleLoader_ = function() {
  var inLoader = !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.ES6;

  if (inLoader) {
    return true;
  }

  var jscomp = goog.global['$jscomp'];

  if (jscomp) {
    // jscomp may not have getCurrentModulePath if this is a compiled bundle
    // that has some of the runtime, but not all of it. This can happen if
    // optimizations are turned on so the unused runtime is removed but renaming
    // and Closure pass are off (so $jscomp is still named $jscomp and the
    // goog.provide/require calls still exist).
    if (typeof jscomp.getCurrentModulePath != 'function') {
      return false;
    }

    // Bundled ES6 module.
    return !!jscomp.getCurrentModulePath();
  }

  return false;
};


/**
 * Provide the module's exports as a globally accessible object under the
 * module's declared name.  This is intended to ease migration to goog.module
 * for files that have existing usages.
 * @suppress {missingProvide}
 */
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInGoogModuleLoader_()) {
    throw new Error(
        'goog.module.declareLegacyNamespace must be called from ' +
        'within a goog.module');
  }
  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
    throw new Error(
        'goog.module must be called prior to ' +
        'goog.module.declareLegacyNamespace.');
  }
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};


/**
 * Associates an ES6 module with a Closure module ID so that is available via
 * goog.require. The associated ID  acts like a goog.module ID - it does not
 * create any global names, it is merely available via goog.require /
 * goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and
 * goog.module.get will return the entire module as if it was import *'d. This
 * allows Closure files to reference ES6 modules for the sake of migration.
 *
 * @param {string} namespace
 * @suppress {missingProvide}
 */
goog.declareModuleId = function(namespace) {
  if (!COMPILED) {
    if (!goog.isInEs6ModuleLoader_()) {
      throw new Error(
          'goog.declareModuleId may only be called from ' +
          'within an ES6 module');
    }
    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {
      throw new Error(
          'goog.declareModuleId may only be called once per module.');
    }
    if (namespace in goog.loadedModules_) {
      throw new Error(
          'Module with namespace "' + namespace + '" already exists.');
    }
  }
  if (goog.moduleLoaderState_) {
    // Not bundled - debug loading.
    goog.moduleLoaderState_.moduleName = namespace;
  } else {
    // Bundled - not debug loading, no module loader state.
    var jscomp = goog.global['$jscomp'];
    if (!jscomp || typeof jscomp.getCurrentModulePath != 'function') {
      throw new Error(
          'Module with namespace "' + namespace +
          '" has been loaded incorrectly.');
    }
    var exports = jscomp.require(jscomp.getCurrentModulePath());
    goog.loadedModules_[namespace] = {
      exports: exports,
      type: goog.ModuleType.ES6,
      moduleId: namespace
    };
  }
};


/**
 * Marks that the current file should only be used for testing, and never for
 * live code in production.
 *
 * In the case of unit tests, the message may optionally be an exact namespace
 * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
 * provide (if not explicitly defined in the code).
 *
 * @param {string=} opt_message Optional message to add to the error that's
 *     raised when used in production code.
 */
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || '';
    throw new Error(
        'Importing test-only code into non-debug environment' +
        (opt_message ? ': ' + opt_message : '.'));
  }
};


/**
 * Forward declares a symbol. This is an indication to the compiler that the
 * symbol may be used in the source yet is not required and may not be provided
 * in compilation.
 *
 * The most common usage of forward declaration is code that takes a type as a
 * function parameter but does not need to require it. By forward declaring
 * instead of requiring, no hard dependency is made, and (if not required
 * elsewhere) the namespace may never be required and thus, not be pulled
 * into the JavaScript binary. If it is required elsewhere, it will be type
 * checked as normal.
 *
 * Before using goog.forwardDeclare, please read the documentation at
 * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to
 * understand the options and tradeoffs when working with forward declarations.
 *
 * @param {string} name The namespace to forward declare in the form of
 *     "goog.package.part".
 */
goog.forwardDeclare = function(name) {};


/**
 * Forward declare type information. Used to assign types to goog.global
 * referenced object that would otherwise result in unknown type references
 * and thus block property disambiguation.
 */
goog.forwardDeclare('Document');
goog.forwardDeclare('HTMLScriptElement');
goog.forwardDeclare('XMLHttpRequest');


if (!COMPILED) {
  /**
   * Check if the given name has been goog.provided. This will return false for
   * names that are available only as implicit namespaces.
   * @param {string} name name of the object to look for.
   * @return {boolean} Whether the name has been provided.
   * @private
   */
  goog.isProvided_ = function(name) {
    return (name in goog.loadedModules_) ||
        (!goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null);
  };

  /**
   * Namespaces implicitly defined by goog.provide. For example,
   * goog.provide('goog.events.Event') implicitly declares that 'goog' and
   * 'goog.events' must be namespaces.
   *
   * @type {!Object<string, (boolean|undefined)>}
   * @private
   */
  goog.implicitNamespaces_ = {'goog.module': true};

  // NOTE: We add goog.module as an implicit namespace as goog.module is defined
  // here and because the existing module package has not been moved yet out of
  // the goog.module namespace. This satisifies both the debug loader and
  // ahead-of-time dependency management.
}


/**
 * Returns an object based on its fully qualified external name.  The object
 * is not found if null or undefined.  If you are using a compilation pass that
 * renames property names beware that using this function will not find renamed
 * properties.
 *
 * @param {string} name The fully qualified name.
 * @param {Object=} opt_obj The object within which to look; default is
 *     |goog.global|.
 * @return {?} The value (object or primitive) or, if not found, null.
 */
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split('.');
  var cur = opt_obj || goog.global;
  for (var i = 0; i < parts.length; i++) {
    cur = cur[parts[i]];
    if (cur == null) {
      return null;
    }
  }
  return cur;
};


/**
 * Globalizes a whole namespace, such as goog or goog.lang.
 *
 * @param {!Object} obj The namespace to globalize.
 * @param {Object=} opt_global The object to add the properties to.
 * @deprecated Properties may be explicitly exported to the global scope, but
 *     this should no longer be done in bulk.
 */
goog.globalize = function(obj, opt_global) {
  var global = opt_global || goog.global;
  for (var x in obj) {
    global[x] = obj[x];
  }
};


/**
 * Adds a dependency from a file to the files it requires.
 * @param {string} relPath The path to the js file.
 * @param {!Array<string>} provides An array of strings with
 *     the names of the objects this file provides.
 * @param {!Array<string>} requires An array of strings with
 *     the names of the objects this file requires.
 * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating
 *     how the file must be loaded.  The boolean 'true' is equivalent
 *     to {'module': 'goog'} for backwards-compatibility.  Valid properties
 *     and values include {'module': 'goog'} and {'lang': 'es6'}.
 */
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);
  }
};




// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
// to do "debug-mode" development.  The dependency system can sometimes be
// confusing, as can the debug DOM loader's asynchronous nature.
//
// With the DOM loader, a call to goog.require() is not blocking -- the script
// will not load until some point after the current script.  If a namespace is
// needed at runtime, it needs to be defined in a previous script, or loaded via
// require() with its registered dependencies.
//
// User-defined namespaces may need their own deps file. For a reference on
// creating a deps file, see:
// Externally: https://developers.google.com/closure/library/docs/depswriter
//
// Because of legacy clients, the DOM loader can't be easily removed from
// base.js.  Work was done to make it disableable or replaceable for
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
// for example). See bootstrap/ for more information.


/**
 * @define {boolean} Whether to enable the debug loader.
 *
 * If enabled, a call to goog.require() will attempt to load the namespace by
 * appending a script tag to the DOM (if the namespace has been registered).
 *
 * If disabled, goog.require() will simply assert that the namespace has been
 * provided (and depend on the fact that some outside tool correctly ordered
 * the script).
 */
goog.ENABLE_DEBUG_LOADER = goog.define('goog.ENABLE_DEBUG_LOADER', true);


/**
 * @param {string} msg
 * @private
 */
goog.logToConsole_ = function(msg) {
  if (goog.global.console) {
    goog.global.console['error'](msg);
  }
};


/**
 * Implements a system for the dynamic resolution of dependencies that works in
 * parallel with the BUILD system.
 *
 * Note that all calls to goog.require will be stripped by the compiler.
 *
 * @see goog.provide
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?} If called within a goog.module or ES6 module file, the associated
 *     namespace or module otherwise null.
 */
goog.require = function(namespace) {
  if (!COMPILED) {
    // Might need to lazy load on old IE.
    if (goog.ENABLE_DEBUG_LOADER) {
      goog.debugLoader_.requested(namespace);
    }

    // If the object already exists we do not need to do anything.
    if (goog.isProvided_(namespace)) {
      if (goog.isInModuleLoader_()) {
        return goog.module.getInternal_(namespace);
      }
    } else if (goog.ENABLE_DEBUG_LOADER) {
      var moduleLoaderState = goog.moduleLoaderState_;
      goog.moduleLoaderState_ = null;
      try {
        goog.debugLoader_.load_(namespace);
      } finally {
        goog.moduleLoaderState_ = moduleLoaderState;
      }
    }

    return null;
  }
};


/**
 * Requires a symbol for its type information. This is an indication to the
 * compiler that the symbol may appear in type annotations, yet it is not
 * referenced at runtime.
 *
 * When called within a goog.module or ES6 module file, the return value may be
 * assigned to or destructured into a variable, but it may not be otherwise used
 * in code outside of a type annotation.
 *
 * Note that all calls to goog.requireType will be stripped by the compiler.
 *
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?}
 */
goog.requireType = function(namespace) {
  // Return an empty object so that single-level destructuring of the return
  // value doesn't crash at runtime when using the debug loader. Multi-level
  // destructuring isn't supported.
  return {};
};


/**
 * Path for included scripts.
 * @type {string}
 */
goog.basePath = '';


/**
 * A hook for overriding the base path.
 * @type {string|undefined}
 */
goog.global.CLOSURE_BASE_PATH;


/**
 * Whether to attempt to load Closure's deps file. By default, when uncompiled,
 * deps files will attempt to be loaded.
 * @type {boolean|undefined}
 */
goog.global.CLOSURE_NO_DEPS;


/**
 * A function to import a single script. This is meant to be overridden when
 * Closure is being run in non-HTML contexts, such as web workers. It's defined
 * in the global scope so that it can be set before base.js is loaded, which
 * allows deps.js to be imported properly.
 *
 * The first parameter the script source, which is a relative URI. The second,
 * optional parameter is the script contents, in the event the script needed
 * transformation. It should return true if the script was imported, false
 * otherwise.
 * @type {(function(string, string=): boolean)|undefined}
 */
goog.global.CLOSURE_IMPORT_SCRIPT;


/**
 * Null function used for default values of callbacks, etc.
 * @return {void} Nothing.
 */
goog.nullFunction = function() {};


/**
 * When defining a class Foo with an abstract method bar(), you can do:
 * Foo.prototype.bar = goog.abstractMethod
 *
 * Now if a subclass of Foo fails to override bar(), an error will be thrown
 * when bar() is invoked.
 *
 * @type {!Function}
 * @throws {Error} when invoked to indicate the method should be overridden.
 * @deprecated Use "@abstract" annotation instead of goog.abstractMethod in new
 *     code. See
 *     https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods
 */
goog.abstractMethod = function() {
  throw new Error('unimplemented abstract method');
};


/**
 * Adds a `getInstance` static method that always returns the same
 * instance object.
 * @param {!Function} ctor The constructor for the class to add the static
 *     method to.
 * @suppress {missingProperties} 'instance_' isn't a property on 'Function'
 *     but we don't have a better type to use here.
 */
goog.addSingletonGetter = function(ctor) {
  // instance_ is immediately set to prevent issues with sealed constructors
  // such as are encountered when a constructor is returned as the export object
  // of a goog.module in unoptimized code.
  // Delcare type to avoid conformance violations that ctor.instance_ is unknown
  /** @type {undefined|!Object} @suppress {underscore} */
  ctor.instance_ = undefined;
  ctor.getInstance = function() {
    if (ctor.instance_) {
      return ctor.instance_;
    }
    if (goog.DEBUG) {
      // NOTE: JSCompiler can't optimize away Array#push.
      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
    }
    // Cast to avoid conformance violations that ctor.instance_ is unknown
    return /** @type {!Object|undefined} */ (ctor.instance_) = new ctor;
  };
};


/**
 * All singleton classes that have been instantiated, for testing. Don't read
 * it directly, use the `goog.testing.singleton` module. The compiler
 * removes this variable if unused.
 * @type {!Array<!Function>}
 * @private
 */
goog.instantiatedSingletons_ = [];


/**
 * @define {boolean} Whether to load goog.modules using `eval` when using
 * the debug loader.  This provides a better debugging experience as the
 * source is unmodified and can be edited using Chrome Workspaces or similar.
 * However in some environments the use of `eval` is banned
 * so we provide an alternative.
 */
goog.LOAD_MODULE_USING_EVAL = goog.define('goog.LOAD_MODULE_USING_EVAL', true);


/**
 * @define {boolean} Whether the exports of goog.modules should be sealed when
 * possible.
 */
goog.SEAL_MODULE_EXPORTS = goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);


/**
 * The registry of initialized modules:
 * The module identifier or path to module exports map.
 * @private @const {!Object<string, {exports:?,type:string,moduleId:string}>}
 */
goog.loadedModules_ = {};


/**
 * True if the debug loader enabled and used.
 * @const {boolean}
 */
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;


/**
 * @define {string} How to decide whether to transpile.  Valid values
 * are 'always', 'never', and 'detect'.  The default ('detect') is to
 * use feature detection to determine which language levels need
 * transpilation.
 */
// NOTE(sdh): we could expand this to accept a language level to bypass
// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but
// would leave ES3 and ES5 files alone.
goog.TRANSPILE = goog.define('goog.TRANSPILE', 'detect');

/**
 * @define {boolean} If true assume that ES modules have already been
 * transpiled by the jscompiler (in the same way that transpile.js would
 * transpile them - to jscomp modules). Useful only for servers that wish to use
 * the debug loader and transpile server side. Thus this is only respected if
 * goog.TRANSPILE is "never".
 */
goog.ASSUME_ES_MODULES_TRANSPILED =
    goog.define('goog.ASSUME_ES_MODULES_TRANSPILED', false);


/**
 * @define {string} If a file needs to be transpiled what the output language
 * should be. By default this is the highest language level this file detects
 * the current environment supports. Generally this flag should not be set, but
 * it could be useful to override. Example: If the current environment supports
 * ES6 then by default ES7+ files will be transpiled to ES6, unless this is
 * overridden.
 *
 * Valid values include: es3, es5, es6, es7, and es8. Anything not recognized
 * is treated as es3.
 *
 * Note that setting this value does not force transpilation. Just if
 * transpilation occurs this will be the output. So this is most useful when
 * goog.TRANSPILE is set to 'always' and then forcing the language level to be
 * something lower than what the environment detects.
 */
goog.TRANSPILE_TO_LANGUAGE = goog.define('goog.TRANSPILE_TO_LANGUAGE', '');


/**
 * @define {string} Path to the transpiler.  Executing the script at this
 * path (relative to base.js) should define a function $jscomp.transpile.
 */
goog.TRANSPILER = goog.define('goog.TRANSPILER', 'transpile.js');


/**
 * @package {?boolean}
 * Visible for testing.
 */
goog.hasBadLetScoping = null;


/**
 * @return {boolean}
 * @package Visible for testing.
 */
goog.useSafari10Workaround = function() {
  if (goog.hasBadLetScoping == null) {
    var hasBadLetScoping;
    try {
      hasBadLetScoping = !eval(
          '"use strict";' +
          'let x = 1; function f() { return typeof x; };' +
          'f() == "number";');
    } catch (e) {
      // Assume that ES6 syntax isn't supported.
      hasBadLetScoping = false;
    }
    goog.hasBadLetScoping = hasBadLetScoping;
  }
  return goog.hasBadLetScoping;
};


/**
 * @param {string} moduleDef
 * @return {string}
 * @package Visible for testing.
 */
goog.workaroundSafari10EvalBug = function(moduleDef) {
  return '(function(){' + moduleDef +
      '\n' +  // Terminate any trailing single line comment.
      ';' +   // Terminate any trailing expression.
      '})();\n';
};


/**
 * @param {function(?):?|string} moduleDef The module definition.
 */
goog.loadModule = function(moduleDef) {
  // NOTE: we allow function definitions to be either in the from
  // of a string to eval (which keeps the original source intact) or
  // in a eval forbidden environment (CSP) we allow a function definition
  // which in its body must call `goog.module`, and return the exports
  // of the module.
  var previousState = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {
      moduleName: '',
      declareLegacyNamespace: false,
      type: goog.ModuleType.GOOG
    };
    var exports;
    if (goog.isFunction(moduleDef)) {
      exports = moduleDef.call(undefined, {});
    } else if (typeof moduleDef === 'string') {
      if (goog.useSafari10Workaround()) {
        moduleDef = goog.workaroundSafari10EvalBug(moduleDef);
      }

      exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
    } else {
      throw new Error('Invalid module definition');
    }

    var moduleName = goog.moduleLoaderState_.moduleName;
    if (typeof moduleName === 'string' && moduleName) {
      // Don't seal legacy namespaces as they may be used as a parent of
      // another namespace
      if (goog.moduleLoaderState_.declareLegacyNamespace) {
        goog.constructNamespace_(moduleName, exports);
      } else if (
          goog.SEAL_MODULE_EXPORTS && Object.seal &&
          typeof exports == 'object' && exports != null) {
        Object.seal(exports);
      }

      var data = {
        exports: exports,
        type: goog.ModuleType.GOOG,
        moduleId: goog.moduleLoaderState_.moduleName
      };
      goog.loadedModules_[moduleName] = data;
    } else {
      throw new Error('Invalid module name \"' + moduleName + '\"');
    }
  } finally {
    goog.moduleLoaderState_ = previousState;
  }
};


/**
 * @private @const
 */
goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {
  // NOTE: we avoid declaring parameters or local variables here to avoid
  // masking globals or leaking values into the module definition.
  'use strict';
  var exports = {};
  eval(arguments[0]);
  return exports;
});


/**
 * Normalize a file path by removing redundant ".." and extraneous "." file
 * path components.
 * @param {string} path
 * @return {string}
 * @private
 */
goog.normalizePath_ = function(path) {
  var components = path.split('/');
  var i = 0;
  while (i < components.length) {
    if (components[i] == '.') {
      components.splice(i, 1);
    } else if (
        i && components[i] == '..' && components[i - 1] &&
        components[i - 1] != '..') {
      components.splice(--i, 2);
    } else {
      i++;
    }
  }
  return components.join('/');
};


/**
 * Provides a hook for loading a file when using Closure's goog.require() API
 * with goog.modules.  In particular this hook is provided to support Node.js.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_LOAD_FILE_SYNC;


/**
 * Loads file by synchronous XHR. Should not be used in production environments.
 * @param {string} src Source URL.
 * @return {?string} File contents, or null if load failed.
 * @private
 */
goog.loadFileSync_ = function(src) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
  } else {
    try {
      /** @type {XMLHttpRequest} */
      var xhr = new goog.global['XMLHttpRequest']();
      xhr.open('get', src, false);
      xhr.send();
      // NOTE: Successful http: requests have a status of 200, but successful
      // file: requests may have a status of zero.  Any other status, or a
      // thrown exception (particularly in case of file: requests) indicates
      // some sort of error, which we treat as a missing or unavailable file.
      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
    } catch (err) {
      // No need to rethrow or log, since errors should show up on their own.
      return null;
    }
  }
};


/**
 * Lazily retrieves the transpiler and applies it to the source.
 * @param {string} code JS code.
 * @param {string} path Path to the code.
 * @param {string} target Language level output.
 * @return {string} The transpiled code.
 * @private
 */
goog.transpile_ = function(code, path, target) {
  var jscomp = goog.global['$jscomp'];
  if (!jscomp) {
    goog.global['$jscomp'] = jscomp = {};
  }
  var transpile = jscomp.transpile;
  if (!transpile) {
    var transpilerPath = goog.basePath + goog.TRANSPILER;
    var transpilerCode = goog.loadFileSync_(transpilerPath);
    if (transpilerCode) {
      // This must be executed synchronously, since by the time we know we
      // need it, we're about to load and write the ES6 code synchronously,
      // so a normal script-tag load will be too slow. Wrapped in a function
      // so that code is eval'd in the global scope.
      (function() {
        (0, eval)(transpilerCode + '\n//# sourceURL=' + transpilerPath);
      }).call(goog.global);
      // Even though the transpiler is optional, if $gwtExport is found, it's
      // a sign the transpiler was loaded and the $jscomp.transpile *should*
      // be there.
      if (goog.global['$gwtExport'] && goog.global['$gwtExport']['$jscomp'] &&
          !goog.global['$gwtExport']['$jscomp']['transpile']) {
        throw new Error(
            'The transpiler did not properly export the "transpile" ' +
            'method. $gwtExport: ' + JSON.stringify(goog.global['$gwtExport']));
      }
      // transpile.js only exports a single $jscomp function, transpile. We
      // grab just that and add it to the existing definition of $jscomp which
      // contains the polyfills.
      goog.global['$jscomp'].transpile =
          goog.global['$gwtExport']['$jscomp']['transpile'];
      jscomp = goog.global['$jscomp'];
      transpile = jscomp.transpile;
    }
  }
  if (!transpile) {
    // The transpiler is an optional component.  If it's not available then
    // replace it with a pass-through function that simply logs.
    var suffix = ' requires transpilation but no transpiler was found.';
    transpile = jscomp.transpile = function(code, path) {
      // TODO(sdh): figure out some way to get this error to show up
      // in test results, noting that the failure may occur in many
      // different ways, including in loadModule() before the test
      // runner even comes up.
      goog.logToConsole_(path + suffix);
      return code;
    };
  }
  // Note: any transpilation errors/warnings will be logged to the console.
  return transpile(code, path, target);
};

//==============================================================================
// Language Enhancements
//==============================================================================


/**
 * This is a "fixed" version of the typeof operator.  It differs from the typeof
 * operator in such a way that null returns 'null' and arrays return 'array'.
 * @param {?} value The value to get the type of.
 * @return {string} The name of the type.
 */
goog.typeOf = function(value) {
  var s = typeof value;
  if (s == 'object') {
    if (value) {
      // Check these first, so we can avoid calling Object.prototype.toString if
      // possible.
      //
      // IE improperly marshals typeof across execution contexts, but a
      // cross-context object will still return false for "instanceof Object".
      if (value instanceof Array) {
        return 'array';
      } else if (value instanceof Object) {
        return s;
      }

      // HACK: In order to use an Object prototype method on the arbitrary
      //   value, the compiler requires the value be cast to type Object,
      //   even though the ECMA spec explicitly allows it.
      var className = Object.prototype.toString.call(
          /** @type {!Object} */ (value));
      // In Firefox 3.6, attempting to access iframe window objects' length
      // property throws an NS_ERROR_FAILURE, so we need to special-case it
      // here.
      if (className == '[object Window]') {
        return 'object';
      }

      // We cannot always use constructor == Array or instanceof Array because
      // different frames have different Array objects. In IE6, if the iframe
      // where the array was created is destroyed, the array loses its
      // prototype. Then dereferencing val.splice here throws an exception, so
      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'
      // so that will work. In this case, this function will return false and
      // most array functions will still work because the array is still
      // array-like (supports length and []) even though it has lost its
      // prototype.
      // Mark Miller noticed that Object.prototype.toString
      // allows access to the unforgeable [[Class]] property.
      //  15.2.4.2 Object.prototype.toString ( )
      //  When the toString method is called, the following steps are taken:
      //      1. Get the [[Class]] property of this object.
      //      2. Compute a string value by concatenating the three strings
      //         "[object ", Result(1), and "]".
      //      3. Return Result(2).
      // and this behavior survives the destruction of the execution context.
      if ((className == '[object Array]' ||
           // In IE all non value types are wrapped as objects across window
           // boundaries (not iframe though) so we have to do object detection
           // for this edge case.
           typeof value.length == 'number' &&
               typeof value.splice != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('splice')

               )) {
        return 'array';
      }
      // HACK: There is still an array case that fails.
      //     function ArrayImpostor() {}
      //     ArrayImpostor.prototype = [];
      //     var impostor = new ArrayImpostor;
      // this can be fixed by getting rid of the fast path
      // (value instanceof Array) and solely relying on
      // (value && Object.prototype.toString.vall(value) === '[object Array]')
      // but that would require many more function calls and is not warranted
      // unless closure code is receiving objects from untrusted sources.

      // IE in cross-window calls does not correctly marshal the function type
      // (it appears just as an object) so we cannot use just typeof val ==
      // 'function'. However, if the object has a call property, it is a
      // function.
      if ((className == '[object Function]' ||
           typeof value.call != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('call'))) {
        return 'function';
      }

    } else {
      return 'null';
    }

  } else if (s == 'function' && typeof value.call == 'undefined') {
    // In Safari typeof nodeList returns 'function', and on Firefox typeof
    // behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
    // would like to return object for those and we can detect an invalid
    // function by making sure that the function object has a call method.
    return 'object';
  }
  return s;
};


/**
 * Returns true if the specified value is null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is null.
 * @deprecated Use `val === null` instead.
 */
goog.isNull = function(val) {
  return val === null;
};


/**
 * Returns true if the specified value is defined and not null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined and not null.
 * @deprecated Use `val != null` instead.
 */
goog.isDefAndNotNull = function(val) {
  // Note that undefined == null.
  return val != null;
};


/**
 * Returns true if the specified value is an array.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArray = function(val) {
  return goog.typeOf(val) == 'array';
};


/**
 * Returns true if the object looks like an array. To qualify as array like
 * the value needs to be either a NodeList or an object with a Number length
 * property. Note that for this function neither strings nor functions are
 * considered "array-like".
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArrayLike = function(val) {
  var type = goog.typeOf(val);
  // We do not use goog.isObject here in order to exclude function values.
  return type == 'array' || type == 'object' && typeof val.length == 'number';
};


/**
 * Returns true if the object looks like a Date. To qualify as Date-like the
 * value needs to be an object and have a getFullYear() function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a like a Date.
 */
goog.isDateLike = function(val) {
  return goog.isObject(val) && typeof val.getFullYear == 'function';
};


/**
 * Returns true if the specified value is a function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a function.
 */
goog.isFunction = function(val) {
  return goog.typeOf(val) == 'function';
};


/**
 * Returns true if the specified value is an object.  This includes arrays and
 * functions.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an object.
 */
goog.isObject = function(val) {
  var type = typeof val;
  return type == 'object' && val != null || type == 'function';
  // return Object(val) === val also works, but is slower, especially if val is
  // not an object.
};


/**
 * Gets a unique ID for an object. This mutates the object so that further calls
 * with the same object as a parameter returns the same value. The unique ID is
 * guaranteed to be unique across the current session amongst objects that are
 * passed into `getUid`. There is no guarantee that the ID is unique or
 * consistent across sessions. It is unsafe to generate unique ID for function
 * prototypes.
 *
 * @param {Object} obj The object to get the unique ID for.
 * @return {number} The unique ID for the object.
 */
goog.getUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In Opera window.hasOwnProperty exists but always returns false so we avoid
  // using it. As a consequence the unique ID generated for BaseClass.prototype
  // and SubClass.prototype will be the same.
  // TODO(b/141512323): UUIDs are broken for ctors with class-side inheritance.
  return obj[goog.UID_PROPERTY_] ||
      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};


/**
 * Whether the given object is already assigned a unique ID.
 *
 * This does not modify the object.
 *
 * @param {!Object} obj The object to check.
 * @return {boolean} Whether there is an assigned unique id for the object.
 */
goog.hasUid = function(obj) {
  return !!obj[goog.UID_PROPERTY_];
};


/**
 * Removes the unique ID from an object. This is useful if the object was
 * previously mutated using `goog.getUid` in which case the mutation is
 * undone.
 * @param {Object} obj The object to remove the unique ID field from.
 */
goog.removeUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In IE, DOM nodes are not instances of Object and throw an exception if we
  // try to delete.  Instead we try to use removeAttribute.
  if (obj !== null && 'removeAttribute' in obj) {
    obj.removeAttribute(goog.UID_PROPERTY_);
  }

  try {
    delete obj[goog.UID_PROPERTY_];
  } catch (ex) {
  }
};


/**
 * Name for unique ID property. Initialized in a way to help avoid collisions
 * with other closure JavaScript on the same page.
 * @type {string}
 * @private
 */
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);


/**
 * Counter for UID.
 * @type {number}
 * @private
 */
goog.uidCounter_ = 0;


/**
 * Adds a hash code field to an object. The hash code is unique for the
 * given object.
 * @param {Object} obj The object to get the hash code for.
 * @return {number} The hash code for the object.
 * @deprecated Use goog.getUid instead.
 */
goog.getHashCode = goog.getUid;


/**
 * Removes the hash code field from an object.
 * @param {Object} obj The object to remove the field from.
 * @deprecated Use goog.removeUid instead.
 */
goog.removeHashCode = goog.removeUid;


/**
 * Clones a value. The input may be an Object, Array, or basic type. Objects and
 * arrays will be cloned recursively.
 *
 * WARNINGS:
 * <code>goog.cloneObject</code> does not detect reference loops. Objects that
 * refer to themselves will cause infinite recursion.
 *
 * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
 * UIDs created by <code>getUid</code> into cloned results.
 *
 * @param {*} obj The value to clone.
 * @return {*} A clone of the input value.
 * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
 */
goog.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == 'object' || type == 'array') {
    if (typeof obj.clone === 'function') {
      return obj.clone();
    }
    var clone = type == 'array' ? [] : {};
    for (var key in obj) {
      clone[key] = goog.cloneObject(obj[key]);
    }
    return clone;
  }

  return obj;
};


/**
 * A native implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindNative_ = function(fn, selfObj, var_args) {
  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
};


/**
 * A pure-JS implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindJs_ = function(fn, selfObj, var_args) {
  if (!fn) {
    throw new Error();
  }

  if (arguments.length > 2) {
    var boundArgs = Array.prototype.slice.call(arguments, 2);
    return function() {
      // Prepend the bound arguments to the current arguments.
      var newArgs = Array.prototype.slice.call(arguments);
      Array.prototype.unshift.apply(newArgs, boundArgs);
      return fn.apply(selfObj, newArgs);
    };

  } else {
    return function() {
      return fn.apply(selfObj, arguments);
    };
  }
};


/**
 * Partially applies this function to a particular 'this object' and zero or
 * more arguments. The result is a new function with some arguments of the first
 * function pre-filled and the value of this 'pre-specified'.
 *
 * Remaining arguments specified at call-time are appended to the pre-specified
 * ones.
 *
 * Also see: {@link #partial}.
 *
 * Usage:
 * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
 * barMethBound('arg3', 'arg4');</pre>
 *
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @suppress {deprecated} See above.
 */
goog.bind = function(fn, selfObj, var_args) {
  // TODO(nicksantos): narrow the type signature.
  if (Function.prototype.bind &&
      // NOTE(nicksantos): Somebody pulled base.js into the default Chrome
      // extension environment. This means that for Chrome extensions, they get
      // the implementation of Function.prototype.bind that calls goog.bind
      // instead of the native one. Even worse, we don't want to introduce a
      // circular dependency between goog.bind and Function.prototype.bind, so
      // we have to hack this to make sure it works correctly.
      Function.prototype.bind.toString().indexOf('native code') != -1) {
    goog.bind = goog.bindNative_;
  } else {
    goog.bind = goog.bindJs_;
  }
  return goog.bind.apply(null, arguments);
};


/**
 * Like goog.bind(), except that a 'this object' is not required. Useful when
 * the target function is already bound.
 *
 * Usage:
 * var g = goog.partial(f, arg1, arg2);
 * g(arg3, arg4);
 *
 * @param {Function} fn A function to partially apply.
 * @param {...*} var_args Additional arguments that are partially applied to fn.
 * @return {!Function} A partially-applied form of the function goog.partial()
 *     was invoked as a method of.
 */
goog.partial = function(fn, var_args) {
  var args = Array.prototype.slice.call(arguments, 1);
  return function() {
    // Clone the array (with slice()) and append additional arguments
    // to the existing arguments.
    var newArgs = args.slice();
    newArgs.push.apply(newArgs, arguments);
    return fn.apply(/** @type {?} */ (this), newArgs);
  };
};


/**
 * Copies all the members of a source object to a target object. This method
 * does not work on all browsers for all objects that contain keys such as
 * toString or hasOwnProperty. Use goog.object.extend for this purpose.
 *
 * NOTE: Some have advocated for the use of goog.mixin to setup classes
 * with multiple inheritence (traits, mixins, etc).  However, as it simply
 * uses "for in", this is not compatible with ES6 classes whose methods are
 * non-enumerable.  Changing this, would break cases where non-enumerable
 * properties are not expected.
 *
 * @param {Object} target Target.
 * @param {Object} source Source.
 * @deprecated Prefer Object.assign
 */
goog.mixin = function(target, source) {
  for (var x in source) {
    target[x] = source[x];
  }

  // For IE7 or lower, the for-in-loop does not contain any properties that are
  // not enumerable on the prototype object (for example, isPrototypeOf from
  // Object.prototype) but also it will not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
};


/**
 * @return {number} An integer value representing the number of milliseconds
 *     between midnight, January 1, 1970 and the current time.
 * @deprecated Use Date.now
 */
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
             // Unary plus operator converts its operand to a number which in
             // the case of
             // a date is done by calling getTime().
             return +new Date();
           });


/**
 * Evals JavaScript in the global scope.  In IE this uses execScript, other
 * browsers use goog.global.eval. If goog.global.eval does not evaluate in the
 * global scope (for example, in Safari), appends a script tag instead.
 * Throws an exception if neither execScript or eval is defined.
 * @param {string} script JavaScript string.
 */
goog.globalEval = function(script) {
  if (goog.global.execScript) {
    goog.global.execScript(script, 'JavaScript');
  } else if (goog.global.eval) {
    // Test to see if eval works
    if (goog.evalWorksForGlobals_ == null) {
      try {
        goog.global.eval('var _evalTest_ = 1;');
      } catch (ignore) {
      }
      if (typeof goog.global['_evalTest_'] != 'undefined') {
        try {
          delete goog.global['_evalTest_'];
        } catch (ignore) {
          // Microsoft edge fails the deletion above in strict mode.
        }
        goog.evalWorksForGlobals_ = true;
      } else {
        goog.evalWorksForGlobals_ = false;
      }
    }

    if (goog.evalWorksForGlobals_) {
      goog.global.eval(script);
    } else {
      /** @type {!Document} */
      var doc = goog.global.document;
      var scriptElt =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptElt.type = 'text/javascript';
      scriptElt.defer = false;
      // Note(user): can't use .innerHTML since "t('<test>')" will fail and
      // .text doesn't work in Safari 2.  Therefore we append a text node.
      scriptElt.appendChild(doc.createTextNode(script));
      doc.head.appendChild(scriptElt);
      doc.head.removeChild(scriptElt);
    }
  } else {
    throw new Error('goog.globalEval not available');
  }
};


/**
 * Indicates whether or not we can call 'eval' directly to eval code in the
 * global scope. Set to a Boolean by the first call to goog.globalEval (which
 * empirically tests whether eval works for globals). @see goog.globalEval
 * @type {?boolean}
 * @private
 */
goog.evalWorksForGlobals_ = null;


/**
 * Optional map of CSS class names to obfuscated names used with
 * goog.getCssName().
 * @private {!Object<string, string>|undefined}
 * @see goog.setCssNameMapping
 */
goog.cssNameMapping_;


/**
 * Optional obfuscation style for CSS class names. Should be set to either
 * 'BY_WHOLE' or 'BY_PART' if defined.
 * @type {string|undefined}
 * @private
 * @see goog.setCssNameMapping
 */
goog.cssNameMappingStyle_;



/**
 * A hook for modifying the default behavior goog.getCssName. The function
 * if present, will receive the standard output of the goog.getCssName as
 * its input.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAP_FN;


/**
 * Handles strings that are intended to be used as CSS class names.
 *
 * This function works in tandem with @see goog.setCssNameMapping.
 *
 * Without any mapping set, the arguments are simple joined with a hyphen and
 * passed through unaltered.
 *
 * When there is a mapping, there are two possible styles in which these
 * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
 * of the passed in css name is rewritten according to the map. In the BY_WHOLE
 * style, the full css name is looked up in the map directly. If a rewrite is
 * not specified by the map, the compiler will output a warning.
 *
 * When the mapping is passed to the compiler, it will replace calls to
 * goog.getCssName with the strings from the mapping, e.g.
 *     var x = goog.getCssName('foo');
 *     var y = goog.getCssName(this.baseClass, 'active');
 *  becomes:
 *     var x = 'foo';
 *     var y = this.baseClass + '-active';
 *
 * If one argument is passed it will be processed, if two are passed only the
 * modifier will be processed, as it is assumed the first argument was generated
 * as a result of calling goog.getCssName.
 *
 * @param {string} className The class name.
 * @param {string=} opt_modifier A modifier to be appended to the class name.
 * @return {string} The class name or the concatenation of the class name and
 *     the modifier.
 */
goog.getCssName = function(className, opt_modifier) {
  // String() is used for compatibility with compiled soy where the passed
  // className can be non-string objects.
  if (String(className).charAt(0) == '.') {
    throw new Error(
        'className passed in goog.getCssName must not start with ".".' +
        ' You passed: ' + className);
  }

  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };

  var renameByParts = function(cssName) {
    // Remap all the parts individually.
    var parts = cssName.split('-');
    var mapped = [];
    for (var i = 0; i < parts.length; i++) {
      mapped.push(getMapping(parts[i]));
    }
    return mapped.join('-');
  };

  var rename;
  if (goog.cssNameMapping_) {
    rename =
        goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;
  } else {
    rename = function(a) {
      return a;
    };
  }

  var result =
      opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);

  // The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further
  // processing of the class name.
  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
  }

  return result;
};


/**
 * Sets the map to check when returning a value from goog.getCssName(). Example:
 * <pre>
 * goog.setCssNameMapping({
 *   "goog": "a",
 *   "disabled": "b",
 * });
 *
 * var x = goog.getCssName('goog');
 * // The following evaluates to: "a a-b".
 * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
 * </pre>
 * When declared as a map of string literals to string literals, the JSCompiler
 * will replace all calls to goog.getCssName() using the supplied map if the
 * --process_closure_primitives flag is set.
 *
 * @param {!Object} mapping A map of strings to strings where keys are possible
 *     arguments to goog.getCssName() and values are the corresponding values
 *     that should be returned.
 * @param {string=} opt_style The style of css name mapping. There are two valid
 *     options: 'BY_PART', and 'BY_WHOLE'.
 * @see goog.getCssName for a description.
 */
goog.setCssNameMapping = function(mapping, opt_style) {
  goog.cssNameMapping_ = mapping;
  goog.cssNameMappingStyle_ = opt_style;
};


/**
 * To use CSS renaming in compiled mode, one of the input files should have a
 * call to goog.setCssNameMapping() with an object literal that the JSCompiler
 * can extract and use to replace all calls to goog.getCssName(). In uncompiled
 * mode, JavaScript code should be loaded before this base.js file that declares
 * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
 * to ensure that the mapping is loaded before any calls to goog.getCssName()
 * are made in uncompiled mode.
 *
 * A hook for overriding the CSS name mapping.
 * @type {!Object<string, string>|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAPPING;


if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
  // This does not call goog.setCssNameMapping() because the JSCompiler
  // requires that goog.setCssNameMapping() be called with an object literal.
  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}


/**
 * Gets a localized message.
 *
 * This function is a compiler primitive. If you give the compiler a localized
 * message bundle, it will replace the string at compile-time with a localized
 * version, and expand goog.getMsg call to a concatenated string.
 *
 * Messages must be initialized in the form:
 * <code>
 * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
 * </code>
 *
 * This function produces a string which should be treated as plain text. Use
 * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
 * produce SafeHtml.
 *
 * @param {string} str Translatable string, places holders in the form {$foo}.
 * @param {Object<string, string>=} opt_values Maps place holder name to value.
 * @param {{html: boolean}=} opt_options Options:
 *     html: Escape '<' in str to '&lt;'. Used by Closure Templates where the
 *     generated code size and performance is critical which is why {@link
 *     goog.html.SafeHtmlFormatter} is not used. The value must be literal true
 *     or false.
 * @return {string} message with placeholders filled.
 */
goog.getMsg = function(str, opt_values, opt_options) {
  if (opt_options && opt_options.html) {
    // Note that '&' is not replaced because the translation can contain HTML
    // entities.
    str = str.replace(/</g, '&lt;');
  }
  if (opt_values) {
    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
      return (opt_values != null && key in opt_values) ? opt_values[key] :
                                                         match;
    });
  }
  return str;
};


/**
 * Gets a localized message. If the message does not have a translation, gives a
 * fallback message.
 *
 * This is useful when introducing a new message that has not yet been
 * translated into all languages.
 *
 * This function is a compiler primitive. Must be used in the form:
 * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
 * where MSG_A and MSG_B were initialized with goog.getMsg.
 *
 * @param {string} a The preferred message.
 * @param {string} b The fallback message.
 * @return {string} The best translated message.
 */
goog.getMsgWithFallback = function(a, b) {
  return a;
};


/**
 * Exposes an unobfuscated global namespace path for the given object.
 * Note that fields of the exported object *will* be obfuscated, unless they are
 * exported in turn via this function or goog.exportProperty.
 *
 * Also handy for making public items that are defined in anonymous closures.
 *
 * ex. goog.exportSymbol('public.path.Foo', Foo);
 *
 * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
 *     public.path.Foo.staticFunction();
 *
 * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
 *                       Foo.prototype.myMethod);
 *     new public.path.Foo().myMethod();
 *
 * @param {string} publicPath Unobfuscated name to export.
 * @param {*} object Object the name should point to.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is goog.global.
 */
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  goog.exportPath_(publicPath, object, opt_objectToExportTo);
};


/**
 * Exports a property unobfuscated into the object's namespace.
 * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
 * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
 * @param {Object} object Object whose static property is being exported.
 * @param {string} publicName Unobfuscated name to export.
 * @param {*} symbol Object the name should point to.
 */
goog.exportProperty = function(object, publicName, symbol) {
  object[publicName] = symbol;
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * Usage:
 * <pre>
 * function ParentClass(a, b) { }
 * ParentClass.prototype.foo = function(a) { };
 *
 * function ChildClass(a, b, c) {
 *   ChildClass.base(this, 'constructor', a, b);
 * }
 * goog.inherits(ChildClass, ParentClass);
 *
 * var child = new ChildClass('a', 'b', 'see');
 * child.foo(); // This works.
 * </pre>
 *
 * @param {!Function} childCtor Child class.
 * @param {!Function} parentCtor Parent class.
 * @suppress {strictMissingProperties} superClass_ and base is not defined on
 *    Function.
 */
goog.inherits = function(childCtor, parentCtor) {
  /** @constructor */
  function tempCtor() {}
  tempCtor.prototype = parentCtor.prototype;
  childCtor.superClass_ = parentCtor.prototype;
  childCtor.prototype = new tempCtor();
  /** @override */
  childCtor.prototype.constructor = childCtor;

  /**
   * Calls superclass constructor/method.
   *
   * This function is only available if you use goog.inherits to
   * express inheritance relationships between classes.
   *
   * NOTE: This is a replacement for goog.base and for superClass_
   * property defined in childCtor.
   *
   * @param {!Object} me Should always be "this".
   * @param {string} methodName The method name to call. Calling
   *     superclass constructor can be done with the special string
   *     'constructor'.
   * @param {...*} var_args The arguments to pass to superclass
   *     method/constructor.
   * @return {*} The return value of the superclass method/constructor.
   */
  childCtor.base = function(me, methodName, var_args) {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var args = new Array(arguments.length - 2);
    for (var i = 2; i < arguments.length; i++) {
      args[i - 2] = arguments[i];
    }
    return parentCtor.prototype[methodName].apply(me, args);
  };
};


/**
 * Call up to the superclass.
 *
 * If this is called from a constructor, then this calls the superclass
 * constructor with arguments 1-N.
 *
 * If this is called from a prototype method, then you must pass the name of the
 * method as the second argument to this function. If you do not, you will get a
 * runtime error. This calls the superclass' method with arguments 2-N.
 *
 * This function only works if you use goog.inherits to express inheritance
 * relationships between your classes.
 *
 * This function is a compiler primitive. At compile-time, the compiler will do
 * macro expansion to remove a lot of the extra overhead that this function
 * introduces. The compiler will also enforce a lot of the assumptions that this
 * function makes, and treat it as a compiler error if you break them.
 *
 * @param {!Object} me Should always be "this".
 * @param {*=} opt_methodName The method name if calling a super method.
 * @param {...*} var_args The rest of the arguments.
 * @return {*} The return value of the superclass method.
 * @suppress {es5Strict} This method can not be used in strict mode, but
 *     all Closure Library consumers must depend on this file.
 * @deprecated goog.base is not strict mode compatible.  Prefer the static
 *     "base" method added to the constructor by goog.inherits
 *     or ES6 classes and the "super" keyword.
 */
goog.base = function(me, opt_methodName, var_args) {
  var caller = arguments.callee.caller;

  if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
    throw new Error(
        'arguments.caller not defined.  goog.base() cannot be used ' +
        'with strict mode code. See ' +
        'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
  }

  if (typeof caller.superClass_ !== 'undefined') {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var ctorArgs = new Array(arguments.length - 1);
    for (var i = 1; i < arguments.length; i++) {
      ctorArgs[i - 1] = arguments[i];
    }
    // This is a constructor. Call the superclass constructor.
    return /** @type {!Function} */ (caller.superClass_)
        .constructor.apply(me, ctorArgs);
  }

  if (typeof opt_methodName != 'string' && typeof opt_methodName != 'symbol') {
    throw new Error(
        'method names provided to goog.base must be a string or a symbol');
  }

  // Copying using loop to avoid deop due to passing arguments object to
  // function. This is faster in many JS engines as of late 2014.
  var args = new Array(arguments.length - 2);
  for (var i = 2; i < arguments.length; i++) {
    args[i - 2] = arguments[i];
  }
  var foundCaller = false;
  for (var proto = me.constructor.prototype; proto;
       proto = Object.getPrototypeOf(proto)) {
    if (proto[opt_methodName] === caller) {
      foundCaller = true;
    } else if (foundCaller) {
      return proto[opt_methodName].apply(me, args);
    }
  }

  // If we did not find the caller in the prototype chain, then one of two
  // things happened:
  // 1) The caller is an instance method.
  // 2) This method was not called by the right caller.
  if (me[opt_methodName] === caller) {
    return me.constructor.prototype[opt_methodName].apply(me, args);
  } else {
    throw new Error(
        'goog.base called from a method of one name ' +
        'to a method of a different name');
  }
};


/**
 * Allow for aliasing within scope functions.  This function exists for
 * uncompiled code - in compiled code the calls will be inlined and the aliases
 * applied.  In uncompiled code the function is simply run since the aliases as
 * written are valid JavaScript.
 *
 *
 * @param {function()} fn Function to call.  This function can contain aliases
 *     to namespaces (e.g. "var dom = goog.dom") or classes
 *     (e.g. "var Timer = goog.Timer").
 */
goog.scope = function(fn) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.scope is not supported within a module.');
  }
  fn.call(goog.global);
};


/*
 * To support uncompiled, strict mode bundles that use eval to divide source
 * like so:
 *    eval('someSource;//# sourceUrl sourcefile.js');
 * We need to export the globally defined symbols "goog" and "COMPILED".
 * Exporting "goog" breaks the compiler optimizations, so we required that
 * be defined externally.
 * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
 * extern generation when that compiler option is enabled.
 */
if (!COMPILED) {
  goog.global['COMPILED'] = COMPILED;
}


//==============================================================================
// goog.defineClass implementation
//==============================================================================


/**
 * Creates a restricted form of a Closure "class":
 *   - from the compiler's perspective, the instance returned from the
 *     constructor is sealed (no new properties may be added).  This enables
 *     better checks.
 *   - the compiler will rewrite this definition to a form that is optimal
 *     for type checking and optimization (initially this will be a more
 *     traditional form).
 *
 * @param {Function} superClass The superclass, Object or null.
 * @param {goog.defineClass.ClassDescriptor} def
 *     An object literal describing
 *     the class.  It may have the following properties:
 *     "constructor": the constructor function
 *     "statics": an object literal containing methods to add to the constructor
 *        as "static" methods or a function that will receive the constructor
 *        function as its only parameter to which static properties can
 *        be added.
 *     all other properties are added to the prototype.
 * @return {!Function} The class constructor.
 * @deprecated Use ES6 class syntax instead.
 */
goog.defineClass = function(superClass, def) {
  // TODO(johnlenz): consider making the superClass an optional parameter.
  var constructor = def.constructor;
  var statics = def.statics;
  // Wrap the constructor prior to setting up the prototype and static methods.
  if (!constructor || constructor == Object.prototype.constructor) {
    constructor = function() {
      throw new Error(
          'cannot instantiate an interface (no constructor defined).');
    };
  }

  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
  if (superClass) {
    goog.inherits(cls, superClass);
  }

  // Remove all the properties that should not be copied to the prototype.
  delete def.constructor;
  delete def.statics;

  goog.defineClass.applyProperties_(cls.prototype, def);
  if (statics != null) {
    if (statics instanceof Function) {
      statics(cls);
    } else {
      goog.defineClass.applyProperties_(cls, statics);
    }
  }

  return cls;
};


/**
 * @typedef {{
 *   constructor: (!Function|undefined),
 *   statics: (Object|undefined|function(Function):void)
 * }}
 */
goog.defineClass.ClassDescriptor;


/**
 * @define {boolean} Whether the instances returned by goog.defineClass should
 *     be sealed when possible.
 *
 * When sealing is disabled the constructor function will not be wrapped by
 * goog.defineClass, making it incompatible with ES6 class methods.
 */
goog.defineClass.SEAL_CLASS_INSTANCES =
    goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);


/**
 * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
 * defined, this function will wrap the constructor in a function that seals the
 * results of the provided constructor function.
 *
 * @param {!Function} ctr The constructor whose results maybe be sealed.
 * @param {Function} superClass The superclass constructor.
 * @return {!Function} The replacement constructor.
 * @private
 */
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
    // Do now wrap the constructor when sealing is disabled. Angular code
    // depends on this for injection to work properly.
    return ctr;
  }

  // Compute whether the constructor is sealable at definition time, rather
  // than when the instance is being constructed.
  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);

  /**
   * @this {Object}
   * @return {?}
   */
  var wrappedCtr = function() {
    // Don't seal an instance of a subclass when it calls the constructor of
    // its super class as there is most likely still setup to do.
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];

    if (this.constructor === wrappedCtr && superclassSealable &&
        Object.seal instanceof Function) {
      Object.seal(instance);
    }
    return instance;
  };

  return wrappedCtr;
};


/**
 * @param {Function} ctr The constructor to test.
 * @return {boolean} Whether the constructor has been tagged as unsealable
 *     using goog.tagUnsealableClass.
 * @private
 */
goog.defineClass.isUnsealable_ = function(ctr) {
  return ctr && ctr.prototype &&
      ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};


// TODO(johnlenz): share these values with the goog.object
/**
 * The names of the fields that are defined on Object.prototype.
 * @type {!Array<string>}
 * @private
 * @const
 */
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
  'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
  'toLocaleString', 'toString', 'valueOf'
];


// TODO(johnlenz): share this function with the goog.object
/**
 * @param {!Object} target The object to add properties to.
 * @param {!Object} source The object to copy properties from.
 * @private
 */
goog.defineClass.applyProperties_ = function(target, source) {
  // TODO(johnlenz): update this to support ES5 getters/setters

  var key;
  for (key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }

  // For IE the for-in-loop does not contain any properties that are not
  // enumerable on the prototype object (for example isPrototypeOf from
  // Object.prototype) and it will also not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
  for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }
};


/**
 * Sealing classes breaks the older idiom of assigning properties on the
 * prototype rather than in the constructor. As such, goog.defineClass
 * must not seal subclasses of these old-style classes until they are fixed.
 * Until then, this marks a class as "broken", instructing defineClass
 * not to seal subclasses.
 * @param {!Function} ctr The legacy constructor to tag as unsealable.
 */
goog.tagUnsealableClass = function(ctr) {
  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
  }
};


/**
 * Name for unsealable tag property.
 * @const @private {string}
 */
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';


// There's a bug in the compiler where without collapse properties the
// Closure namespace defines do not guard code correctly. To help reduce code
// size also check for !COMPILED even though it redundant until this is fixed.
if (!COMPILED && goog.DEPENDENCIES_ENABLED) {

  /**
   * Tries to detect whether is in the context of an HTML document.
   * @return {boolean} True if it looks like HTML document.
   * @private
   */
  goog.inHtmlDocument_ = function() {
    /** @type {!Document} */
    var doc = goog.global.document;
    return doc != null && 'write' in doc;  // XULDocument misses write.
  };


  /**
   * We'd like to check for if the document readyState is 'loading'; however
   * there are bugs on IE 10 and below where the readyState being anything other
   * than 'complete' is not reliable.
   * @return {boolean}
   * @private
   */
  goog.isDocumentLoading_ = function() {
    // attachEvent is available on IE 6 thru 10 only, and thus can be used to
    // detect those browsers.
    /** @type {!HTMLDocument} */
    var doc = goog.global.document;
    return doc.attachEvent ? doc.readyState != 'complete' :
                             doc.readyState == 'loading';
  };


  /**
   * Tries to detect the base path of base.js script that bootstraps Closure.
   * @private
   */
  goog.findBasePath_ = function() {
    if (goog.global.CLOSURE_BASE_PATH != undefined &&
        // Anti DOM-clobbering runtime check (b/37736576).
        typeof goog.global.CLOSURE_BASE_PATH === 'string') {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else if (!goog.inHtmlDocument_()) {
      return;
    }
    /** @type {!Document} */
    var doc = goog.global.document;
    // If we have a currentScript available, use it exclusively.
    var currentScript = doc.currentScript;
    if (currentScript) {
      var scripts = [currentScript];
    } else {
      var scripts = doc.getElementsByTagName('SCRIPT');
    }
    // Search backwards since the current script is in almost all cases the one
    // that has base.js.
    for (var i = scripts.length - 1; i >= 0; --i) {
      var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
      var src = script.src;
      var qmark = src.lastIndexOf('?');
      var l = qmark == -1 ? src.length : qmark;
      if (src.substr(l - 7, 7) == 'base.js') {
        goog.basePath = src.substr(0, l - 7);
        return;
      }
    }
  };

  goog.findBasePath_();

  /** @struct @constructor @final */
  goog.Transpiler = function() {
    /** @private {?Object<string, boolean>} */
    this.requiresTranspilation_ = null;
    /** @private {string} */
    this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
  };


  /**
   * Returns a newly created map from language mode string to a boolean
   * indicating whether transpilation should be done for that mode as well as
   * the highest level language that this environment supports.
   *
   * Guaranteed invariant:
   * For any two modes, l1 and l2 where l2 is a newer mode than l1,
   * `map[l1] == true` implies that `map[l2] == true`.
   *
   * Note this method is extracted and used elsewhere, so it cannot rely on
   * anything external (it should easily be able to be transformed into a
   * standalone, top level function).
   *
   * @private
   * @return {{
   *   target: string,
   *   map: !Object<string, boolean>
   * }}
   */
  goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
    var transpilationTarget = 'es3';
    var /** !Object<string, boolean> */ requiresTranspilation = {'es3': false};
    var transpilationRequiredForAllLaterModes = false;

    /**
     * Adds an entry to requiresTranspliation for the given language mode.
     *
     * IMPORTANT: Calls must be made in order from oldest to newest language
     * mode.
     * @param {string} modeName
     * @param {function(): boolean} isSupported Returns true if the JS engine
     *     supports the given mode.
     */
    function addNewerLanguageTranspilationCheck(modeName, isSupported) {
      if (transpilationRequiredForAllLaterModes) {
        requiresTranspilation[modeName] = true;
      } else if (isSupported()) {
        transpilationTarget = modeName;
        requiresTranspilation[modeName] = false;
      } else {
        requiresTranspilation[modeName] = true;
        transpilationRequiredForAllLaterModes = true;
      }
    }

    /**
     * Does the given code evaluate without syntax errors and return a truthy
     * result?
     */
    function /** boolean */ evalCheck(/** string */ code) {
      try {
        return !!eval(code);
      } catch (ignored) {
        return false;
      }
    }

    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
        goog.global.navigator.userAgent :
        '';

    // Identify ES3-only browsers by their incorrect treatment of commas.
    addNewerLanguageTranspilationCheck('es5', function() {
      return evalCheck('[1,].length==1');
    });
    addNewerLanguageTranspilationCheck('es6', function() {
      // Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
      // https://github.com/Microsoft/ChakraCore/issues/1496.
      var re = /Edge\/(\d+)(\.\d)*/i;
      var edgeUserAgent = userAgent.match(re);
      if (edgeUserAgent) {
        // The Reflect.construct test below is flaky on Edge. It can sometimes
        // pass or fail on 40 15.15063, so just exit early for Edge and treat
        // it as ES5. Until we're on a more up to date version just always use
        // ES5. See https://github.com/Microsoft/ChakraCore/issues/3217.
        return false;
      }
      // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
      //   (a) default params (specifically shadowing locals),
      //   (b) destructuring, (c) block-scoped functions,
      //   (d) for-of (const), (e) new.target/Reflect.construct
      var es6fullTest =
          'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
          'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
          'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
          'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
          '==3}';

      return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
    });
    // ** and **= are the only new features in 'es7'
    addNewerLanguageTranspilationCheck('es7', function() {
      return evalCheck('2 ** 2 == 4');
    });
    // async functions are the only new features in 'es8'
    addNewerLanguageTranspilationCheck('es8', function() {
      return evalCheck('async () => 1, true');
    });
    addNewerLanguageTranspilationCheck('es9', function() {
      return evalCheck('({...rest} = {}), true');
    });
    addNewerLanguageTranspilationCheck('es_next', function() {
      return false;  // assume it always need to transpile
    });
    return {target: transpilationTarget, map: requiresTranspilation};
  };


  /**
   * Determines whether the given language needs to be transpiled.
   * @param {string} lang
   * @param {string|undefined} module
   * @return {boolean}
   */
  goog.Transpiler.prototype.needsTranspile = function(lang, module) {
    if (goog.TRANSPILE == 'always') {
      return true;
    } else if (goog.TRANSPILE == 'never') {
      return false;
    } else if (!this.requiresTranspilation_) {
      var obj = this.createRequiresTranspilation_();
      this.requiresTranspilation_ = obj.map;
      this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
    }
    if (lang in this.requiresTranspilation_) {
      if (this.requiresTranspilation_[lang]) {
        return true;
      } else if (
          goog.inHtmlDocument_() && module == 'es6' &&
          !('noModule' in goog.global.document.createElement('script'))) {
        return true;
      } else {
        return false;
      }
    } else {
      throw new Error('Unknown language mode: ' + lang);
    }
  };


  /**
   * Lazily retrieves the transpiler and applies it to the source.
   * @param {string} code JS code.
   * @param {string} path Path to the code.
   * @return {string} The transpiled code.
   */
  goog.Transpiler.prototype.transpile = function(code, path) {
    // TODO(johnplaisted): We should delete goog.transpile_ and just have this
    // function. But there's some compile error atm where goog.global is being
    // stripped incorrectly without this.
    return goog.transpile_(code, path, this.transpilationTarget_);
  };


  /** @private @final {!goog.Transpiler} */
  goog.transpiler_ = new goog.Transpiler();

  /**
   * Rewrites closing script tags in input to avoid ending an enclosing script
   * tag.
   *
   * @param {string} str
   * @return {string}
   * @private
   */
  goog.protectScriptTag_ = function(str) {
    return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
  };


  /**
   * A debug loader is responsible for downloading and executing javascript
   * files in an unbundled, uncompiled environment.
   *
   * This can be custimized via the setDependencyFactory method, or by
   * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
   *
   * @struct @constructor @final @private
   */
  goog.DebugLoader_ = function() {
    /** @private @const {!Object<string, !goog.Dependency>} */
    this.dependencies_ = {};
    /** @private @const {!Object<string, string>} */
    this.idToPath_ = {};
    /** @private @const {!Object<string, boolean>} */
    this.written_ = {};
    /** @private @const {!Array<!goog.Dependency>} */
    this.loadingDeps_ = [];
    /** @private {!Array<!goog.Dependency>} */
    this.depsToLoad_ = [];
    /** @private {boolean} */
    this.paused_ = false;
    /** @private {!goog.DependencyFactory} */
    this.factory_ = new goog.DependencyFactory(goog.transpiler_);
    /** @private @const {!Object<string, !Function>} */
    this.deferredCallbacks_ = {};
    /** @private @const {!Array<string>} */
    this.deferredQueue_ = [];
  };

  /**
   * @param {!Array<string>} namespaces
   * @param {function(): undefined} callback Function to call once all the
   *     namespaces have loaded.
   */
  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
    var cb = callback;
    function resolve() {
      if (cb) {
        goog.global.setTimeout(cb, 0);
        cb = null;
      }
    }

    if (!namespaces.length) {
      resolve();
      return;
    }

    var deps = [];
    for (var i = 0; i < namespaces.length; i++) {
      var path = this.getPathFromDeps_(namespaces[i]);
      if (!path) {
        throw new Error('Unregonized namespace: ' + namespaces[i]);
      }
      deps.push(this.dependencies_[path]);
    }

    var require = goog.require;
    var loaded = 0;
    for (var i = 0; i < namespaces.length; i++) {
      require(namespaces[i]);
      deps[i].onLoad(function() {
        if (++loaded == namespaces.length) {
          resolve();
        }
      });
    }
  };


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.DebugLoader_.prototype.loadClosureDeps = function() {
    // Circumvent addDependency, which would try to transpile deps.js if
    // transpile is set to always.
    var relPath = 'deps.js';
    this.depsToLoad_.push(this.factory_.createDependency(
        goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {},
        false));
    this.loadDeps_();
  };


  /**
   * Notifies the debug loader when a dependency has been requested.
   *
   * @param {string} absPathOrId Path of the dependency or goog id.
   * @param {boolean=} opt_force
   */
  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
    var path = this.getPathFromDeps_(absPathOrId);
    if (path &&
        (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
      var callback = this.deferredCallbacks_[path];
      if (callback) {
        delete this.deferredCallbacks_[path];
        callback();
      }
    }
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
    this.factory_ = factory;
  };


  /**
   * Travserses the dependency graph and queues the given dependency, and all of
   * its transitive dependencies, for loading and then starts loading if not
   * paused.
   *
   * @param {string} namespace
   * @private
   */
  goog.DebugLoader_.prototype.load_ = function(namespace) {
    if (!this.getPathFromDeps_(namespace)) {
      var errorMessage = 'goog.require could not find: ' + namespace;

      goog.logToConsole_(errorMessage);
      throw Error(errorMessage);
    } else {
      var loader = this;

      var deps = [];

      /** @param {string} namespace */
      var visit = function(namespace) {
        var path = loader.getPathFromDeps_(namespace);

        if (!path) {
          throw new Error('Bad dependency path or symbol: ' + namespace);
        }

        if (loader.written_[path]) {
          return;
        }

        loader.written_[path] = true;

        var dep = loader.dependencies_[path];
        for (var i = 0; i < dep.requires.length; i++) {
          if (!goog.isProvided_(dep.requires[i])) {
            visit(dep.requires[i]);
          }
        }

        deps.push(dep);
      };

      visit(namespace);

      var wasLoading = !!this.depsToLoad_.length;
      this.depsToLoad_ = this.depsToLoad_.concat(deps);

      if (!this.paused_ && !wasLoading) {
        this.loadDeps_();
      }
    }
  };


  /**
   * Loads any queued dependencies until they are all loaded or paused.
   *
   * @private
   */
  goog.DebugLoader_.prototype.loadDeps_ = function() {
    var loader = this;
    var paused = this.paused_;

    while (this.depsToLoad_.length && !paused) {
      (function() {
        var loadCallDone = false;
        var dep = loader.depsToLoad_.shift();

        var loaded = false;
        loader.loading_(dep);

        var controller = {
          pause: function() {
            if (loadCallDone) {
              throw new Error('Cannot call pause after the call to load.');
            } else {
              paused = true;
            }
          },
          resume: function() {
            if (loadCallDone) {
              loader.resume_();
            } else {
              // Some dep called pause and then resume in the same load call.
              // Just keep running this same loop.
              paused = false;
            }
          },
          loaded: function() {
            if (loaded) {
              throw new Error('Double call to loaded.');
            }

            loaded = true;
            loader.loaded_(dep);
          },
          pending: function() {
            // Defensive copy.
            var pending = [];
            for (var i = 0; i < loader.loadingDeps_.length; i++) {
              pending.push(loader.loadingDeps_[i]);
            }
            return pending;
          },
          /**
           * @param {goog.ModuleType} type
           */
          setModuleState: function(type) {
            goog.moduleLoaderState_ = {
              type: type,
              moduleName: '',
              declareLegacyNamespace: false
            };
          },
          /** @type {function(string, string, string=)} */
          registerEs6ModuleExports: function(
              path, exports, opt_closureNamespace) {
            if (opt_closureNamespace) {
              goog.loadedModules_[opt_closureNamespace] = {
                exports: exports,
                type: goog.ModuleType.ES6,
                moduleId: opt_closureNamespace || ''
              };
            }
          },
          /** @type {function(string, ?)} */
          registerGoogModuleExports: function(moduleId, exports) {
            goog.loadedModules_[moduleId] = {
              exports: exports,
              type: goog.ModuleType.GOOG,
              moduleId: moduleId
            };
          },
          clearModuleState: function() {
            goog.moduleLoaderState_ = null;
          },
          defer: function(callback) {
            if (loadCallDone) {
              throw new Error(
                  'Cannot register with defer after the call to load.');
            }
            loader.defer_(dep, callback);
          },
          areDepsLoaded: function() {
            return loader.areDepsLoaded_(dep.requires);
          }
        };

        try {
          dep.load(controller);
        } finally {
          loadCallDone = true;
        }
      })();
    }

    if (paused) {
      this.pause_();
    }
  };


  /** @private */
  goog.DebugLoader_.prototype.pause_ = function() {
    this.paused_ = true;
  };


  /** @private */
  goog.DebugLoader_.prototype.resume_ = function() {
    if (this.paused_) {
      this.paused_ = false;
      this.loadDeps_();
    }
  };


  /**
   * Marks the given dependency as loading (load has been called but it has not
   * yet marked itself as finished). Useful for dependencies that want to know
   * what else is loading. Example: goog.modules cannot eval if there are
   * loading dependencies.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loading_ = function(dep) {
    this.loadingDeps_.push(dep);
  };


  /**
   * Marks the given dependency as having finished loading and being available
   * for require.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loaded_ = function(dep) {
    for (var i = 0; i < this.loadingDeps_.length; i++) {
      if (this.loadingDeps_[i] == dep) {
        this.loadingDeps_.splice(i, 1);
        break;
      }
    }

    for (var i = 0; i < this.deferredQueue_.length; i++) {
      if (this.deferredQueue_[i] == dep.path) {
        this.deferredQueue_.splice(i, 1);
        break;
      }
    }

    if (this.loadingDeps_.length == this.deferredQueue_.length &&
        !this.depsToLoad_.length) {
      // Something has asked to load these, but they may not be directly
      // required again later, so load them now that we know we're done loading
      // everything else. e.g. a goog module entry point.
      while (this.deferredQueue_.length) {
        this.requested(this.deferredQueue_.shift(), true);
      }
    }

    dep.loaded();
  };


  /**
   * @param {!Array<string>} pathsOrIds
   * @return {boolean}
   * @private
   */
  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
    for (var i = 0; i < pathsOrIds.length; i++) {
      var path = this.getPathFromDeps_(pathsOrIds[i]);
      if (!path ||
          (!(path in this.deferredCallbacks_) &&
           !goog.isProvided_(pathsOrIds[i]))) {
        return false;
      }
    }

    return true;
  };


  /**
   * @param {string} absPathOrId
   * @return {?string}
   * @private
   */
  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
    if (absPathOrId in this.idToPath_) {
      return this.idToPath_[absPathOrId];
    } else if (absPathOrId in this.dependencies_) {
      return absPathOrId;
    } else {
      return null;
    }
  };


  /**
   * @param {!goog.Dependency} dependency
   * @param {!Function} callback
   * @private
   */
  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
    this.deferredCallbacks_[dependency.path] = callback;
    this.deferredQueue_.push(dependency.path);
  };


  /**
   * Interface for goog.Dependency implementations to have some control over
   * loading of dependencies.
   *
   * @record
   */
  goog.LoadController = function() {};


  /**
   * Tells the controller to halt loading of more dependencies.
   */
  goog.LoadController.prototype.pause = function() {};


  /**
   * Tells the controller to resume loading of more dependencies if paused.
   */
  goog.LoadController.prototype.resume = function() {};


  /**
   * Tells the controller that this dependency has finished loading.
   *
   * This causes this to be removed from pending() and any load callbacks to
   * fire.
   */
  goog.LoadController.prototype.loaded = function() {};


  /**
   * List of dependencies on which load has been called but which have not
   * called loaded on their controller. This includes the current dependency.
   *
   * @return {!Array<!goog.Dependency>}
   */
  goog.LoadController.prototype.pending = function() {};


  /**
   * Registers an object as an ES6 module's exports so that goog.modules may
   * require it by path.
   *
   * @param {string} path Full path of the module.
   * @param {?} exports
   * @param {string=} opt_closureNamespace Closure namespace to associate with
   *     this module.
   */
  goog.LoadController.prototype.registerEs6ModuleExports = function(
      path, exports, opt_closureNamespace) {};


  /**
   * Sets the current module state.
   *
   * @param {goog.ModuleType} type Type of module.
   */
  goog.LoadController.prototype.setModuleState = function(type) {};


  /**
   * Clears the current module state.
   */
  goog.LoadController.prototype.clearModuleState = function() {};


  /**
   * Registers a callback to call once the dependency is actually requested
   * via goog.require + all of the immediate dependencies have been loaded or
   * all other files have been loaded. Allows for lazy loading until
   * require'd without pausing dependency loading, which is needed on old IE.
   *
   * @param {!Function} callback
   */
  goog.LoadController.prototype.defer = function(callback) {};


  /**
   * @return {boolean}
   */
  goog.LoadController.prototype.areDepsLoaded = function() {};


  /**
   * Basic super class for all dependencies Closure Library can load.
   *
   * This default implementation is designed to load untranspiled, non-module
   * scripts in a web broswer.
   *
   * For transpiled non-goog.module files {@see goog.TranspiledDependency}.
   * For goog.modules see {@see goog.GoogModuleDependency}.
   * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   */
  goog.Dependency = function(
      path, relativePath, provides, requires, loadFlags) {
    /** @const */
    this.path = path;
    /** @const */
    this.relativePath = relativePath;
    /** @const */
    this.provides = provides;
    /** @const */
    this.requires = requires;
    /** @const */
    this.loadFlags = loadFlags;
    /** @private {boolean} */
    this.loaded_ = false;
    /** @private {!Array<function()>} */
    this.loadCallbacks_ = [];
  };


  /**
   * @return {string} The pathname part of this dependency's path if it is a
   *     URI.
   */
  goog.Dependency.prototype.getPathName = function() {
    var pathName = this.path;
    var protocolIndex = pathName.indexOf('://');
    if (protocolIndex >= 0) {
      pathName = pathName.substring(protocolIndex + 3);
      var slashIndex = pathName.indexOf('/');
      if (slashIndex >= 0) {
        pathName = pathName.substring(slashIndex + 1);
      }
    }
    return pathName;
  };


  /**
   * @param {function()} callback Callback to fire as soon as this has loaded.
   * @final
   */
  goog.Dependency.prototype.onLoad = function(callback) {
    if (this.loaded_) {
      callback();
    } else {
      this.loadCallbacks_.push(callback);
    }
  };


  /**
   * Marks this dependency as loaded and fires any callbacks registered with
   * onLoad.
   * @final
   */
  goog.Dependency.prototype.loaded = function() {
    this.loaded_ = true;
    var callbacks = this.loadCallbacks_;
    this.loadCallbacks_ = [];
    for (var i = 0; i < callbacks.length; i++) {
      callbacks[i]();
    }
  };


  /**
   * Whether or not document.written / appended script tags should be deferred.
   *
   * @private {boolean}
   */
  goog.Dependency.defer_ = false;


  /**
   * Map of script ready / state change callbacks. Old IE cannot handle putting
   * these properties on goog.global.
   *
   * @private @const {!Object<string, function(?):undefined>}
   */
  goog.Dependency.callbackMap_ = {};


  /**
   * @param {function(...?):?} callback
   * @return {string}
   * @private
   */
  goog.Dependency.registerCallback_ = function(callback) {
    var key = Math.random().toString(32);
    goog.Dependency.callbackMap_[key] = callback;
    return key;
  };


  /**
   * @param {string} key
   * @private
   */
  goog.Dependency.unregisterCallback_ = function(key) {
    delete goog.Dependency.callbackMap_[key];
  };


  /**
   * @param {string} key
   * @param {...?} var_args
   * @private
   * @suppress {unusedPrivateMembers}
   */
  goog.Dependency.callback_ = function(key, var_args) {
    if (key in goog.Dependency.callbackMap_) {
      var callback = goog.Dependency.callbackMap_[key];
      var args = [];
      for (var i = 1; i < arguments.length; i++) {
        args.push(arguments[i]);
      }
      callback.apply(undefined, args);
    } else {
      var errorMessage = 'Callback key ' + key +
          ' does not exist (was base.js loaded more than once?).';
      throw Error(errorMessage);
    }
  };


  /**
   * Starts loading this dependency. This dependency can pause loading if it
   * needs to and resume it later via the controller interface.
   *
   * When this is loaded it should call controller.loaded(). Note that this will
   * end up calling the loaded method of this dependency; there is no need to
   * call it explicitly.
   *
   * @param {!goog.LoadController} controller
   */
  goog.Dependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      if (this.relativePath == 'deps.js') {
        // Some old code is relying on base.js auto loading deps.js failing with
        // no error before later setting CLOSURE_IMPORT_SCRIPT.
        // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
        // CLOSURE_NO_DEPS set to true.
        goog.logToConsole_(
            'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
            'or setting CLOSURE_NO_DEPS to true.');
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    // If the user tries to require a new symbol after document load,
    // something has gone terribly wrong. Doing a document.write would
    // wipe out the page. This does not apply to the CSP-compliant method
    // of writing script tags.
    if (doc.readyState == 'complete' &&
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
      // Certain test frameworks load base.js multiple times, which tries
      // to write deps.js each time. If that happens, just fail silently.
      // These frameworks wipe the page between each load of base.js, so this
      // is OK.
      var isDeps = /\bdeps.js$/.test(this.path);
      if (isDeps) {
        controller.loaded();
        return;
      } else {
        throw Error('Cannot write "' + this.path + '" after document load');
      }
    }

    if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
        goog.isDocumentLoading_()) {
      var key = goog.Dependency.registerCallback_(function(script) {
        if (!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {
          goog.Dependency.unregisterCallback_(key);
          controller.loaded();
        }
      });
      var nonceAttr = !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce() ?
          ' nonce="' + goog.getScriptNonce() + '"' :
          '';
      var event =
          goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';
      var defer = goog.Dependency.defer_ ? 'defer' : '';
      var script = '<script src="' + this.path + '" ' + event +
          '="goog.Dependency.callback_(\'' + key +
          '\', this)" type="text/javascript" ' + defer + nonceAttr + '><' +
          '/script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    } else {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = goog.Dependency.defer_;
      scriptEl.async = false;
      scriptEl.type = 'text/javascript';

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (goog.DebugLoader_.IS_OLD_IE_) {
        // Execution order is not guaranteed on old IE, halt loading and write
        // these scripts one at a time, after each loads.
        controller.pause();
        scriptEl.onreadystatechange = function() {
          if (scriptEl.readyState == 'loaded' ||
              scriptEl.readyState == 'complete') {
            controller.loaded();
            controller.resume();
          }
        };
      } else {
        scriptEl.onload = function() {
          scriptEl.onload = null;
          controller.loaded();
        };
      }

      scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
          goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) :
          this.path;
      doc.head.appendChild(scriptEl);
    }
  };


  /**
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides Should be an empty array.
   *     TODO(johnplaisted) add support for adding closure namespaces to ES6
   *     modules for interop purposes.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.Dependency}
   */
  goog.Es6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.Es6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.Es6ModuleDependency, goog.Dependency);


  /** @override */
  goog.Es6ModuleDependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      controller.pause();
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    var dep = this;

    // TODO(johnplaisted): Does document.writing really speed up anything? Any
    // difference between this and just waiting for interactive mode and then
    // appending?
    function write(src, contents) {
      if (contents) {
        var script = '<script type="module" crossorigin>' + contents + '</' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      } else {
        var script = '<script type="module" crossorigin src="' + src + '"></' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      }
    }

    function append(src, contents) {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = true;
      scriptEl.async = false;
      scriptEl.type = 'module';
      scriptEl.setAttribute('crossorigin', true);

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (contents) {
        scriptEl.textContent = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScript(contents) :
            contents;
      } else {
        scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) :
            src;
      }

      doc.head.appendChild(scriptEl);
    }

    var create;

    if (goog.isDocumentLoading_()) {
      create = write;
      // We can ONLY call document.write if we are guaranteed that any
      // non-module script tags document.written after this are deferred.
      // Small optimization, in theory document.writing is faster.
      goog.Dependency.defer_ = true;
    } else {
      create = append;
    }

    // Write 4 separate tags here:
    // 1) Sets the module state at the correct time (just before execution).
    // 2) A src node for this, which just hopefully lets the browser load it a
    //    little early (no need to parse #3).
    // 3) Import the module and register it.
    // 4) Clear the module state at the correct time. Guaranteed to run even
    //    if there is an error in the module (#3 will not run if there is an
    //    error in the module).
    var beforeKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(beforeKey);
      controller.setModuleState(goog.ModuleType.ES6);
    });
    create(undefined, 'goog.Dependency.callback_("' + beforeKey + '")');

    // TODO(johnplaisted): Does this really speed up anything?
    create(this.path, undefined);

    var registerKey = goog.Dependency.registerCallback_(function(exports) {
      goog.Dependency.unregisterCallback_(registerKey);
      controller.registerEs6ModuleExports(
          dep.path, exports, goog.moduleLoaderState_.moduleName);
    });
    create(
        undefined,
        'import * as m from "' + this.path + '"; goog.Dependency.callback_("' +
            registerKey + '", m)');

    var afterKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(afterKey);
      controller.clearModuleState();
      controller.loaded();
    });
    create(undefined, 'goog.Dependency.callback_("' + afterKey + '")');
  };


  /**
   * Superclass of any dependency that needs to be loaded into memory,
   * transformed, and then eval'd (goog.modules and transpiled files).
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor @abstract
   * @extends {goog.Dependency}
   */
  goog.TransformedDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.TransformedDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private {?string} */
    this.contents_ = null;

    /**
     * Whether to lazily make the synchronous XHR (when goog.require'd) or make
     * the synchronous XHR when initially loading. On FireFox 61 there is a bug
     * where an ES6 module cannot make a synchronous XHR (rather, it can, but if
     * it does then no other ES6 modules will load after).
     *
     * tl;dr we lazy load due to bugs on older browsers and eager load due to
     * bugs on newer ones.
     *
     * https://bugzilla.mozilla.org/show_bug.cgi?id=1477090
     *
     * @private @const {boolean}
     */
    this.lazyFetch_ = !goog.inHtmlDocument_() ||
        !('noModule' in goog.global.document.createElement('script'));
  };
  goog.inherits(goog.TransformedDependency, goog.Dependency);


  /** @override */
  goog.TransformedDependency.prototype.load = function(controller) {
    var dep = this;

    function fetch() {
      dep.contents_ = goog.loadFileSync_(dep.path);

      if (dep.contents_) {
        dep.contents_ = dep.transform(dep.contents_);
        if (dep.contents_) {
          dep.contents_ += '\n//# sourceURL=' + dep.path;
        }
      }
    }

    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      fetch();
      if (this.contents_ &&
          goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)) {
        this.contents_ = null;
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }


    var isEs6 = this.loadFlags['module'] == goog.ModuleType.ES6;

    if (!this.lazyFetch_) {
      fetch();
    }

    function load() {
      if (dep.lazyFetch_) {
        fetch();
      }

      if (!dep.contents_) {
        // loadFileSync_ or transform are responsible. Assume they logged an
        // error.
        return;
      }

      if (isEs6) {
        controller.setModuleState(goog.ModuleType.ES6);
      }

      var namespace;

      try {
        var contents = dep.contents_;
        dep.contents_ = null;
        goog.globalEval(contents);
        if (isEs6) {
          namespace = goog.moduleLoaderState_.moduleName;
        }
      } finally {
        if (isEs6) {
          controller.clearModuleState();
        }
      }

      if (isEs6) {
        // Due to circular dependencies this may not be available for require
        // right now.
        goog.global['$jscomp']['require']['ensure'](
            [dep.getPathName()], function() {
              controller.registerEs6ModuleExports(
                  dep.path,
                  goog.global['$jscomp']['require'](dep.getPathName()),
                  namespace);
            });
      }

      controller.loaded();
    }

    // Do not fetch now; in FireFox 47 the synchronous XHR doesn't block all
    // events. If we fetched now and then document.write'd the contents the
    // document.write would be an eval and would execute too soon! Instead write
    // a script tag to fetch and eval synchronously at the correct time.
    function fetchInOwnScriptThenLoad() {
      /** @type {!HTMLDocument} */
      var doc = goog.global.document;

      var key = goog.Dependency.registerCallback_(function() {
        goog.Dependency.unregisterCallback_(key);
        load();
      });

      var script = '<script type="text/javascript">' +
          goog.protectScriptTag_('goog.Dependency.callback_("' + key + '");') +
          '</' +
          'script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    }

    // If one thing is pending it is this.
    var anythingElsePending = controller.pending().length > 1;

    // If anything else is loading we need to lazy load due to bugs in old IE.
    // Specifically script tags with src and script tags with contents could
    // execute out of order if document.write is used, so we cannot use
    // document.write. Do not pause here; it breaks old IE as well.
    var useOldIeWorkAround =
        anythingElsePending && goog.DebugLoader_.IS_OLD_IE_;

    // Additionally if we are meant to defer scripts but the page is still
    // loading (e.g. an ES6 module is loading) then also defer. Or if we are
    // meant to defer and anything else is pending then defer (those may be
    // scripts that did not need transformation and are just script tags with
    // defer set to true, and we need to evaluate after that deferred script).
    var needsAsyncLoading = goog.Dependency.defer_ &&
        (anythingElsePending || goog.isDocumentLoading_());

    if (useOldIeWorkAround || needsAsyncLoading) {
      // Note that we only defer when we have to rather than 100% of the time.
      // Always defering would work, but then in theory the order of
      // goog.require calls would then matter. We want to enforce that most of
      // the time the order of the require calls does not matter.
      controller.defer(function() {
        load();
      });
      return;
    }
    // TODO(johnplaisted): Externs are missing onreadystatechange for
    // HTMLDocument.
    /** @type {?} */
    var doc = goog.global.document;

    var isInternetExplorer =
        goog.inHtmlDocument_() && 'ActiveXObject' in goog.global;

    // Don't delay in any version of IE. There's bug around this that will
    // cause out of order script execution. This means that on older IE ES6
    // modules will load too early (while the document is still loading + the
    // dom is not available). The other option is to load too late (when the
    // document is complete and the onload even will never fire). This seems
    // to be the lesser of two evils as scripts already act like the former.
    if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() &&
        !isInternetExplorer) {
      goog.Dependency.defer_ = true;
      // Transpiled ES6 modules still need to load like regular ES6 modules,
      // aka only after the document is interactive.
      controller.pause();
      var oldCallback = doc.onreadystatechange;
      doc.onreadystatechange = function() {
        if (doc.readyState == 'interactive') {
          doc.onreadystatechange = oldCallback;
          load();
          controller.resume();
        }
        if (goog.isFunction(oldCallback)) {
          oldCallback.apply(undefined, arguments);
        }
      };
    } else {
      // Always eval on old IE.
      if (goog.DebugLoader_.IS_OLD_IE_ || !goog.inHtmlDocument_() ||
          !goog.isDocumentLoading_()) {
        load();
      } else {
        fetchInOwnScriptThenLoad();
      }
    }
  };


  /**
   * @param {string} contents
   * @return {string}
   * @abstract
   */
  goog.TransformedDependency.prototype.transform = function(contents) {};


  /**
   * Any non-goog.module dependency which needs to be transpiled before eval.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.TranspiledDependency = function(
      path, relativePath, provides, requires, loadFlags, transpiler) {
    goog.TranspiledDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @protected @const*/
    this.transpiler = transpiler;
  };
  goog.inherits(goog.TranspiledDependency, goog.TransformedDependency);


  /** @override */
  goog.TranspiledDependency.prototype.transform = function(contents) {
    // Transpile with the pathname so that ES6 modules are domain agnostic.
    return this.transpiler.transpile(contents, this.getPathName());
  };


  /**
   * An ES6 module dependency that was transpiled to a jscomp module outside
   * of the debug loader, e.g. server side.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.PreTranspiledEs6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.PreTranspiledEs6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(
      goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(
      contents) {
    return contents;
  };


  /**
   * A goog.module, transpiled or not. Will always perform some minimal
   * transformation even when not transpiled to wrap in a goog.loadModule
   * statement.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.GoogModuleDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile,
      transpiler) {
    goog.GoogModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private @const */
    this.needsTranspile_ = needsTranspile;
    /** @private @const */
    this.transpiler_ = transpiler;
  };
  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.GoogModuleDependency.prototype.transform = function(contents) {
    if (this.needsTranspile_) {
      contents = this.transpiler_.transpile(contents, this.getPathName());
    }

    if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {
      return '' +
          'goog.loadModule(function(exports) {' +
          '"use strict";' + contents +
          '\n' +  // terminate any trailing single line comment.
          ';return exports' +
          '});' +
          '\n//# sourceURL=' + this.path + '\n';
    } else {
      return '' +
          'goog.loadModule(' +
          goog.global.JSON.stringify(
              contents + '\n//# sourceURL=' + this.path + '\n') +
          ');';
    }
  };


  /**
   * Whether the browser is IE9 or earlier, which needs special handling
   * for deferred modules.
   * @const @private {boolean}
   */
  goog.DebugLoader_.IS_OLD_IE_ = !!(
      !goog.global.atob && goog.global.document && goog.global.document['all']);


  /**
   * @param {string} relPath
   * @param {!Array<string>|undefined} provides
   * @param {!Array<string>} requires
   * @param {boolean|!Object<string>=} opt_loadFlags
   * @see goog.addDependency
   */
  goog.DebugLoader_.prototype.addDependency = function(
      relPath, provides, requires, opt_loadFlags) {
    provides = provides || [];
    relPath = relPath.replace(/\\/g, '/');
    var path = goog.normalizePath_(goog.basePath + relPath);
    if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {
      opt_loadFlags = opt_loadFlags ? {'module': goog.ModuleType.GOOG} : {};
    }
    var dep = this.factory_.createDependency(
        path, relPath, provides, requires, opt_loadFlags,
        goog.transpiler_.needsTranspile(
            opt_loadFlags['lang'] || 'es3', opt_loadFlags['module']));
    this.dependencies_[path] = dep;
    for (var i = 0; i < provides.length; i++) {
      this.idToPath_[provides[i]] = path;
    }
    this.idToPath_[relPath] = path;
  };


  /**
   * Creates goog.Dependency instances for the debug loader to load.
   *
   * Should be overridden to have the debug loader use custom subclasses of
   * goog.Dependency.
   *
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   */
  goog.DependencyFactory = function(transpiler) {
    /** @protected @const */
    this.transpiler = transpiler;
  };


  /**
   * @param {string} path Absolute path of the file.
   * @param {string} relativePath Path relative to closure’s base.js.
   * @param {!Array<string>} provides Array of provided goog.provide/module ids.
   * @param {!Array<string>} requires Array of required goog.provide/module /
   *     relative ES6 module paths.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile True if the file needs to be transpiled
   *     per the goog.Transpiler.
   * @return {!goog.Dependency}
   */
  goog.DependencyFactory.prototype.createDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile) {

    if (loadFlags['module'] == goog.ModuleType.GOOG) {
      return new goog.GoogModuleDependency(
          path, relativePath, provides, requires, loadFlags, needsTranspile,
          this.transpiler);
    } else if (needsTranspile) {
      return new goog.TranspiledDependency(
          path, relativePath, provides, requires, loadFlags, this.transpiler);
    } else {
      if (loadFlags['module'] == goog.ModuleType.ES6) {
        if (goog.TRANSPILE == 'never' && goog.ASSUME_ES_MODULES_TRANSPILED) {
          return new goog.PreTranspiledEs6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        } else {
          return new goog.Es6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        }
      } else {
        return new goog.Dependency(
            path, relativePath, provides, requires, loadFlags);
      }
    }
  };


  /** @private @const */
  goog.debugLoader_ = new goog.DebugLoader_();


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.loadClosureDeps = function() {
    goog.debugLoader_.loadClosureDeps();
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * Note: if you wish to call this function and provide your own implemnetation
   * it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency
   * file and all of its goog.addDependency calls will use the default factory.
   * You can call goog.loadClosureDeps to load the Closure dependency file
   * later, after your factory is injected.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.setDependencyFactory = function(factory) {
    goog.debugLoader_.setDependencyFactory(factory);
  };


  if (!goog.global.CLOSURE_NO_DEPS) {
    goog.debugLoader_.loadClosureDeps();
  }


  /**
   * Bootstraps the given namespaces and calls the callback once they are
   * available either via goog.require. This is a replacement for using
   * `goog.require` to bootstrap Closure JavaScript. Previously a `goog.require`
   * in an HTML file would guarantee that the require'd namespace was available
   * in the next immediate script tag. With ES6 modules this no longer a
   * guarantee.
   *
   * @param {!Array<string>} namespaces
   * @param {function(): ?} callback Function to call once all the namespaces
   *     have loaded. Always called asynchronously.
   */
  goog.bootstrap = function(namespaces, callback) {
    goog.debugLoader_.bootstrap(namespaces, callback);
  };
}


/**
 * @define {string} Trusted Types policy name. If non-empty then Closure will
 * use Trusted Types.
 */
goog.TRUSTED_TYPES_POLICY_NAME =
    goog.define('goog.TRUSTED_TYPES_POLICY_NAME', '');


/**
 * Returns the parameter.
 * @param {string} s
 * @return {string}
 * @private
 */
goog.identity_ = function(s) {
  return s;
};


/**
 * Creates Trusted Types policy if Trusted Types are supported by the browser.
 * The policy just blesses any string as a Trusted Type. It is not visibility
 * restricted because anyone can also call TrustedTypes.createPolicy directly.
 * However, the allowed names should be restricted by a HTTP header and the
 * reference to the created policy should be visibility restricted.
 * @param {string} name
 * @return {?TrustedTypePolicy}
 */
goog.createTrustedTypesPolicy = function(name) {
  var policy = null;
  // TODO(koto): Remove window.TrustedTypes variant when the newer API ships.
  var policyFactory = goog.global.trustedTypes || goog.global.TrustedTypes;
  if (!policyFactory || !policyFactory.createPolicy) {
    return policy;
  }
  // TrustedTypes.createPolicy throws if called with a name that is already
  // registered, even in report-only mode. Until the API changes, catch the
  // error not to break the applications functionally. In such case, the code
  // will fall back to using regular Safe Types.
  // TODO(koto): Remove catching once createPolicy API stops throwing.
  try {
    policy = policyFactory.createPolicy(name, {
      createHTML: goog.identity_,
      createScript: goog.identity_,
      createScriptURL: goog.identity_,
      createURL: goog.identity_
    });
  } catch (e) {
    goog.logToConsole_(e.message);
  }
  return policy;
};


/** @private @const {?TrustedTypePolicy} */
goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ?
    goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base') :
    null;

// Copyright 2019 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// This file has been auto-generated by GenJsDeps, please do not edit.

// Disable Clang formatter for this file.
// See http://goo.gl/SdiwZH
// clang-format off

goog.addDependency('collections/sets.js', ['goog.collections.sets'], ['goog.labs.collections.iterables'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('collections/sets_test.js', ['goog.collections.setsTest'], ['goog.collections.sets', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred.js', ['goog.async.Deferred', 'goog.async.Deferred.AlreadyCalledError', 'goog.async.Deferred.CanceledError'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_async_test.js', ['goog.async.deferredAsyncTest'], ['goog.async.Deferred', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_test.js', ['goog.async.deferredTest'], ['goog.Promise', 'goog.Thenable', 'goog.async.Deferred', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist.js', ['goog.async.DeferredList'], ['goog.async.Deferred'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist_test.js', ['goog.async.deferredListTest'], ['goog.array', 'goog.async.Deferred', 'goog.async.DeferredList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto/proto.js', ['goog.proto'], ['goog.proto.Serializer'], {});
goog.addDependency('proto/serializer.js', ['goog.proto.Serializer'], ['goog.json.Serializer', 'goog.string'], {});
goog.addDependency('proto/serializer_test.js', ['goog.protoTest'], ['goog.proto', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/announcer.js', ['goog.a11y.aria.Announcer'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.object'], {});
goog.addDependency('a11y/aria/announcer_test.js', ['goog.a11y.aria.AnnouncerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/aria.js', ['goog.a11y.aria'], ['goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.a11y.aria.datatables', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.string'], {});
goog.addDependency('a11y/aria/aria_test.js', ['goog.a11y.ariaTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/attributes.js', ['goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.CheckedValues', 'goog.a11y.aria.DropEffectValues', 'goog.a11y.aria.ExpandedValues', 'goog.a11y.aria.GrabbedValues', 'goog.a11y.aria.InvalidValues', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.OrientationValues', 'goog.a11y.aria.PressedValues', 'goog.a11y.aria.RelevantValues', 'goog.a11y.aria.SelectedValues', 'goog.a11y.aria.SortValues', 'goog.a11y.aria.State'], [], {});
goog.addDependency('a11y/aria/datatables.js', ['goog.a11y.aria.datatables'], ['goog.a11y.aria.State', 'goog.object'], {});
goog.addDependency('a11y/aria/roles.js', ['goog.a11y.aria.Role'], [], {});
goog.addDependency('array/array.js', ['goog.array'], ['goog.asserts'], {});
goog.addDependency('array/array_test.js', ['goog.arrayTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es7', 'module': 'goog'});
goog.addDependency('asserts/asserts.js', ['goog.asserts', 'goog.asserts.AssertionError'], ['goog.debug.Error', 'goog.dom.NodeType'], {});
goog.addDependency('asserts/asserts_test.js', ['goog.assertsTest'], ['goog.asserts', 'goog.asserts.AssertionError', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.string', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/animationdelay.js', ['goog.async.AnimationDelay'], ['goog.Disposable', 'goog.events', 'goog.functions'], {});
goog.addDependency('async/animationdelay_test.js', ['goog.async.AnimationDelayTest'], ['goog.Promise', 'goog.Timer', 'goog.async.AnimationDelay', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/conditionaldelay.js', ['goog.async.ConditionalDelay'], ['goog.Disposable', 'goog.async.Delay'], {});
goog.addDependency('async/conditionaldelay_test.js', ['goog.async.ConditionalDelayTest'], ['goog.async.ConditionalDelay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/debouncer.js', ['goog.async.Debouncer'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/debouncer_test.js', ['goog.async.DebouncerTest'], ['goog.array', 'goog.async.Debouncer', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/delay.js', ['goog.Delay', 'goog.async.Delay'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/delay_test.js', ['goog.async.DelayTest'], ['goog.async.Delay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/freelist.js', ['goog.async.FreeList'], [], {'lang': 'es6'});
goog.addDependency('async/freelist_test.js', ['goog.async.FreeListTest'], ['goog.async.FreeList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/nexttick.js', ['goog.async.nextTick', 'goog.async.throwException'], ['goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.string.Const'], {});
goog.addDependency('async/nexttick_test.js', ['goog.async.nextTickTest'], ['goog.Promise', 'goog.async.nextTick', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run.js', ['goog.async.run'], ['goog.async.WorkQueue', 'goog.async.nextTick', 'goog.async.throwException'], {});
goog.addDependency('async/run_next_tick_test.js', ['goog.async.runNextTickTest'], ['goog.async.run', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run_test.js', ['goog.async.runTest'], ['goog.async.run', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/throttle.js', ['goog.Throttle', 'goog.async.Throttle'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/throttle_test.js', ['goog.async.ThrottleTest'], ['goog.async.Throttle', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/workqueue.js', ['goog.async.WorkItem', 'goog.async.WorkQueue'], ['goog.asserts', 'goog.async.FreeList'], {});
goog.addDependency('async/workqueue_test.js', ['goog.async.WorkQueueTest'], ['goog.async.WorkQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base.js', ['goog'], [], {});
goog.addDependency('base_module_test.js', ['goog.baseModuleTest'], ['goog.Timer', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base_test.js', ['goog.baseTest'], ['goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.recordFunction', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('color/alpha.js', ['goog.color.alpha'], ['goog.color'], {});
goog.addDependency('color/alpha_test.js', ['goog.color.alphaTest'], ['goog.array', 'goog.color.alpha', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/color.js', ['goog.color', 'goog.color.Hsl', 'goog.color.Hsv', 'goog.color.Rgb'], ['goog.color.names', 'goog.math'], {});
goog.addDependency('color/color_test.js', ['goog.colorTest'], ['goog.array', 'goog.color', 'goog.color.names', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/names.js', ['goog.color.names'], [], {});
goog.addDependency('crypt/aes.js', ['goog.crypt.Aes'], ['goog.asserts', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/aes_test.js', ['goog.crypt.AesTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/arc4.js', ['goog.crypt.Arc4'], ['goog.asserts'], {});
goog.addDependency('crypt/arc4_test.js', ['goog.crypt.Arc4Test'], ['goog.array', 'goog.crypt.Arc4', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/base64.js', ['goog.crypt.base64'], ['goog.asserts', 'goog.crypt', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es5'});
goog.addDependency('crypt/base64_test.js', ['goog.crypt.base64Test'], ['goog.crypt', 'goog.crypt.base64', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/basen.js', ['goog.crypt.baseN'], [], {'lang': 'es6'});
goog.addDependency('crypt/basen_test.js', ['goog.crypt.baseNTest'], ['goog.crypt.baseN', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blobhasher.js', ['goog.crypt.BlobHasher', 'goog.crypt.BlobHasher.EventType'], ['goog.asserts', 'goog.events.EventTarget', 'goog.fs', 'goog.log'], {});
goog.addDependency('crypt/blobhasher_test.js', ['goog.crypt.BlobHasherTest'], ['goog.crypt', 'goog.crypt.BlobHasher', 'goog.crypt.Md5', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blockcipher.js', ['goog.crypt.BlockCipher'], [], {});
goog.addDependency('crypt/bytestring_perf.js', ['goog.crypt.byteArrayToStringPerf'], ['goog.array', 'goog.dom', 'goog.testing.PerformanceTable'], {});
goog.addDependency('crypt/cbc.js', ['goog.crypt.Cbc'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/cbc_test.js', ['goog.crypt.CbcTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Cbc', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/crypt.js', ['goog.crypt'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('crypt/crypt_test.js', ['goog.cryptTest'], ['goog.crypt', 'goog.string', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/ctr.js', ['goog.crypt.Ctr'], ['goog.array', 'goog.asserts', 'goog.crypt'], {});
goog.addDependency('crypt/ctr_test.js', ['goog.crypt.CtrTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Ctr', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('crypt/hash.js', ['goog.crypt.Hash'], [], {});
goog.addDependency('crypt/hash32.js', ['goog.crypt.hash32'], ['goog.crypt'], {});
goog.addDependency('crypt/hash32_test.js', ['goog.crypt.hash32Test'], ['goog.crypt.hash32', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/hashtester.js', ['goog.crypt.hashTester'], ['goog.array', 'goog.crypt', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.testing.PerformanceTable', 'goog.testing.PseudoRandom', 'goog.testing.asserts'], {});
goog.addDependency('crypt/hmac.js', ['goog.crypt.Hmac'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/hmac_test.js', ['goog.crypt.HmacTest'], ['goog.crypt.Hmac', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/md5.js', ['goog.crypt.Md5'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/md5_test.js', ['goog.crypt.Md5Test'], ['goog.crypt', 'goog.crypt.Md5', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/pbkdf2.js', ['goog.crypt.pbkdf2'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.Hmac', 'goog.crypt.Sha1'], {});
goog.addDependency('crypt/pbkdf2_test.js', ['goog.crypt.pbkdf2Test'], ['goog.crypt', 'goog.crypt.pbkdf2', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha1.js', ['goog.crypt.Sha1'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/sha1_test.js', ['goog.crypt.Sha1Test'], ['goog.crypt', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2.js', ['goog.crypt.Sha2'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash'], {});
goog.addDependency('crypt/sha224.js', ['goog.crypt.Sha224'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha224_test.js', ['goog.crypt.Sha224Test'], ['goog.crypt', 'goog.crypt.Sha224', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha256.js', ['goog.crypt.Sha256'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha256_test.js', ['goog.crypt.Sha256Test'], ['goog.crypt', 'goog.crypt.Sha256', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2_64bit.js', ['goog.crypt.Sha2_64bit'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash', 'goog.math.Long'], {});
goog.addDependency('crypt/sha2_64bit_test.js', ['goog.crypt.Sha2_64bit_test'], ['goog.array', 'goog.crypt', 'goog.crypt.Sha384', 'goog.crypt.Sha512', 'goog.crypt.Sha512_256', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha384.js', ['goog.crypt.Sha384'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512.js', ['goog.crypt.Sha512'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512_256.js', ['goog.crypt.Sha512_256'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('cssom/cssom.js', ['goog.cssom', 'goog.cssom.CssRuleType'], ['goog.array', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('cssom/cssom_test.js', ['goog.cssomTest'], ['goog.array', 'goog.cssom', 'goog.cssom.CssRuleType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('cssom/iframe/style.js', ['goog.cssom.iframe.style'], ['goog.asserts', 'goog.cssom', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('cssom/iframe/style_test.js', ['goog.cssom.iframe.styleTest'], ['goog.cssom', 'goog.cssom.iframe.style', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/datamanager.js', ['goog.ds.DataManager'], ['goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.Expr', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map'], {});
goog.addDependency('datasource/datasource.js', ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState', 'goog.ds.SortedNodeList', 'goog.ds.Util', 'goog.ds.logger'], ['goog.array', 'goog.log'], {});
goog.addDependency('datasource/datasource_test.js', ['goog.ds.JsDataSourceTest'], ['goog.dom.xml', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.SortedNodeList', 'goog.ds.XmlDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/expr.js', ['goog.ds.Expr'], ['goog.ds.BasicNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/expr_test.js', ['goog.ds.ExprTest'], ['goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.JsDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/fastdatanode.js', ['goog.ds.AbstractFastDataNode', 'goog.ds.FastDataNode', 'goog.ds.FastListNode', 'goog.ds.PrimitiveFastDataNode'], ['goog.ds.DataManager', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/fastdatanode_test.js', ['goog.ds.FastDataNodeTest'], ['goog.array', 'goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.FastDataNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/jsdatasource.js', ['goog.ds.JsDataSource', 'goog.ds.JsPropertyDataSource'], ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState'], {});
goog.addDependency('datasource/jsondatasource.js', ['goog.ds.JsonDataSource'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log'], {});
goog.addDependency('datasource/jsxmlhttpdatasource.js', ['goog.ds.JsXmlHttpDataSource'], ['goog.Uri', 'goog.ds.DataManager', 'goog.ds.FastDataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.events', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('datasource/jsxmlhttpdatasource_test.js', ['goog.ds.JsXmlHttpDataSourceTest'], ['goog.ds.JsXmlHttpDataSource', 'goog.testing.TestQueue', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/xmldatasource.js', ['goog.ds.XmlDataSource', 'goog.ds.XmlHttpDataSource'], ['goog.Uri', 'goog.dom.NodeType', 'goog.dom.xml', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log', 'goog.net.XhrIo', 'goog.string'], {});
goog.addDependency('date/date.js', ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay'], ['goog.asserts', 'goog.date.DateLike', 'goog.i18n.DateTimeSymbols', 'goog.string'], {});
goog.addDependency('date/date_test.js', ['goog.dateTest'], ['goog.array', 'goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay', 'goog.i18n.DateTimeSymbols', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/datelike.js', ['goog.date.DateLike'], [], {});
goog.addDependency('date/daterange.js', ['goog.date.DateRange', 'goog.date.DateRange.Iterator', 'goog.date.DateRange.StandardDateRangeKeys'], ['goog.date.Date', 'goog.date.Interval', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('date/daterange_test.js', ['goog.date.DateRangeTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.i18n.DateTimeSymbols', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/duration.js', ['goog.date.duration'], ['goog.i18n.DateTimeFormat', 'goog.i18n.MessageFormat'], {});
goog.addDependency('date/duration_test.js', ['goog.date.durationTest'], ['goog.date.duration', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relative.js', ['goog.date.relative', 'goog.date.relative.TimeDeltaFormatter', 'goog.date.relative.Unit'], ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.RelativeDateTimeFormat'], {});
goog.addDependency('date/relative_test.js', ['goog.date.relativeTest'], ['goog.date.relativeCommonTests'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relativecommontests.js', ['goog.date.relativeCommonTests'], ['goog.date.DateTime', 'goog.date.relative', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.relativeDateTimeSymbols', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('date/utcdatetime.js', ['goog.date.UtcDateTime'], ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval'], {});
goog.addDependency('date/utcdatetime_test.js', ['goog.date.UtcDateTimeTest'], ['goog.date.Interval', 'goog.date.UtcDateTime', 'goog.date.month', 'goog.date.weekDay', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/cursor.js', ['goog.db.Cursor'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug', 'goog.events.EventTarget'], {});
goog.addDependency('db/db.js', ['goog.db', 'goog.db.BlockedCallback', 'goog.db.UpgradeNeededCallback'], ['goog.asserts', 'goog.async.Deferred', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.Transaction'], {});
goog.addDependency('db/db_test.js', ['goog.dbTest'], ['goog.Promise', 'goog.array', 'goog.db', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.KeyRange', 'goog.db.Transaction', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/error.js', ['goog.db.DomErrorLike', 'goog.db.Error', 'goog.db.Error.ErrorCode', 'goog.db.Error.ErrorName', 'goog.db.Error.VersionChangeBlockedError'], ['goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('db/index.js', ['goog.db.Index'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/indexeddb.js', ['goog.db.IndexedDb'], ['goog.db.Error', 'goog.db.ObjectStore', 'goog.db.Transaction', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget'], {'lang': 'es6'});
goog.addDependency('db/keyrange.js', ['goog.db.KeyRange'], [], {});
goog.addDependency('db/objectstore.js', ['goog.db.ObjectStore'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.Index', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/transaction.js', ['goog.db.Transaction', 'goog.db.Transaction.TransactionMode'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.ObjectStore', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget'], {});
goog.addDependency('debug/console.js', ['goog.debug.Console'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.debug.TextFormatter'], {});
goog.addDependency('debug/console_test.js', ['goog.debug.ConsoleTest'], ['goog.debug.Console', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debug.js', ['goog.debug'], ['goog.array', 'goog.debug.errorcontext', 'goog.userAgent'], {});
goog.addDependency('debug/debug_test.js', ['goog.debugTest'], ['goog.debug', 'goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debugwindow.js', ['goog.debug.DebugWindow'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.structs.CircularBuffer', 'goog.userAgent'], {});
goog.addDependency('debug/debugwindow_test.js', ['goog.debug.DebugWindowTest'], ['goog.debug.DebugWindow', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcss.js', ['goog.debug.DevCss', 'goog.debug.DevCss.UserAgent'], ['goog.asserts', 'goog.cssom', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('debug/devcss/devcss_test.js', ['goog.debug.DevCssTest'], ['goog.debug.DevCss', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcssrunner.js', ['goog.debug.devCssRunner'], ['goog.debug.DevCss'], {});
goog.addDependency('debug/divconsole.js', ['goog.debug.DivConsole'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.style'], {});
goog.addDependency('debug/enhanceerror_test.js', ['goog.debugEnhanceErrorTest'], ['goog.debug', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/entrypointregistry.js', ['goog.debug.EntryPointMonitor', 'goog.debug.entryPointRegistry'], ['goog.asserts'], {});
goog.addDependency('debug/entrypointregistry_test.js', ['goog.debug.entryPointRegistryTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/error.js', ['goog.debug.Error'], [], {'lang': 'es6'});
goog.addDependency('debug/error_test.js', ['goog.debug.ErrorTest'], ['goog.debug.Error', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorcontext.js', ['goog.debug.errorcontext'], [], {});
goog.addDependency('debug/errorcontext_test.js', ['goog.debug.errorcontextTest'], ['goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandler.js', ['goog.debug.ErrorHandler', 'goog.debug.ErrorHandler.ProtectedFunctionError'], ['goog.Disposable', 'goog.asserts', 'goog.debug', 'goog.debug.EntryPointMonitor', 'goog.debug.Error', 'goog.debug.Trace'], {'lang': 'es6'});
goog.addDependency('debug/errorhandler_async_test.js', ['goog.debug.ErrorHandlerAsyncTest'], ['goog.Promise', 'goog.debug.ErrorHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('debug/errorhandler_test.js', ['goog.debug.ErrorHandlerTest'], ['goog.debug.ErrorHandler', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandlerweakdep.js', ['goog.debug.errorHandlerWeakDep'], [], {});
goog.addDependency('debug/errorreporter.js', ['goog.debug.ErrorReporter', 'goog.debug.ErrorReporter.ExceptionEvent'], ['goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.debug.errorcontext', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log', 'goog.net.XhrIo', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('debug/errorreporter_test.js', ['goog.debug.ErrorReporterTest'], ['goog.debug.Error', 'goog.debug.ErrorReporter', 'goog.debug.errorcontext', 'goog.events', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fancywindow.js', ['goog.debug.FancyWindow'], ['goog.array', 'goog.asserts', 'goog.debug.DebugWindow', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('debug/formatter.js', ['goog.debug.Formatter', 'goog.debug.HtmlFormatter', 'goog.debug.TextFormatter'], ['goog.debug', 'goog.debug.Logger', 'goog.debug.RelativeTimeProvider', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.string.Const'], {});
goog.addDependency('debug/formatter_test.js', ['goog.debug.FormatterTest'], ['goog.debug.HtmlFormatter', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fpsdisplay.js', ['goog.debug.FpsDisplay'], ['goog.asserts', 'goog.async.AnimationDelay', 'goog.dom', 'goog.dom.TagName', 'goog.ui.Component'], {});
goog.addDependency('debug/fpsdisplay_test.js', ['goog.debug.FpsDisplayTest'], ['goog.Timer', 'goog.debug.FpsDisplay', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logbuffer.js', ['goog.debug.LogBuffer'], ['goog.asserts', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logbuffer_test.js', ['goog.debug.LogBufferTest'], ['goog.debug.LogBuffer', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logger.js', ['goog.debug.LogManager', 'goog.debug.Loggable', 'goog.debug.Logger', 'goog.debug.Logger.Level'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.LogBuffer', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logger_test.js', ['goog.debug.LoggerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logrecord.js', ['goog.debug.LogRecord'], [], {});
goog.addDependency('debug/logrecordserializer.js', ['goog.debug.logRecordSerializer'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.json', 'goog.object'], {});
goog.addDependency('debug/logrecordserializer_test.js', ['goog.debug.logRecordSerializerTest'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.debug.logRecordSerializer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/relativetimeprovider.js', ['goog.debug.RelativeTimeProvider'], [], {});
goog.addDependency('debug/tracer.js', ['goog.debug.StopTraceDetail', 'goog.debug.Trace'], ['goog.array', 'goog.asserts', 'goog.debug.Logger', 'goog.iter', 'goog.log', 'goog.structs.Map', 'goog.structs.SimplePool'], {});
goog.addDependency('debug/tracer_test.js', ['goog.debug.TraceTest'], ['goog.array', 'goog.debug.Trace', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('defineclass_test.js', ['goog.defineClassTest'], ['goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry.js', ['goog.delegate.DelegateRegistry'], ['goog.array', 'goog.asserts', 'goog.debug'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry_test.js', ['goog.delegate.DelegateRegistryTest'], ['goog.array', 'goog.delegate.DelegateRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates.js', ['goog.delegate.delegates'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates_test.js', ['goog.delegate.delegatesTest'], ['goog.delegate.delegates', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/disposable.js', ['goog.Disposable', 'goog.dispose', 'goog.disposeAll'], ['goog.disposable.IDisposable'], {});
goog.addDependency('disposable/disposable_test.js', ['goog.DisposableTest'], ['goog.Disposable', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/idisposable.js', ['goog.disposable.IDisposable'], [], {});
goog.addDependency('dom/abstractmultirange.js', ['goog.dom.AbstractMultiRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.TextRange'], {});
goog.addDependency('dom/abstractrange.js', ['goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.SavedCaretRange', 'goog.dom.TagIterator', 'goog.userAgent'], {});
goog.addDependency('dom/abstractrange_test.js', ['goog.dom.AbstractRangeTest'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.Range', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/animationframe.js', ['goog.dom.animationFrame', 'goog.dom.animationFrame.Spec', 'goog.dom.animationFrame.State'], ['goog.dom.animationFrame.polyfill'], {});
goog.addDependency('dom/animationframe/animationframe_test.js', ['goog.dom.AnimationFrameTest'], ['goog.dom.animationFrame', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/polyfill.js', ['goog.dom.animationFrame.polyfill'], [], {'lang': 'es6'});
goog.addDependency('dom/annotate.js', ['goog.dom.annotate', 'goog.dom.annotate.AnnotateFn'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.object'], {});
goog.addDependency('dom/annotate_test.js', ['goog.dom.annotateTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.annotate', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/asserts.js', ['goog.dom.asserts'], ['goog.asserts'], {});
goog.addDependency('dom/asserts_test.js', ['goog.dom.assertsTest'], ['goog.dom.asserts', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/attr.js', ['goog.dom.Attr'], [], {});
goog.addDependency('dom/browserfeature.js', ['goog.dom.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('dom/browserfeature_test.js', ['goog.dom.BrowserFeatureTest'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/abstractrange.js', ['goog.dom.browserrange.AbstractRange'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter', 'goog.math.Coordinate', 'goog.string', 'goog.string.StringBuffer', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange.js', ['goog.dom.browserrange', 'goog.dom.browserrange.Error'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.browserrange.GeckoRange', 'goog.dom.browserrange.IeRange', 'goog.dom.browserrange.OperaRange', 'goog.dom.browserrange.W3cRange', 'goog.dom.browserrange.WebKitRange', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange_test.js', ['goog.dom.browserrangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange', 'goog.html.testing', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/geckorange.js', ['goog.dom.browserrange.GeckoRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/ierange.js', ['goog.dom.browserrange.IeRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string'], {});
goog.addDependency('dom/browserrange/operarange.js', ['goog.dom.browserrange.OperaRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/w3crange.js', ['goog.dom.browserrange.W3cRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/webkitrange.js', ['goog.dom.browserrange.WebKitRange'], ['goog.dom.RangeEndpoint', 'goog.dom.browserrange.W3cRange', 'goog.userAgent'], {});
goog.addDependency('dom/bufferedviewportsizemonitor.js', ['goog.dom.BufferedViewportSizeMonitor'], ['goog.asserts', 'goog.async.Delay', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('dom/bufferedviewportsizemonitor_test.js', ['goog.dom.BufferedViewportSizeMonitorTest'], ['goog.dom.BufferedViewportSizeMonitor', 'goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classes.js', ['goog.dom.classes'], ['goog.array'], {});
goog.addDependency('dom/classes_test.js', ['goog.dom.classes_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classlist.js', ['goog.dom.classlist'], ['goog.array'], {});
goog.addDependency('dom/classlist_test.js', ['goog.dom.classlist_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/controlrange.js', ['goog.dom.ControlRange', 'goog.dom.ControlRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagWalkType', 'goog.dom.TextRange', 'goog.iter.StopIteration', 'goog.userAgent'], {});
goog.addDependency('dom/controlrange_test.js', ['goog.dom.ControlRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dataset.js', ['goog.dom.dataset'], ['goog.labs.userAgent.browser', 'goog.string', 'goog.userAgent.product'], {});
goog.addDependency('dom/dataset_test.js', ['goog.dom.datasetTest'], ['goog.dom', 'goog.dom.dataset', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom.js', ['goog.dom', 'goog.dom.Appendable', 'goog.dom.DomHelper'], ['goog.array', 'goog.asserts', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math.Coordinate', 'goog.math.Size', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('dom/dom_compile_test.js', ['goog.dom.DomCompileTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom_test.js', ['goog.dom.dom_test'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.DomHelper', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeUrl', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.string.Unicode', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fontsizemonitor.js', ['goog.dom.FontSizeMonitor', 'goog.dom.FontSizeMonitor.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('dom/fontsizemonitor_test.js', ['goog.dom.FontSizeMonitorTest'], ['goog.dom', 'goog.dom.FontSizeMonitor', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/forms.js', ['goog.dom.forms'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.structs.Map', 'goog.window'], {});
goog.addDependency('dom/forms_test.js', ['goog.dom.formsTest'], ['goog.dom', 'goog.dom.forms', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fullscreen.js', ['goog.dom.fullscreen', 'goog.dom.fullscreen.EventType'], ['goog.dom'], {});
goog.addDependency('dom/fullscreen_test.js', ['goog.dom.fullscreen_test'], ['goog.dom.DomHelper', 'goog.dom.fullscreen', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/htmlelement.js', ['goog.dom.HtmlElement'], [], {});
goog.addDependency('dom/iframe.js', ['goog.dom.iframe'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('dom/iframe_test.js', ['goog.dom.iframeTest'], ['goog.dom', 'goog.dom.iframe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/inputtype.js', ['goog.dom.InputType'], [], {});
goog.addDependency('dom/inputtype_test.js', ['goog.dom.InputTypeTest'], ['goog.dom.InputType', 'goog.object', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/iter.js', ['goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/iter_test.js', ['goog.dom.iterTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/multirange.js', ['goog.dom.MultiRange', 'goog.dom.MultiRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TextRange', 'goog.iter', 'goog.iter.StopIteration', 'goog.log'], {});
goog.addDependency('dom/multirange_test.js', ['goog.dom.MultiRangeTest'], ['goog.dom', 'goog.dom.MultiRange', 'goog.dom.Range', 'goog.iter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeiterator.js', ['goog.dom.NodeIterator'], ['goog.dom.TagIterator'], {});
goog.addDependency('dom/nodeiterator_test.js', ['goog.dom.NodeIteratorTest'], ['goog.dom', 'goog.dom.NodeIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeoffset.js', ['goog.dom.NodeOffset'], ['goog.Disposable', 'goog.dom.TagName'], {});
goog.addDependency('dom/nodeoffset_test.js', ['goog.dom.NodeOffsetTest'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodetype.js', ['goog.dom.NodeType'], [], {});
goog.addDependency('dom/pattern/abstractpattern.js', ['goog.dom.pattern.AbstractPattern'], ['goog.dom.TagWalkType', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/allchildren.js', ['goog.dom.pattern.AllChildren'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/callback/callback.js', ['goog.dom.pattern.callback'], ['goog.dom', 'goog.dom.TagWalkType', 'goog.iter'], {});
goog.addDependency('dom/pattern/callback/counter.js', ['goog.dom.pattern.callback.Counter'], [], {});
goog.addDependency('dom/pattern/callback/test.js', ['goog.dom.pattern.callback.Test'], ['goog.iter.StopIteration'], {});
goog.addDependency('dom/pattern/childmatches.js', ['goog.dom.pattern.ChildMatches'], ['goog.dom.pattern.AllChildren', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/endtag.js', ['goog.dom.pattern.EndTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/fulltag.js', ['goog.dom.pattern.FullTag'], ['goog.dom.pattern.MatchType', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/matcher.js', ['goog.dom.pattern.Matcher'], ['goog.dom.TagIterator', 'goog.dom.pattern.MatchType', 'goog.iter'], {});
goog.addDependency('dom/pattern/matcher_test.js', ['goog.dom.pattern.matcherTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.Matcher', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.callback.Counter', 'goog.dom.pattern.callback.Test', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/nodetype.js', ['goog.dom.pattern.NodeType'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/pattern.js', ['goog.dom.pattern', 'goog.dom.pattern.MatchType'], [], {});
goog.addDependency('dom/pattern/pattern_test.js', ['goog.dom.patternTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagWalkType', 'goog.dom.pattern.AllChildren', 'goog.dom.pattern.ChildMatches', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.MatchType', 'goog.dom.pattern.NodeType', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Text', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/repeat.js', ['goog.dom.pattern.Repeat'], ['goog.dom.NodeType', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/sequence.js', ['goog.dom.pattern.Sequence'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/starttag.js', ['goog.dom.pattern.StartTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/tag.js', ['goog.dom.pattern.Tag'], ['goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType', 'goog.object'], {});
goog.addDependency('dom/pattern/text.js', ['goog.dom.pattern.Text'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/range.js', ['goog.dom.Range'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.BrowserFeature', 'goog.dom.ControlRange', 'goog.dom.MultiRange', 'goog.dom.NodeType', 'goog.dom.TextRange'], {});
goog.addDependency('dom/range_test.js', ['goog.dom.RangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.dom.browserrange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/rangeendpoint.js', ['goog.dom.RangeEndpoint'], [], {});
goog.addDependency('dom/safe.js', ['goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition'], ['goog.asserts', 'goog.dom.asserts', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('dom/safe_test.js', ['goog.dom.safeTest'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.string', 'goog.string.Const', 'goog.testing', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedcaretrange.js', ['goog.dom.SavedCaretRange'], ['goog.array', 'goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.string'], {});
goog.addDependency('dom/savedcaretrange_test.js', ['goog.dom.SavedCaretRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.SavedCaretRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedrange.js', ['goog.dom.SavedRange'], ['goog.Disposable', 'goog.log'], {});
goog.addDependency('dom/savedrange_test.js', ['goog.dom.SavedRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/selection.js', ['goog.dom.selection'], ['goog.dom.InputType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/selection_test.js', ['goog.dom.selectionTest'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.selection', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagiterator.js', ['goog.dom.TagIterator', 'goog.dom.TagWalkType'], ['goog.dom', 'goog.dom.NodeType', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/tagiterator_test.js', ['goog.dom.TagIteratorTest'], ['goog.dom', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.TagWalkType', 'goog.iter', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagname.js', ['goog.dom.TagName'], ['goog.dom.HtmlElement'], {});
goog.addDependency('dom/tagname_test.js', ['goog.dom.TagNameTest'], ['goog.dom.TagName', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tags.js', ['goog.dom.tags'], ['goog.object'], {});
goog.addDependency('dom/tags_test.js', ['goog.dom.tagsTest'], ['goog.dom.tags', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textassert.js', ['goog.dom.textAssert'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('dom/textassert_test.js', ['goog.dom.textassert_test'], ['goog.dom.textAssert', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrange.js', ['goog.dom.TextRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.dom.browserrange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/textrange_test.js', ['goog.dom.TextRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.Range', 'goog.dom.TextRange', 'goog.math.Coordinate', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrangeiterator.js', ['goog.dom.TextRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeIterator', 'goog.dom.TagName', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/textrangeiterator_test.js', ['goog.dom.TextRangeIteratorTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri.js', ['goog.dom.uri'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri_test.js', ['goog.dom.uriTest'], ['goog.dom.uri', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/vendor.js', ['goog.dom.vendor'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/vendor_test.js', ['goog.dom.vendorTest'], ['goog.array', 'goog.dom.vendor', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/viewportsizemonitor.js', ['goog.dom.ViewportSizeMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size'], {});
goog.addDependency('dom/viewportsizemonitor_test.js', ['goog.dom.ViewportSizeMonitorTest'], ['goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/xml.js', ['goog.dom.xml'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.userAgent'], {});
goog.addDependency('dom/xml_test.js', ['goog.dom.xmlTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.xml', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/browserfeature.js', ['goog.editor.BrowserFeature'], ['goog.editor.defines', 'goog.labs.userAgent.browser', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('editor/browserfeature_test.js', ['goog.editor.BrowserFeatureTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/clicktoeditwrapper.js', ['goog.editor.ClickToEditWrapper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.range', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType'], {});
goog.addDependency('editor/clicktoeditwrapper_test.js', ['goog.editor.ClickToEditWrapperTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.ClickToEditWrapper', 'goog.editor.SeamlessField', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/command.js', ['goog.editor.Command'], [], {});
goog.addDependency('editor/contenteditablefield.js', ['goog.editor.ContentEditableField'], ['goog.asserts', 'goog.editor.Field', 'goog.log'], {});
goog.addDependency('editor/contenteditablefield_test.js', ['goog.editor.ContentEditableFieldTest'], ['goog.dom', 'goog.editor.ContentEditableField', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/defines.js', ['goog.editor.defines'], [], {});
goog.addDependency('editor/field.js', ['goog.editor.Field', 'goog.editor.Field.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.asserts', 'goog.async.Delay', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.PluginImpl', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.editor.range', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.log', 'goog.log.Level', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('editor/field_test.js', ['goog.editor.field_test'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.LooseMock', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/focus.js', ['goog.editor.focus'], ['goog.dom.selection'], {});
goog.addDependency('editor/focus_test.js', ['goog.editor.focusTest'], ['goog.dom.selection', 'goog.editor.BrowserFeature', 'goog.editor.focus', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/icontent.js', ['goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo'], ['goog.dom', 'goog.editor.BrowserFeature', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/icontent_test.js', ['goog.editor.icontentTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/link.js', ['goog.editor.Link'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.string.Unicode', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex'], {});
goog.addDependency('editor/link_test.js', ['goog.editor.LinkTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Link', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/node.js', ['goog.editor.node'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.iter', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('editor/node_test.js', ['goog.editor.nodeTest'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.node', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugin.js', ['goog.editor.Plugin'], ['goog.editor.Field', 'goog.editor.PluginImpl'], {});
goog.addDependency('editor/plugin_impl.js', ['goog.editor.PluginImpl'], ['goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.object', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('editor/plugin_test.js', ['goog.editor.PluginTest'], ['goog.editor.Field', 'goog.editor.Plugin', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractbubbleplugin.js', ['goog.editor.plugins.AbstractBubblePlugin'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Plugin', 'goog.editor.style', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.functions', 'goog.string.Unicode', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstractbubbleplugin_test.js', ['goog.editor.plugins.AbstractBubblePluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.style', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.editor.Bubble', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractdialogplugin.js', ['goog.editor.plugins.AbstractDialogPlugin', 'goog.editor.plugins.AbstractDialogPlugin.EventType'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.ui.editor.AbstractDialog'], {});
goog.addDependency('editor/plugins/abstractdialogplugin_test.js', ['goog.editor.plugins.AbstractDialogPluginTest'], ['goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.Event', 'goog.events.EventHandler', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstracttabhandler.js', ['goog.editor.plugins.AbstractTabHandler'], ['goog.editor.Plugin', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstracttabhandler_test.js', ['goog.editor.plugins.AbstractTabHandlerTest'], ['goog.editor.Field', 'goog.editor.plugins.AbstractTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/basictextformatter.js', ['goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.BasicTextFormatter.COMMAND'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.editor.style', 'goog.iter', 'goog.iter.StopIteration', 'goog.log', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/basictextformatter_test.js', ['goog.editor.plugins.BasicTextFormatterTest'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.BasicTextFormatter', 'goog.html.SafeHtml', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.LooseMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/blockquote.js', ['goog.editor.plugins.Blockquote'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.log'], {});
goog.addDependency('editor/plugins/blockquote_test.js', ['goog.editor.plugins.BlockquoteTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.Blockquote', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/emoticons.js', ['goog.editor.plugins.Emoticons'], ['goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.range', 'goog.functions', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/emoticons_test.js', ['goog.editor.plugins.EmoticonsTest'], ['goog.Uri', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.Emoticons', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/enterhandler.js', ['goog.editor.plugins.EnterHandler'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.Blockquote', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/enterhandler_test.js', ['goog.editor.plugins.EnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.Blockquote', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.events', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.ExpectedFailures', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/firststrong.js', ['goog.editor.plugins.FirstStrong'], ['goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.i18n.bidi', 'goog.i18n.uChar', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/firststrong_test.js', ['goog.editor.plugins.FirstStrongTest'], ['goog.dom.Range', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.FirstStrong', 'goog.editor.range', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.MockClock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/headerformatter.js', ['goog.editor.plugins.HeaderFormatter'], ['goog.editor.Command', 'goog.editor.Plugin', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/headerformatter_test.js', ['goog.editor.plugins.HeaderFormatterTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.HeaderFormatter', 'goog.events.BrowserEvent', 'goog.testing.LooseMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkbubble.js', ['goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkBubble.Action'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.functions', 'goog.string', 'goog.style', 'goog.ui.editor.messages', 'goog.uri.utils', 'goog.window'], {});
goog.addDependency('editor/plugins/linkbubble_test.js', ['goog.editor.plugins.LinkBubbleTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.LinkBubble', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.testing.FunctionMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkdialogplugin.js', ['goog.editor.plugins.LinkDialogPlugin'], ['goog.array', 'goog.dom', 'goog.editor.Command', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.EventHandler', 'goog.functions', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.uri.utils'], {});
goog.addDependency('editor/plugins/linkdialogplugin_test.js', ['goog.ui.editor.plugins.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Link', 'goog.editor.plugins.LinkDialogPlugin', 'goog.html.SafeHtml', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.editor.dom', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkshortcutplugin.js', ['goog.editor.plugins.LinkShortcutPlugin'], ['goog.editor.Command', 'goog.editor.Plugin'], {});
goog.addDependency('editor/plugins/linkshortcutplugin_test.js', ['goog.editor.plugins.LinkShortcutPluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkShortcutPlugin', 'goog.events.KeyCodes', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/listtabhandler.js', ['goog.editor.plugins.ListTabHandler'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.plugins.AbstractTabHandler', 'goog.iter'], {});
goog.addDependency('editor/plugins/listtabhandler_test.js', ['goog.editor.plugins.ListTabHandlerTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.ListTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/loremipsum.js', ['goog.editor.plugins.LoremIpsum'], ['goog.asserts', 'goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.html.SafeHtml', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/loremipsum_test.js', ['goog.editor.plugins.LoremIpsumTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/removeformatting.js', ['goog.editor.plugins.RemoveFormatting'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/removeformatting_test.js', ['goog.editor.plugins.RemoveFormattingTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.RemoveFormatting', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/spacestabhandler.js', ['goog.editor.plugins.SpacesTabHandler'], ['goog.dom.TagName', 'goog.editor.plugins.AbstractTabHandler', 'goog.editor.range'], {});
goog.addDependency('editor/plugins/spacestabhandler_test.js', ['goog.editor.plugins.SpacesTabHandlerTest'], ['goog.dom', 'goog.dom.Range', 'goog.editor.plugins.SpacesTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tableeditor.js', ['goog.editor.plugins.TableEditor'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.Table', 'goog.editor.node', 'goog.editor.range', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tableeditor_test.js', ['goog.editor.plugins.TableEditorTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.plugins.TableEditor', 'goog.object', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.TestCase', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tagonenterhandler.js', ['goog.editor.plugins.TagOnEnterHandler'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.node', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.string.Unicode', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tagonenterhandler_test.js', ['goog.editor.plugins.TagOnEnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.TagOnEnterHandler', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredo.js', ['goog.editor.plugins.UndoRedo'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.object'], {});
goog.addDependency('editor/plugins/undoredo_test.js', ['goog.editor.plugins.UndoRedoTest'], ['goog.array', 'goog.dom', 'goog.dom.browserrange', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.editor.plugins.UndoRedo', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredomanager.js', ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoManager.EventType'], ['goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredomanager_test.js', ['goog.editor.plugins.UndoRedoManagerTest'], ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredostate.js', ['goog.editor.plugins.UndoRedoState'], ['goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredostate_test.js', ['goog.editor.plugins.UndoRedoStateTest'], ['goog.editor.plugins.UndoRedoState', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/range.js', ['goog.editor.range', 'goog.editor.range.Point'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.SavedCaretRange', 'goog.editor.node', 'goog.editor.style', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/range_test.js', ['goog.editor.rangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.range', 'goog.editor.range.Point', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/seamlessfield.js', ['goog.editor.SeamlessField'], ['goog.cssom.iframe.style', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.style'], {});
goog.addDependency('editor/seamlessfield_test.js', ['goog.editor.seamlessfield_test'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.SeamlessField', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.testing.MockClock', 'goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/style.js', ['goog.editor.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/style_test.js', ['goog.editor.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/table.js', ['goog.editor.Table', 'goog.editor.TableCell', 'goog.editor.TableRow'], ['goog.asserts', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.log', 'goog.string.Unicode', 'goog.style'], {});
goog.addDependency('editor/table_test.js', ['goog.editor.TableTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Table', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actioneventwrapper.js', ['goog.events.actionEventWrapper'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.EventWrapper', 'goog.events.KeyCodes'], {});
goog.addDependency('events/actioneventwrapper_test.js', ['goog.events.actionEventWrapperTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.events', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actionhandler.js', ['goog.events.ActionEvent', 'goog.events.ActionHandler', 'goog.events.ActionHandler.EventType', 'goog.events.BeforeActionEvent'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/actionhandler_test.js', ['goog.events.ActionHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.ActionHandler', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserevent.js', ['goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.BrowserEvent.PointerType'], ['goog.debug', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('events/browserevent_test.js', ['goog.events.BrowserEventTest'], ['goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.math.Coordinate', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserfeature.js', ['goog.events.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('events/event.js', ['goog.events.Event', 'goog.events.EventLike'], ['goog.Disposable', 'goog.events.EventId'], {});
goog.addDependency('events/event_test.js', ['goog.events.EventTest'], ['goog.events.Event', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventhandler.js', ['goog.events.EventHandler'], ['goog.Disposable', 'goog.events', 'goog.object'], {});
goog.addDependency('events/eventhandler_test.js', ['goog.events.EventHandlerTest'], ['goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventid.js', ['goog.events.EventId'], [], {});
goog.addDependency('events/events.js', ['goog.events', 'goog.events.CaptureSimulationMode', 'goog.events.Key', 'goog.events.ListenableType'], ['goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Listenable', 'goog.events.ListenerMap'], {});
goog.addDependency('events/events_test.js', ['goog.eventsTest'], ['goog.asserts.AssertionError', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserFeature', 'goog.events.CaptureSimulationMode', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.Listener', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget.js', ['goog.events.EventTarget'], ['goog.Disposable', 'goog.asserts', 'goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('events/eventtarget_test.js', ['goog.events.EventTargetTest'], ['goog.events.EventTarget', 'goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_googevents_test.js', ['goog.events.EventTargetGoogEventsTest'], ['goog.events', 'goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_w3cinterface_test.js', ['goog.events.EventTargetW3CTest'], ['goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtargettester.js', ['goog.events.eventTargetTester'], ['goog.array', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.testing.asserts', 'goog.testing.recordFunction'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtype.js', ['goog.events.EventType', 'goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType', 'goog.events.PointerAsTouchEventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType'], ['goog.events.BrowserFeature', 'goog.userAgent'], {});
goog.addDependency('events/eventtype_test.js', ['goog.events.EventTypeTest'], ['goog.events.BrowserFeature', 'goog.events.EventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventwrapper.js', ['goog.events.EventWrapper'], [], {});
goog.addDependency('events/filedrophandler.js', ['goog.events.FileDropHandler', 'goog.events.FileDropHandler.EventType'], ['goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('events/filedrophandler_test.js', ['goog.events.FileDropHandlerTest'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.FileDropHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/focushandler.js', ['goog.events.FocusHandler', 'goog.events.FocusHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.userAgent'], {});
goog.addDependency('events/imehandler.js', ['goog.events.ImeHandler', 'goog.events.ImeHandler.Event', 'goog.events.ImeHandler.EventType'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/imehandler_test.js', ['goog.events.ImeHandlerTest'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.ImeHandler', 'goog.events.KeyCodes', 'goog.object', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/inputhandler.js', ['goog.events.InputHandler', 'goog.events.InputHandler.EventType'], ['goog.Timer', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/inputhandler_test.js', ['goog.events.InputHandlerTest'], ['goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keycodes.js', ['goog.events.KeyCodes'], ['goog.userAgent'], {});
goog.addDependency('events/keycodes_test.js', ['goog.events.KeyCodesTest'], ['goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keyhandler.js', ['goog.events.KeyEvent', 'goog.events.KeyHandler', 'goog.events.KeyHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/keyhandler_test.js', ['goog.events.KeyEventTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keynames.js', ['goog.events.KeyNames'], [], {});
goog.addDependency('events/keys.js', ['goog.events.Keys'], [], {'lang': 'es5'});
goog.addDependency('events/listenable.js', ['goog.events.Listenable', 'goog.events.ListenableKey'], ['goog.events.EventId'], {});
goog.addDependency('events/listenable_test.js', ['goog.events.ListenableTest'], ['goog.events.Listenable', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/listener.js', ['goog.events.Listener'], ['goog.events.ListenableKey'], {});
goog.addDependency('events/listenermap.js', ['goog.events.ListenerMap'], ['goog.array', 'goog.events.Listener', 'goog.object'], {});
goog.addDependency('events/listenermap_test.js', ['goog.events.ListenerMapTest'], ['goog.dispose', 'goog.events', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.ListenerMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/mousewheelhandler.js', ['goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.events.MouseWheelHandler.EventType'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.math', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('events/mousewheelhandler_test.js', ['goog.events.MouseWheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/onlinehandler.js', ['goog.events.OnlineHandler', 'goog.events.OnlineHandler.EventType'], ['goog.Timer', 'goog.events.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('events/onlinelistener_test.js', ['goog.events.OnlineHandlerTest'], ['goog.events', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.OnlineHandler', 'goog.net.NetworkStatusMonitor', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/pastehandler.js', ['goog.events.PasteHandler', 'goog.events.PasteHandler.EventType', 'goog.events.PasteHandler.State'], ['goog.Timer', 'goog.async.ConditionalDelay', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.log', 'goog.userAgent'], {});
goog.addDependency('events/pastehandler_test.js', ['goog.events.PasteHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.PasteHandler', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/wheelevent.js', ['goog.events.WheelEvent'], ['goog.asserts', 'goog.events.BrowserEvent'], {});
goog.addDependency('events/wheelhandler.js', ['goog.events.WheelHandler'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.WheelEvent', 'goog.style', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('events/wheelhandler_test.js', ['goog.events.WheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.WheelEvent', 'goog.events.WheelHandler', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/emailaddress.js', ['goog.format.EmailAddress'], ['goog.string'], {});
goog.addDependency('format/emailaddress_test.js', ['goog.format.EmailAddressTest'], ['goog.array', 'goog.format.EmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/format.js', ['goog.format'], ['goog.i18n.GraphemeBreak', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('format/format_test.js', ['goog.formatTest'], ['goog.dom', 'goog.dom.TagName', 'goog.format', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/htmlprettyprinter.js', ['goog.format.HtmlPrettyPrinter', 'goog.format.HtmlPrettyPrinter.Buffer'], ['goog.dom.TagName', 'goog.object', 'goog.string.StringBuffer'], {});
goog.addDependency('format/htmlprettyprinter_test.js', ['goog.format.HtmlPrettyPrinterTest'], ['goog.format.HtmlPrettyPrinter', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/internationalizedemailaddress.js', ['goog.format.InternationalizedEmailAddress'], ['goog.format.EmailAddress', 'goog.string'], {});
goog.addDependency('format/internationalizedemailaddress_test.js', ['goog.format.InternationalizedEmailAddressTest'], ['goog.array', 'goog.format.InternationalizedEmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/jsonprettyprinter.js', ['goog.format.JsonPrettyPrinter', 'goog.format.JsonPrettyPrinter.SafeHtmlDelimiters', 'goog.format.JsonPrettyPrinter.TextDelimiters'], ['goog.html.SafeHtml', 'goog.json', 'goog.json.Serializer', 'goog.string', 'goog.string.format'], {});
goog.addDependency('format/jsonprettyprinter_test.js', ['goog.format.JsonPrettyPrinterTest'], ['goog.format.JsonPrettyPrinter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/entry.js', ['goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntry.Behavior', 'goog.fs.Entry', 'goog.fs.FileEntry'], [], {});
goog.addDependency('fs/entryimpl.js', ['goog.fs.DirectoryEntryImpl', 'goog.fs.EntryImpl', 'goog.fs.FileEntryImpl'], ['goog.array', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.fs.FileWriter', 'goog.functions', 'goog.string'], {});
goog.addDependency('fs/error.js', ['goog.fs.DOMErrorLike', 'goog.fs.Error', 'goog.fs.Error.ErrorCode'], ['goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string'], {});
goog.addDependency('fs/filereader.js', ['goog.fs.FileReader', 'goog.fs.FileReader.EventType', 'goog.fs.FileReader.ReadyState'], ['goog.async.Deferred', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesaver.js', ['goog.fs.FileSaver', 'goog.fs.FileSaver.EventType', 'goog.fs.FileSaver.ReadyState'], ['goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesystem.js', ['goog.fs.FileSystem'], [], {});
goog.addDependency('fs/filesystemimpl.js', ['goog.fs.FileSystemImpl'], ['goog.fs.DirectoryEntryImpl', 'goog.fs.FileSystem'], {});
goog.addDependency('fs/filewriter.js', ['goog.fs.FileWriter'], ['goog.fs.Error', 'goog.fs.FileSaver'], {});
goog.addDependency('fs/fs.js', ['goog.fs'], ['goog.array', 'goog.async.Deferred', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSystemImpl', 'goog.fs.url', 'goog.userAgent'], {});
goog.addDependency('fs/fs_test.js', ['goog.fsTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/progressevent.js', ['goog.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('fs/url.js', ['goog.fs.url'], [], {'lang': 'es6'});
goog.addDependency('fs/url_test.js', ['goog.urlTest'], ['goog.fs.url', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('functions/functions.js', ['goog.functions'], [], {'lang': 'es6'});
goog.addDependency('functions/functions_test.js', ['goog.functionsTest'], ['goog.array', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/abstractdragdrop.js', ['goog.fx.AbstractDragDrop', 'goog.fx.AbstractDragDrop.EventType', 'goog.fx.DragDropEvent', 'goog.fx.DragDropItem'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/abstractdragdrop_test.js', ['goog.fx.AbstractDragDropTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('fx/anim/anim.js', ['goog.fx.anim', 'goog.fx.anim.Animated'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.object'], {});
goog.addDependency('fx/anim/anim_test.js', ['goog.fx.animTest'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.anim', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animation.js', ['goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.fx.Transition', 'goog.fx.TransitionBase', 'goog.fx.anim', 'goog.fx.anim.Animated'], {});
goog.addDependency('fx/animation_test.js', ['goog.fx.AnimationTest'], ['goog.events', 'goog.fx.Animation', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animationqueue.js', ['goog.fx.AnimationParallelQueue', 'goog.fx.AnimationQueue', 'goog.fx.AnimationSerialQueue'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.TransitionBase'], {});
goog.addDependency('fx/animationqueue_test.js', ['goog.fx.AnimationQueueTest'], ['goog.events', 'goog.fx.Animation', 'goog.fx.AnimationParallelQueue', 'goog.fx.AnimationSerialQueue', 'goog.fx.Transition', 'goog.fx.anim', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/css3/fx.js', ['goog.fx.css3'], ['goog.fx.css3.Transition'], {});
goog.addDependency('fx/css3/transition.js', ['goog.fx.css3.Transition'], ['goog.Timer', 'goog.asserts', 'goog.fx.TransitionBase', 'goog.style', 'goog.style.transition'], {});
goog.addDependency('fx/css3/transition_test.js', ['goog.fx.css3.TransitionTest'], ['goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Transition', 'goog.fx.css3.Transition', 'goog.style.transition', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/cssspriteanimation.js', ['goog.fx.CssSpriteAnimation'], ['goog.fx.Animation'], {});
goog.addDependency('fx/cssspriteanimation_test.js', ['goog.fx.CssSpriteAnimationTest'], ['goog.fx.CssSpriteAnimation', 'goog.math.Box', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dom.js', ['goog.fx.dom', 'goog.fx.dom.BgColorTransform', 'goog.fx.dom.ColorTransform', 'goog.fx.dom.Fade', 'goog.fx.dom.FadeIn', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOut', 'goog.fx.dom.FadeOutAndHide', 'goog.fx.dom.PredefinedEffect', 'goog.fx.dom.Resize', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Scroll', 'goog.fx.dom.Slide', 'goog.fx.dom.SlideFrom', 'goog.fx.dom.Swipe'], ['goog.color', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('fx/dragdrop.js', ['goog.fx.DragDrop'], ['goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup.js', ['goog.fx.DragDropGroup'], ['goog.dom', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup_test.js', ['goog.fx.DragDropGroupTest'], ['goog.events', 'goog.fx.DragDropGroup', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragger.js', ['goog.fx.DragEvent', 'goog.fx.Dragger', 'goog.fx.Dragger.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.style', 'goog.style.bidi', 'goog.userAgent'], {});
goog.addDependency('fx/dragger_test.js', ['goog.fx.DraggerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.style.bidi', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/draglistgroup.js', ['goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListGroup.EventType', 'goog.fx.DragListGroupEvent', 'goog.fx.DragListPermission'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.string', 'goog.style'], {});
goog.addDependency('fx/draglistgroup_test.js', ['goog.fx.DragListGroupTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.DragEvent', 'goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListPermission', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.object', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragscrollsupport.js', ['goog.fx.DragScrollSupport'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/dragscrollsupport_test.js', ['goog.fx.DragScrollSupportTest'], ['goog.fx.DragScrollSupport', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/easing.js', ['goog.fx.easing'], [], {});
goog.addDependency('fx/easing_test.js', ['goog.fx.easingTest'], ['goog.fx.easing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/fx.js', ['goog.fx'], ['goog.asserts', 'goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent', 'goog.fx.Transition.EventType', 'goog.fx.easing'], {});
goog.addDependency('fx/fx_test.js', ['goog.fxTest'], ['goog.fx.Animation', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/transition.js', ['goog.fx.Transition', 'goog.fx.Transition.EventType'], [], {});
goog.addDependency('fx/transitionbase.js', ['goog.fx.TransitionBase', 'goog.fx.TransitionBase.State'], ['goog.events.EventTarget', 'goog.fx.Transition'], {});
goog.addDependency('goog.js', [], [], {'lang': 'es6', 'module': 'es6'});
goog.addDependency('graphics/abstractgraphics.js', ['goog.graphics.AbstractGraphics'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.Element', 'goog.graphics.EllipseElement', 'goog.graphics.Fill', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.Stroke', 'goog.graphics.StrokeAndFillElement', 'goog.graphics.TextElement', 'goog.math.Coordinate', 'goog.math.Size', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('graphics/affinetransform.js', ['goog.graphics.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('graphics/affinetransform_test.js', ['goog.graphics.AffineTransformTest'], ['goog.array', 'goog.graphics', 'goog.graphics.AffineTransform', 'goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/canvaselement.js', ['goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.graphics.EllipseElement', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('graphics/canvasgraphics.js', ['goog.graphics.CanvasGraphics'], ['goog.dom.TagName', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement', 'goog.graphics.Font', 'goog.graphics.SolidFill', 'goog.math.Size', 'goog.style'], {});
goog.addDependency('graphics/canvasgraphics_test.js', ['goog.graphics.CanvasGraphicsTest'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/element.js', ['goog.graphics.Element'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/ellipseelement.js', ['goog.graphics.EllipseElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/coordinates.js', ['goog.graphics.ext.coordinates'], ['goog.string'], {});
goog.addDependency('graphics/ext/coordinates_test.js', ['goog.graphics.ext.coordinatesTest'], ['goog.graphics', 'goog.graphics.ext.coordinates', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/element.js', ['goog.graphics.ext.Element'], ['goog.events.EventTarget', 'goog.functions', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/element_test.js', ['goog.graphics.ext.ElementTest'], ['goog.graphics', 'goog.graphics.ext', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/ellipse.js', ['goog.graphics.ext.Ellipse'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/ext.js', ['goog.graphics.ext'], ['goog.graphics.ext.Ellipse', 'goog.graphics.ext.Graphics', 'goog.graphics.ext.Group', 'goog.graphics.ext.Image', 'goog.graphics.ext.Rectangle', 'goog.graphics.ext.Shape', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/graphics.js', ['goog.graphics.ext.Graphics'], ['goog.events', 'goog.events.EventType', 'goog.graphics', 'goog.graphics.ext.Group'], {});
goog.addDependency('graphics/ext/group.js', ['goog.graphics.ext.Group'], ['goog.array', 'goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/image.js', ['goog.graphics.ext.Image'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/path.js', ['goog.graphics.ext.Path'], ['goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.math.Rect'], {});
goog.addDependency('graphics/ext/path_test.js', ['goog.graphics.ext.PathTest'], ['goog.graphics', 'goog.graphics.ext.Path', 'goog.math.Rect', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/rectangle.js', ['goog.graphics.ext.Rectangle'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/shape.js', ['goog.graphics.ext.Shape'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/strokeandfillelement.js', ['goog.graphics.ext.StrokeAndFillElement'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/fill.js', ['goog.graphics.Fill'], [], {});
goog.addDependency('graphics/font.js', ['goog.graphics.Font'], [], {});
goog.addDependency('graphics/graphics.js', ['goog.graphics'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SvgGraphics', 'goog.graphics.VmlGraphics', 'goog.userAgent'], {});
goog.addDependency('graphics/groupelement.js', ['goog.graphics.GroupElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/imageelement.js', ['goog.graphics.ImageElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/lineargradient.js', ['goog.graphics.LinearGradient'], ['goog.asserts', 'goog.graphics.Fill'], {});
goog.addDependency('graphics/path.js', ['goog.graphics.Path', 'goog.graphics.Path.Segment'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/path_test.js', ['goog.graphics.PathTest'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/pathelement.js', ['goog.graphics.PathElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/paths.js', ['goog.graphics.paths'], ['goog.graphics.Path', 'goog.math.Coordinate'], {});
goog.addDependency('graphics/paths_test.js', ['goog.graphics.pathsTest'], ['goog.dom', 'goog.graphics', 'goog.graphics.paths', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/rectelement.js', ['goog.graphics.RectElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/solidfill.js', ['goog.graphics.SolidFill'], ['goog.graphics.Fill'], {});
goog.addDependency('graphics/solidfill_test.js', ['goog.graphics.SolidFillTest'], ['goog.graphics.SolidFill', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/stroke.js', ['goog.graphics.Stroke'], [], {});
goog.addDependency('graphics/strokeandfillelement.js', ['goog.graphics.StrokeAndFillElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/svgelement.js', ['goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/svggraphics.js', ['goog.graphics.SvgGraphics'], ['goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement', 'goog.math', 'goog.math.Size', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('graphics/svggraphics_test.js', ['goog.graphics.SvgGraphicsTest'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.SolidFill', 'goog.graphics.SvgGraphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/textelement.js', ['goog.graphics.TextElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/vmlelement.js', ['goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/vmlgraphics.js', ['goog.graphics.VmlGraphics'], ['goog.array', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement', 'goog.html.uncheckedconversions', 'goog.math', 'goog.math.Size', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('history/event.js', ['goog.history.Event'], ['goog.events.Event', 'goog.history.EventType'], {});
goog.addDependency('history/eventtype.js', ['goog.history.EventType'], [], {});
goog.addDependency('history/history.js', ['goog.History', 'goog.History.Event', 'goog.History.EventType'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event', 'goog.history.EventType', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.device', 'goog.memoize', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('history/history_test.js', ['goog.HistoryTest'], ['goog.History', 'goog.dispose', 'goog.dom', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('history/html5history.js', ['goog.history.Html5History', 'goog.history.Html5History.TokenTransformer'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event'], {});
goog.addDependency('history/html5history_test.js', ['goog.history.Html5HistoryTest'], ['goog.Timer', 'goog.events', 'goog.events.EventType', 'goog.history.EventType', 'goog.history.Html5History', 'goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/cssspecificity.js', ['goog.html.CssSpecificity'], ['goog.userAgent', 'goog.userAgent.product'], {'module': 'goog'});
goog.addDependency('html/cssspecificity_test.js', ['goog.html.CssSpecificityTest'], ['goog.html.CssSpecificity', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/flash.js', ['goog.html.flash'], ['goog.asserts', 'goog.html.SafeHtml'], {});
goog.addDependency('html/flash_test.js', ['goog.html.flashTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/legacyconversions.js', ['goog.html.legacyconversions'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('html/legacyconversions_test.js', ['goog.html.legacyconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.legacyconversions', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtml.js', ['goog.html.SafeHtml'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.tags', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safehtml_test.js', ['goog.html.safeHtmlTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtmlformatter.js', ['goog.html.SafeHtmlFormatter'], ['goog.asserts', 'goog.dom.tags', 'goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('html/safehtmlformatter_test.js', ['goog.html.safeHtmlFormatterTest'], ['goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.html.SafeUrl', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safescript.js', ['goog.html.SafeScript'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/safescript_test.js', ['goog.html.safeScriptTest'], ['goog.html.SafeScript', 'goog.html.trustedtypes', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestyle.js', ['goog.html.SafeStyle'], ['goog.array', 'goog.asserts', 'goog.html.SafeUrl', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {'lang': 'es5'});
goog.addDependency('html/safestyle_test.js', ['goog.html.safeStyleTest'], ['goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestylesheet.js', ['goog.html.SafeStyleSheet'], ['goog.array', 'goog.asserts', 'goog.html.SafeStyle', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safestylesheet_test.js', ['goog.html.safeStyleSheetTest'], ['goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl.js', ['goog.html.SafeUrl'], ['goog.asserts', 'goog.fs.url', 'goog.html.TrustedResourceUrl', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safeurl_test.js', ['goog.html.safeUrlTest'], ['goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.safeUrlTestVectors', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl_test_vectors.js', ['goog.html.safeUrlTestVectors'], [], {});
goog.addDependency('html/sanitizer/attributewhitelist.js', ['goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist'], [], {});
goog.addDependency('html/sanitizer/csspropertysanitizer.js', ['goog.html.sanitizer.CssPropertySanitizer'], ['goog.asserts', 'goog.html.SafeUrl', 'goog.object', 'goog.string'], {'module': 'goog'});
goog.addDependency('html/sanitizer/csspropertysanitizer_test.js', ['goog.html.sanitizer.CssPropertySanitizerTest'], ['goog.functions', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/csssanitizer.js', ['goog.html.sanitizer.CssSanitizer'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.CssSpecificity', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('html/sanitizer/csssanitizer_test.js', ['goog.html.CssSanitizerTest'], ['goog.array', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssSanitizer', 'goog.html.testing', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap.js', ['goog.html.sanitizer.ElementWeakMap'], ['goog.html.sanitizer.noclobber'], {'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap_test.js', ['goog.html.sanitizer.ElementWeakMapTest'], ['goog.html.sanitizer.ElementWeakMap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/html_test_vectors.js', ['goog.html.htmlTestVectors'], [], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer.js', ['goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.HtmlSanitizerAttributePolicy', 'goog.html.sanitizer.HtmlSanitizerPolicy', 'goog.html.sanitizer.HtmlSanitizerPolicyContext', 'goog.html.sanitizer.HtmlSanitizerPolicyHints', 'goog.html.sanitizer.HtmlSanitizerUrlPolicy'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.CssSanitizer', 'goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.TagBlacklist', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const'], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer_test.js', ['goog.html.HtmlSanitizerTest'], ['goog.array', 'goog.dom', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.TagWhitelist', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/htmlsanitizer_unified_test.js', ['goog.html.HtmlSanitizerUnifiedTest'], ['goog.html.SafeHtml', 'goog.html.htmlTestVectors', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber.js', ['goog.html.sanitizer.noclobber'], ['goog.asserts', 'goog.dom.NodeType', 'goog.userAgent.product'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber_test.js', ['goog.html.sanitizer.noclobberTest'], ['goog.dom.NodeType', 'goog.html.sanitizer.noclobber', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor.js', ['goog.html.sanitizer.SafeDomTreeProcessor'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.sanitizer.ElementWeakMap', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string.Const', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor_test.js', ['goog.html.sanitizer.SafeDomTreeProcessorTest'], ['goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.noclobber', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/tagblacklist.js', ['goog.html.sanitizer.TagBlacklist'], [], {});
goog.addDependency('html/sanitizer/tagwhitelist.js', ['goog.html.sanitizer.TagWhitelist'], [], {});
goog.addDependency('html/sanitizer/unsafe.js', ['goog.html.sanitizer.unsafe'], ['goog.asserts', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('html/sanitizer/unsafe_test.js', ['goog.html.UnsafeTest'], ['goog.html.SafeHtml', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.unsafe', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/silverlight.js', ['goog.html.silverlight'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const'], {});
goog.addDependency('html/silverlight_test.js', ['goog.html.silverlightTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.silverlight', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/testing.js', ['goog.html.testing'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('html/textextractor.js', ['goog.html.textExtractor'], ['goog.array', 'goog.dom.TagName', 'goog.html.sanitizer.HtmlSanitizer', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('html/textextractor_test.js', ['goog.html.textExtractorTest'], ['goog.html.textExtractor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedresourceurl.js', ['goog.html.TrustedResourceUrl'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/trustedresourceurl_test.js', ['goog.html.trustedResourceUrlTest'], ['goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedtypes.js', ['goog.html.trustedtypes'], [], {});
goog.addDependency('html/uncheckedconversions.js', ['goog.html.uncheckedconversions'], ['goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('html/uncheckedconversions_test.js', ['goog.html.uncheckedconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/utils.js', ['goog.html.utils'], ['goog.string'], {});
goog.addDependency('html/utils_test.js', ['goog.html.UtilsTest'], ['goog.array', 'goog.dom.TagName', 'goog.html.utils', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidi.js', ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.i18n.bidi.Format'], [], {'lang': 'es6'});
goog.addDependency('i18n/bidi_test.js', ['goog.i18n.bidiTest'], ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidiformatter.js', ['goog.i18n.BidiFormatter'], ['goog.html.SafeHtml', 'goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format'], {});
goog.addDependency('i18n/bidiformatter_test.js', ['goog.i18n.BidiFormatterTest'], ['goog.html.SafeHtml', 'goog.html.testing', 'goog.i18n.BidiFormatter', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charlistdecompressor.js', ['goog.i18n.CharListDecompressor'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/charlistdecompressor_test.js', ['goog.i18n.CharListDecompressorTest'], ['goog.i18n.CharListDecompressor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charpickerdata.js', ['goog.i18n.CharPickerData'], [], {});
goog.addDependency('i18n/collation.js', ['goog.i18n.collation'], [], {'lang': 'es6'});
goog.addDependency('i18n/collation_test.js', ['goog.i18n.collationTest'], ['goog.i18n.collation', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/compactnumberformatsymbols.js', ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_af', 'goog.i18n.CompactNumberFormatSymbols_am', 'goog.i18n.CompactNumberFormatSymbols_ar', 'goog.i18n.CompactNumberFormatSymbols_ar_DZ', 'goog.i18n.CompactNumberFormatSymbols_ar_EG', 'goog.i18n.CompactNumberFormatSymbols_az', 'goog.i18n.CompactNumberFormatSymbols_be', 'goog.i18n.CompactNumberFormatSymbols_bg', 'goog.i18n.CompactNumberFormatSymbols_bn', 'goog.i18n.CompactNumberFormatSymbols_br', 'goog.i18n.CompactNumberFormatSymbols_bs', 'goog.i18n.CompactNumberFormatSymbols_ca', 'goog.i18n.CompactNumberFormatSymbols_chr', 'goog.i18n.CompactNumberFormatSymbols_cs', 'goog.i18n.CompactNumberFormatSymbols_cy', 'goog.i18n.CompactNumberFormatSymbols_da', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_de_AT', 'goog.i18n.CompactNumberFormatSymbols_de_CH', 'goog.i18n.CompactNumberFormatSymbols_el', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_en_AU', 'goog.i18n.CompactNumberFormatSymbols_en_CA', 'goog.i18n.CompactNumberFormatSymbols_en_GB', 'goog.i18n.CompactNumberFormatSymbols_en_IE', 'goog.i18n.CompactNumberFormatSymbols_en_IN', 'goog.i18n.CompactNumberFormatSymbols_en_SG', 'goog.i18n.CompactNumberFormatSymbols_en_US', 'goog.i18n.CompactNumberFormatSymbols_en_ZA', 'goog.i18n.CompactNumberFormatSymbols_es', 'goog.i18n.CompactNumberFormatSymbols_es_419', 'goog.i18n.CompactNumberFormatSymbols_es_ES', 'goog.i18n.CompactNumberFormatSymbols_es_MX', 'goog.i18n.CompactNumberFormatSymbols_es_US', 'goog.i18n.CompactNumberFormatSymbols_et', 'goog.i18n.CompactNumberFormatSymbols_eu', 'goog.i18n.CompactNumberFormatSymbols_fa', 'goog.i18n.CompactNumberFormatSymbols_fi', 'goog.i18n.CompactNumberFormatSymbols_fil', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.CompactNumberFormatSymbols_fr_CA', 'goog.i18n.CompactNumberFormatSymbols_ga', 'goog.i18n.CompactNumberFormatSymbols_gl', 'goog.i18n.CompactNumberFormatSymbols_gsw', 'goog.i18n.CompactNumberFormatSymbols_gu', 'goog.i18n.CompactNumberFormatSymbols_haw', 'goog.i18n.CompactNumberFormatSymbols_he', 'goog.i18n.CompactNumberFormatSymbols_hi', 'goog.i18n.CompactNumberFormatSymbols_hr', 'goog.i18n.CompactNumberFormatSymbols_hu', 'goog.i18n.CompactNumberFormatSymbols_hy', 'goog.i18n.CompactNumberFormatSymbols_id', 'goog.i18n.CompactNumberFormatSymbols_in', 'goog.i18n.CompactNumberFormatSymbols_is', 'goog.i18n.CompactNumberFormatSymbols_it', 'goog.i18n.CompactNumberFormatSymbols_iw', 'goog.i18n.CompactNumberFormatSymbols_ja', 'goog.i18n.CompactNumberFormatSymbols_ka', 'goog.i18n.CompactNumberFormatSymbols_kk', 'goog.i18n.CompactNumberFormatSymbols_km', 'goog.i18n.CompactNumberFormatSymbols_kn', 'goog.i18n.CompactNumberFormatSymbols_ko', 'goog.i18n.CompactNumberFormatSymbols_ky', 'goog.i18n.CompactNumberFormatSymbols_ln', 'goog.i18n.CompactNumberFormatSymbols_lo', 'goog.i18n.CompactNumberFormatSymbols_lt', 'goog.i18n.CompactNumberFormatSymbols_lv', 'goog.i18n.CompactNumberFormatSymbols_mk', 'goog.i18n.CompactNumberFormatSymbols_ml', 'goog.i18n.CompactNumberFormatSymbols_mn', 'goog.i18n.CompactNumberFormatSymbols_mo', 'goog.i18n.CompactNumberFormatSymbols_mr', 'goog.i18n.CompactNumberFormatSymbols_ms', 'goog.i18n.CompactNumberFormatSymbols_mt', 'goog.i18n.CompactNumberFormatSymbols_my', 'goog.i18n.CompactNumberFormatSymbols_nb', 'goog.i18n.CompactNumberFormatSymbols_ne', 'goog.i18n.CompactNumberFormatSymbols_nl', 'goog.i18n.CompactNumberFormatSymbols_no', 'goog.i18n.CompactNumberFormatSymbols_no_NO', 'goog.i18n.CompactNumberFormatSymbols_or', 'goog.i18n.CompactNumberFormatSymbols_pa', 'goog.i18n.CompactNumberFormatSymbols_pl', 'goog.i18n.CompactNumberFormatSymbols_pt', 'goog.i18n.CompactNumberFormatSymbols_pt_BR', 'goog.i18n.CompactNumberFormatSymbols_pt_PT', 'goog.i18n.CompactNumberFormatSymbols_ro', 'goog.i18n.CompactNumberFormatSymbols_ru', 'goog.i18n.CompactNumberFormatSymbols_sh', 'goog.i18n.CompactNumberFormatSymbols_si', 'goog.i18n.CompactNumberFormatSymbols_sk', 'goog.i18n.CompactNumberFormatSymbols_sl', 'goog.i18n.CompactNumberFormatSymbols_sq', 'goog.i18n.CompactNumberFormatSymbols_sr', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn', 'goog.i18n.CompactNumberFormatSymbols_sv', 'goog.i18n.CompactNumberFormatSymbols_sw', 'goog.i18n.CompactNumberFormatSymbols_ta', 'goog.i18n.CompactNumberFormatSymbols_te', 'goog.i18n.CompactNumberFormatSymbols_th', 'goog.i18n.CompactNumberFormatSymbols_tl', 'goog.i18n.CompactNumberFormatSymbols_tr', 'goog.i18n.CompactNumberFormatSymbols_uk', 'goog.i18n.CompactNumberFormatSymbols_ur', 'goog.i18n.CompactNumberFormatSymbols_uz', 'goog.i18n.CompactNumberFormatSymbols_vi', 'goog.i18n.CompactNumberFormatSymbols_zh', 'goog.i18n.CompactNumberFormatSymbols_zh_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_TW', 'goog.i18n.CompactNumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/compactnumberformatsymbolsext.js', ['goog.i18n.CompactNumberFormatSymbolsExt', 'goog.i18n.CompactNumberFormatSymbols_af_NA', 'goog.i18n.CompactNumberFormatSymbols_af_ZA', 'goog.i18n.CompactNumberFormatSymbols_agq', 'goog.i18n.CompactNumberFormatSymbols_agq_CM', 'goog.i18n.CompactNumberFormatSymbols_ak', 'goog.i18n.CompactNumberFormatSymbols_ak_GH', 'goog.i18n.CompactNumberFormatSymbols_am_ET', 'goog.i18n.CompactNumberFormatSymbols_ar_001', 'goog.i18n.CompactNumberFormatSymbols_ar_AE', 'goog.i18n.CompactNumberFormatSymbols_ar_BH', 'goog.i18n.CompactNumberFormatSymbols_ar_DJ', 'goog.i18n.CompactNumberFormatSymbols_ar_EH', 'goog.i18n.CompactNumberFormatSymbols_ar_ER', 'goog.i18n.CompactNumberFormatSymbols_ar_IL', 'goog.i18n.CompactNumberFormatSymbols_ar_IQ', 'goog.i18n.CompactNumberFormatSymbols_ar_JO', 'goog.i18n.CompactNumberFormatSymbols_ar_KM', 'goog.i18n.CompactNumberFormatSymbols_ar_KW', 'goog.i18n.CompactNumberFormatSymbols_ar_LB', 'goog.i18n.CompactNumberFormatSymbols_ar_LY', 'goog.i18n.CompactNumberFormatSymbols_ar_MA', 'goog.i18n.CompactNumberFormatSymbols_ar_MR', 'goog.i18n.CompactNumberFormatSymbols_ar_OM', 'goog.i18n.CompactNumberFormatSymbols_ar_PS', 'goog.i18n.CompactNumberFormatSymbols_ar_QA', 'goog.i18n.CompactNumberFormatSymbols_ar_SA', 'goog.i18n.CompactNumberFormatSymbols_ar_SD', 'goog.i18n.CompactNumberFormatSymbols_ar_SO', 'goog.i18n.CompactNumberFormatSymbols_ar_SS', 'goog.i18n.CompactNumberFormatSymbols_ar_SY', 'goog.i18n.CompactNumberFormatSymbols_ar_TD', 'goog.i18n.CompactNumberFormatSymbols_ar_TN', 'goog.i18n.CompactNumberFormatSymbols_ar_XB', 'goog.i18n.CompactNumberFormatSymbols_ar_YE', 'goog.i18n.CompactNumberFormatSymbols_as', 'goog.i18n.CompactNumberFormatSymbols_as_IN', 'goog.i18n.CompactNumberFormatSymbols_asa', 'goog.i18n.CompactNumberFormatSymbols_asa_TZ', 'goog.i18n.CompactNumberFormatSymbols_ast', 'goog.i18n.CompactNumberFormatSymbols_ast_ES', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.CompactNumberFormatSymbols_az_Latn', 'goog.i18n.CompactNumberFormatSymbols_az_Latn_AZ', 'goog.i18n.CompactNumberFormatSymbols_bas', 'goog.i18n.CompactNumberFormatSymbols_bas_CM', 'goog.i18n.CompactNumberFormatSymbols_be_BY', 'goog.i18n.CompactNumberFormatSymbols_bem', 'goog.i18n.CompactNumberFormatSymbols_bem_ZM', 'goog.i18n.CompactNumberFormatSymbols_bez', 'goog.i18n.CompactNumberFormatSymbols_bez_TZ', 'goog.i18n.CompactNumberFormatSymbols_bg_BG', 'goog.i18n.CompactNumberFormatSymbols_bm', 'goog.i18n.CompactNumberFormatSymbols_bm_ML', 'goog.i18n.CompactNumberFormatSymbols_bn_BD', 'goog.i18n.CompactNumberFormatSymbols_bn_IN', 'goog.i18n.CompactNumberFormatSymbols_bo', 'goog.i18n.CompactNumberFormatSymbols_bo_CN', 'goog.i18n.CompactNumberFormatSymbols_bo_IN', 'goog.i18n.CompactNumberFormatSymbols_br_FR', 'goog.i18n.CompactNumberFormatSymbols_brx', 'goog.i18n.CompactNumberFormatSymbols_brx_IN', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_ca_AD', 'goog.i18n.CompactNumberFormatSymbols_ca_ES', 'goog.i18n.CompactNumberFormatSymbols_ca_FR', 'goog.i18n.CompactNumberFormatSymbols_ca_IT', 'goog.i18n.CompactNumberFormatSymbols_ccp', 'goog.i18n.CompactNumberFormatSymbols_ccp_BD', 'goog.i18n.CompactNumberFormatSymbols_ccp_IN', 'goog.i18n.CompactNumberFormatSymbols_ce', 'goog.i18n.CompactNumberFormatSymbols_ce_RU', 'goog.i18n.CompactNumberFormatSymbols_ceb', 'goog.i18n.CompactNumberFormatSymbols_ceb_PH', 'goog.i18n.CompactNumberFormatSymbols_cgg', 'goog.i18n.CompactNumberFormatSymbols_cgg_UG', 'goog.i18n.CompactNumberFormatSymbols_chr_US', 'goog.i18n.CompactNumberFormatSymbols_ckb', 'goog.i18n.CompactNumberFormatSymbols_ckb_IQ', 'goog.i18n.CompactNumberFormatSymbols_ckb_IR', 'goog.i18n.CompactNumberFormatSymbols_cs_CZ', 'goog.i18n.CompactNumberFormatSymbols_cy_GB', 'goog.i18n.CompactNumberFormatSymbols_da_DK', 'goog.i18n.CompactNumberFormatSymbols_da_GL', 'goog.i18n.CompactNumberFormatSymbols_dav', 'goog.i18n.CompactNumberFormatSymbols_dav_KE', 'goog.i18n.CompactNumberFormatSymbols_de_BE', 'goog.i18n.CompactNumberFormatSymbols_de_DE', 'goog.i18n.CompactNumberFormatSymbols_de_IT', 'goog.i18n.CompactNumberFormatSymbols_de_LI', 'goog.i18n.CompactNumberFormatSymbols_de_LU', 'goog.i18n.CompactNumberFormatSymbols_dje', 'goog.i18n.CompactNumberFormatSymbols_dje_NE', 'goog.i18n.CompactNumberFormatSymbols_dsb', 'goog.i18n.CompactNumberFormatSymbols_dsb_DE', 'goog.i18n.CompactNumberFormatSymbols_dua', 'goog.i18n.CompactNumberFormatSymbols_dua_CM', 'goog.i18n.CompactNumberFormatSymbols_dyo', 'goog.i18n.CompactNumberFormatSymbols_dyo_SN', 'goog.i18n.CompactNumberFormatSymbols_dz', 'goog.i18n.CompactNumberFormatSymbols_dz_BT', 'goog.i18n.CompactNumberFormatSymbols_ebu', 'goog.i18n.CompactNumberFormatSymbols_ebu_KE', 'goog.i18n.CompactNumberFormatSymbols_ee', 'goog.i18n.CompactNumberFormatSymbols_ee_GH', 'goog.i18n.CompactNumberFormatSymbols_ee_TG', 'goog.i18n.CompactNumberFormatSymbols_el_CY', 'goog.i18n.CompactNumberFormatSymbols_el_GR', 'goog.i18n.CompactNumberFormatSymbols_en_001', 'goog.i18n.CompactNumberFormatSymbols_en_150', 'goog.i18n.CompactNumberFormatSymbols_en_AE', 'goog.i18n.CompactNumberFormatSymbols_en_AG', 'goog.i18n.CompactNumberFormatSymbols_en_AI', 'goog.i18n.CompactNumberFormatSymbols_en_AS', 'goog.i18n.CompactNumberFormatSymbols_en_AT', 'goog.i18n.CompactNumberFormatSymbols_en_BB', 'goog.i18n.CompactNumberFormatSymbols_en_BE', 'goog.i18n.CompactNumberFormatSymbols_en_BI', 'goog.i18n.CompactNumberFormatSymbols_en_BM', 'goog.i18n.CompactNumberFormatSymbols_en_BS', 'goog.i18n.CompactNumberFormatSymbols_en_BW', 'goog.i18n.CompactNumberFormatSymbols_en_BZ', 'goog.i18n.CompactNumberFormatSymbols_en_CC', 'goog.i18n.CompactNumberFormatSymbols_en_CH', 'goog.i18n.CompactNumberFormatSymbols_en_CK', 'goog.i18n.CompactNumberFormatSymbols_en_CM', 'goog.i18n.CompactNumberFormatSymbols_en_CX', 'goog.i18n.CompactNumberFormatSymbols_en_CY', 'goog.i18n.CompactNumberFormatSymbols_en_DE', 'goog.i18n.CompactNumberFormatSymbols_en_DG', 'goog.i18n.CompactNumberFormatSymbols_en_DK', 'goog.i18n.CompactNumberFormatSymbols_en_DM', 'goog.i18n.CompactNumberFormatSymbols_en_ER', 'goog.i18n.CompactNumberFormatSymbols_en_FI', 'goog.i18n.CompactNumberFormatSymbols_en_FJ', 'goog.i18n.CompactNumberFormatSymbols_en_FK', 'goog.i18n.CompactNumberFormatSymbols_en_FM', 'goog.i18n.CompactNumberFormatSymbols_en_GD', 'goog.i18n.CompactNumberFormatSymbols_en_GG', 'goog.i18n.CompactNumberFormatSymbols_en_GH', 'goog.i18n.CompactNumberFormatSymbols_en_GI', 'goog.i18n.CompactNumberFormatSymbols_en_GM', 'goog.i18n.CompactNumberFormatSymbols_en_GU', 'goog.i18n.CompactNumberFormatSymbols_en_GY', 'goog.i18n.CompactNumberFormatSymbols_en_HK', 'goog.i18n.CompactNumberFormatSymbols_en_IL', 'goog.i18n.CompactNumberFormatSymbols_en_IM', 'goog.i18n.CompactNumberFormatSymbols_en_IO', 'goog.i18n.CompactNumberFormatSymbols_en_JE', 'goog.i18n.CompactNumberFormatSymbols_en_JM', 'goog.i18n.CompactNumberFormatSymbols_en_KE', 'goog.i18n.CompactNumberFormatSymbols_en_KI', 'goog.i18n.CompactNumberFormatSymbols_en_KN', 'goog.i18n.CompactNumberFormatSymbols_en_KY', 'goog.i18n.CompactNumberFormatSymbols_en_LC', 'goog.i18n.CompactNumberFormatSymbols_en_LR', 'goog.i18n.CompactNumberFormatSymbols_en_LS', 'goog.i18n.CompactNumberFormatSymbols_en_MG', 'goog.i18n.CompactNumberFormatSymbols_en_MH', 'goog.i18n.CompactNumberFormatSymbols_en_MO', 'goog.i18n.CompactNumberFormatSymbols_en_MP', 'goog.i18n.CompactNumberFormatSymbols_en_MS', 'goog.i18n.CompactNumberFormatSymbols_en_MT', 'goog.i18n.CompactNumberFormatSymbols_en_MU', 'goog.i18n.CompactNumberFormatSymbols_en_MW', 'goog.i18n.CompactNumberFormatSymbols_en_MY', 'goog.i18n.CompactNumberFormatSymbols_en_NA', 'goog.i18n.CompactNumberFormatSymbols_en_NF', 'goog.i18n.CompactNumberFormatSymbols_en_NG', 'goog.i18n.CompactNumberFormatSymbols_en_NL', 'goog.i18n.CompactNumberFormatSymbols_en_NR', 'goog.i18n.CompactNumberFormatSymbols_en_NU', 'goog.i18n.CompactNumberFormatSymbols_en_NZ', 'goog.i18n.CompactNumberFormatSymbols_en_PG', 'goog.i18n.CompactNumberFormatSymbols_en_PH', 'goog.i18n.CompactNumberFormatSymbols_en_PK', 'goog.i18n.CompactNumberFormatSymbols_en_PN', 'goog.i18n.CompactNumberFormatSymbols_en_PR', 'goog.i18n.CompactNumberFormatSymbols_en_PW', 'goog.i18n.CompactNumberFormatSymbols_en_RW', 'goog.i18n.CompactNumberFormatSymbols_en_SB', 'goog.i18n.CompactNumberFormatSymbols_en_SC', 'goog.i18n.CompactNumberFormatSymbols_en_SD', 'goog.i18n.CompactNumberFormatSymbols_en_SE', 'goog.i18n.CompactNumberFormatSymbols_en_SH', 'goog.i18n.CompactNumberFormatSymbols_en_SI', 'goog.i18n.CompactNumberFormatSymbols_en_SL', 'goog.i18n.CompactNumberFormatSymbols_en_SS', 'goog.i18n.CompactNumberFormatSymbols_en_SX', 'goog.i18n.CompactNumberFormatSymbols_en_SZ', 'goog.i18n.CompactNumberFormatSymbols_en_TC', 'goog.i18n.CompactNumberFormatSymbols_en_TK', 'goog.i18n.CompactNumberFormatSymbols_en_TO', 'goog.i18n.CompactNumberFormatSymbols_en_TT', 'goog.i18n.CompactNumberFormatSymbols_en_TV', 'goog.i18n.CompactNumberFormatSymbols_en_TZ', 'goog.i18n.CompactNumberFormatSymbols_en_UG', 'goog.i18n.CompactNumberFormatSymbols_en_UM', 'goog.i18n.CompactNumberFormatSymbols_en_US_POSIX', 'goog.i18n.CompactNumberFormatSymbols_en_VC', 'goog.i18n.CompactNumberFormatSymbols_en_VG', 'goog.i18n.CompactNumberFormatSymbols_en_VI', 'goog.i18n.CompactNumberFormatSymbols_en_VU', 'goog.i18n.CompactNumberFormatSymbols_en_WS', 'goog.i18n.CompactNumberFormatSymbols_en_XA', 'goog.i18n.CompactNumberFormatSymbols_en_ZM', 'goog.i18n.CompactNumberFormatSymbols_en_ZW', 'goog.i18n.CompactNumberFormatSymbols_eo', 'goog.i18n.CompactNumberFormatSymbols_eo_001', 'goog.i18n.CompactNumberFormatSymbols_es_AR', 'goog.i18n.CompactNumberFormatSymbols_es_BO', 'goog.i18n.CompactNumberFormatSymbols_es_BR', 'goog.i18n.CompactNumberFormatSymbols_es_BZ', 'goog.i18n.CompactNumberFormatSymbols_es_CL', 'goog.i18n.CompactNumberFormatSymbols_es_CO', 'goog.i18n.CompactNumberFormatSymbols_es_CR', 'goog.i18n.CompactNumberFormatSymbols_es_CU', 'goog.i18n.CompactNumberFormatSymbols_es_DO', 'goog.i18n.CompactNumberFormatSymbols_es_EA', 'goog.i18n.CompactNumberFormatSymbols_es_EC', 'goog.i18n.CompactNumberFormatSymbols_es_GQ', 'goog.i18n.CompactNumberFormatSymbols_es_GT', 'goog.i18n.CompactNumberFormatSymbols_es_HN', 'goog.i18n.CompactNumberFormatSymbols_es_IC', 'goog.i18n.CompactNumberFormatSymbols_es_NI', 'goog.i18n.CompactNumberFormatSymbols_es_PA', 'goog.i18n.CompactNumberFormatSymbols_es_PE', 'goog.i18n.CompactNumberFormatSymbols_es_PH', 'goog.i18n.CompactNumberFormatSymbols_es_PR', 'goog.i18n.CompactNumberFormatSymbols_es_PY', 'goog.i18n.CompactNumberFormatSymbols_es_SV', 'goog.i18n.CompactNumberFormatSymbols_es_UY', 'goog.i18n.CompactNumberFormatSymbols_es_VE', 'goog.i18n.CompactNumberFormatSymbols_et_EE', 'goog.i18n.CompactNumberFormatSymbols_eu_ES', 'goog.i18n.CompactNumberFormatSymbols_ewo', 'goog.i18n.CompactNumberFormatSymbols_ewo_CM', 'goog.i18n.CompactNumberFormatSymbols_fa_AF', 'goog.i18n.CompactNumberFormatSymbols_fa_IR', 'goog.i18n.CompactNumberFormatSymbols_ff', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_BF', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_CM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GH', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GN', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GW', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_MR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NE', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NG', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SL', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SN', 'goog.i18n.CompactNumberFormatSymbols_fi_FI', 'goog.i18n.CompactNumberFormatSymbols_fil_PH', 'goog.i18n.CompactNumberFormatSymbols_fo', 'goog.i18n.CompactNumberFormatSymbols_fo_DK', 'goog.i18n.CompactNumberFormatSymbols_fo_FO', 'goog.i18n.CompactNumberFormatSymbols_fr_BE', 'goog.i18n.CompactNumberFormatSymbols_fr_BF', 'goog.i18n.CompactNumberFormatSymbols_fr_BI', 'goog.i18n.CompactNumberFormatSymbols_fr_BJ', 'goog.i18n.CompactNumberFormatSymbols_fr_BL', 'goog.i18n.CompactNumberFormatSymbols_fr_CD', 'goog.i18n.CompactNumberFormatSymbols_fr_CF', 'goog.i18n.CompactNumberFormatSymbols_fr_CG', 'goog.i18n.CompactNumberFormatSymbols_fr_CH', 'goog.i18n.CompactNumberFormatSymbols_fr_CI', 'goog.i18n.CompactNumberFormatSymbols_fr_CM', 'goog.i18n.CompactNumberFormatSymbols_fr_DJ', 'goog.i18n.CompactNumberFormatSymbols_fr_DZ', 'goog.i18n.CompactNumberFormatSymbols_fr_FR', 'goog.i18n.CompactNumberFormatSymbols_fr_GA', 'goog.i18n.CompactNumberFormatSymbols_fr_GF', 'goog.i18n.CompactNumberFormatSymbols_fr_GN', 'goog.i18n.CompactNumberFormatSymbols_fr_GP', 'goog.i18n.CompactNumberFormatSymbols_fr_GQ', 'goog.i18n.CompactNumberFormatSymbols_fr_HT', 'goog.i18n.CompactNumberFormatSymbols_fr_KM', 'goog.i18n.CompactNumberFormatSymbols_fr_LU', 'goog.i18n.CompactNumberFormatSymbols_fr_MA', 'goog.i18n.CompactNumberFormatSymbols_fr_MC', 'goog.i18n.CompactNumberFormatSymbols_fr_MF', 'goog.i18n.CompactNumberFormatSymbols_fr_MG', 'goog.i18n.CompactNumberFormatSymbols_fr_ML', 'goog.i18n.CompactNumberFormatSymbols_fr_MQ', 'goog.i18n.CompactNumberFormatSymbols_fr_MR', 'goog.i18n.CompactNumberFormatSymbols_fr_MU', 'goog.i18n.CompactNumberFormatSymbols_fr_NC', 'goog.i18n.CompactNumberFormatSymbols_fr_NE', 'goog.i18n.CompactNumberFormatSymbols_fr_PF', 'goog.i18n.CompactNumberFormatSymbols_fr_PM', 'goog.i18n.CompactNumberFormatSymbols_fr_RE', 'goog.i18n.CompactNumberFormatSymbols_fr_RW', 'goog.i18n.CompactNumberFormatSymbols_fr_SC', 'goog.i18n.CompactNumberFormatSymbols_fr_SN', 'goog.i18n.CompactNumberFormatSymbols_fr_SY', 'goog.i18n.CompactNumberFormatSymbols_fr_TD', 'goog.i18n.CompactNumberFormatSymbols_fr_TG', 'goog.i18n.CompactNumberFormatSymbols_fr_TN', 'goog.i18n.CompactNumberFormatSymbols_fr_VU', 'goog.i18n.CompactNumberFormatSymbols_fr_WF', 'goog.i18n.CompactNumberFormatSymbols_fr_YT', 'goog.i18n.CompactNumberFormatSymbols_fur', 'goog.i18n.CompactNumberFormatSymbols_fur_IT', 'goog.i18n.CompactNumberFormatSymbols_fy', 'goog.i18n.CompactNumberFormatSymbols_fy_NL', 'goog.i18n.CompactNumberFormatSymbols_ga_IE', 'goog.i18n.CompactNumberFormatSymbols_gd', 'goog.i18n.CompactNumberFormatSymbols_gd_GB', 'goog.i18n.CompactNumberFormatSymbols_gl_ES', 'goog.i18n.CompactNumberFormatSymbols_gsw_CH', 'goog.i18n.CompactNumberFormatSymbols_gsw_FR', 'goog.i18n.CompactNumberFormatSymbols_gsw_LI', 'goog.i18n.CompactNumberFormatSymbols_gu_IN', 'goog.i18n.CompactNumberFormatSymbols_guz', 'goog.i18n.CompactNumberFormatSymbols_guz_KE', 'goog.i18n.CompactNumberFormatSymbols_gv', 'goog.i18n.CompactNumberFormatSymbols_gv_IM', 'goog.i18n.CompactNumberFormatSymbols_ha', 'goog.i18n.CompactNumberFormatSymbols_ha_GH', 'goog.i18n.CompactNumberFormatSymbols_ha_NE', 'goog.i18n.CompactNumberFormatSymbols_ha_NG', 'goog.i18n.CompactNumberFormatSymbols_haw_US', 'goog.i18n.CompactNumberFormatSymbols_he_IL', 'goog.i18n.CompactNumberFormatSymbols_hi_IN', 'goog.i18n.CompactNumberFormatSymbols_hr_BA', 'goog.i18n.CompactNumberFormatSymbols_hr_HR', 'goog.i18n.CompactNumberFormatSymbols_hsb', 'goog.i18n.CompactNumberFormatSymbols_hsb_DE', 'goog.i18n.CompactNumberFormatSymbols_hu_HU', 'goog.i18n.CompactNumberFormatSymbols_hy_AM', 'goog.i18n.CompactNumberFormatSymbols_ia', 'goog.i18n.CompactNumberFormatSymbols_ia_001', 'goog.i18n.CompactNumberFormatSymbols_id_ID', 'goog.i18n.CompactNumberFormatSymbols_ig', 'goog.i18n.CompactNumberFormatSymbols_ig_NG', 'goog.i18n.CompactNumberFormatSymbols_ii', 'goog.i18n.CompactNumberFormatSymbols_ii_CN', 'goog.i18n.CompactNumberFormatSymbols_is_IS', 'goog.i18n.CompactNumberFormatSymbols_it_CH', 'goog.i18n.CompactNumberFormatSymbols_it_IT', 'goog.i18n.CompactNumberFormatSymbols_it_SM', 'goog.i18n.CompactNumberFormatSymbols_it_VA', 'goog.i18n.CompactNumberFormatSymbols_ja_JP', 'goog.i18n.CompactNumberFormatSymbols_jgo', 'goog.i18n.CompactNumberFormatSymbols_jgo_CM', 'goog.i18n.CompactNumberFormatSymbols_jmc', 'goog.i18n.CompactNumberFormatSymbols_jmc_TZ', 'goog.i18n.CompactNumberFormatSymbols_jv', 'goog.i18n.CompactNumberFormatSymbols_jv_ID', 'goog.i18n.CompactNumberFormatSymbols_ka_GE', 'goog.i18n.CompactNumberFormatSymbols_kab', 'goog.i18n.CompactNumberFormatSymbols_kab_DZ', 'goog.i18n.CompactNumberFormatSymbols_kam', 'goog.i18n.CompactNumberFormatSymbols_kam_KE', 'goog.i18n.CompactNumberFormatSymbols_kde', 'goog.i18n.CompactNumberFormatSymbols_kde_TZ', 'goog.i18n.CompactNumberFormatSymbols_kea', 'goog.i18n.CompactNumberFormatSymbols_kea_CV', 'goog.i18n.CompactNumberFormatSymbols_khq', 'goog.i18n.CompactNumberFormatSymbols_khq_ML', 'goog.i18n.CompactNumberFormatSymbols_ki', 'goog.i18n.CompactNumberFormatSymbols_ki_KE', 'goog.i18n.CompactNumberFormatSymbols_kk_KZ', 'goog.i18n.CompactNumberFormatSymbols_kkj', 'goog.i18n.CompactNumberFormatSymbols_kkj_CM', 'goog.i18n.CompactNumberFormatSymbols_kl', 'goog.i18n.CompactNumberFormatSymbols_kl_GL', 'goog.i18n.CompactNumberFormatSymbols_kln', 'goog.i18n.CompactNumberFormatSymbols_kln_KE', 'goog.i18n.CompactNumberFormatSymbols_km_KH', 'goog.i18n.CompactNumberFormatSymbols_kn_IN', 'goog.i18n.CompactNumberFormatSymbols_ko_KP', 'goog.i18n.CompactNumberFormatSymbols_ko_KR', 'goog.i18n.CompactNumberFormatSymbols_kok', 'goog.i18n.CompactNumberFormatSymbols_kok_IN', 'goog.i18n.CompactNumberFormatSymbols_ks', 'goog.i18n.CompactNumberFormatSymbols_ks_IN', 'goog.i18n.CompactNumberFormatSymbols_ksb', 'goog.i18n.CompactNumberFormatSymbols_ksb_TZ', 'goog.i18n.CompactNumberFormatSymbols_ksf', 'goog.i18n.CompactNumberFormatSymbols_ksf_CM', 'goog.i18n.CompactNumberFormatSymbols_ksh', 'goog.i18n.CompactNumberFormatSymbols_ksh_DE', 'goog.i18n.CompactNumberFormatSymbols_ku', 'goog.i18n.CompactNumberFormatSymbols_ku_TR', 'goog.i18n.CompactNumberFormatSymbols_kw', 'goog.i18n.CompactNumberFormatSymbols_kw_GB', 'goog.i18n.CompactNumberFormatSymbols_ky_KG', 'goog.i18n.CompactNumberFormatSymbols_lag', 'goog.i18n.CompactNumberFormatSymbols_lag_TZ', 'goog.i18n.CompactNumberFormatSymbols_lb', 'goog.i18n.CompactNumberFormatSymbols_lb_LU', 'goog.i18n.CompactNumberFormatSymbols_lg', 'goog.i18n.CompactNumberFormatSymbols_lg_UG', 'goog.i18n.CompactNumberFormatSymbols_lkt', 'goog.i18n.CompactNumberFormatSymbols_lkt_US', 'goog.i18n.CompactNumberFormatSymbols_ln_AO', 'goog.i18n.CompactNumberFormatSymbols_ln_CD', 'goog.i18n.CompactNumberFormatSymbols_ln_CF', 'goog.i18n.CompactNumberFormatSymbols_ln_CG', 'goog.i18n.CompactNumberFormatSymbols_lo_LA', 'goog.i18n.CompactNumberFormatSymbols_lrc', 'goog.i18n.CompactNumberFormatSymbols_lrc_IQ', 'goog.i18n.CompactNumberFormatSymbols_lrc_IR', 'goog.i18n.CompactNumberFormatSymbols_lt_LT', 'goog.i18n.CompactNumberFormatSymbols_lu', 'goog.i18n.CompactNumberFormatSymbols_lu_CD', 'goog.i18n.CompactNumberFormatSymbols_luo', 'goog.i18n.CompactNumberFormatSymbols_luo_KE', 'goog.i18n.CompactNumberFormatSymbols_luy', 'goog.i18n.CompactNumberFormatSymbols_luy_KE', 'goog.i18n.CompactNumberFormatSymbols_lv_LV', 'goog.i18n.CompactNumberFormatSymbols_mas', 'goog.i18n.CompactNumberFormatSymbols_mas_KE', 'goog.i18n.CompactNumberFormatSymbols_mas_TZ', 'goog.i18n.CompactNumberFormatSymbols_mer', 'goog.i18n.CompactNumberFormatSymbols_mer_KE', 'goog.i18n.CompactNumberFormatSymbols_mfe', 'goog.i18n.CompactNumberFormatSymbols_mfe_MU', 'goog.i18n.CompactNumberFormatSymbols_mg', 'goog.i18n.CompactNumberFormatSymbols_mg_MG', 'goog.i18n.CompactNumberFormatSymbols_mgh', 'goog.i18n.CompactNumberFormatSymbols_mgh_MZ', 'goog.i18n.CompactNumberFormatSymbols_mgo', 'goog.i18n.CompactNumberFormatSymbols_mgo_CM', 'goog.i18n.CompactNumberFormatSymbols_mi', 'goog.i18n.CompactNumberFormatSymbols_mi_NZ', 'goog.i18n.CompactNumberFormatSymbols_mk_MK', 'goog.i18n.CompactNumberFormatSymbols_ml_IN', 'goog.i18n.CompactNumberFormatSymbols_mn_MN', 'goog.i18n.CompactNumberFormatSymbols_mr_IN', 'goog.i18n.CompactNumberFormatSymbols_ms_BN', 'goog.i18n.CompactNumberFormatSymbols_ms_MY', 'goog.i18n.CompactNumberFormatSymbols_ms_SG', 'goog.i18n.CompactNumberFormatSymbols_mt_MT', 'goog.i18n.CompactNumberFormatSymbols_mua', 'goog.i18n.CompactNumberFormatSymbols_mua_CM', 'goog.i18n.CompactNumberFormatSymbols_my_MM', 'goog.i18n.CompactNumberFormatSymbols_mzn', 'goog.i18n.CompactNumberFormatSymbols_mzn_IR', 'goog.i18n.CompactNumberFormatSymbols_naq', 'goog.i18n.CompactNumberFormatSymbols_naq_NA', 'goog.i18n.CompactNumberFormatSymbols_nb_NO', 'goog.i18n.CompactNumberFormatSymbols_nb_SJ', 'goog.i18n.CompactNumberFormatSymbols_nd', 'goog.i18n.CompactNumberFormatSymbols_nd_ZW', 'goog.i18n.CompactNumberFormatSymbols_nds', 'goog.i18n.CompactNumberFormatSymbols_nds_DE', 'goog.i18n.CompactNumberFormatSymbols_nds_NL', 'goog.i18n.CompactNumberFormatSymbols_ne_IN', 'goog.i18n.CompactNumberFormatSymbols_ne_NP', 'goog.i18n.CompactNumberFormatSymbols_nl_AW', 'goog.i18n.CompactNumberFormatSymbols_nl_BE', 'goog.i18n.CompactNumberFormatSymbols_nl_BQ', 'goog.i18n.CompactNumberFormatSymbols_nl_CW', 'goog.i18n.CompactNumberFormatSymbols_nl_NL', 'goog.i18n.CompactNumberFormatSymbols_nl_SR', 'goog.i18n.CompactNumberFormatSymbols_nl_SX', 'goog.i18n.CompactNumberFormatSymbols_nmg', 'goog.i18n.CompactNumberFormatSymbols_nmg_CM', 'goog.i18n.CompactNumberFormatSymbols_nn', 'goog.i18n.CompactNumberFormatSymbols_nn_NO', 'goog.i18n.CompactNumberFormatSymbols_nnh', 'goog.i18n.CompactNumberFormatSymbols_nnh_CM', 'goog.i18n.CompactNumberFormatSymbols_nus', 'goog.i18n.CompactNumberFormatSymbols_nus_SS', 'goog.i18n.CompactNumberFormatSymbols_nyn', 'goog.i18n.CompactNumberFormatSymbols_nyn_UG', 'goog.i18n.CompactNumberFormatSymbols_om', 'goog.i18n.CompactNumberFormatSymbols_om_ET', 'goog.i18n.CompactNumberFormatSymbols_om_KE', 'goog.i18n.CompactNumberFormatSymbols_or_IN', 'goog.i18n.CompactNumberFormatSymbols_os', 'goog.i18n.CompactNumberFormatSymbols_os_GE', 'goog.i18n.CompactNumberFormatSymbols_os_RU', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab_PK', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru_IN', 'goog.i18n.CompactNumberFormatSymbols_pl_PL', 'goog.i18n.CompactNumberFormatSymbols_ps', 'goog.i18n.CompactNumberFormatSymbols_ps_AF', 'goog.i18n.CompactNumberFormatSymbols_ps_PK', 'goog.i18n.CompactNumberFormatSymbols_pt_AO', 'goog.i18n.CompactNumberFormatSymbols_pt_CH', 'goog.i18n.CompactNumberFormatSymbols_pt_CV', 'goog.i18n.CompactNumberFormatSymbols_pt_GQ', 'goog.i18n.CompactNumberFormatSymbols_pt_GW', 'goog.i18n.CompactNumberFormatSymbols_pt_LU', 'goog.i18n.CompactNumberFormatSymbols_pt_MO', 'goog.i18n.CompactNumberFormatSymbols_pt_MZ', 'goog.i18n.CompactNumberFormatSymbols_pt_ST', 'goog.i18n.CompactNumberFormatSymbols_pt_TL', 'goog.i18n.CompactNumberFormatSymbols_qu', 'goog.i18n.CompactNumberFormatSymbols_qu_BO', 'goog.i18n.CompactNumberFormatSymbols_qu_EC', 'goog.i18n.CompactNumberFormatSymbols_qu_PE', 'goog.i18n.CompactNumberFormatSymbols_rm', 'goog.i18n.CompactNumberFormatSymbols_rm_CH', 'goog.i18n.CompactNumberFormatSymbols_rn', 'goog.i18n.CompactNumberFormatSymbols_rn_BI', 'goog.i18n.CompactNumberFormatSymbols_ro_MD', 'goog.i18n.CompactNumberFormatSymbols_ro_RO', 'goog.i18n.CompactNumberFormatSymbols_rof', 'goog.i18n.CompactNumberFormatSymbols_rof_TZ', 'goog.i18n.CompactNumberFormatSymbols_ru_BY', 'goog.i18n.CompactNumberFormatSymbols_ru_KG', 'goog.i18n.CompactNumberFormatSymbols_ru_KZ', 'goog.i18n.CompactNumberFormatSymbols_ru_MD', 'goog.i18n.CompactNumberFormatSymbols_ru_RU', 'goog.i18n.CompactNumberFormatSymbols_ru_UA', 'goog.i18n.CompactNumberFormatSymbols_rw', 'goog.i18n.CompactNumberFormatSymbols_rw_RW', 'goog.i18n.CompactNumberFormatSymbols_rwk', 'goog.i18n.CompactNumberFormatSymbols_rwk_TZ', 'goog.i18n.CompactNumberFormatSymbols_sah', 'goog.i18n.CompactNumberFormatSymbols_sah_RU', 'goog.i18n.CompactNumberFormatSymbols_saq', 'goog.i18n.CompactNumberFormatSymbols_saq_KE', 'goog.i18n.CompactNumberFormatSymbols_sbp', 'goog.i18n.CompactNumberFormatSymbols_sbp_TZ', 'goog.i18n.CompactNumberFormatSymbols_sd', 'goog.i18n.CompactNumberFormatSymbols_sd_PK', 'goog.i18n.CompactNumberFormatSymbols_se', 'goog.i18n.CompactNumberFormatSymbols_se_FI', 'goog.i18n.CompactNumberFormatSymbols_se_NO', 'goog.i18n.CompactNumberFormatSymbols_se_SE', 'goog.i18n.CompactNumberFormatSymbols_seh', 'goog.i18n.CompactNumberFormatSymbols_seh_MZ', 'goog.i18n.CompactNumberFormatSymbols_ses', 'goog.i18n.CompactNumberFormatSymbols_ses_ML', 'goog.i18n.CompactNumberFormatSymbols_sg', 'goog.i18n.CompactNumberFormatSymbols_sg_CF', 'goog.i18n.CompactNumberFormatSymbols_shi', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn_MA', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.CompactNumberFormatSymbols_si_LK', 'goog.i18n.CompactNumberFormatSymbols_sk_SK', 'goog.i18n.CompactNumberFormatSymbols_sl_SI', 'goog.i18n.CompactNumberFormatSymbols_smn', 'goog.i18n.CompactNumberFormatSymbols_smn_FI', 'goog.i18n.CompactNumberFormatSymbols_sn', 'goog.i18n.CompactNumberFormatSymbols_sn_ZW', 'goog.i18n.CompactNumberFormatSymbols_so', 'goog.i18n.CompactNumberFormatSymbols_so_DJ', 'goog.i18n.CompactNumberFormatSymbols_so_ET', 'goog.i18n.CompactNumberFormatSymbols_so_KE', 'goog.i18n.CompactNumberFormatSymbols_so_SO', 'goog.i18n.CompactNumberFormatSymbols_sq_AL', 'goog.i18n.CompactNumberFormatSymbols_sq_MK', 'goog.i18n.CompactNumberFormatSymbols_sq_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_XK', 'goog.i18n.CompactNumberFormatSymbols_sv_AX', 'goog.i18n.CompactNumberFormatSymbols_sv_FI', 'goog.i18n.CompactNumberFormatSymbols_sv_SE', 'goog.i18n.CompactNumberFormatSymbols_sw_CD', 'goog.i18n.CompactNumberFormatSymbols_sw_KE', 'goog.i18n.CompactNumberFormatSymbols_sw_TZ', 'goog.i18n.CompactNumberFormatSymbols_sw_UG', 'goog.i18n.CompactNumberFormatSymbols_ta_IN', 'goog.i18n.CompactNumberFormatSymbols_ta_LK', 'goog.i18n.CompactNumberFormatSymbols_ta_MY', 'goog.i18n.CompactNumberFormatSymbols_ta_SG', 'goog.i18n.CompactNumberFormatSymbols_te_IN', 'goog.i18n.CompactNumberFormatSymbols_teo', 'goog.i18n.CompactNumberFormatSymbols_teo_KE', 'goog.i18n.CompactNumberFormatSymbols_teo_UG', 'goog.i18n.CompactNumberFormatSymbols_tg', 'goog.i18n.CompactNumberFormatSymbols_tg_TJ', 'goog.i18n.CompactNumberFormatSymbols_th_TH', 'goog.i18n.CompactNumberFormatSymbols_ti', 'goog.i18n.CompactNumberFormatSymbols_ti_ER', 'goog.i18n.CompactNumberFormatSymbols_ti_ET', 'goog.i18n.CompactNumberFormatSymbols_tk', 'goog.i18n.CompactNumberFormatSymbols_tk_TM', 'goog.i18n.CompactNumberFormatSymbols_to', 'goog.i18n.CompactNumberFormatSymbols_to_TO', 'goog.i18n.CompactNumberFormatSymbols_tr_CY', 'goog.i18n.CompactNumberFormatSymbols_tr_TR', 'goog.i18n.CompactNumberFormatSymbols_tt', 'goog.i18n.CompactNumberFormatSymbols_tt_RU', 'goog.i18n.CompactNumberFormatSymbols_twq', 'goog.i18n.CompactNumberFormatSymbols_twq_NE', 'goog.i18n.CompactNumberFormatSymbols_tzm', 'goog.i18n.CompactNumberFormatSymbols_tzm_MA', 'goog.i18n.CompactNumberFormatSymbols_ug', 'goog.i18n.CompactNumberFormatSymbols_ug_CN', 'goog.i18n.CompactNumberFormatSymbols_uk_UA', 'goog.i18n.CompactNumberFormatSymbols_ur_IN', 'goog.i18n.CompactNumberFormatSymbols_ur_PK', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab_AF', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.CompactNumberFormatSymbols_vai', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.CompactNumberFormatSymbols_vi_VN', 'goog.i18n.CompactNumberFormatSymbols_vun', 'goog.i18n.CompactNumberFormatSymbols_vun_TZ', 'goog.i18n.CompactNumberFormatSymbols_wae', 'goog.i18n.CompactNumberFormatSymbols_wae_CH', 'goog.i18n.CompactNumberFormatSymbols_wo', 'goog.i18n.CompactNumberFormatSymbols_wo_SN', 'goog.i18n.CompactNumberFormatSymbols_xh', 'goog.i18n.CompactNumberFormatSymbols_xh_ZA', 'goog.i18n.CompactNumberFormatSymbols_xog', 'goog.i18n.CompactNumberFormatSymbols_xog_UG', 'goog.i18n.CompactNumberFormatSymbols_yav', 'goog.i18n.CompactNumberFormatSymbols_yav_CM', 'goog.i18n.CompactNumberFormatSymbols_yi', 'goog.i18n.CompactNumberFormatSymbols_yi_001', 'goog.i18n.CompactNumberFormatSymbols_yo', 'goog.i18n.CompactNumberFormatSymbols_yo_BJ', 'goog.i18n.CompactNumberFormatSymbols_yo_NG', 'goog.i18n.CompactNumberFormatSymbols_yue', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zgh', 'goog.i18n.CompactNumberFormatSymbols_zgh_MA', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_SG', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_TW', 'goog.i18n.CompactNumberFormatSymbols_zu_ZA'], ['goog.i18n.CompactNumberFormatSymbols'], {});
goog.addDependency('i18n/currency.js', ['goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.i18n.currency.CurrencyInfoTier2'], [], {'lang': 'es6'});
goog.addDependency('i18n/currency_test.js', ['goog.i18n.currencyTest'], ['goog.i18n.NumberFormat', 'goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/currencycodemap.js', ['goog.i18n.currencyCodeMap', 'goog.i18n.currencyCodeMapTier2'], [], {});
goog.addDependency('i18n/dateintervalformat.js', ['goog.i18n.DateIntervalFormat'], ['goog.array', 'goog.asserts', 'goog.date.DateLike', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalSymbols', 'goog.object'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/dateintervalformat_test.js', ['goog.i18n.DateIntervalFormatTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateIntervalFormat', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalPatterns', 'goog.i18n.dateIntervalSymbols', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalpatterns.js', ['goog.i18n.dateIntervalPatterns'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalpatternsext.js', ['goog.i18n.dateIntervalPatternsExt'], ['goog.i18n.dateIntervalPatterns'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbols.js', ['goog.i18n.dateIntervalSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbolsext.js', ['goog.i18n.dateIntervalSymbolsExt'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/datetimeformat.js', ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeFormat.Format'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeSymbols', 'goog.i18n.TimeZone', 'goog.string'], {});
goog.addDependency('i18n/datetimeformat_test.js', ['goog.i18n.DateTimeFormatTest'], ['goog.date.Date', 'goog.date.DateTime', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimeparse.js', ['goog.i18n.DateTimeParse'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/datetimeparse_test.js', ['goog.i18n.DateTimeParseTest'], ['goog.date.Date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_zh', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimepatterns.js', ['goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_af', 'goog.i18n.DateTimePatterns_am', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_ar_DZ', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_az', 'goog.i18n.DateTimePatterns_be', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_br', 'goog.i18n.DateTimePatterns_bs', 'goog.i18n.DateTimePatterns_ca', 'goog.i18n.DateTimePatterns_chr', 'goog.i18n.DateTimePatterns_cs', 'goog.i18n.DateTimePatterns_cy', 'goog.i18n.DateTimePatterns_da', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_de_AT', 'goog.i18n.DateTimePatterns_de_CH', 'goog.i18n.DateTimePatterns_el', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_AU', 'goog.i18n.DateTimePatterns_en_CA', 'goog.i18n.DateTimePatterns_en_GB', 'goog.i18n.DateTimePatterns_en_IE', 'goog.i18n.DateTimePatterns_en_IN', 'goog.i18n.DateTimePatterns_en_SG', 'goog.i18n.DateTimePatterns_en_US', 'goog.i18n.DateTimePatterns_en_ZA', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_es_419', 'goog.i18n.DateTimePatterns_es_ES', 'goog.i18n.DateTimePatterns_es_MX', 'goog.i18n.DateTimePatterns_es_US', 'goog.i18n.DateTimePatterns_et', 'goog.i18n.DateTimePatterns_eu', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fi', 'goog.i18n.DateTimePatterns_fil', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_fr_CA', 'goog.i18n.DateTimePatterns_ga', 'goog.i18n.DateTimePatterns_gl', 'goog.i18n.DateTimePatterns_gsw', 'goog.i18n.DateTimePatterns_gu', 'goog.i18n.DateTimePatterns_haw', 'goog.i18n.DateTimePatterns_he', 'goog.i18n.DateTimePatterns_hi', 'goog.i18n.DateTimePatterns_hr', 'goog.i18n.DateTimePatterns_hu', 'goog.i18n.DateTimePatterns_hy', 'goog.i18n.DateTimePatterns_id', 'goog.i18n.DateTimePatterns_in', 'goog.i18n.DateTimePatterns_is', 'goog.i18n.DateTimePatterns_it', 'goog.i18n.DateTimePatterns_iw', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_ka', 'goog.i18n.DateTimePatterns_kk', 'goog.i18n.DateTimePatterns_km', 'goog.i18n.DateTimePatterns_kn', 'goog.i18n.DateTimePatterns_ko', 'goog.i18n.DateTimePatterns_ky', 'goog.i18n.DateTimePatterns_ln', 'goog.i18n.DateTimePatterns_lo', 'goog.i18n.DateTimePatterns_lt', 'goog.i18n.DateTimePatterns_lv', 'goog.i18n.DateTimePatterns_mk', 'goog.i18n.DateTimePatterns_ml', 'goog.i18n.DateTimePatterns_mn', 'goog.i18n.DateTimePatterns_mo', 'goog.i18n.DateTimePatterns_mr', 'goog.i18n.DateTimePatterns_ms', 'goog.i18n.DateTimePatterns_mt', 'goog.i18n.DateTimePatterns_my', 'goog.i18n.DateTimePatterns_nb', 'goog.i18n.DateTimePatterns_ne', 'goog.i18n.DateTimePatterns_nl', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimePatterns_no_NO', 'goog.i18n.DateTimePatterns_or', 'goog.i18n.DateTimePatterns_pa', 'goog.i18n.DateTimePatterns_pl', 'goog.i18n.DateTimePatterns_pt', 'goog.i18n.DateTimePatterns_pt_BR', 'goog.i18n.DateTimePatterns_pt_PT', 'goog.i18n.DateTimePatterns_ro', 'goog.i18n.DateTimePatterns_ru', 'goog.i18n.DateTimePatterns_sh', 'goog.i18n.DateTimePatterns_si', 'goog.i18n.DateTimePatterns_sk', 'goog.i18n.DateTimePatterns_sl', 'goog.i18n.DateTimePatterns_sq', 'goog.i18n.DateTimePatterns_sr', 'goog.i18n.DateTimePatterns_sr_Latn', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_sw', 'goog.i18n.DateTimePatterns_ta', 'goog.i18n.DateTimePatterns_te', 'goog.i18n.DateTimePatterns_th', 'goog.i18n.DateTimePatterns_tl', 'goog.i18n.DateTimePatterns_tr', 'goog.i18n.DateTimePatterns_uk', 'goog.i18n.DateTimePatterns_ur', 'goog.i18n.DateTimePatterns_uz', 'goog.i18n.DateTimePatterns_vi', 'goog.i18n.DateTimePatterns_zh', 'goog.i18n.DateTimePatterns_zh_CN', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_TW', 'goog.i18n.DateTimePatterns_zu'], [], {});
goog.addDependency('i18n/datetimepatternsext.js', ['goog.i18n.DateTimePatternsExt', 'goog.i18n.DateTimePatterns_af_NA', 'goog.i18n.DateTimePatterns_af_ZA', 'goog.i18n.DateTimePatterns_agq', 'goog.i18n.DateTimePatterns_agq_CM', 'goog.i18n.DateTimePatterns_ak', 'goog.i18n.DateTimePatterns_ak_GH', 'goog.i18n.DateTimePatterns_am_ET', 'goog.i18n.DateTimePatterns_ar_001', 'goog.i18n.DateTimePatterns_ar_AE', 'goog.i18n.DateTimePatterns_ar_BH', 'goog.i18n.DateTimePatterns_ar_DJ', 'goog.i18n.DateTimePatterns_ar_EH', 'goog.i18n.DateTimePatterns_ar_ER', 'goog.i18n.DateTimePatterns_ar_IL', 'goog.i18n.DateTimePatterns_ar_IQ', 'goog.i18n.DateTimePatterns_ar_JO', 'goog.i18n.DateTimePatterns_ar_KM', 'goog.i18n.DateTimePatterns_ar_KW', 'goog.i18n.DateTimePatterns_ar_LB', 'goog.i18n.DateTimePatterns_ar_LY', 'goog.i18n.DateTimePatterns_ar_MA', 'goog.i18n.DateTimePatterns_ar_MR', 'goog.i18n.DateTimePatterns_ar_OM', 'goog.i18n.DateTimePatterns_ar_PS', 'goog.i18n.DateTimePatterns_ar_QA', 'goog.i18n.DateTimePatterns_ar_SA', 'goog.i18n.DateTimePatterns_ar_SD', 'goog.i18n.DateTimePatterns_ar_SO', 'goog.i18n.DateTimePatterns_ar_SS', 'goog.i18n.DateTimePatterns_ar_SY', 'goog.i18n.DateTimePatterns_ar_TD', 'goog.i18n.DateTimePatterns_ar_TN', 'goog.i18n.DateTimePatterns_ar_XB', 'goog.i18n.DateTimePatterns_ar_YE', 'goog.i18n.DateTimePatterns_as', 'goog.i18n.DateTimePatterns_as_IN', 'goog.i18n.DateTimePatterns_asa', 'goog.i18n.DateTimePatterns_asa_TZ', 'goog.i18n.DateTimePatterns_ast', 'goog.i18n.DateTimePatterns_ast_ES', 'goog.i18n.DateTimePatterns_az_Cyrl', 'goog.i18n.DateTimePatterns_az_Cyrl_AZ', 'goog.i18n.DateTimePatterns_az_Latn', 'goog.i18n.DateTimePatterns_az_Latn_AZ', 'goog.i18n.DateTimePatterns_bas', 'goog.i18n.DateTimePatterns_bas_CM', 'goog.i18n.DateTimePatterns_be_BY', 'goog.i18n.DateTimePatterns_bem', 'goog.i18n.DateTimePatterns_bem_ZM', 'goog.i18n.DateTimePatterns_bez', 'goog.i18n.DateTimePatterns_bez_TZ', 'goog.i18n.DateTimePatterns_bg_BG', 'goog.i18n.DateTimePatterns_bm', 'goog.i18n.DateTimePatterns_bm_ML', 'goog.i18n.DateTimePatterns_bn_BD', 'goog.i18n.DateTimePatterns_bn_IN', 'goog.i18n.DateTimePatterns_bo', 'goog.i18n.DateTimePatterns_bo_CN', 'goog.i18n.DateTimePatterns_bo_IN', 'goog.i18n.DateTimePatterns_br_FR', 'goog.i18n.DateTimePatterns_brx', 'goog.i18n.DateTimePatterns_brx_IN', 'goog.i18n.DateTimePatterns_bs_Cyrl', 'goog.i18n.DateTimePatterns_bs_Cyrl_BA', 'goog.i18n.DateTimePatterns_bs_Latn', 'goog.i18n.DateTimePatterns_bs_Latn_BA', 'goog.i18n.DateTimePatterns_ca_AD', 'goog.i18n.DateTimePatterns_ca_ES', 'goog.i18n.DateTimePatterns_ca_FR', 'goog.i18n.DateTimePatterns_ca_IT', 'goog.i18n.DateTimePatterns_ccp', 'goog.i18n.DateTimePatterns_ccp_BD', 'goog.i18n.DateTimePatterns_ccp_IN', 'goog.i18n.DateTimePatterns_ce', 'goog.i18n.DateTimePatterns_ce_RU', 'goog.i18n.DateTimePatterns_ceb', 'goog.i18n.DateTimePatterns_ceb_PH', 'goog.i18n.DateTimePatterns_cgg', 'goog.i18n.DateTimePatterns_cgg_UG', 'goog.i18n.DateTimePatterns_chr_US', 'goog.i18n.DateTimePatterns_ckb', 'goog.i18n.DateTimePatterns_ckb_IQ', 'goog.i18n.DateTimePatterns_ckb_IR', 'goog.i18n.DateTimePatterns_cs_CZ', 'goog.i18n.DateTimePatterns_cy_GB', 'goog.i18n.DateTimePatterns_da_DK', 'goog.i18n.DateTimePatterns_da_GL', 'goog.i18n.DateTimePatterns_dav', 'goog.i18n.DateTimePatterns_dav_KE', 'goog.i18n.DateTimePatterns_de_BE', 'goog.i18n.DateTimePatterns_de_DE', 'goog.i18n.DateTimePatterns_de_IT', 'goog.i18n.DateTimePatterns_de_LI', 'goog.i18n.DateTimePatterns_de_LU', 'goog.i18n.DateTimePatterns_dje', 'goog.i18n.DateTimePatterns_dje_NE', 'goog.i18n.DateTimePatterns_dsb', 'goog.i18n.DateTimePatterns_dsb_DE', 'goog.i18n.DateTimePatterns_dua', 'goog.i18n.DateTimePatterns_dua_CM', 'goog.i18n.DateTimePatterns_dyo', 'goog.i18n.DateTimePatterns_dyo_SN', 'goog.i18n.DateTimePatterns_dz', 'goog.i18n.DateTimePatterns_dz_BT', 'goog.i18n.DateTimePatterns_ebu', 'goog.i18n.DateTimePatterns_ebu_KE', 'goog.i18n.DateTimePatterns_ee', 'goog.i18n.DateTimePatterns_ee_GH', 'goog.i18n.DateTimePatterns_ee_TG', 'goog.i18n.DateTimePatterns_el_CY', 'goog.i18n.DateTimePatterns_el_GR', 'goog.i18n.DateTimePatterns_en_001', 'goog.i18n.DateTimePatterns_en_150', 'goog.i18n.DateTimePatterns_en_AE', 'goog.i18n.DateTimePatterns_en_AG', 'goog.i18n.DateTimePatterns_en_AI', 'goog.i18n.DateTimePatterns_en_AS', 'goog.i18n.DateTimePatterns_en_AT', 'goog.i18n.DateTimePatterns_en_BB', 'goog.i18n.DateTimePatterns_en_BE', 'goog.i18n.DateTimePatterns_en_BI', 'goog.i18n.DateTimePatterns_en_BM', 'goog.i18n.DateTimePatterns_en_BS', 'goog.i18n.DateTimePatterns_en_BW', 'goog.i18n.DateTimePatterns_en_BZ', 'goog.i18n.DateTimePatterns_en_CC', 'goog.i18n.DateTimePatterns_en_CH', 'goog.i18n.DateTimePatterns_en_CK', 'goog.i18n.DateTimePatterns_en_CM', 'goog.i18n.DateTimePatterns_en_CX', 'goog.i18n.DateTimePatterns_en_CY', 'goog.i18n.DateTimePatterns_en_DE', 'goog.i18n.DateTimePatterns_en_DG', 'goog.i18n.DateTimePatterns_en_DK', 'goog.i18n.DateTimePatterns_en_DM', 'goog.i18n.DateTimePatterns_en_ER', 'goog.i18n.DateTimePatterns_en_FI', 'goog.i18n.DateTimePatterns_en_FJ', 'goog.i18n.DateTimePatterns_en_FK', 'goog.i18n.DateTimePatterns_en_FM', 'goog.i18n.DateTimePatterns_en_GD', 'goog.i18n.DateTimePatterns_en_GG', 'goog.i18n.DateTimePatterns_en_GH', 'goog.i18n.DateTimePatterns_en_GI', 'goog.i18n.DateTimePatterns_en_GM', 'goog.i18n.DateTimePatterns_en_GU', 'goog.i18n.DateTimePatterns_en_GY', 'goog.i18n.DateTimePatterns_en_HK', 'goog.i18n.DateTimePatterns_en_IL', 'goog.i18n.DateTimePatterns_en_IM', 'goog.i18n.DateTimePatterns_en_IO', 'goog.i18n.DateTimePatterns_en_JE', 'goog.i18n.DateTimePatterns_en_JM', 'goog.i18n.DateTimePatterns_en_KE', 'goog.i18n.DateTimePatterns_en_KI', 'goog.i18n.DateTimePatterns_en_KN', 'goog.i18n.DateTimePatterns_en_KY', 'goog.i18n.DateTimePatterns_en_LC', 'goog.i18n.DateTimePatterns_en_LR', 'goog.i18n.DateTimePatterns_en_LS', 'goog.i18n.DateTimePatterns_en_MG', 'goog.i18n.DateTimePatterns_en_MH', 'goog.i18n.DateTimePatterns_en_MO', 'goog.i18n.DateTimePatterns_en_MP', 'goog.i18n.DateTimePatterns_en_MS', 'goog.i18n.DateTimePatterns_en_MT', 'goog.i18n.DateTimePatterns_en_MU', 'goog.i18n.DateTimePatterns_en_MW', 'goog.i18n.DateTimePatterns_en_MY', 'goog.i18n.DateTimePatterns_en_NA', 'goog.i18n.DateTimePatterns_en_NF', 'goog.i18n.DateTimePatterns_en_NG', 'goog.i18n.DateTimePatterns_en_NL', 'goog.i18n.DateTimePatterns_en_NR', 'goog.i18n.DateTimePatterns_en_NU', 'goog.i18n.DateTimePatterns_en_NZ', 'goog.i18n.DateTimePatterns_en_PG', 'goog.i18n.DateTimePatterns_en_PH', 'goog.i18n.DateTimePatterns_en_PK', 'goog.i18n.DateTimePatterns_en_PN', 'goog.i18n.DateTimePatterns_en_PR', 'goog.i18n.DateTimePatterns_en_PW', 'goog.i18n.DateTimePatterns_en_RW', 'goog.i18n.DateTimePatterns_en_SB', 'goog.i18n.DateTimePatterns_en_SC', 'goog.i18n.DateTimePatterns_en_SD', 'goog.i18n.DateTimePatterns_en_SE', 'goog.i18n.DateTimePatterns_en_SH', 'goog.i18n.DateTimePatterns_en_SI', 'goog.i18n.DateTimePatterns_en_SL', 'goog.i18n.DateTimePatterns_en_SS', 'goog.i18n.DateTimePatterns_en_SX', 'goog.i18n.DateTimePatterns_en_SZ', 'goog.i18n.DateTimePatterns_en_TC', 'goog.i18n.DateTimePatterns_en_TK', 'goog.i18n.DateTimePatterns_en_TO', 'goog.i18n.DateTimePatterns_en_TT', 'goog.i18n.DateTimePatterns_en_TV', 'goog.i18n.DateTimePatterns_en_TZ', 'goog.i18n.DateTimePatterns_en_UG', 'goog.i18n.DateTimePatterns_en_UM', 'goog.i18n.DateTimePatterns_en_US_POSIX', 'goog.i18n.DateTimePatterns_en_VC', 'goog.i18n.DateTimePatterns_en_VG', 'goog.i18n.DateTimePatterns_en_VI', 'goog.i18n.DateTimePatterns_en_VU', 'goog.i18n.DateTimePatterns_en_WS', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_en_ZM', 'goog.i18n.DateTimePatterns_en_ZW', 'goog.i18n.DateTimePatterns_eo', 'goog.i18n.DateTimePatterns_eo_001', 'goog.i18n.DateTimePatterns_es_AR', 'goog.i18n.DateTimePatterns_es_BO', 'goog.i18n.DateTimePatterns_es_BR', 'goog.i18n.DateTimePatterns_es_BZ', 'goog.i18n.DateTimePatterns_es_CL', 'goog.i18n.DateTimePatterns_es_CO', 'goog.i18n.DateTimePatterns_es_CR', 'goog.i18n.DateTimePatterns_es_CU', 'goog.i18n.DateTimePatterns_es_DO', 'goog.i18n.DateTimePatterns_es_EA', 'goog.i18n.DateTimePatterns_es_EC', 'goog.i18n.DateTimePatterns_es_GQ', 'goog.i18n.DateTimePatterns_es_GT', 'goog.i18n.DateTimePatterns_es_HN', 'goog.i18n.DateTimePatterns_es_IC', 'goog.i18n.DateTimePatterns_es_NI', 'goog.i18n.DateTimePatterns_es_PA', 'goog.i18n.DateTimePatterns_es_PE', 'goog.i18n.DateTimePatterns_es_PH', 'goog.i18n.DateTimePatterns_es_PR', 'goog.i18n.DateTimePatterns_es_PY', 'goog.i18n.DateTimePatterns_es_SV', 'goog.i18n.DateTimePatterns_es_UY', 'goog.i18n.DateTimePatterns_es_VE', 'goog.i18n.DateTimePatterns_et_EE', 'goog.i18n.DateTimePatterns_eu_ES', 'goog.i18n.DateTimePatterns_ewo', 'goog.i18n.DateTimePatterns_ewo_CM', 'goog.i18n.DateTimePatterns_fa_AF', 'goog.i18n.DateTimePatterns_fa_IR', 'goog.i18n.DateTimePatterns_ff', 'goog.i18n.DateTimePatterns_ff_Latn', 'goog.i18n.DateTimePatterns_ff_Latn_BF', 'goog.i18n.DateTimePatterns_ff_Latn_CM', 'goog.i18n.DateTimePatterns_ff_Latn_GH', 'goog.i18n.DateTimePatterns_ff_Latn_GM', 'goog.i18n.DateTimePatterns_ff_Latn_GN', 'goog.i18n.DateTimePatterns_ff_Latn_GW', 'goog.i18n.DateTimePatterns_ff_Latn_LR', 'goog.i18n.DateTimePatterns_ff_Latn_MR', 'goog.i18n.DateTimePatterns_ff_Latn_NE', 'goog.i18n.DateTimePatterns_ff_Latn_NG', 'goog.i18n.DateTimePatterns_ff_Latn_SL', 'goog.i18n.DateTimePatterns_ff_Latn_SN', 'goog.i18n.DateTimePatterns_fi_FI', 'goog.i18n.DateTimePatterns_fil_PH', 'goog.i18n.DateTimePatterns_fo', 'goog.i18n.DateTimePatterns_fo_DK', 'goog.i18n.DateTimePatterns_fo_FO', 'goog.i18n.DateTimePatterns_fr_BE', 'goog.i18n.DateTimePatterns_fr_BF', 'goog.i18n.DateTimePatterns_fr_BI', 'goog.i18n.DateTimePatterns_fr_BJ', 'goog.i18n.DateTimePatterns_fr_BL', 'goog.i18n.DateTimePatterns_fr_CD', 'goog.i18n.DateTimePatterns_fr_CF', 'goog.i18n.DateTimePatterns_fr_CG', 'goog.i18n.DateTimePatterns_fr_CH', 'goog.i18n.DateTimePatterns_fr_CI', 'goog.i18n.DateTimePatterns_fr_CM', 'goog.i18n.DateTimePatterns_fr_DJ', 'goog.i18n.DateTimePatterns_fr_DZ', 'goog.i18n.DateTimePatterns_fr_FR', 'goog.i18n.DateTimePatterns_fr_GA', 'goog.i18n.DateTimePatterns_fr_GF', 'goog.i18n.DateTimePatterns_fr_GN', 'goog.i18n.DateTimePatterns_fr_GP', 'goog.i18n.DateTimePatterns_fr_GQ', 'goog.i18n.DateTimePatterns_fr_HT', 'goog.i18n.DateTimePatterns_fr_KM', 'goog.i18n.DateTimePatterns_fr_LU', 'goog.i18n.DateTimePatterns_fr_MA', 'goog.i18n.DateTimePatterns_fr_MC', 'goog.i18n.DateTimePatterns_fr_MF', 'goog.i18n.DateTimePatterns_fr_MG', 'goog.i18n.DateTimePatterns_fr_ML', 'goog.i18n.DateTimePatterns_fr_MQ', 'goog.i18n.DateTimePatterns_fr_MR', 'goog.i18n.DateTimePatterns_fr_MU', 'goog.i18n.DateTimePatterns_fr_NC', 'goog.i18n.DateTimePatterns_fr_NE', 'goog.i18n.DateTimePatterns_fr_PF', 'goog.i18n.DateTimePatterns_fr_PM', 'goog.i18n.DateTimePatterns_fr_RE', 'goog.i18n.DateTimePatterns_fr_RW', 'goog.i18n.DateTimePatterns_fr_SC', 'goog.i18n.DateTimePatterns_fr_SN', 'goog.i18n.DateTimePatterns_fr_SY', 'goog.i18n.DateTimePatterns_fr_TD', 'goog.i18n.DateTimePatterns_fr_TG', 'goog.i18n.DateTimePatterns_fr_TN', 'goog.i18n.DateTimePatterns_fr_VU', 'goog.i18n.DateTimePatterns_fr_WF', 'goog.i18n.DateTimePatterns_fr_YT', 'goog.i18n.DateTimePatterns_fur', 'goog.i18n.DateTimePatterns_fur_IT', 'goog.i18n.DateTimePatterns_fy', 'goog.i18n.DateTimePatterns_fy_NL', 'goog.i18n.DateTimePatterns_ga_IE', 'goog.i18n.DateTimePatterns_gd', 'goog.i18n.DateTimePatterns_gd_GB', 'goog.i18n.DateTimePatterns_gl_ES', 'goog.i18n.DateTimePatterns_gsw_CH', 'goog.i18n.DateTimePatterns_gsw_FR', 'goog.i18n.DateTimePatterns_gsw_LI', 'goog.i18n.DateTimePatterns_gu_IN', 'goog.i18n.DateTimePatterns_guz', 'goog.i18n.DateTimePatterns_guz_KE', 'goog.i18n.DateTimePatterns_gv', 'goog.i18n.DateTimePatterns_gv_IM', 'goog.i18n.DateTimePatterns_ha', 'goog.i18n.DateTimePatterns_ha_GH', 'goog.i18n.DateTimePatterns_ha_NE', 'goog.i18n.DateTimePatterns_ha_NG', 'goog.i18n.DateTimePatterns_haw_US', 'goog.i18n.DateTimePatterns_he_IL', 'goog.i18n.DateTimePatterns_hi_IN', 'goog.i18n.DateTimePatterns_hr_BA', 'goog.i18n.DateTimePatterns_hr_HR', 'goog.i18n.DateTimePatterns_hsb', 'goog.i18n.DateTimePatterns_hsb_DE', 'goog.i18n.DateTimePatterns_hu_HU', 'goog.i18n.DateTimePatterns_hy_AM', 'goog.i18n.DateTimePatterns_ia', 'goog.i18n.DateTimePatterns_ia_001', 'goog.i18n.DateTimePatterns_id_ID', 'goog.i18n.DateTimePatterns_ig', 'goog.i18n.DateTimePatterns_ig_NG', 'goog.i18n.DateTimePatterns_ii', 'goog.i18n.DateTimePatterns_ii_CN', 'goog.i18n.DateTimePatterns_is_IS', 'goog.i18n.DateTimePatterns_it_CH', 'goog.i18n.DateTimePatterns_it_IT', 'goog.i18n.DateTimePatterns_it_SM', 'goog.i18n.DateTimePatterns_it_VA', 'goog.i18n.DateTimePatterns_ja_JP', 'goog.i18n.DateTimePatterns_jgo', 'goog.i18n.DateTimePatterns_jgo_CM', 'goog.i18n.DateTimePatterns_jmc', 'goog.i18n.DateTimePatterns_jmc_TZ', 'goog.i18n.DateTimePatterns_jv', 'goog.i18n.DateTimePatterns_jv_ID', 'goog.i18n.DateTimePatterns_ka_GE', 'goog.i18n.DateTimePatterns_kab', 'goog.i18n.DateTimePatterns_kab_DZ', 'goog.i18n.DateTimePatterns_kam', 'goog.i18n.DateTimePatterns_kam_KE', 'goog.i18n.DateTimePatterns_kde', 'goog.i18n.DateTimePatterns_kde_TZ', 'goog.i18n.DateTimePatterns_kea', 'goog.i18n.DateTimePatterns_kea_CV', 'goog.i18n.DateTimePatterns_khq', 'goog.i18n.DateTimePatterns_khq_ML', 'goog.i18n.DateTimePatterns_ki', 'goog.i18n.DateTimePatterns_ki_KE', 'goog.i18n.DateTimePatterns_kk_KZ', 'goog.i18n.DateTimePatterns_kkj', 'goog.i18n.DateTimePatterns_kkj_CM', 'goog.i18n.DateTimePatterns_kl', 'goog.i18n.DateTimePatterns_kl_GL', 'goog.i18n.DateTimePatterns_kln', 'goog.i18n.DateTimePatterns_kln_KE', 'goog.i18n.DateTimePatterns_km_KH', 'goog.i18n.DateTimePatterns_kn_IN', 'goog.i18n.DateTimePatterns_ko_KP', 'goog.i18n.DateTimePatterns_ko_KR', 'goog.i18n.DateTimePatterns_kok', 'goog.i18n.DateTimePatterns_kok_IN', 'goog.i18n.DateTimePatterns_ks', 'goog.i18n.DateTimePatterns_ks_IN', 'goog.i18n.DateTimePatterns_ksb', 'goog.i18n.DateTimePatterns_ksb_TZ', 'goog.i18n.DateTimePatterns_ksf', 'goog.i18n.DateTimePatterns_ksf_CM', 'goog.i18n.DateTimePatterns_ksh', 'goog.i18n.DateTimePatterns_ksh_DE', 'goog.i18n.DateTimePatterns_ku', 'goog.i18n.DateTimePatterns_ku_TR', 'goog.i18n.DateTimePatterns_kw', 'goog.i18n.DateTimePatterns_kw_GB', 'goog.i18n.DateTimePatterns_ky_KG', 'goog.i18n.DateTimePatterns_lag', 'goog.i18n.DateTimePatterns_lag_TZ', 'goog.i18n.DateTimePatterns_lb', 'goog.i18n.DateTimePatterns_lb_LU', 'goog.i18n.DateTimePatterns_lg', 'goog.i18n.DateTimePatterns_lg_UG', 'goog.i18n.DateTimePatterns_lkt', 'goog.i18n.DateTimePatterns_lkt_US', 'goog.i18n.DateTimePatterns_ln_AO', 'goog.i18n.DateTimePatterns_ln_CD', 'goog.i18n.DateTimePatterns_ln_CF', 'goog.i18n.DateTimePatterns_ln_CG', 'goog.i18n.DateTimePatterns_lo_LA', 'goog.i18n.DateTimePatterns_lrc', 'goog.i18n.DateTimePatterns_lrc_IQ', 'goog.i18n.DateTimePatterns_lrc_IR', 'goog.i18n.DateTimePatterns_lt_LT', 'goog.i18n.DateTimePatterns_lu', 'goog.i18n.DateTimePatterns_lu_CD', 'goog.i18n.DateTimePatterns_luo', 'goog.i18n.DateTimePatterns_luo_KE', 'goog.i18n.DateTimePatterns_luy', 'goog.i18n.DateTimePatterns_luy_KE', 'goog.i18n.DateTimePatterns_lv_LV', 'goog.i18n.DateTimePatterns_mas', 'goog.i18n.DateTimePatterns_mas_KE', 'goog.i18n.DateTimePatterns_mas_TZ', 'goog.i18n.DateTimePatterns_mer', 'goog.i18n.DateTimePatterns_mer_KE', 'goog.i18n.DateTimePatterns_mfe', 'goog.i18n.DateTimePatterns_mfe_MU', 'goog.i18n.DateTimePatterns_mg', 'goog.i18n.DateTimePatterns_mg_MG', 'goog.i18n.DateTimePatterns_mgh', 'goog.i18n.DateTimePatterns_mgh_MZ', 'goog.i18n.DateTimePatterns_mgo', 'goog.i18n.DateTimePatterns_mgo_CM', 'goog.i18n.DateTimePatterns_mi', 'goog.i18n.DateTimePatterns_mi_NZ', 'goog.i18n.DateTimePatterns_mk_MK', 'goog.i18n.DateTimePatterns_ml_IN', 'goog.i18n.DateTimePatterns_mn_MN', 'goog.i18n.DateTimePatterns_mr_IN', 'goog.i18n.DateTimePatterns_ms_BN', 'goog.i18n.DateTimePatterns_ms_MY', 'goog.i18n.DateTimePatterns_ms_SG', 'goog.i18n.DateTimePatterns_mt_MT', 'goog.i18n.DateTimePatterns_mua', 'goog.i18n.DateTimePatterns_mua_CM', 'goog.i18n.DateTimePatterns_my_MM', 'goog.i18n.DateTimePatterns_mzn', 'goog.i18n.DateTimePatterns_mzn_IR', 'goog.i18n.DateTimePatterns_naq', 'goog.i18n.DateTimePatterns_naq_NA', 'goog.i18n.DateTimePatterns_nb_NO', 'goog.i18n.DateTimePatterns_nb_SJ', 'goog.i18n.DateTimePatterns_nd', 'goog.i18n.DateTimePatterns_nd_ZW', 'goog.i18n.DateTimePatterns_nds', 'goog.i18n.DateTimePatterns_nds_DE', 'goog.i18n.DateTimePatterns_nds_NL', 'goog.i18n.DateTimePatterns_ne_IN', 'goog.i18n.DateTimePatterns_ne_NP', 'goog.i18n.DateTimePatterns_nl_AW', 'goog.i18n.DateTimePatterns_nl_BE', 'goog.i18n.DateTimePatterns_nl_BQ', 'goog.i18n.DateTimePatterns_nl_CW', 'goog.i18n.DateTimePatterns_nl_NL', 'goog.i18n.DateTimePatterns_nl_SR', 'goog.i18n.DateTimePatterns_nl_SX', 'goog.i18n.DateTimePatterns_nmg', 'goog.i18n.DateTimePatterns_nmg_CM', 'goog.i18n.DateTimePatterns_nn', 'goog.i18n.DateTimePatterns_nn_NO', 'goog.i18n.DateTimePatterns_nnh', 'goog.i18n.DateTimePatterns_nnh_CM', 'goog.i18n.DateTimePatterns_nus', 'goog.i18n.DateTimePatterns_nus_SS', 'goog.i18n.DateTimePatterns_nyn', 'goog.i18n.DateTimePatterns_nyn_UG', 'goog.i18n.DateTimePatterns_om', 'goog.i18n.DateTimePatterns_om_ET', 'goog.i18n.DateTimePatterns_om_KE', 'goog.i18n.DateTimePatterns_or_IN', 'goog.i18n.DateTimePatterns_os', 'goog.i18n.DateTimePatterns_os_GE', 'goog.i18n.DateTimePatterns_os_RU', 'goog.i18n.DateTimePatterns_pa_Arab', 'goog.i18n.DateTimePatterns_pa_Arab_PK', 'goog.i18n.DateTimePatterns_pa_Guru', 'goog.i18n.DateTimePatterns_pa_Guru_IN', 'goog.i18n.DateTimePatterns_pl_PL', 'goog.i18n.DateTimePatterns_ps', 'goog.i18n.DateTimePatterns_ps_AF', 'goog.i18n.DateTimePatterns_ps_PK', 'goog.i18n.DateTimePatterns_pt_AO', 'goog.i18n.DateTimePatterns_pt_CH', 'goog.i18n.DateTimePatterns_pt_CV', 'goog.i18n.DateTimePatterns_pt_GQ', 'goog.i18n.DateTimePatterns_pt_GW', 'goog.i18n.DateTimePatterns_pt_LU', 'goog.i18n.DateTimePatterns_pt_MO', 'goog.i18n.DateTimePatterns_pt_MZ', 'goog.i18n.DateTimePatterns_pt_ST', 'goog.i18n.DateTimePatterns_pt_TL', 'goog.i18n.DateTimePatterns_qu', 'goog.i18n.DateTimePatterns_qu_BO', 'goog.i18n.DateTimePatterns_qu_EC', 'goog.i18n.DateTimePatterns_qu_PE', 'goog.i18n.DateTimePatterns_rm', 'goog.i18n.DateTimePatterns_rm_CH', 'goog.i18n.DateTimePatterns_rn', 'goog.i18n.DateTimePatterns_rn_BI', 'goog.i18n.DateTimePatterns_ro_MD', 'goog.i18n.DateTimePatterns_ro_RO', 'goog.i18n.DateTimePatterns_rof', 'goog.i18n.DateTimePatterns_rof_TZ', 'goog.i18n.DateTimePatterns_ru_BY', 'goog.i18n.DateTimePatterns_ru_KG', 'goog.i18n.DateTimePatterns_ru_KZ', 'goog.i18n.DateTimePatterns_ru_MD', 'goog.i18n.DateTimePatterns_ru_RU', 'goog.i18n.DateTimePatterns_ru_UA', 'goog.i18n.DateTimePatterns_rw', 'goog.i18n.DateTimePatterns_rw_RW', 'goog.i18n.DateTimePatterns_rwk', 'goog.i18n.DateTimePatterns_rwk_TZ', 'goog.i18n.DateTimePatterns_sah', 'goog.i18n.DateTimePatterns_sah_RU', 'goog.i18n.DateTimePatterns_saq', 'goog.i18n.DateTimePatterns_saq_KE', 'goog.i18n.DateTimePatterns_sbp', 'goog.i18n.DateTimePatterns_sbp_TZ', 'goog.i18n.DateTimePatterns_sd', 'goog.i18n.DateTimePatterns_sd_PK', 'goog.i18n.DateTimePatterns_se', 'goog.i18n.DateTimePatterns_se_FI', 'goog.i18n.DateTimePatterns_se_NO', 'goog.i18n.DateTimePatterns_se_SE', 'goog.i18n.DateTimePatterns_seh', 'goog.i18n.DateTimePatterns_seh_MZ', 'goog.i18n.DateTimePatterns_ses', 'goog.i18n.DateTimePatterns_ses_ML', 'goog.i18n.DateTimePatterns_sg', 'goog.i18n.DateTimePatterns_sg_CF', 'goog.i18n.DateTimePatterns_shi', 'goog.i18n.DateTimePatterns_shi_Latn', 'goog.i18n.DateTimePatterns_shi_Latn_MA', 'goog.i18n.DateTimePatterns_shi_Tfng', 'goog.i18n.DateTimePatterns_shi_Tfng_MA', 'goog.i18n.DateTimePatterns_si_LK', 'goog.i18n.DateTimePatterns_sk_SK', 'goog.i18n.DateTimePatterns_sl_SI', 'goog.i18n.DateTimePatterns_smn', 'goog.i18n.DateTimePatterns_smn_FI', 'goog.i18n.DateTimePatterns_sn', 'goog.i18n.DateTimePatterns_sn_ZW', 'goog.i18n.DateTimePatterns_so', 'goog.i18n.DateTimePatterns_so_DJ', 'goog.i18n.DateTimePatterns_so_ET', 'goog.i18n.DateTimePatterns_so_KE', 'goog.i18n.DateTimePatterns_so_SO', 'goog.i18n.DateTimePatterns_sq_AL', 'goog.i18n.DateTimePatterns_sq_MK', 'goog.i18n.DateTimePatterns_sq_XK', 'goog.i18n.DateTimePatterns_sr_Cyrl', 'goog.i18n.DateTimePatterns_sr_Cyrl_BA', 'goog.i18n.DateTimePatterns_sr_Cyrl_ME', 'goog.i18n.DateTimePatterns_sr_Cyrl_RS', 'goog.i18n.DateTimePatterns_sr_Cyrl_XK', 'goog.i18n.DateTimePatterns_sr_Latn_BA', 'goog.i18n.DateTimePatterns_sr_Latn_ME', 'goog.i18n.DateTimePatterns_sr_Latn_RS', 'goog.i18n.DateTimePatterns_sr_Latn_XK', 'goog.i18n.DateTimePatterns_sv_AX', 'goog.i18n.DateTimePatterns_sv_FI', 'goog.i18n.DateTimePatterns_sv_SE', 'goog.i18n.DateTimePatterns_sw_CD', 'goog.i18n.DateTimePatterns_sw_KE', 'goog.i18n.DateTimePatterns_sw_TZ', 'goog.i18n.DateTimePatterns_sw_UG', 'goog.i18n.DateTimePatterns_ta_IN', 'goog.i18n.DateTimePatterns_ta_LK', 'goog.i18n.DateTimePatterns_ta_MY', 'goog.i18n.DateTimePatterns_ta_SG', 'goog.i18n.DateTimePatterns_te_IN', 'goog.i18n.DateTimePatterns_teo', 'goog.i18n.DateTimePatterns_teo_KE', 'goog.i18n.DateTimePatterns_teo_UG', 'goog.i18n.DateTimePatterns_tg', 'goog.i18n.DateTimePatterns_tg_TJ', 'goog.i18n.DateTimePatterns_th_TH', 'goog.i18n.DateTimePatterns_ti', 'goog.i18n.DateTimePatterns_ti_ER', 'goog.i18n.DateTimePatterns_ti_ET', 'goog.i18n.DateTimePatterns_tk', 'goog.i18n.DateTimePatterns_tk_TM', 'goog.i18n.DateTimePatterns_to', 'goog.i18n.DateTimePatterns_to_TO', 'goog.i18n.DateTimePatterns_tr_CY', 'goog.i18n.DateTimePatterns_tr_TR', 'goog.i18n.DateTimePatterns_tt', 'goog.i18n.DateTimePatterns_tt_RU', 'goog.i18n.DateTimePatterns_twq', 'goog.i18n.DateTimePatterns_twq_NE', 'goog.i18n.DateTimePatterns_tzm', 'goog.i18n.DateTimePatterns_tzm_MA', 'goog.i18n.DateTimePatterns_ug', 'goog.i18n.DateTimePatterns_ug_CN', 'goog.i18n.DateTimePatterns_uk_UA', 'goog.i18n.DateTimePatterns_ur_IN', 'goog.i18n.DateTimePatterns_ur_PK', 'goog.i18n.DateTimePatterns_uz_Arab', 'goog.i18n.DateTimePatterns_uz_Arab_AF', 'goog.i18n.DateTimePatterns_uz_Cyrl', 'goog.i18n.DateTimePatterns_uz_Cyrl_UZ', 'goog.i18n.DateTimePatterns_uz_Latn', 'goog.i18n.DateTimePatterns_uz_Latn_UZ', 'goog.i18n.DateTimePatterns_vai', 'goog.i18n.DateTimePatterns_vai_Latn', 'goog.i18n.DateTimePatterns_vai_Latn_LR', 'goog.i18n.DateTimePatterns_vai_Vaii', 'goog.i18n.DateTimePatterns_vai_Vaii_LR', 'goog.i18n.DateTimePatterns_vi_VN', 'goog.i18n.DateTimePatterns_vun', 'goog.i18n.DateTimePatterns_vun_TZ', 'goog.i18n.DateTimePatterns_wae', 'goog.i18n.DateTimePatterns_wae_CH', 'goog.i18n.DateTimePatterns_wo', 'goog.i18n.DateTimePatterns_wo_SN', 'goog.i18n.DateTimePatterns_xh', 'goog.i18n.DateTimePatterns_xh_ZA', 'goog.i18n.DateTimePatterns_xog', 'goog.i18n.DateTimePatterns_xog_UG', 'goog.i18n.DateTimePatterns_yav', 'goog.i18n.DateTimePatterns_yav_CM', 'goog.i18n.DateTimePatterns_yi', 'goog.i18n.DateTimePatterns_yi_001', 'goog.i18n.DateTimePatterns_yo', 'goog.i18n.DateTimePatterns_yo_BJ', 'goog.i18n.DateTimePatterns_yo_NG', 'goog.i18n.DateTimePatterns_yue', 'goog.i18n.DateTimePatterns_yue_Hans', 'goog.i18n.DateTimePatterns_yue_Hans_CN', 'goog.i18n.DateTimePatterns_yue_Hant', 'goog.i18n.DateTimePatterns_yue_Hant_HK', 'goog.i18n.DateTimePatterns_zgh', 'goog.i18n.DateTimePatterns_zgh_MA', 'goog.i18n.DateTimePatterns_zh_Hans', 'goog.i18n.DateTimePatterns_zh_Hans_CN', 'goog.i18n.DateTimePatterns_zh_Hans_HK', 'goog.i18n.DateTimePatterns_zh_Hans_MO', 'goog.i18n.DateTimePatterns_zh_Hans_SG', 'goog.i18n.DateTimePatterns_zh_Hant', 'goog.i18n.DateTimePatterns_zh_Hant_HK', 'goog.i18n.DateTimePatterns_zh_Hant_MO', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimePatterns_zu_ZA'], ['goog.i18n.DateTimePatterns'], {});
goog.addDependency('i18n/datetimesymbols.js', ['goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.DateTimeSymbols_af', 'goog.i18n.DateTimeSymbols_am', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_ar_DZ', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_az', 'goog.i18n.DateTimeSymbols_be', 'goog.i18n.DateTimeSymbols_bg', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_br', 'goog.i18n.DateTimeSymbols_bs', 'goog.i18n.DateTimeSymbols_ca', 'goog.i18n.DateTimeSymbols_chr', 'goog.i18n.DateTimeSymbols_cs', 'goog.i18n.DateTimeSymbols_cy', 'goog.i18n.DateTimeSymbols_da', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_de_AT', 'goog.i18n.DateTimeSymbols_de_CH', 'goog.i18n.DateTimeSymbols_el', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_AU', 'goog.i18n.DateTimeSymbols_en_CA', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_ISO', 'goog.i18n.DateTimeSymbols_en_SG', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_en_ZA', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_es_419', 'goog.i18n.DateTimeSymbols_es_ES', 'goog.i18n.DateTimeSymbols_es_MX', 'goog.i18n.DateTimeSymbols_es_US', 'goog.i18n.DateTimeSymbols_et', 'goog.i18n.DateTimeSymbols_eu', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fi', 'goog.i18n.DateTimeSymbols_fil', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_ga', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_gsw', 'goog.i18n.DateTimeSymbols_gu', 'goog.i18n.DateTimeSymbols_haw', 'goog.i18n.DateTimeSymbols_he', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_hr', 'goog.i18n.DateTimeSymbols_hu', 'goog.i18n.DateTimeSymbols_hy', 'goog.i18n.DateTimeSymbols_id', 'goog.i18n.DateTimeSymbols_in', 'goog.i18n.DateTimeSymbols_is', 'goog.i18n.DateTimeSymbols_it', 'goog.i18n.DateTimeSymbols_iw', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ka', 'goog.i18n.DateTimeSymbols_kk', 'goog.i18n.DateTimeSymbols_km', 'goog.i18n.DateTimeSymbols_kn', 'goog.i18n.DateTimeSymbols_ko', 'goog.i18n.DateTimeSymbols_ky', 'goog.i18n.DateTimeSymbols_ln', 'goog.i18n.DateTimeSymbols_lo', 'goog.i18n.DateTimeSymbols_lt', 'goog.i18n.DateTimeSymbols_lv', 'goog.i18n.DateTimeSymbols_mk', 'goog.i18n.DateTimeSymbols_ml', 'goog.i18n.DateTimeSymbols_mn', 'goog.i18n.DateTimeSymbols_mo', 'goog.i18n.DateTimeSymbols_mr', 'goog.i18n.DateTimeSymbols_ms', 'goog.i18n.DateTimeSymbols_mt', 'goog.i18n.DateTimeSymbols_my', 'goog.i18n.DateTimeSymbols_nb', 'goog.i18n.DateTimeSymbols_ne', 'goog.i18n.DateTimeSymbols_nl', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.DateTimeSymbols_no_NO', 'goog.i18n.DateTimeSymbols_or', 'goog.i18n.DateTimeSymbols_pa', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_pt', 'goog.i18n.DateTimeSymbols_pt_BR', 'goog.i18n.DateTimeSymbols_pt_PT', 'goog.i18n.DateTimeSymbols_ro', 'goog.i18n.DateTimeSymbols_ru', 'goog.i18n.DateTimeSymbols_sh', 'goog.i18n.DateTimeSymbols_si', 'goog.i18n.DateTimeSymbols_sk', 'goog.i18n.DateTimeSymbols_sl', 'goog.i18n.DateTimeSymbols_sq', 'goog.i18n.DateTimeSymbols_sr', 'goog.i18n.DateTimeSymbols_sr_Latn', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.DateTimeSymbols_sw', 'goog.i18n.DateTimeSymbols_ta', 'goog.i18n.DateTimeSymbols_te', 'goog.i18n.DateTimeSymbols_th', 'goog.i18n.DateTimeSymbols_tl', 'goog.i18n.DateTimeSymbols_tr', 'goog.i18n.DateTimeSymbols_uk', 'goog.i18n.DateTimeSymbols_ur', 'goog.i18n.DateTimeSymbols_uz', 'goog.i18n.DateTimeSymbols_vi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.DateTimeSymbols_zh_CN', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.i18n.DateTimeSymbols_zh_TW', 'goog.i18n.DateTimeSymbols_zu'], [], {});
goog.addDependency('i18n/datetimesymbolsext.js', ['goog.i18n.DateTimeSymbolsExt', 'goog.i18n.DateTimeSymbols_af_NA', 'goog.i18n.DateTimeSymbols_af_ZA', 'goog.i18n.DateTimeSymbols_agq', 'goog.i18n.DateTimeSymbols_agq_CM', 'goog.i18n.DateTimeSymbols_ak', 'goog.i18n.DateTimeSymbols_ak_GH', 'goog.i18n.DateTimeSymbols_am_ET', 'goog.i18n.DateTimeSymbols_ar_001', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_BH', 'goog.i18n.DateTimeSymbols_ar_DJ', 'goog.i18n.DateTimeSymbols_ar_EH', 'goog.i18n.DateTimeSymbols_ar_ER', 'goog.i18n.DateTimeSymbols_ar_IL', 'goog.i18n.DateTimeSymbols_ar_IQ', 'goog.i18n.DateTimeSymbols_ar_JO', 'goog.i18n.DateTimeSymbols_ar_KM', 'goog.i18n.DateTimeSymbols_ar_KW', 'goog.i18n.DateTimeSymbols_ar_LB', 'goog.i18n.DateTimeSymbols_ar_LY', 'goog.i18n.DateTimeSymbols_ar_MA', 'goog.i18n.DateTimeSymbols_ar_MR', 'goog.i18n.DateTimeSymbols_ar_OM', 'goog.i18n.DateTimeSymbols_ar_PS', 'goog.i18n.DateTimeSymbols_ar_QA', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_ar_SD', 'goog.i18n.DateTimeSymbols_ar_SO', 'goog.i18n.DateTimeSymbols_ar_SS', 'goog.i18n.DateTimeSymbols_ar_SY', 'goog.i18n.DateTimeSymbols_ar_TD', 'goog.i18n.DateTimeSymbols_ar_TN', 'goog.i18n.DateTimeSymbols_ar_XB', 'goog.i18n.DateTimeSymbols_ar_YE', 'goog.i18n.DateTimeSymbols_as', 'goog.i18n.DateTimeSymbols_as_IN', 'goog.i18n.DateTimeSymbols_asa', 'goog.i18n.DateTimeSymbols_asa_TZ', 'goog.i18n.DateTimeSymbols_ast', 'goog.i18n.DateTimeSymbols_ast_ES', 'goog.i18n.DateTimeSymbols_az_Cyrl', 'goog.i18n.DateTimeSymbols_az_Cyrl_AZ', 'goog.i18n.DateTimeSymbols_az_Latn', 'goog.i18n.DateTimeSymbols_az_Latn_AZ', 'goog.i18n.DateTimeSymbols_bas', 'goog.i18n.DateTimeSymbols_bas_CM', 'goog.i18n.DateTimeSymbols_be_BY', 'goog.i18n.DateTimeSymbols_bem', 'goog.i18n.DateTimeSymbols_bem_ZM', 'goog.i18n.DateTimeSymbols_bez', 'goog.i18n.DateTimeSymbols_bez_TZ', 'goog.i18n.DateTimeSymbols_bg_BG', 'goog.i18n.DateTimeSymbols_bm', 'goog.i18n.DateTimeSymbols_bm_ML', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_bn_IN', 'goog.i18n.DateTimeSymbols_bo', 'goog.i18n.DateTimeSymbols_bo_CN', 'goog.i18n.DateTimeSymbols_bo_IN', 'goog.i18n.DateTimeSymbols_br_FR', 'goog.i18n.DateTimeSymbols_brx', 'goog.i18n.DateTimeSymbols_brx_IN', 'goog.i18n.DateTimeSymbols_bs_Cyrl', 'goog.i18n.DateTimeSymbols_bs_Cyrl_BA', 'goog.i18n.DateTimeSymbols_bs_Latn', 'goog.i18n.DateTimeSymbols_bs_Latn_BA', 'goog.i18n.DateTimeSymbols_ca_AD', 'goog.i18n.DateTimeSymbols_ca_ES', 'goog.i18n.DateTimeSymbols_ca_FR', 'goog.i18n.DateTimeSymbols_ca_IT', 'goog.i18n.DateTimeSymbols_ccp', 'goog.i18n.DateTimeSymbols_ccp_BD', 'goog.i18n.DateTimeSymbols_ccp_IN', 'goog.i18n.DateTimeSymbols_ce', 'goog.i18n.DateTimeSymbols_ce_RU', 'goog.i18n.DateTimeSymbols_ceb', 'goog.i18n.DateTimeSymbols_ceb_PH', 'goog.i18n.DateTimeSymbols_cgg', 'goog.i18n.DateTimeSymbols_cgg_UG', 'goog.i18n.DateTimeSymbols_chr_US', 'goog.i18n.DateTimeSymbols_ckb', 'goog.i18n.DateTimeSymbols_ckb_IQ', 'goog.i18n.DateTimeSymbols_ckb_IR', 'goog.i18n.DateTimeSymbols_cs_CZ', 'goog.i18n.DateTimeSymbols_cy_GB', 'goog.i18n.DateTimeSymbols_da_DK', 'goog.i18n.DateTimeSymbols_da_GL', 'goog.i18n.DateTimeSymbols_dav', 'goog.i18n.DateTimeSymbols_dav_KE', 'goog.i18n.DateTimeSymbols_de_BE', 'goog.i18n.DateTimeSymbols_de_DE', 'goog.i18n.DateTimeSymbols_de_IT', 'goog.i18n.DateTimeSymbols_de_LI', 'goog.i18n.DateTimeSymbols_de_LU', 'goog.i18n.DateTimeSymbols_dje', 'goog.i18n.DateTimeSymbols_dje_NE', 'goog.i18n.DateTimeSymbols_dsb', 'goog.i18n.DateTimeSymbols_dsb_DE', 'goog.i18n.DateTimeSymbols_dua', 'goog.i18n.DateTimeSymbols_dua_CM', 'goog.i18n.DateTimeSymbols_dyo', 'goog.i18n.DateTimeSymbols_dyo_SN', 'goog.i18n.DateTimeSymbols_dz', 'goog.i18n.DateTimeSymbols_dz_BT', 'goog.i18n.DateTimeSymbols_ebu', 'goog.i18n.DateTimeSymbols_ebu_KE', 'goog.i18n.DateTimeSymbols_ee', 'goog.i18n.DateTimeSymbols_ee_GH', 'goog.i18n.DateTimeSymbols_ee_TG', 'goog.i18n.DateTimeSymbols_el_CY', 'goog.i18n.DateTimeSymbols_el_GR', 'goog.i18n.DateTimeSymbols_en_001', 'goog.i18n.DateTimeSymbols_en_150', 'goog.i18n.DateTimeSymbols_en_AE', 'goog.i18n.DateTimeSymbols_en_AG', 'goog.i18n.DateTimeSymbols_en_AI', 'goog.i18n.DateTimeSymbols_en_AS', 'goog.i18n.DateTimeSymbols_en_AT', 'goog.i18n.DateTimeSymbols_en_BB', 'goog.i18n.DateTimeSymbols_en_BE', 'goog.i18n.DateTimeSymbols_en_BI', 'goog.i18n.DateTimeSymbols_en_BM', 'goog.i18n.DateTimeSymbols_en_BS', 'goog.i18n.DateTimeSymbols_en_BW', 'goog.i18n.DateTimeSymbols_en_BZ', 'goog.i18n.DateTimeSymbols_en_CC', 'goog.i18n.DateTimeSymbols_en_CH', 'goog.i18n.DateTimeSymbols_en_CK', 'goog.i18n.DateTimeSymbols_en_CM', 'goog.i18n.DateTimeSymbols_en_CX', 'goog.i18n.DateTimeSymbols_en_CY', 'goog.i18n.DateTimeSymbols_en_DE', 'goog.i18n.DateTimeSymbols_en_DG', 'goog.i18n.DateTimeSymbols_en_DK', 'goog.i18n.DateTimeSymbols_en_DM', 'goog.i18n.DateTimeSymbols_en_ER', 'goog.i18n.DateTimeSymbols_en_FI', 'goog.i18n.DateTimeSymbols_en_FJ', 'goog.i18n.DateTimeSymbols_en_FK', 'goog.i18n.DateTimeSymbols_en_FM', 'goog.i18n.DateTimeSymbols_en_GD', 'goog.i18n.DateTimeSymbols_en_GG', 'goog.i18n.DateTimeSymbols_en_GH', 'goog.i18n.DateTimeSymbols_en_GI', 'goog.i18n.DateTimeSymbols_en_GM', 'goog.i18n.DateTimeSymbols_en_GU', 'goog.i18n.DateTimeSymbols_en_GY', 'goog.i18n.DateTimeSymbols_en_HK', 'goog.i18n.DateTimeSymbols_en_IL', 'goog.i18n.DateTimeSymbols_en_IM', 'goog.i18n.DateTimeSymbols_en_IO', 'goog.i18n.DateTimeSymbols_en_JE', 'goog.i18n.DateTimeSymbols_en_JM', 'goog.i18n.DateTimeSymbols_en_KE', 'goog.i18n.DateTimeSymbols_en_KI', 'goog.i18n.DateTimeSymbols_en_KN', 'goog.i18n.DateTimeSymbols_en_KY', 'goog.i18n.DateTimeSymbols_en_LC', 'goog.i18n.DateTimeSymbols_en_LR', 'goog.i18n.DateTimeSymbols_en_LS', 'goog.i18n.DateTimeSymbols_en_MG', 'goog.i18n.DateTimeSymbols_en_MH', 'goog.i18n.DateTimeSymbols_en_MO', 'goog.i18n.DateTimeSymbols_en_MP', 'goog.i18n.DateTimeSymbols_en_MS', 'goog.i18n.DateTimeSymbols_en_MT', 'goog.i18n.DateTimeSymbols_en_MU', 'goog.i18n.DateTimeSymbols_en_MW', 'goog.i18n.DateTimeSymbols_en_MY', 'goog.i18n.DateTimeSymbols_en_NA', 'goog.i18n.DateTimeSymbols_en_NF', 'goog.i18n.DateTimeSymbols_en_NG', 'goog.i18n.DateTimeSymbols_en_NL', 'goog.i18n.DateTimeSymbols_en_NR', 'goog.i18n.DateTimeSymbols_en_NU', 'goog.i18n.DateTimeSymbols_en_NZ', 'goog.i18n.DateTimeSymbols_en_PG', 'goog.i18n.DateTimeSymbols_en_PH', 'goog.i18n.DateTimeSymbols_en_PK', 'goog.i18n.DateTimeSymbols_en_PN', 'goog.i18n.DateTimeSymbols_en_PR', 'goog.i18n.DateTimeSymbols_en_PW', 'goog.i18n.DateTimeSymbols_en_RW', 'goog.i18n.DateTimeSymbols_en_SB', 'goog.i18n.DateTimeSymbols_en_SC', 'goog.i18n.DateTimeSymbols_en_SD', 'goog.i18n.DateTimeSymbols_en_SE', 'goog.i18n.DateTimeSymbols_en_SH', 'goog.i18n.DateTimeSymbols_en_SI', 'goog.i18n.DateTimeSymbols_en_SL', 'goog.i18n.DateTimeSymbols_en_SS', 'goog.i18n.DateTimeSymbols_en_SX', 'goog.i18n.DateTimeSymbols_en_SZ', 'goog.i18n.DateTimeSymbols_en_TC', 'goog.i18n.DateTimeSymbols_en_TK', 'goog.i18n.DateTimeSymbols_en_TO', 'goog.i18n.DateTimeSymbols_en_TT', 'goog.i18n.DateTimeSymbols_en_TV', 'goog.i18n.DateTimeSymbols_en_TZ', 'goog.i18n.DateTimeSymbols_en_UG', 'goog.i18n.DateTimeSymbols_en_UM', 'goog.i18n.DateTimeSymbols_en_US_POSIX', 'goog.i18n.DateTimeSymbols_en_VC', 'goog.i18n.DateTimeSymbols_en_VG', 'goog.i18n.DateTimeSymbols_en_VI', 'goog.i18n.DateTimeSymbols_en_VU', 'goog.i18n.DateTimeSymbols_en_WS', 'goog.i18n.DateTimeSymbols_en_XA', 'goog.i18n.DateTimeSymbols_en_ZM', 'goog.i18n.DateTimeSymbols_en_ZW', 'goog.i18n.DateTimeSymbols_eo', 'goog.i18n.DateTimeSymbols_eo_001', 'goog.i18n.DateTimeSymbols_es_AR', 'goog.i18n.DateTimeSymbols_es_BO', 'goog.i18n.DateTimeSymbols_es_BR', 'goog.i18n.DateTimeSymbols_es_BZ', 'goog.i18n.DateTimeSymbols_es_CL', 'goog.i18n.DateTimeSymbols_es_CO', 'goog.i18n.DateTimeSymbols_es_CR', 'goog.i18n.DateTimeSymbols_es_CU', 'goog.i18n.DateTimeSymbols_es_DO', 'goog.i18n.DateTimeSymbols_es_EA', 'goog.i18n.DateTimeSymbols_es_EC', 'goog.i18n.DateTimeSymbols_es_GQ', 'goog.i18n.DateTimeSymbols_es_GT', 'goog.i18n.DateTimeSymbols_es_HN', 'goog.i18n.DateTimeSymbols_es_IC', 'goog.i18n.DateTimeSymbols_es_NI', 'goog.i18n.DateTimeSymbols_es_PA', 'goog.i18n.DateTimeSymbols_es_PE', 'goog.i18n.DateTimeSymbols_es_PH', 'goog.i18n.DateTimeSymbols_es_PR', 'goog.i18n.DateTimeSymbols_es_PY', 'goog.i18n.DateTimeSymbols_es_SV', 'goog.i18n.DateTimeSymbols_es_UY', 'goog.i18n.DateTimeSymbols_es_VE', 'goog.i18n.DateTimeSymbols_et_EE', 'goog.i18n.DateTimeSymbols_eu_ES', 'goog.i18n.DateTimeSymbols_ewo', 'goog.i18n.DateTimeSymbols_ewo_CM', 'goog.i18n.DateTimeSymbols_fa_AF', 'goog.i18n.DateTimeSymbols_fa_IR', 'goog.i18n.DateTimeSymbols_ff', 'goog.i18n.DateTimeSymbols_ff_Latn', 'goog.i18n.DateTimeSymbols_ff_Latn_BF', 'goog.i18n.DateTimeSymbols_ff_Latn_CM', 'goog.i18n.DateTimeSymbols_ff_Latn_GH', 'goog.i18n.DateTimeSymbols_ff_Latn_GM', 'goog.i18n.DateTimeSymbols_ff_Latn_GN', 'goog.i18n.DateTimeSymbols_ff_Latn_GW', 'goog.i18n.DateTimeSymbols_ff_Latn_LR', 'goog.i18n.DateTimeSymbols_ff_Latn_MR', 'goog.i18n.DateTimeSymbols_ff_Latn_NE', 'goog.i18n.DateTimeSymbols_ff_Latn_NG', 'goog.i18n.DateTimeSymbols_ff_Latn_SL', 'goog.i18n.DateTimeSymbols_ff_Latn_SN', 'goog.i18n.DateTimeSymbols_fi_FI', 'goog.i18n.DateTimeSymbols_fil_PH', 'goog.i18n.DateTimeSymbols_fo', 'goog.i18n.DateTimeSymbols_fo_DK', 'goog.i18n.DateTimeSymbols_fo_FO', 'goog.i18n.DateTimeSymbols_fr_BE', 'goog.i18n.DateTimeSymbols_fr_BF', 'goog.i18n.DateTimeSymbols_fr_BI', 'goog.i18n.DateTimeSymbols_fr_BJ', 'goog.i18n.DateTimeSymbols_fr_BL', 'goog.i18n.DateTimeSymbols_fr_CD', 'goog.i18n.DateTimeSymbols_fr_CF', 'goog.i18n.DateTimeSymbols_fr_CG', 'goog.i18n.DateTimeSymbols_fr_CH', 'goog.i18n.DateTimeSymbols_fr_CI', 'goog.i18n.DateTimeSymbols_fr_CM', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_fr_DZ', 'goog.i18n.DateTimeSymbols_fr_FR', 'goog.i18n.DateTimeSymbols_fr_GA', 'goog.i18n.DateTimeSymbols_fr_GF', 'goog.i18n.DateTimeSymbols_fr_GN', 'goog.i18n.DateTimeSymbols_fr_GP', 'goog.i18n.DateTimeSymbols_fr_GQ', 'goog.i18n.DateTimeSymbols_fr_HT', 'goog.i18n.DateTimeSymbols_fr_KM', 'goog.i18n.DateTimeSymbols_fr_LU', 'goog.i18n.DateTimeSymbols_fr_MA', 'goog.i18n.DateTimeSymbols_fr_MC', 'goog.i18n.DateTimeSymbols_fr_MF', 'goog.i18n.DateTimeSymbols_fr_MG', 'goog.i18n.DateTimeSymbols_fr_ML', 'goog.i18n.DateTimeSymbols_fr_MQ', 'goog.i18n.DateTimeSymbols_fr_MR', 'goog.i18n.DateTimeSymbols_fr_MU', 'goog.i18n.DateTimeSymbols_fr_NC', 'goog.i18n.DateTimeSymbols_fr_NE', 'goog.i18n.DateTimeSymbols_fr_PF', 'goog.i18n.DateTimeSymbols_fr_PM', 'goog.i18n.DateTimeSymbols_fr_RE', 'goog.i18n.DateTimeSymbols_fr_RW', 'goog.i18n.DateTimeSymbols_fr_SC', 'goog.i18n.DateTimeSymbols_fr_SN', 'goog.i18n.DateTimeSymbols_fr_SY', 'goog.i18n.DateTimeSymbols_fr_TD', 'goog.i18n.DateTimeSymbols_fr_TG', 'goog.i18n.DateTimeSymbols_fr_TN', 'goog.i18n.DateTimeSymbols_fr_VU', 'goog.i18n.DateTimeSymbols_fr_WF', 'goog.i18n.DateTimeSymbols_fr_YT', 'goog.i18n.DateTimeSymbols_fur', 'goog.i18n.DateTimeSymbols_fur_IT', 'goog.i18n.DateTimeSymbols_fy', 'goog.i18n.DateTimeSymbols_fy_NL', 'goog.i18n.DateTimeSymbols_ga_IE', 'goog.i18n.DateTimeSymbols_gd', 'goog.i18n.DateTimeSymbols_gd_GB', 'goog.i18n.DateTimeSymbols_gl_ES', 'goog.i18n.DateTimeSymbols_gsw_CH', 'goog.i18n.DateTimeSymbols_gsw_FR', 'goog.i18n.DateTimeSymbols_gsw_LI', 'goog.i18n.DateTimeSymbols_gu_IN', 'goog.i18n.DateTimeSymbols_guz', 'goog.i18n.DateTimeSymbols_guz_KE', 'goog.i18n.DateTimeSymbols_gv', 'goog.i18n.DateTimeSymbols_gv_IM', 'goog.i18n.DateTimeSymbols_ha', 'goog.i18n.DateTimeSymbols_ha_GH', 'goog.i18n.DateTimeSymbols_ha_NE', 'goog.i18n.DateTimeSymbols_ha_NG', 'goog.i18n.DateTimeSymbols_haw_US', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_hi_IN', 'goog.i18n.DateTimeSymbols_hr_BA', 'goog.i18n.DateTimeSymbols_hr_HR', 'goog.i18n.DateTimeSymbols_hsb', 'goog.i18n.DateTimeSymbols_hsb_DE', 'goog.i18n.DateTimeSymbols_hu_HU', 'goog.i18n.DateTimeSymbols_hy_AM', 'goog.i18n.DateTimeSymbols_ia', 'goog.i18n.DateTimeSymbols_ia_001', 'goog.i18n.DateTimeSymbols_id_ID', 'goog.i18n.DateTimeSymbols_ig', 'goog.i18n.DateTimeSymbols_ig_NG', 'goog.i18n.DateTimeSymbols_ii', 'goog.i18n.DateTimeSymbols_ii_CN', 'goog.i18n.DateTimeSymbols_is_IS', 'goog.i18n.DateTimeSymbols_it_CH', 'goog.i18n.DateTimeSymbols_it_IT', 'goog.i18n.DateTimeSymbols_it_SM', 'goog.i18n.DateTimeSymbols_it_VA', 'goog.i18n.DateTimeSymbols_ja_JP', 'goog.i18n.DateTimeSymbols_jgo', 'goog.i18n.DateTimeSymbols_jgo_CM', 'goog.i18n.DateTimeSymbols_jmc', 'goog.i18n.DateTimeSymbols_jmc_TZ', 'goog.i18n.DateTimeSymbols_jv', 'goog.i18n.DateTimeSymbols_jv_ID', 'goog.i18n.DateTimeSymbols_ka_GE', 'goog.i18n.DateTimeSymbols_kab', 'goog.i18n.DateTimeSymbols_kab_DZ', 'goog.i18n.DateTimeSymbols_kam', 'goog.i18n.DateTimeSymbols_kam_KE', 'goog.i18n.DateTimeSymbols_kde', 'goog.i18n.DateTimeSymbols_kde_TZ', 'goog.i18n.DateTimeSymbols_kea', 'goog.i18n.DateTimeSymbols_kea_CV', 'goog.i18n.DateTimeSymbols_khq', 'goog.i18n.DateTimeSymbols_khq_ML', 'goog.i18n.DateTimeSymbols_ki', 'goog.i18n.DateTimeSymbols_ki_KE', 'goog.i18n.DateTimeSymbols_kk_KZ', 'goog.i18n.DateTimeSymbols_kkj', 'goog.i18n.DateTimeSymbols_kkj_CM', 'goog.i18n.DateTimeSymbols_kl', 'goog.i18n.DateTimeSymbols_kl_GL', 'goog.i18n.DateTimeSymbols_kln', 'goog.i18n.DateTimeSymbols_kln_KE', 'goog.i18n.DateTimeSymbols_km_KH', 'goog.i18n.DateTimeSymbols_kn_IN', 'goog.i18n.DateTimeSymbols_ko_KP', 'goog.i18n.DateTimeSymbols_ko_KR', 'goog.i18n.DateTimeSymbols_kok', 'goog.i18n.DateTimeSymbols_kok_IN', 'goog.i18n.DateTimeSymbols_ks', 'goog.i18n.DateTimeSymbols_ks_IN', 'goog.i18n.DateTimeSymbols_ksb', 'goog.i18n.DateTimeSymbols_ksb_TZ', 'goog.i18n.DateTimeSymbols_ksf', 'goog.i18n.DateTimeSymbols_ksf_CM', 'goog.i18n.DateTimeSymbols_ksh', 'goog.i18n.DateTimeSymbols_ksh_DE', 'goog.i18n.DateTimeSymbols_ku', 'goog.i18n.DateTimeSymbols_ku_TR', 'goog.i18n.DateTimeSymbols_kw', 'goog.i18n.DateTimeSymbols_kw_GB', 'goog.i18n.DateTimeSymbols_ky_KG', 'goog.i18n.DateTimeSymbols_lag', 'goog.i18n.DateTimeSymbols_lag_TZ', 'goog.i18n.DateTimeSymbols_lb', 'goog.i18n.DateTimeSymbols_lb_LU', 'goog.i18n.DateTimeSymbols_lg', 'goog.i18n.DateTimeSymbols_lg_UG', 'goog.i18n.DateTimeSymbols_lkt', 'goog.i18n.DateTimeSymbols_lkt_US', 'goog.i18n.DateTimeSymbols_ln_AO', 'goog.i18n.DateTimeSymbols_ln_CD', 'goog.i18n.DateTimeSymbols_ln_CF', 'goog.i18n.DateTimeSymbols_ln_CG', 'goog.i18n.DateTimeSymbols_lo_LA', 'goog.i18n.DateTimeSymbols_lrc', 'goog.i18n.DateTimeSymbols_lrc_IQ', 'goog.i18n.DateTimeSymbols_lrc_IR', 'goog.i18n.DateTimeSymbols_lt_LT', 'goog.i18n.DateTimeSymbols_lu', 'goog.i18n.DateTimeSymbols_lu_CD', 'goog.i18n.DateTimeSymbols_luo', 'goog.i18n.DateTimeSymbols_luo_KE', 'goog.i18n.DateTimeSymbols_luy', 'goog.i18n.DateTimeSymbols_luy_KE', 'goog.i18n.DateTimeSymbols_lv_LV', 'goog.i18n.DateTimeSymbols_mas', 'goog.i18n.DateTimeSymbols_mas_KE', 'goog.i18n.DateTimeSymbols_mas_TZ', 'goog.i18n.DateTimeSymbols_mer', 'goog.i18n.DateTimeSymbols_mer_KE', 'goog.i18n.DateTimeSymbols_mfe', 'goog.i18n.DateTimeSymbols_mfe_MU', 'goog.i18n.DateTimeSymbols_mg', 'goog.i18n.DateTimeSymbols_mg_MG', 'goog.i18n.DateTimeSymbols_mgh', 'goog.i18n.DateTimeSymbols_mgh_MZ', 'goog.i18n.DateTimeSymbols_mgo', 'goog.i18n.DateTimeSymbols_mgo_CM', 'goog.i18n.DateTimeSymbols_mi', 'goog.i18n.DateTimeSymbols_mi_NZ', 'goog.i18n.DateTimeSymbols_mk_MK', 'goog.i18n.DateTimeSymbols_ml_IN', 'goog.i18n.DateTimeSymbols_mn_MN', 'goog.i18n.DateTimeSymbols_mr_IN', 'goog.i18n.DateTimeSymbols_ms_BN', 'goog.i18n.DateTimeSymbols_ms_MY', 'goog.i18n.DateTimeSymbols_ms_SG', 'goog.i18n.DateTimeSymbols_mt_MT', 'goog.i18n.DateTimeSymbols_mua', 'goog.i18n.DateTimeSymbols_mua_CM', 'goog.i18n.DateTimeSymbols_my_MM', 'goog.i18n.DateTimeSymbols_mzn', 'goog.i18n.DateTimeSymbols_mzn_IR', 'goog.i18n.DateTimeSymbols_naq', 'goog.i18n.DateTimeSymbols_naq_NA', 'goog.i18n.DateTimeSymbols_nb_NO', 'goog.i18n.DateTimeSymbols_nb_SJ', 'goog.i18n.DateTimeSymbols_nd', 'goog.i18n.DateTimeSymbols_nd_ZW', 'goog.i18n.DateTimeSymbols_nds', 'goog.i18n.DateTimeSymbols_nds_DE', 'goog.i18n.DateTimeSymbols_nds_NL', 'goog.i18n.DateTimeSymbols_ne_IN', 'goog.i18n.DateTimeSymbols_ne_NP', 'goog.i18n.DateTimeSymbols_nl_AW', 'goog.i18n.DateTimeSymbols_nl_BE', 'goog.i18n.DateTimeSymbols_nl_BQ', 'goog.i18n.DateTimeSymbols_nl_CW', 'goog.i18n.DateTimeSymbols_nl_NL', 'goog.i18n.DateTimeSymbols_nl_SR', 'goog.i18n.DateTimeSymbols_nl_SX', 'goog.i18n.DateTimeSymbols_nmg', 'goog.i18n.DateTimeSymbols_nmg_CM', 'goog.i18n.DateTimeSymbols_nn', 'goog.i18n.DateTimeSymbols_nn_NO', 'goog.i18n.DateTimeSymbols_nnh', 'goog.i18n.DateTimeSymbols_nnh_CM', 'goog.i18n.DateTimeSymbols_nus', 'goog.i18n.DateTimeSymbols_nus_SS', 'goog.i18n.DateTimeSymbols_nyn', 'goog.i18n.DateTimeSymbols_nyn_UG', 'goog.i18n.DateTimeSymbols_om', 'goog.i18n.DateTimeSymbols_om_ET', 'goog.i18n.DateTimeSymbols_om_KE', 'goog.i18n.DateTimeSymbols_or_IN', 'goog.i18n.DateTimeSymbols_os', 'goog.i18n.DateTimeSymbols_os_GE', 'goog.i18n.DateTimeSymbols_os_RU', 'goog.i18n.DateTimeSymbols_pa_Arab', 'goog.i18n.DateTimeSymbols_pa_Arab_PK', 'goog.i18n.DateTimeSymbols_pa_Guru', 'goog.i18n.DateTimeSymbols_pa_Guru_IN', 'goog.i18n.DateTimeSymbols_pl_PL', 'goog.i18n.DateTimeSymbols_ps', 'goog.i18n.DateTimeSymbols_ps_AF', 'goog.i18n.DateTimeSymbols_ps_PK', 'goog.i18n.DateTimeSymbols_pt_AO', 'goog.i18n.DateTimeSymbols_pt_CH', 'goog.i18n.DateTimeSymbols_pt_CV', 'goog.i18n.DateTimeSymbols_pt_GQ', 'goog.i18n.DateTimeSymbols_pt_GW', 'goog.i18n.DateTimeSymbols_pt_LU', 'goog.i18n.DateTimeSymbols_pt_MO', 'goog.i18n.DateTimeSymbols_pt_MZ', 'goog.i18n.DateTimeSymbols_pt_ST', 'goog.i18n.DateTimeSymbols_pt_TL', 'goog.i18n.DateTimeSymbols_qu', 'goog.i18n.DateTimeSymbols_qu_BO', 'goog.i18n.DateTimeSymbols_qu_EC', 'goog.i18n.DateTimeSymbols_qu_PE', 'goog.i18n.DateTimeSymbols_rm', 'goog.i18n.DateTimeSymbols_rm_CH', 'goog.i18n.DateTimeSymbols_rn', 'goog.i18n.DateTimeSymbols_rn_BI', 'goog.i18n.DateTimeSymbols_ro_MD', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_rof', 'goog.i18n.DateTimeSymbols_rof_TZ', 'goog.i18n.DateTimeSymbols_ru_BY', 'goog.i18n.DateTimeSymbols_ru_KG', 'goog.i18n.DateTimeSymbols_ru_KZ', 'goog.i18n.DateTimeSymbols_ru_MD', 'goog.i18n.DateTimeSymbols_ru_RU', 'goog.i18n.DateTimeSymbols_ru_UA', 'goog.i18n.DateTimeSymbols_rw', 'goog.i18n.DateTimeSymbols_rw_RW', 'goog.i18n.DateTimeSymbols_rwk', 'goog.i18n.DateTimeSymbols_rwk_TZ', 'goog.i18n.DateTimeSymbols_sah', 'goog.i18n.DateTimeSymbols_sah_RU', 'goog.i18n.DateTimeSymbols_saq', 'goog.i18n.DateTimeSymbols_saq_KE', 'goog.i18n.DateTimeSymbols_sbp', 'goog.i18n.DateTimeSymbols_sbp_TZ', 'goog.i18n.DateTimeSymbols_sd', 'goog.i18n.DateTimeSymbols_sd_PK', 'goog.i18n.DateTimeSymbols_se', 'goog.i18n.DateTimeSymbols_se_FI', 'goog.i18n.DateTimeSymbols_se_NO', 'goog.i18n.DateTimeSymbols_se_SE', 'goog.i18n.DateTimeSymbols_seh', 'goog.i18n.DateTimeSymbols_seh_MZ', 'goog.i18n.DateTimeSymbols_ses', 'goog.i18n.DateTimeSymbols_ses_ML', 'goog.i18n.DateTimeSymbols_sg', 'goog.i18n.DateTimeSymbols_sg_CF', 'goog.i18n.DateTimeSymbols_shi', 'goog.i18n.DateTimeSymbols_shi_Latn', 'goog.i18n.DateTimeSymbols_shi_Latn_MA', 'goog.i18n.DateTimeSymbols_shi_Tfng', 'goog.i18n.DateTimeSymbols_shi_Tfng_MA', 'goog.i18n.DateTimeSymbols_si_LK', 'goog.i18n.DateTimeSymbols_sk_SK', 'goog.i18n.DateTimeSymbols_sl_SI', 'goog.i18n.DateTimeSymbols_smn', 'goog.i18n.DateTimeSymbols_smn_FI', 'goog.i18n.DateTimeSymbols_sn', 'goog.i18n.DateTimeSymbols_sn_ZW', 'goog.i18n.DateTimeSymbols_so', 'goog.i18n.DateTimeSymbols_so_DJ', 'goog.i18n.DateTimeSymbols_so_ET', 'goog.i18n.DateTimeSymbols_so_KE', 'goog.i18n.DateTimeSymbols_so_SO', 'goog.i18n.DateTimeSymbols_sq_AL', 'goog.i18n.DateTimeSymbols_sq_MK', 'goog.i18n.DateTimeSymbols_sq_XK', 'goog.i18n.DateTimeSymbols_sr_Cyrl', 'goog.i18n.DateTimeSymbols_sr_Cyrl_BA', 'goog.i18n.DateTimeSymbols_sr_Cyrl_ME', 'goog.i18n.DateTimeSymbols_sr_Cyrl_RS', 'goog.i18n.DateTimeSymbols_sr_Cyrl_XK', 'goog.i18n.DateTimeSymbols_sr_Latn_BA', 'goog.i18n.DateTimeSymbols_sr_Latn_ME', 'goog.i18n.DateTimeSymbols_sr_Latn_RS', 'goog.i18n.DateTimeSymbols_sr_Latn_XK', 'goog.i18n.DateTimeSymbols_sv_AX', 'goog.i18n.DateTimeSymbols_sv_FI', 'goog.i18n.DateTimeSymbols_sv_SE', 'goog.i18n.DateTimeSymbols_sw_CD', 'goog.i18n.DateTimeSymbols_sw_KE', 'goog.i18n.DateTimeSymbols_sw_TZ', 'goog.i18n.DateTimeSymbols_sw_UG', 'goog.i18n.DateTimeSymbols_ta_IN', 'goog.i18n.DateTimeSymbols_ta_LK', 'goog.i18n.DateTimeSymbols_ta_MY', 'goog.i18n.DateTimeSymbols_ta_SG', 'goog.i18n.DateTimeSymbols_te_IN', 'goog.i18n.DateTimeSymbols_teo', 'goog.i18n.DateTimeSymbols_teo_KE', 'goog.i18n.DateTimeSymbols_teo_UG', 'goog.i18n.DateTimeSymbols_tg', 'goog.i18n.DateTimeSymbols_tg_TJ', 'goog.i18n.DateTimeSymbols_th_TH', 'goog.i18n.DateTimeSymbols_ti', 'goog.i18n.DateTimeSymbols_ti_ER', 'goog.i18n.DateTimeSymbols_ti_ET', 'goog.i18n.DateTimeSymbols_tk', 'goog.i18n.DateTimeSymbols_tk_TM', 'goog.i18n.DateTimeSymbols_to', 'goog.i18n.DateTimeSymbols_to_TO', 'goog.i18n.DateTimeSymbols_tr_CY', 'goog.i18n.DateTimeSymbols_tr_TR', 'goog.i18n.DateTimeSymbols_tt', 'goog.i18n.DateTimeSymbols_tt_RU', 'goog.i18n.DateTimeSymbols_twq', 'goog.i18n.DateTimeSymbols_twq_NE', 'goog.i18n.DateTimeSymbols_tzm', 'goog.i18n.DateTimeSymbols_tzm_MA', 'goog.i18n.DateTimeSymbols_ug', 'goog.i18n.DateTimeSymbols_ug_CN', 'goog.i18n.DateTimeSymbols_uk_UA', 'goog.i18n.DateTimeSymbols_ur_IN', 'goog.i18n.DateTimeSymbols_ur_PK', 'goog.i18n.DateTimeSymbols_uz_Arab', 'goog.i18n.DateTimeSymbols_uz_Arab_AF', 'goog.i18n.DateTimeSymbols_uz_Cyrl', 'goog.i18n.DateTimeSymbols_uz_Cyrl_UZ', 'goog.i18n.DateTimeSymbols_uz_Latn', 'goog.i18n.DateTimeSymbols_uz_Latn_UZ', 'goog.i18n.DateTimeSymbols_vai', 'goog.i18n.DateTimeSymbols_vai_Latn', 'goog.i18n.DateTimeSymbols_vai_Latn_LR', 'goog.i18n.DateTimeSymbols_vai_Vaii', 'goog.i18n.DateTimeSymbols_vai_Vaii_LR', 'goog.i18n.DateTimeSymbols_vi_VN', 'goog.i18n.DateTimeSymbols_vun', 'goog.i18n.DateTimeSymbols_vun_TZ', 'goog.i18n.DateTimeSymbols_wae', 'goog.i18n.DateTimeSymbols_wae_CH', 'goog.i18n.DateTimeSymbols_wo', 'goog.i18n.DateTimeSymbols_wo_SN', 'goog.i18n.DateTimeSymbols_xh', 'goog.i18n.DateTimeSymbols_xh_ZA', 'goog.i18n.DateTimeSymbols_xog', 'goog.i18n.DateTimeSymbols_xog_UG', 'goog.i18n.DateTimeSymbols_yav', 'goog.i18n.DateTimeSymbols_yav_CM', 'goog.i18n.DateTimeSymbols_yi', 'goog.i18n.DateTimeSymbols_yi_001', 'goog.i18n.DateTimeSymbols_yo', 'goog.i18n.DateTimeSymbols_yo_BJ', 'goog.i18n.DateTimeSymbols_yo_NG', 'goog.i18n.DateTimeSymbols_yue', 'goog.i18n.DateTimeSymbols_yue_Hans', 'goog.i18n.DateTimeSymbols_yue_Hans_CN', 'goog.i18n.DateTimeSymbols_yue_Hant', 'goog.i18n.DateTimeSymbols_yue_Hant_HK', 'goog.i18n.DateTimeSymbols_zgh', 'goog.i18n.DateTimeSymbols_zgh_MA', 'goog.i18n.DateTimeSymbols_zh_Hans', 'goog.i18n.DateTimeSymbols_zh_Hans_CN', 'goog.i18n.DateTimeSymbols_zh_Hans_HK', 'goog.i18n.DateTimeSymbols_zh_Hans_MO', 'goog.i18n.DateTimeSymbols_zh_Hans_SG', 'goog.i18n.DateTimeSymbols_zh_Hant', 'goog.i18n.DateTimeSymbols_zh_Hant_HK', 'goog.i18n.DateTimeSymbols_zh_Hant_MO', 'goog.i18n.DateTimeSymbols_zh_Hant_TW', 'goog.i18n.DateTimeSymbols_zu_ZA'], ['goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/graphemebreak.js', ['goog.i18n.GraphemeBreak'], ['goog.asserts', 'goog.i18n.uChar', 'goog.structs.InversionMap'], {});
goog.addDependency('i18n/graphemebreak_test.js', ['goog.i18n.GraphemeBreakTest'], ['goog.i18n.GraphemeBreak', 'goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/localefeature.js', ['goog.i18n.LocaleFeature'], [], {'module': 'goog'});
goog.addDependency('i18n/localefeature_test.js', ['goog.i18n.LocaleFeatureTest'], ['goog.i18n.LocaleFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/messageformat.js', ['goog.i18n.MessageFormat'], ['goog.array', 'goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.ordinalRules', 'goog.i18n.pluralRules'], {});
goog.addDependency('i18n/messageformat_test.js', ['goog.i18n.MessageFormatTest'], ['goog.i18n.MessageFormat', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.pluralRules', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/mime.js', ['goog.i18n.mime', 'goog.i18n.mime.encode'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/mime_test.js', ['goog.i18n.mime.encodeTest'], ['goog.i18n.mime.encode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformat.js', ['goog.i18n.NumberFormat', 'goog.i18n.NumberFormat.CurrencyStyle', 'goog.i18n.NumberFormat.Format'], ['goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.currency', 'goog.math', 'goog.string'], {});
goog.addDependency('i18n/numberformat_test.js', ['goog.i18n.NumberFormatTest'], ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformatsymbols.js', ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_af', 'goog.i18n.NumberFormatSymbols_am', 'goog.i18n.NumberFormatSymbols_ar', 'goog.i18n.NumberFormatSymbols_ar_DZ', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_az', 'goog.i18n.NumberFormatSymbols_be', 'goog.i18n.NumberFormatSymbols_bg', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_bn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_br', 'goog.i18n.NumberFormatSymbols_bs', 'goog.i18n.NumberFormatSymbols_ca', 'goog.i18n.NumberFormatSymbols_chr', 'goog.i18n.NumberFormatSymbols_cs', 'goog.i18n.NumberFormatSymbols_cy', 'goog.i18n.NumberFormatSymbols_da', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_de_AT', 'goog.i18n.NumberFormatSymbols_de_CH', 'goog.i18n.NumberFormatSymbols_el', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_CA', 'goog.i18n.NumberFormatSymbols_en_GB', 'goog.i18n.NumberFormatSymbols_en_IE', 'goog.i18n.NumberFormatSymbols_en_IN', 'goog.i18n.NumberFormatSymbols_en_SG', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_en_ZA', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_es_419', 'goog.i18n.NumberFormatSymbols_es_ES', 'goog.i18n.NumberFormatSymbols_es_MX', 'goog.i18n.NumberFormatSymbols_es_US', 'goog.i18n.NumberFormatSymbols_et', 'goog.i18n.NumberFormatSymbols_eu', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_fa_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fil', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_fr_CA', 'goog.i18n.NumberFormatSymbols_ga', 'goog.i18n.NumberFormatSymbols_gl', 'goog.i18n.NumberFormatSymbols_gsw', 'goog.i18n.NumberFormatSymbols_gu', 'goog.i18n.NumberFormatSymbols_haw', 'goog.i18n.NumberFormatSymbols_he', 'goog.i18n.NumberFormatSymbols_hi', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.NumberFormatSymbols_hu', 'goog.i18n.NumberFormatSymbols_hy', 'goog.i18n.NumberFormatSymbols_id', 'goog.i18n.NumberFormatSymbols_in', 'goog.i18n.NumberFormatSymbols_is', 'goog.i18n.NumberFormatSymbols_it', 'goog.i18n.NumberFormatSymbols_iw', 'goog.i18n.NumberFormatSymbols_ja', 'goog.i18n.NumberFormatSymbols_ka', 'goog.i18n.NumberFormatSymbols_kk', 'goog.i18n.NumberFormatSymbols_km', 'goog.i18n.NumberFormatSymbols_kn', 'goog.i18n.NumberFormatSymbols_ko', 'goog.i18n.NumberFormatSymbols_ky', 'goog.i18n.NumberFormatSymbols_ln', 'goog.i18n.NumberFormatSymbols_lo', 'goog.i18n.NumberFormatSymbols_lt', 'goog.i18n.NumberFormatSymbols_lv', 'goog.i18n.NumberFormatSymbols_mk', 'goog.i18n.NumberFormatSymbols_ml', 'goog.i18n.NumberFormatSymbols_mn', 'goog.i18n.NumberFormatSymbols_mo', 'goog.i18n.NumberFormatSymbols_mr', 'goog.i18n.NumberFormatSymbols_mr_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms', 'goog.i18n.NumberFormatSymbols_mt', 'goog.i18n.NumberFormatSymbols_my', 'goog.i18n.NumberFormatSymbols_my_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nb', 'goog.i18n.NumberFormatSymbols_ne', 'goog.i18n.NumberFormatSymbols_ne_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.NumberFormatSymbols_no_NO', 'goog.i18n.NumberFormatSymbols_or', 'goog.i18n.NumberFormatSymbols_pa', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_pt', 'goog.i18n.NumberFormatSymbols_pt_BR', 'goog.i18n.NumberFormatSymbols_pt_PT', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_ru', 'goog.i18n.NumberFormatSymbols_sh', 'goog.i18n.NumberFormatSymbols_si', 'goog.i18n.NumberFormatSymbols_sk', 'goog.i18n.NumberFormatSymbols_sl', 'goog.i18n.NumberFormatSymbols_sq', 'goog.i18n.NumberFormatSymbols_sr', 'goog.i18n.NumberFormatSymbols_sr_Latn', 'goog.i18n.NumberFormatSymbols_sv', 'goog.i18n.NumberFormatSymbols_sw', 'goog.i18n.NumberFormatSymbols_ta', 'goog.i18n.NumberFormatSymbols_te', 'goog.i18n.NumberFormatSymbols_th', 'goog.i18n.NumberFormatSymbols_tl', 'goog.i18n.NumberFormatSymbols_tr', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uk', 'goog.i18n.NumberFormatSymbols_ur', 'goog.i18n.NumberFormatSymbols_uz', 'goog.i18n.NumberFormatSymbols_vi', 'goog.i18n.NumberFormatSymbols_zh', 'goog.i18n.NumberFormatSymbols_zh_CN', 'goog.i18n.NumberFormatSymbols_zh_HK', 'goog.i18n.NumberFormatSymbols_zh_TW', 'goog.i18n.NumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/numberformatsymbolsext.js', ['goog.i18n.NumberFormatSymbolsExt', 'goog.i18n.NumberFormatSymbols_af_NA', 'goog.i18n.NumberFormatSymbols_af_ZA', 'goog.i18n.NumberFormatSymbols_agq', 'goog.i18n.NumberFormatSymbols_agq_CM', 'goog.i18n.NumberFormatSymbols_ak', 'goog.i18n.NumberFormatSymbols_ak_GH', 'goog.i18n.NumberFormatSymbols_am_ET', 'goog.i18n.NumberFormatSymbols_ar_001', 'goog.i18n.NumberFormatSymbols_ar_AE', 'goog.i18n.NumberFormatSymbols_ar_AE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_BH', 'goog.i18n.NumberFormatSymbols_ar_BH_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_DJ', 'goog.i18n.NumberFormatSymbols_ar_DJ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_EH', 'goog.i18n.NumberFormatSymbols_ar_ER', 'goog.i18n.NumberFormatSymbols_ar_ER_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IL', 'goog.i18n.NumberFormatSymbols_ar_IL_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IQ', 'goog.i18n.NumberFormatSymbols_ar_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_JO', 'goog.i18n.NumberFormatSymbols_ar_JO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KM', 'goog.i18n.NumberFormatSymbols_ar_KM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KW', 'goog.i18n.NumberFormatSymbols_ar_KW_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LB', 'goog.i18n.NumberFormatSymbols_ar_LB_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LY', 'goog.i18n.NumberFormatSymbols_ar_MA', 'goog.i18n.NumberFormatSymbols_ar_MR', 'goog.i18n.NumberFormatSymbols_ar_MR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_OM', 'goog.i18n.NumberFormatSymbols_ar_OM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_PS', 'goog.i18n.NumberFormatSymbols_ar_PS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_QA', 'goog.i18n.NumberFormatSymbols_ar_QA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SA', 'goog.i18n.NumberFormatSymbols_ar_SA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SD', 'goog.i18n.NumberFormatSymbols_ar_SD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SO', 'goog.i18n.NumberFormatSymbols_ar_SO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SS', 'goog.i18n.NumberFormatSymbols_ar_SS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SY', 'goog.i18n.NumberFormatSymbols_ar_SY_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TD', 'goog.i18n.NumberFormatSymbols_ar_TD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TN', 'goog.i18n.NumberFormatSymbols_ar_XB', 'goog.i18n.NumberFormatSymbols_ar_YE', 'goog.i18n.NumberFormatSymbols_ar_YE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as', 'goog.i18n.NumberFormatSymbols_as_IN', 'goog.i18n.NumberFormatSymbols_as_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as_u_nu_latn', 'goog.i18n.NumberFormatSymbols_asa', 'goog.i18n.NumberFormatSymbols_asa_TZ', 'goog.i18n.NumberFormatSymbols_ast', 'goog.i18n.NumberFormatSymbols_ast_ES', 'goog.i18n.NumberFormatSymbols_az_Cyrl', 'goog.i18n.NumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.NumberFormatSymbols_az_Latn', 'goog.i18n.NumberFormatSymbols_az_Latn_AZ', 'goog.i18n.NumberFormatSymbols_bas', 'goog.i18n.NumberFormatSymbols_bas_CM', 'goog.i18n.NumberFormatSymbols_be_BY', 'goog.i18n.NumberFormatSymbols_bem', 'goog.i18n.NumberFormatSymbols_bem_ZM', 'goog.i18n.NumberFormatSymbols_bez', 'goog.i18n.NumberFormatSymbols_bez_TZ', 'goog.i18n.NumberFormatSymbols_bg_BG', 'goog.i18n.NumberFormatSymbols_bm', 'goog.i18n.NumberFormatSymbols_bm_ML', 'goog.i18n.NumberFormatSymbols_bn_BD', 'goog.i18n.NumberFormatSymbols_bn_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bn_IN', 'goog.i18n.NumberFormatSymbols_bn_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bo', 'goog.i18n.NumberFormatSymbols_bo_CN', 'goog.i18n.NumberFormatSymbols_bo_IN', 'goog.i18n.NumberFormatSymbols_br_FR', 'goog.i18n.NumberFormatSymbols_brx', 'goog.i18n.NumberFormatSymbols_brx_IN', 'goog.i18n.NumberFormatSymbols_bs_Cyrl', 'goog.i18n.NumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_bs_Latn', 'goog.i18n.NumberFormatSymbols_bs_Latn_BA', 'goog.i18n.NumberFormatSymbols_ca_AD', 'goog.i18n.NumberFormatSymbols_ca_ES', 'goog.i18n.NumberFormatSymbols_ca_FR', 'goog.i18n.NumberFormatSymbols_ca_IT', 'goog.i18n.NumberFormatSymbols_ccp', 'goog.i18n.NumberFormatSymbols_ccp_BD', 'goog.i18n.NumberFormatSymbols_ccp_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_IN', 'goog.i18n.NumberFormatSymbols_ccp_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ce', 'goog.i18n.NumberFormatSymbols_ce_RU', 'goog.i18n.NumberFormatSymbols_ceb', 'goog.i18n.NumberFormatSymbols_ceb_PH', 'goog.i18n.NumberFormatSymbols_cgg', 'goog.i18n.NumberFormatSymbols_cgg_UG', 'goog.i18n.NumberFormatSymbols_chr_US', 'goog.i18n.NumberFormatSymbols_ckb', 'goog.i18n.NumberFormatSymbols_ckb_IQ', 'goog.i18n.NumberFormatSymbols_ckb_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_IR', 'goog.i18n.NumberFormatSymbols_ckb_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_u_nu_latn', 'goog.i18n.NumberFormatSymbols_cs_CZ', 'goog.i18n.NumberFormatSymbols_cy_GB', 'goog.i18n.NumberFormatSymbols_da_DK', 'goog.i18n.NumberFormatSymbols_da_GL', 'goog.i18n.NumberFormatSymbols_dav', 'goog.i18n.NumberFormatSymbols_dav_KE', 'goog.i18n.NumberFormatSymbols_de_BE', 'goog.i18n.NumberFormatSymbols_de_DE', 'goog.i18n.NumberFormatSymbols_de_IT', 'goog.i18n.NumberFormatSymbols_de_LI', 'goog.i18n.NumberFormatSymbols_de_LU', 'goog.i18n.NumberFormatSymbols_dje', 'goog.i18n.NumberFormatSymbols_dje_NE', 'goog.i18n.NumberFormatSymbols_dsb', 'goog.i18n.NumberFormatSymbols_dsb_DE', 'goog.i18n.NumberFormatSymbols_dua', 'goog.i18n.NumberFormatSymbols_dua_CM', 'goog.i18n.NumberFormatSymbols_dyo', 'goog.i18n.NumberFormatSymbols_dyo_SN', 'goog.i18n.NumberFormatSymbols_dz', 'goog.i18n.NumberFormatSymbols_dz_BT', 'goog.i18n.NumberFormatSymbols_dz_BT_u_nu_latn', 'goog.i18n.NumberFormatSymbols_dz_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ebu', 'goog.i18n.NumberFormatSymbols_ebu_KE', 'goog.i18n.NumberFormatSymbols_ee', 'goog.i18n.NumberFormatSymbols_ee_GH', 'goog.i18n.NumberFormatSymbols_ee_TG', 'goog.i18n.NumberFormatSymbols_el_CY', 'goog.i18n.NumberFormatSymbols_el_GR', 'goog.i18n.NumberFormatSymbols_en_001', 'goog.i18n.NumberFormatSymbols_en_150', 'goog.i18n.NumberFormatSymbols_en_AE', 'goog.i18n.NumberFormatSymbols_en_AG', 'goog.i18n.NumberFormatSymbols_en_AI', 'goog.i18n.NumberFormatSymbols_en_AS', 'goog.i18n.NumberFormatSymbols_en_AT', 'goog.i18n.NumberFormatSymbols_en_BB', 'goog.i18n.NumberFormatSymbols_en_BE', 'goog.i18n.NumberFormatSymbols_en_BI', 'goog.i18n.NumberFormatSymbols_en_BM', 'goog.i18n.NumberFormatSymbols_en_BS', 'goog.i18n.NumberFormatSymbols_en_BW', 'goog.i18n.NumberFormatSymbols_en_BZ', 'goog.i18n.NumberFormatSymbols_en_CC', 'goog.i18n.NumberFormatSymbols_en_CH', 'goog.i18n.NumberFormatSymbols_en_CK', 'goog.i18n.NumberFormatSymbols_en_CM', 'goog.i18n.NumberFormatSymbols_en_CX', 'goog.i18n.NumberFormatSymbols_en_CY', 'goog.i18n.NumberFormatSymbols_en_DE', 'goog.i18n.NumberFormatSymbols_en_DG', 'goog.i18n.NumberFormatSymbols_en_DK', 'goog.i18n.NumberFormatSymbols_en_DM', 'goog.i18n.NumberFormatSymbols_en_ER', 'goog.i18n.NumberFormatSymbols_en_FI', 'goog.i18n.NumberFormatSymbols_en_FJ', 'goog.i18n.NumberFormatSymbols_en_FK', 'goog.i18n.NumberFormatSymbols_en_FM', 'goog.i18n.NumberFormatSymbols_en_GD', 'goog.i18n.NumberFormatSymbols_en_GG', 'goog.i18n.NumberFormatSymbols_en_GH', 'goog.i18n.NumberFormatSymbols_en_GI', 'goog.i18n.NumberFormatSymbols_en_GM', 'goog.i18n.NumberFormatSymbols_en_GU', 'goog.i18n.NumberFormatSymbols_en_GY', 'goog.i18n.NumberFormatSymbols_en_HK', 'goog.i18n.NumberFormatSymbols_en_IL', 'goog.i18n.NumberFormatSymbols_en_IM', 'goog.i18n.NumberFormatSymbols_en_IO', 'goog.i18n.NumberFormatSymbols_en_JE', 'goog.i18n.NumberFormatSymbols_en_JM', 'goog.i18n.NumberFormatSymbols_en_KE', 'goog.i18n.NumberFormatSymbols_en_KI', 'goog.i18n.NumberFormatSymbols_en_KN', 'goog.i18n.NumberFormatSymbols_en_KY', 'goog.i18n.NumberFormatSymbols_en_LC', 'goog.i18n.NumberFormatSymbols_en_LR', 'goog.i18n.NumberFormatSymbols_en_LS', 'goog.i18n.NumberFormatSymbols_en_MG', 'goog.i18n.NumberFormatSymbols_en_MH', 'goog.i18n.NumberFormatSymbols_en_MO', 'goog.i18n.NumberFormatSymbols_en_MP', 'goog.i18n.NumberFormatSymbols_en_MS', 'goog.i18n.NumberFormatSymbols_en_MT', 'goog.i18n.NumberFormatSymbols_en_MU', 'goog.i18n.NumberFormatSymbols_en_MW', 'goog.i18n.NumberFormatSymbols_en_MY', 'goog.i18n.NumberFormatSymbols_en_NA', 'goog.i18n.NumberFormatSymbols_en_NF', 'goog.i18n.NumberFormatSymbols_en_NG', 'goog.i18n.NumberFormatSymbols_en_NL', 'goog.i18n.NumberFormatSymbols_en_NR', 'goog.i18n.NumberFormatSymbols_en_NU', 'goog.i18n.NumberFormatSymbols_en_NZ', 'goog.i18n.NumberFormatSymbols_en_PG', 'goog.i18n.NumberFormatSymbols_en_PH', 'goog.i18n.NumberFormatSymbols_en_PK', 'goog.i18n.NumberFormatSymbols_en_PN', 'goog.i18n.NumberFormatSymbols_en_PR', 'goog.i18n.NumberFormatSymbols_en_PW', 'goog.i18n.NumberFormatSymbols_en_RW', 'goog.i18n.NumberFormatSymbols_en_SB', 'goog.i18n.NumberFormatSymbols_en_SC', 'goog.i18n.NumberFormatSymbols_en_SD', 'goog.i18n.NumberFormatSymbols_en_SE', 'goog.i18n.NumberFormatSymbols_en_SH', 'goog.i18n.NumberFormatSymbols_en_SI', 'goog.i18n.NumberFormatSymbols_en_SL', 'goog.i18n.NumberFormatSymbols_en_SS', 'goog.i18n.NumberFormatSymbols_en_SX', 'goog.i18n.NumberFormatSymbols_en_SZ', 'goog.i18n.NumberFormatSymbols_en_TC', 'goog.i18n.NumberFormatSymbols_en_TK', 'goog.i18n.NumberFormatSymbols_en_TO', 'goog.i18n.NumberFormatSymbols_en_TT', 'goog.i18n.NumberFormatSymbols_en_TV', 'goog.i18n.NumberFormatSymbols_en_TZ', 'goog.i18n.NumberFormatSymbols_en_UG', 'goog.i18n.NumberFormatSymbols_en_UM', 'goog.i18n.NumberFormatSymbols_en_US_POSIX', 'goog.i18n.NumberFormatSymbols_en_VC', 'goog.i18n.NumberFormatSymbols_en_VG', 'goog.i18n.NumberFormatSymbols_en_VI', 'goog.i18n.NumberFormatSymbols_en_VU', 'goog.i18n.NumberFormatSymbols_en_WS', 'goog.i18n.NumberFormatSymbols_en_XA', 'goog.i18n.NumberFormatSymbols_en_ZM', 'goog.i18n.NumberFormatSymbols_en_ZW', 'goog.i18n.NumberFormatSymbols_eo', 'goog.i18n.NumberFormatSymbols_eo_001', 'goog.i18n.NumberFormatSymbols_es_AR', 'goog.i18n.NumberFormatSymbols_es_BO', 'goog.i18n.NumberFormatSymbols_es_BR', 'goog.i18n.NumberFormatSymbols_es_BZ', 'goog.i18n.NumberFormatSymbols_es_CL', 'goog.i18n.NumberFormatSymbols_es_CO', 'goog.i18n.NumberFormatSymbols_es_CR', 'goog.i18n.NumberFormatSymbols_es_CU', 'goog.i18n.NumberFormatSymbols_es_DO', 'goog.i18n.NumberFormatSymbols_es_EA', 'goog.i18n.NumberFormatSymbols_es_EC', 'goog.i18n.NumberFormatSymbols_es_GQ', 'goog.i18n.NumberFormatSymbols_es_GT', 'goog.i18n.NumberFormatSymbols_es_HN', 'goog.i18n.NumberFormatSymbols_es_IC', 'goog.i18n.NumberFormatSymbols_es_NI', 'goog.i18n.NumberFormatSymbols_es_PA', 'goog.i18n.NumberFormatSymbols_es_PE', 'goog.i18n.NumberFormatSymbols_es_PH', 'goog.i18n.NumberFormatSymbols_es_PR', 'goog.i18n.NumberFormatSymbols_es_PY', 'goog.i18n.NumberFormatSymbols_es_SV', 'goog.i18n.NumberFormatSymbols_es_UY', 'goog.i18n.NumberFormatSymbols_es_VE', 'goog.i18n.NumberFormatSymbols_et_EE', 'goog.i18n.NumberFormatSymbols_eu_ES', 'goog.i18n.NumberFormatSymbols_ewo', 'goog.i18n.NumberFormatSymbols_ewo_CM', 'goog.i18n.NumberFormatSymbols_fa_AF', 'goog.i18n.NumberFormatSymbols_fa_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fa_IR', 'goog.i18n.NumberFormatSymbols_fa_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ff', 'goog.i18n.NumberFormatSymbols_ff_Latn', 'goog.i18n.NumberFormatSymbols_ff_Latn_BF', 'goog.i18n.NumberFormatSymbols_ff_Latn_CM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GH', 'goog.i18n.NumberFormatSymbols_ff_Latn_GM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GN', 'goog.i18n.NumberFormatSymbols_ff_Latn_GW', 'goog.i18n.NumberFormatSymbols_ff_Latn_LR', 'goog.i18n.NumberFormatSymbols_ff_Latn_MR', 'goog.i18n.NumberFormatSymbols_ff_Latn_NE', 'goog.i18n.NumberFormatSymbols_ff_Latn_NG', 'goog.i18n.NumberFormatSymbols_ff_Latn_SL', 'goog.i18n.NumberFormatSymbols_ff_Latn_SN', 'goog.i18n.NumberFormatSymbols_fi_FI', 'goog.i18n.NumberFormatSymbols_fil_PH', 'goog.i18n.NumberFormatSymbols_fo', 'goog.i18n.NumberFormatSymbols_fo_DK', 'goog.i18n.NumberFormatSymbols_fo_FO', 'goog.i18n.NumberFormatSymbols_fr_BE', 'goog.i18n.NumberFormatSymbols_fr_BF', 'goog.i18n.NumberFormatSymbols_fr_BI', 'goog.i18n.NumberFormatSymbols_fr_BJ', 'goog.i18n.NumberFormatSymbols_fr_BL', 'goog.i18n.NumberFormatSymbols_fr_CD', 'goog.i18n.NumberFormatSymbols_fr_CF', 'goog.i18n.NumberFormatSymbols_fr_CG', 'goog.i18n.NumberFormatSymbols_fr_CH', 'goog.i18n.NumberFormatSymbols_fr_CI', 'goog.i18n.NumberFormatSymbols_fr_CM', 'goog.i18n.NumberFormatSymbols_fr_DJ', 'goog.i18n.NumberFormatSymbols_fr_DZ', 'goog.i18n.NumberFormatSymbols_fr_FR', 'goog.i18n.NumberFormatSymbols_fr_GA', 'goog.i18n.NumberFormatSymbols_fr_GF', 'goog.i18n.NumberFormatSymbols_fr_GN', 'goog.i18n.NumberFormatSymbols_fr_GP', 'goog.i18n.NumberFormatSymbols_fr_GQ', 'goog.i18n.NumberFormatSymbols_fr_HT', 'goog.i18n.NumberFormatSymbols_fr_KM', 'goog.i18n.NumberFormatSymbols_fr_LU', 'goog.i18n.NumberFormatSymbols_fr_MA', 'goog.i18n.NumberFormatSymbols_fr_MC', 'goog.i18n.NumberFormatSymbols_fr_MF', 'goog.i18n.NumberFormatSymbols_fr_MG', 'goog.i18n.NumberFormatSymbols_fr_ML', 'goog.i18n.NumberFormatSymbols_fr_MQ', 'goog.i18n.NumberFormatSymbols_fr_MR', 'goog.i18n.NumberFormatSymbols_fr_MU', 'goog.i18n.NumberFormatSymbols_fr_NC', 'goog.i18n.NumberFormatSymbols_fr_NE', 'goog.i18n.NumberFormatSymbols_fr_PF', 'goog.i18n.NumberFormatSymbols_fr_PM', 'goog.i18n.NumberFormatSymbols_fr_RE', 'goog.i18n.NumberFormatSymbols_fr_RW', 'goog.i18n.NumberFormatSymbols_fr_SC', 'goog.i18n.NumberFormatSymbols_fr_SN', 'goog.i18n.NumberFormatSymbols_fr_SY', 'goog.i18n.NumberFormatSymbols_fr_TD', 'goog.i18n.NumberFormatSymbols_fr_TG', 'goog.i18n.NumberFormatSymbols_fr_TN', 'goog.i18n.NumberFormatSymbols_fr_VU', 'goog.i18n.NumberFormatSymbols_fr_WF', 'goog.i18n.NumberFormatSymbols_fr_YT', 'goog.i18n.NumberFormatSymbols_fur', 'goog.i18n.NumberFormatSymbols_fur_IT', 'goog.i18n.NumberFormatSymbols_fy', 'goog.i18n.NumberFormatSymbols_fy_NL', 'goog.i18n.NumberFormatSymbols_ga_IE', 'goog.i18n.NumberFormatSymbols_gd', 'goog.i18n.NumberFormatSymbols_gd_GB', 'goog.i18n.NumberFormatSymbols_gl_ES', 'goog.i18n.NumberFormatSymbols_gsw_CH', 'goog.i18n.NumberFormatSymbols_gsw_FR', 'goog.i18n.NumberFormatSymbols_gsw_LI', 'goog.i18n.NumberFormatSymbols_gu_IN', 'goog.i18n.NumberFormatSymbols_guz', 'goog.i18n.NumberFormatSymbols_guz_KE', 'goog.i18n.NumberFormatSymbols_gv', 'goog.i18n.NumberFormatSymbols_gv_IM', 'goog.i18n.NumberFormatSymbols_ha', 'goog.i18n.NumberFormatSymbols_ha_GH', 'goog.i18n.NumberFormatSymbols_ha_NE', 'goog.i18n.NumberFormatSymbols_ha_NG', 'goog.i18n.NumberFormatSymbols_haw_US', 'goog.i18n.NumberFormatSymbols_he_IL', 'goog.i18n.NumberFormatSymbols_hi_IN', 'goog.i18n.NumberFormatSymbols_hr_BA', 'goog.i18n.NumberFormatSymbols_hr_HR', 'goog.i18n.NumberFormatSymbols_hsb', 'goog.i18n.NumberFormatSymbols_hsb_DE', 'goog.i18n.NumberFormatSymbols_hu_HU', 'goog.i18n.NumberFormatSymbols_hy_AM', 'goog.i18n.NumberFormatSymbols_ia', 'goog.i18n.NumberFormatSymbols_ia_001', 'goog.i18n.NumberFormatSymbols_id_ID', 'goog.i18n.NumberFormatSymbols_ig', 'goog.i18n.NumberFormatSymbols_ig_NG', 'goog.i18n.NumberFormatSymbols_ii', 'goog.i18n.NumberFormatSymbols_ii_CN', 'goog.i18n.NumberFormatSymbols_is_IS', 'goog.i18n.NumberFormatSymbols_it_CH', 'goog.i18n.NumberFormatSymbols_it_IT', 'goog.i18n.NumberFormatSymbols_it_SM', 'goog.i18n.NumberFormatSymbols_it_VA', 'goog.i18n.NumberFormatSymbols_ja_JP', 'goog.i18n.NumberFormatSymbols_jgo', 'goog.i18n.NumberFormatSymbols_jgo_CM', 'goog.i18n.NumberFormatSymbols_jmc', 'goog.i18n.NumberFormatSymbols_jmc_TZ', 'goog.i18n.NumberFormatSymbols_jv', 'goog.i18n.NumberFormatSymbols_jv_ID', 'goog.i18n.NumberFormatSymbols_ka_GE', 'goog.i18n.NumberFormatSymbols_kab', 'goog.i18n.NumberFormatSymbols_kab_DZ', 'goog.i18n.NumberFormatSymbols_kam', 'goog.i18n.NumberFormatSymbols_kam_KE', 'goog.i18n.NumberFormatSymbols_kde', 'goog.i18n.NumberFormatSymbols_kde_TZ', 'goog.i18n.NumberFormatSymbols_kea', 'goog.i18n.NumberFormatSymbols_kea_CV', 'goog.i18n.NumberFormatSymbols_khq', 'goog.i18n.NumberFormatSymbols_khq_ML', 'goog.i18n.NumberFormatSymbols_ki', 'goog.i18n.NumberFormatSymbols_ki_KE', 'goog.i18n.NumberFormatSymbols_kk_KZ', 'goog.i18n.NumberFormatSymbols_kkj', 'goog.i18n.NumberFormatSymbols_kkj_CM', 'goog.i18n.NumberFormatSymbols_kl', 'goog.i18n.NumberFormatSymbols_kl_GL', 'goog.i18n.NumberFormatSymbols_kln', 'goog.i18n.NumberFormatSymbols_kln_KE', 'goog.i18n.NumberFormatSymbols_km_KH', 'goog.i18n.NumberFormatSymbols_kn_IN', 'goog.i18n.NumberFormatSymbols_ko_KP', 'goog.i18n.NumberFormatSymbols_ko_KR', 'goog.i18n.NumberFormatSymbols_kok', 'goog.i18n.NumberFormatSymbols_kok_IN', 'goog.i18n.NumberFormatSymbols_ks', 'goog.i18n.NumberFormatSymbols_ks_IN', 'goog.i18n.NumberFormatSymbols_ks_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ks_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ksb', 'goog.i18n.NumberFormatSymbols_ksb_TZ', 'goog.i18n.NumberFormatSymbols_ksf', 'goog.i18n.NumberFormatSymbols_ksf_CM', 'goog.i18n.NumberFormatSymbols_ksh', 'goog.i18n.NumberFormatSymbols_ksh_DE', 'goog.i18n.NumberFormatSymbols_ku', 'goog.i18n.NumberFormatSymbols_ku_TR', 'goog.i18n.NumberFormatSymbols_kw', 'goog.i18n.NumberFormatSymbols_kw_GB', 'goog.i18n.NumberFormatSymbols_ky_KG', 'goog.i18n.NumberFormatSymbols_lag', 'goog.i18n.NumberFormatSymbols_lag_TZ', 'goog.i18n.NumberFormatSymbols_lb', 'goog.i18n.NumberFormatSymbols_lb_LU', 'goog.i18n.NumberFormatSymbols_lg', 'goog.i18n.NumberFormatSymbols_lg_UG', 'goog.i18n.NumberFormatSymbols_lkt', 'goog.i18n.NumberFormatSymbols_lkt_US', 'goog.i18n.NumberFormatSymbols_ln_AO', 'goog.i18n.NumberFormatSymbols_ln_CD', 'goog.i18n.NumberFormatSymbols_ln_CF', 'goog.i18n.NumberFormatSymbols_ln_CG', 'goog.i18n.NumberFormatSymbols_lo_LA', 'goog.i18n.NumberFormatSymbols_lrc', 'goog.i18n.NumberFormatSymbols_lrc_IQ', 'goog.i18n.NumberFormatSymbols_lrc_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_IR', 'goog.i18n.NumberFormatSymbols_lrc_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lt_LT', 'goog.i18n.NumberFormatSymbols_lu', 'goog.i18n.NumberFormatSymbols_lu_CD', 'goog.i18n.NumberFormatSymbols_luo', 'goog.i18n.NumberFormatSymbols_luo_KE', 'goog.i18n.NumberFormatSymbols_luy', 'goog.i18n.NumberFormatSymbols_luy_KE', 'goog.i18n.NumberFormatSymbols_lv_LV', 'goog.i18n.NumberFormatSymbols_mas', 'goog.i18n.NumberFormatSymbols_mas_KE', 'goog.i18n.NumberFormatSymbols_mas_TZ', 'goog.i18n.NumberFormatSymbols_mer', 'goog.i18n.NumberFormatSymbols_mer_KE', 'goog.i18n.NumberFormatSymbols_mfe', 'goog.i18n.NumberFormatSymbols_mfe_MU', 'goog.i18n.NumberFormatSymbols_mg', 'goog.i18n.NumberFormatSymbols_mg_MG', 'goog.i18n.NumberFormatSymbols_mgh', 'goog.i18n.NumberFormatSymbols_mgh_MZ', 'goog.i18n.NumberFormatSymbols_mgo', 'goog.i18n.NumberFormatSymbols_mgo_CM', 'goog.i18n.NumberFormatSymbols_mi', 'goog.i18n.NumberFormatSymbols_mi_NZ', 'goog.i18n.NumberFormatSymbols_mk_MK', 'goog.i18n.NumberFormatSymbols_ml_IN', 'goog.i18n.NumberFormatSymbols_mn_MN', 'goog.i18n.NumberFormatSymbols_mr_IN', 'goog.i18n.NumberFormatSymbols_mr_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms_BN', 'goog.i18n.NumberFormatSymbols_ms_MY', 'goog.i18n.NumberFormatSymbols_ms_SG', 'goog.i18n.NumberFormatSymbols_mt_MT', 'goog.i18n.NumberFormatSymbols_mua', 'goog.i18n.NumberFormatSymbols_mua_CM', 'goog.i18n.NumberFormatSymbols_my_MM', 'goog.i18n.NumberFormatSymbols_my_MM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn', 'goog.i18n.NumberFormatSymbols_mzn_IR', 'goog.i18n.NumberFormatSymbols_mzn_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_naq', 'goog.i18n.NumberFormatSymbols_naq_NA', 'goog.i18n.NumberFormatSymbols_nb_NO', 'goog.i18n.NumberFormatSymbols_nb_SJ', 'goog.i18n.NumberFormatSymbols_nd', 'goog.i18n.NumberFormatSymbols_nd_ZW', 'goog.i18n.NumberFormatSymbols_nds', 'goog.i18n.NumberFormatSymbols_nds_DE', 'goog.i18n.NumberFormatSymbols_nds_NL', 'goog.i18n.NumberFormatSymbols_ne_IN', 'goog.i18n.NumberFormatSymbols_ne_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ne_NP', 'goog.i18n.NumberFormatSymbols_ne_NP_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl_AW', 'goog.i18n.NumberFormatSymbols_nl_BE', 'goog.i18n.NumberFormatSymbols_nl_BQ', 'goog.i18n.NumberFormatSymbols_nl_CW', 'goog.i18n.NumberFormatSymbols_nl_NL', 'goog.i18n.NumberFormatSymbols_nl_SR', 'goog.i18n.NumberFormatSymbols_nl_SX', 'goog.i18n.NumberFormatSymbols_nmg', 'goog.i18n.NumberFormatSymbols_nmg_CM', 'goog.i18n.NumberFormatSymbols_nn', 'goog.i18n.NumberFormatSymbols_nn_NO', 'goog.i18n.NumberFormatSymbols_nnh', 'goog.i18n.NumberFormatSymbols_nnh_CM', 'goog.i18n.NumberFormatSymbols_nus', 'goog.i18n.NumberFormatSymbols_nus_SS', 'goog.i18n.NumberFormatSymbols_nyn', 'goog.i18n.NumberFormatSymbols_nyn_UG', 'goog.i18n.NumberFormatSymbols_om', 'goog.i18n.NumberFormatSymbols_om_ET', 'goog.i18n.NumberFormatSymbols_om_KE', 'goog.i18n.NumberFormatSymbols_or_IN', 'goog.i18n.NumberFormatSymbols_os', 'goog.i18n.NumberFormatSymbols_os_GE', 'goog.i18n.NumberFormatSymbols_os_RU', 'goog.i18n.NumberFormatSymbols_pa_Arab', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Guru', 'goog.i18n.NumberFormatSymbols_pa_Guru_IN', 'goog.i18n.NumberFormatSymbols_pl_PL', 'goog.i18n.NumberFormatSymbols_ps', 'goog.i18n.NumberFormatSymbols_ps_AF', 'goog.i18n.NumberFormatSymbols_ps_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_PK', 'goog.i18n.NumberFormatSymbols_ps_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pt_AO', 'goog.i18n.NumberFormatSymbols_pt_CH', 'goog.i18n.NumberFormatSymbols_pt_CV', 'goog.i18n.NumberFormatSymbols_pt_GQ', 'goog.i18n.NumberFormatSymbols_pt_GW', 'goog.i18n.NumberFormatSymbols_pt_LU', 'goog.i18n.NumberFormatSymbols_pt_MO', 'goog.i18n.NumberFormatSymbols_pt_MZ', 'goog.i18n.NumberFormatSymbols_pt_ST', 'goog.i18n.NumberFormatSymbols_pt_TL', 'goog.i18n.NumberFormatSymbols_qu', 'goog.i18n.NumberFormatSymbols_qu_BO', 'goog.i18n.NumberFormatSymbols_qu_EC', 'goog.i18n.NumberFormatSymbols_qu_PE', 'goog.i18n.NumberFormatSymbols_rm', 'goog.i18n.NumberFormatSymbols_rm_CH', 'goog.i18n.NumberFormatSymbols_rn', 'goog.i18n.NumberFormatSymbols_rn_BI', 'goog.i18n.NumberFormatSymbols_ro_MD', 'goog.i18n.NumberFormatSymbols_ro_RO', 'goog.i18n.NumberFormatSymbols_rof', 'goog.i18n.NumberFormatSymbols_rof_TZ', 'goog.i18n.NumberFormatSymbols_ru_BY', 'goog.i18n.NumberFormatSymbols_ru_KG', 'goog.i18n.NumberFormatSymbols_ru_KZ', 'goog.i18n.NumberFormatSymbols_ru_MD', 'goog.i18n.NumberFormatSymbols_ru_RU', 'goog.i18n.NumberFormatSymbols_ru_UA', 'goog.i18n.NumberFormatSymbols_rw', 'goog.i18n.NumberFormatSymbols_rw_RW', 'goog.i18n.NumberFormatSymbols_rwk', 'goog.i18n.NumberFormatSymbols_rwk_TZ', 'goog.i18n.NumberFormatSymbols_sah', 'goog.i18n.NumberFormatSymbols_sah_RU', 'goog.i18n.NumberFormatSymbols_saq', 'goog.i18n.NumberFormatSymbols_saq_KE', 'goog.i18n.NumberFormatSymbols_sbp', 'goog.i18n.NumberFormatSymbols_sbp_TZ', 'goog.i18n.NumberFormatSymbols_sd', 'goog.i18n.NumberFormatSymbols_sd_PK', 'goog.i18n.NumberFormatSymbols_sd_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_sd_u_nu_latn', 'goog.i18n.NumberFormatSymbols_se', 'goog.i18n.NumberFormatSymbols_se_FI', 'goog.i18n.NumberFormatSymbols_se_NO', 'goog.i18n.NumberFormatSymbols_se_SE', 'goog.i18n.NumberFormatSymbols_seh', 'goog.i18n.NumberFormatSymbols_seh_MZ', 'goog.i18n.NumberFormatSymbols_ses', 'goog.i18n.NumberFormatSymbols_ses_ML', 'goog.i18n.NumberFormatSymbols_sg', 'goog.i18n.NumberFormatSymbols_sg_CF', 'goog.i18n.NumberFormatSymbols_shi', 'goog.i18n.NumberFormatSymbols_shi_Latn', 'goog.i18n.NumberFormatSymbols_shi_Latn_MA', 'goog.i18n.NumberFormatSymbols_shi_Tfng', 'goog.i18n.NumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.NumberFormatSymbols_si_LK', 'goog.i18n.NumberFormatSymbols_sk_SK', 'goog.i18n.NumberFormatSymbols_sl_SI', 'goog.i18n.NumberFormatSymbols_smn', 'goog.i18n.NumberFormatSymbols_smn_FI', 'goog.i18n.NumberFormatSymbols_sn', 'goog.i18n.NumberFormatSymbols_sn_ZW', 'goog.i18n.NumberFormatSymbols_so', 'goog.i18n.NumberFormatSymbols_so_DJ', 'goog.i18n.NumberFormatSymbols_so_ET', 'goog.i18n.NumberFormatSymbols_so_KE', 'goog.i18n.NumberFormatSymbols_so_SO', 'goog.i18n.NumberFormatSymbols_sq_AL', 'goog.i18n.NumberFormatSymbols_sq_MK', 'goog.i18n.NumberFormatSymbols_sq_XK', 'goog.i18n.NumberFormatSymbols_sr_Cyrl', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.NumberFormatSymbols_sr_Latn_BA', 'goog.i18n.NumberFormatSymbols_sr_Latn_ME', 'goog.i18n.NumberFormatSymbols_sr_Latn_RS', 'goog.i18n.NumberFormatSymbols_sr_Latn_XK', 'goog.i18n.NumberFormatSymbols_sv_AX', 'goog.i18n.NumberFormatSymbols_sv_FI', 'goog.i18n.NumberFormatSymbols_sv_SE', 'goog.i18n.NumberFormatSymbols_sw_CD', 'goog.i18n.NumberFormatSymbols_sw_KE', 'goog.i18n.NumberFormatSymbols_sw_TZ', 'goog.i18n.NumberFormatSymbols_sw_UG', 'goog.i18n.NumberFormatSymbols_ta_IN', 'goog.i18n.NumberFormatSymbols_ta_LK', 'goog.i18n.NumberFormatSymbols_ta_MY', 'goog.i18n.NumberFormatSymbols_ta_SG', 'goog.i18n.NumberFormatSymbols_te_IN', 'goog.i18n.NumberFormatSymbols_teo', 'goog.i18n.NumberFormatSymbols_teo_KE', 'goog.i18n.NumberFormatSymbols_teo_UG', 'goog.i18n.NumberFormatSymbols_tg', 'goog.i18n.NumberFormatSymbols_tg_TJ', 'goog.i18n.NumberFormatSymbols_th_TH', 'goog.i18n.NumberFormatSymbols_ti', 'goog.i18n.NumberFormatSymbols_ti_ER', 'goog.i18n.NumberFormatSymbols_ti_ET', 'goog.i18n.NumberFormatSymbols_tk', 'goog.i18n.NumberFormatSymbols_tk_TM', 'goog.i18n.NumberFormatSymbols_to', 'goog.i18n.NumberFormatSymbols_to_TO', 'goog.i18n.NumberFormatSymbols_tr_CY', 'goog.i18n.NumberFormatSymbols_tr_TR', 'goog.i18n.NumberFormatSymbols_tt', 'goog.i18n.NumberFormatSymbols_tt_RU', 'goog.i18n.NumberFormatSymbols_twq', 'goog.i18n.NumberFormatSymbols_twq_NE', 'goog.i18n.NumberFormatSymbols_tzm', 'goog.i18n.NumberFormatSymbols_tzm_MA', 'goog.i18n.NumberFormatSymbols_ug', 'goog.i18n.NumberFormatSymbols_ug_CN', 'goog.i18n.NumberFormatSymbols_uk_UA', 'goog.i18n.NumberFormatSymbols_ur_IN', 'goog.i18n.NumberFormatSymbols_ur_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ur_PK', 'goog.i18n.NumberFormatSymbols_uz_Arab', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Cyrl', 'goog.i18n.NumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.NumberFormatSymbols_uz_Latn', 'goog.i18n.NumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.NumberFormatSymbols_vai', 'goog.i18n.NumberFormatSymbols_vai_Latn', 'goog.i18n.NumberFormatSymbols_vai_Latn_LR', 'goog.i18n.NumberFormatSymbols_vai_Vaii', 'goog.i18n.NumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.NumberFormatSymbols_vi_VN', 'goog.i18n.NumberFormatSymbols_vun', 'goog.i18n.NumberFormatSymbols_vun_TZ', 'goog.i18n.NumberFormatSymbols_wae', 'goog.i18n.NumberFormatSymbols_wae_CH', 'goog.i18n.NumberFormatSymbols_wo', 'goog.i18n.NumberFormatSymbols_wo_SN', 'goog.i18n.NumberFormatSymbols_xh', 'goog.i18n.NumberFormatSymbols_xh_ZA', 'goog.i18n.NumberFormatSymbols_xog', 'goog.i18n.NumberFormatSymbols_xog_UG', 'goog.i18n.NumberFormatSymbols_yav', 'goog.i18n.NumberFormatSymbols_yav_CM', 'goog.i18n.NumberFormatSymbols_yi', 'goog.i18n.NumberFormatSymbols_yi_001', 'goog.i18n.NumberFormatSymbols_yo', 'goog.i18n.NumberFormatSymbols_yo_BJ', 'goog.i18n.NumberFormatSymbols_yo_NG', 'goog.i18n.NumberFormatSymbols_yue', 'goog.i18n.NumberFormatSymbols_yue_Hans', 'goog.i18n.NumberFormatSymbols_yue_Hans_CN', 'goog.i18n.NumberFormatSymbols_yue_Hant', 'goog.i18n.NumberFormatSymbols_yue_Hant_HK', 'goog.i18n.NumberFormatSymbols_zgh', 'goog.i18n.NumberFormatSymbols_zgh_MA', 'goog.i18n.NumberFormatSymbols_zh_Hans', 'goog.i18n.NumberFormatSymbols_zh_Hans_CN', 'goog.i18n.NumberFormatSymbols_zh_Hans_HK', 'goog.i18n.NumberFormatSymbols_zh_Hans_MO', 'goog.i18n.NumberFormatSymbols_zh_Hans_SG', 'goog.i18n.NumberFormatSymbols_zh_Hant', 'goog.i18n.NumberFormatSymbols_zh_Hant_HK', 'goog.i18n.NumberFormatSymbols_zh_Hant_MO', 'goog.i18n.NumberFormatSymbols_zh_Hant_TW', 'goog.i18n.NumberFormatSymbols_zu_ZA'], ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn'], {});
goog.addDependency('i18n/ordinalrules.js', ['goog.i18n.ordinalRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules.js', ['goog.i18n.pluralRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules_test.js', ['goog.i18n.pluralRulesTest'], ['goog.i18n.pluralRules', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat.js', ['goog.i18n.RelativeDateTimeFormat'], ['goog.asserts', 'goog.i18n.LocaleFeature', 'goog.i18n.MessageFormat', 'goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat_test.js', ['goog.i18n.RelativeDateTimeFormatTest'], ['goog.i18n.LocaleFeature', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.RelativeDateTimeFormat', 'goog.i18n.relativeDateTimeSymbols', 'goog.i18n.relativeDateTimeSymbolsExt', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbols.js', ['goog.i18n.relativeDateTimeSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbolsext.js', ['goog.i18n.relativeDateTimeSymbolsExt'], ['goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/timezone.js', ['goog.i18n.TimeZone'], ['goog.array', 'goog.date.DateLike', 'goog.object', 'goog.string'], {});
goog.addDependency('i18n/timezone_test.js', ['goog.i18n.TimeZoneTest'], ['goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar.js', ['goog.i18n.uChar'], [], {'lang': 'es6'});
goog.addDependency('i18n/uchar/localnamefetcher.js', ['goog.i18n.uChar.LocalNameFetcher'], ['goog.i18n.uChar.NameFetcher', 'goog.i18n.uCharNames', 'goog.log'], {});
goog.addDependency('i18n/uchar/localnamefetcher_test.js', ['goog.i18n.uChar.LocalNameFetcherTest'], ['goog.i18n.uChar.LocalNameFetcher', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar/namefetcher.js', ['goog.i18n.uChar.NameFetcher'], [], {});
goog.addDependency('i18n/uchar/remotenamefetcher.js', ['goog.i18n.uChar.RemoteNameFetcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('i18n/uchar/remotenamefetcher_test.js', ['goog.i18n.uChar.RemoteNameFetcherTest'], ['goog.i18n.uChar.RemoteNameFetcher', 'goog.net.XhrIo', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar_test.js', ['goog.i18n.uCharTest'], ['goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/ucharnames.js', ['goog.i18n.uCharNames'], ['goog.i18n.uChar'], {});
goog.addDependency('i18n/ucharnames_test.js', ['goog.i18n.uCharNamesTest'], ['goog.i18n.uCharNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6.js', ['goog.iter.es6'], ['goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6_test.js', ['goog.iter.es6Test'], ['goog.iter', 'goog.iter.es6', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/iter.js', ['goog.iter', 'goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], ['goog.array', 'goog.asserts', 'goog.functions', 'goog.math'], {});
goog.addDependency('iter/iter_test.js', ['goog.iterTest'], ['goog.iter', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/hybrid.js', ['goog.json.hybrid'], ['goog.asserts', 'goog.json'], {});
goog.addDependency('json/hybrid_test.js', ['goog.json.hybridTest'], ['goog.json', 'goog.json.hybrid', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/json.js', ['goog.json', 'goog.json.Replacer', 'goog.json.Reviver', 'goog.json.Serializer'], [], {'lang': 'es6'});
goog.addDependency('json/json_perf.js', ['goog.jsonPerf'], ['goog.dom', 'goog.json', 'goog.math', 'goog.string', 'goog.testing.PerformanceTable', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {});
goog.addDependency('json/json_test.js', ['goog.jsonTest'], ['goog.functions', 'goog.json', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/jsonable.js', ['goog.json.Jsonable'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/nativejsonprocessor.js', ['goog.json.NativeJsonProcessor'], ['goog.asserts', 'goog.json.Processor'], {});
goog.addDependency('json/processor.js', ['goog.json.Processor'], ['goog.string.Parser', 'goog.string.Stringifier'], {});
goog.addDependency('json/processor_test.js', ['goog.json.processorTest'], ['goog.json.NativeJsonProcessor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables.js', ['goog.labs.collections.iterables'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables_test.js', ['goog.labs.iterableTest'], ['goog.labs.collections.iterables', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/dom/pagevisibilitymonitor.js', ['goog.labs.dom.PageVisibilityEvent', 'goog.labs.dom.PageVisibilityMonitor', 'goog.labs.dom.PageVisibilityState'], ['goog.dom', 'goog.dom.vendor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.memoize'], {});
goog.addDependency('labs/dom/pagevisibilitymonitor_test.js', ['goog.labs.dom.PageVisibilityMonitorTest'], ['goog.events', 'goog.functions', 'goog.labs.dom.PageVisibilityMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget.js', ['goog.labs.events.NonDisposableEventTarget'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('labs/events/nondisposableeventtarget_test.js', ['goog.labs.events.NonDisposableEventTargetTest'], ['goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget_via_googevents_test.js', ['goog.labs.events.NonDisposableEventTargetGoogEventsTest'], ['goog.events', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/touch.js', ['goog.labs.events.touch', 'goog.labs.events.touch.TouchData'], ['goog.array', 'goog.asserts', 'goog.events.EventType', 'goog.string'], {});
goog.addDependency('labs/events/touch_test.js', ['goog.labs.events.touchTest'], ['goog.labs.events.touch', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/format/csv.js', ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.labs.format.csv.Token'], ['goog.array', 'goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string', 'goog.string.newlines'], {});
goog.addDependency('labs/format/csv_test.js', ['goog.labs.format.csvTest'], ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listformat.js', ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.GenderInfo.Gender', 'goog.labs.i18n.ListFormat'], ['goog.asserts', 'goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/i18n/listformat_test.js', ['goog.labs.i18n.ListFormatTest'], ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.ListFormat', 'goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_zu', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listsymbols.js', ['goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_af', 'goog.labs.i18n.ListFormatSymbols_am', 'goog.labs.i18n.ListFormatSymbols_ar', 'goog.labs.i18n.ListFormatSymbols_ar_DZ', 'goog.labs.i18n.ListFormatSymbols_ar_EG', 'goog.labs.i18n.ListFormatSymbols_az', 'goog.labs.i18n.ListFormatSymbols_be', 'goog.labs.i18n.ListFormatSymbols_bg', 'goog.labs.i18n.ListFormatSymbols_bn', 'goog.labs.i18n.ListFormatSymbols_br', 'goog.labs.i18n.ListFormatSymbols_bs', 'goog.labs.i18n.ListFormatSymbols_ca', 'goog.labs.i18n.ListFormatSymbols_chr', 'goog.labs.i18n.ListFormatSymbols_cs', 'goog.labs.i18n.ListFormatSymbols_cy', 'goog.labs.i18n.ListFormatSymbols_da', 'goog.labs.i18n.ListFormatSymbols_de', 'goog.labs.i18n.ListFormatSymbols_de_AT', 'goog.labs.i18n.ListFormatSymbols_de_CH', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_en_AU', 'goog.labs.i18n.ListFormatSymbols_en_CA', 'goog.labs.i18n.ListFormatSymbols_en_GB', 'goog.labs.i18n.ListFormatSymbols_en_IE', 'goog.labs.i18n.ListFormatSymbols_en_IN', 'goog.labs.i18n.ListFormatSymbols_en_SG', 'goog.labs.i18n.ListFormatSymbols_en_US', 'goog.labs.i18n.ListFormatSymbols_en_ZA', 'goog.labs.i18n.ListFormatSymbols_es', 'goog.labs.i18n.ListFormatSymbols_es_419', 'goog.labs.i18n.ListFormatSymbols_es_ES', 'goog.labs.i18n.ListFormatSymbols_es_MX', 'goog.labs.i18n.ListFormatSymbols_es_US', 'goog.labs.i18n.ListFormatSymbols_et', 'goog.labs.i18n.ListFormatSymbols_eu', 'goog.labs.i18n.ListFormatSymbols_fa', 'goog.labs.i18n.ListFormatSymbols_fi', 'goog.labs.i18n.ListFormatSymbols_fil', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_fr_CA', 'goog.labs.i18n.ListFormatSymbols_ga', 'goog.labs.i18n.ListFormatSymbols_gl', 'goog.labs.i18n.ListFormatSymbols_gsw', 'goog.labs.i18n.ListFormatSymbols_gu', 'goog.labs.i18n.ListFormatSymbols_haw', 'goog.labs.i18n.ListFormatSymbols_he', 'goog.labs.i18n.ListFormatSymbols_hi', 'goog.labs.i18n.ListFormatSymbols_hr', 'goog.labs.i18n.ListFormatSymbols_hu', 'goog.labs.i18n.ListFormatSymbols_hy', 'goog.labs.i18n.ListFormatSymbols_id', 'goog.labs.i18n.ListFormatSymbols_in', 'goog.labs.i18n.ListFormatSymbols_is', 'goog.labs.i18n.ListFormatSymbols_it', 'goog.labs.i18n.ListFormatSymbols_iw', 'goog.labs.i18n.ListFormatSymbols_ja', 'goog.labs.i18n.ListFormatSymbols_ka', 'goog.labs.i18n.ListFormatSymbols_kk', 'goog.labs.i18n.ListFormatSymbols_km', 'goog.labs.i18n.ListFormatSymbols_kn', 'goog.labs.i18n.ListFormatSymbols_ko', 'goog.labs.i18n.ListFormatSymbols_ky', 'goog.labs.i18n.ListFormatSymbols_ln', 'goog.labs.i18n.ListFormatSymbols_lo', 'goog.labs.i18n.ListFormatSymbols_lt', 'goog.labs.i18n.ListFormatSymbols_lv', 'goog.labs.i18n.ListFormatSymbols_mk', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_mn', 'goog.labs.i18n.ListFormatSymbols_mo', 'goog.labs.i18n.ListFormatSymbols_mr', 'goog.labs.i18n.ListFormatSymbols_ms', 'goog.labs.i18n.ListFormatSymbols_mt', 'goog.labs.i18n.ListFormatSymbols_my', 'goog.labs.i18n.ListFormatSymbols_nb', 'goog.labs.i18n.ListFormatSymbols_ne', 'goog.labs.i18n.ListFormatSymbols_nl', 'goog.labs.i18n.ListFormatSymbols_no', 'goog.labs.i18n.ListFormatSymbols_no_NO', 'goog.labs.i18n.ListFormatSymbols_or', 'goog.labs.i18n.ListFormatSymbols_pa', 'goog.labs.i18n.ListFormatSymbols_pl', 'goog.labs.i18n.ListFormatSymbols_pt', 'goog.labs.i18n.ListFormatSymbols_pt_BR', 'goog.labs.i18n.ListFormatSymbols_pt_PT', 'goog.labs.i18n.ListFormatSymbols_ro', 'goog.labs.i18n.ListFormatSymbols_ru', 'goog.labs.i18n.ListFormatSymbols_sh', 'goog.labs.i18n.ListFormatSymbols_si', 'goog.labs.i18n.ListFormatSymbols_sk', 'goog.labs.i18n.ListFormatSymbols_sl', 'goog.labs.i18n.ListFormatSymbols_sq', 'goog.labs.i18n.ListFormatSymbols_sr', 'goog.labs.i18n.ListFormatSymbols_sr_Latn', 'goog.labs.i18n.ListFormatSymbols_sv', 'goog.labs.i18n.ListFormatSymbols_sw', 'goog.labs.i18n.ListFormatSymbols_ta', 'goog.labs.i18n.ListFormatSymbols_te', 'goog.labs.i18n.ListFormatSymbols_th', 'goog.labs.i18n.ListFormatSymbols_tl', 'goog.labs.i18n.ListFormatSymbols_tr', 'goog.labs.i18n.ListFormatSymbols_uk', 'goog.labs.i18n.ListFormatSymbols_ur', 'goog.labs.i18n.ListFormatSymbols_uz', 'goog.labs.i18n.ListFormatSymbols_vi', 'goog.labs.i18n.ListFormatSymbols_zh', 'goog.labs.i18n.ListFormatSymbols_zh_CN', 'goog.labs.i18n.ListFormatSymbols_zh_HK', 'goog.labs.i18n.ListFormatSymbols_zh_TW', 'goog.labs.i18n.ListFormatSymbols_zu'], [], {});
goog.addDependency('labs/i18n/listsymbolsext.js', ['goog.labs.i18n.ListFormatSymbolsExt', 'goog.labs.i18n.ListFormatSymbols_af_NA', 'goog.labs.i18n.ListFormatSymbols_af_ZA', 'goog.labs.i18n.ListFormatSymbols_agq', 'goog.labs.i18n.ListFormatSymbols_agq_CM', 'goog.labs.i18n.ListFormatSymbols_ak', 'goog.labs.i18n.ListFormatSymbols_ak_GH', 'goog.labs.i18n.ListFormatSymbols_am_ET', 'goog.labs.i18n.ListFormatSymbols_ar_001', 'goog.labs.i18n.ListFormatSymbols_ar_AE', 'goog.labs.i18n.ListFormatSymbols_ar_BH', 'goog.labs.i18n.ListFormatSymbols_ar_DJ', 'goog.labs.i18n.ListFormatSymbols_ar_EH', 'goog.labs.i18n.ListFormatSymbols_ar_ER', 'goog.labs.i18n.ListFormatSymbols_ar_IL', 'goog.labs.i18n.ListFormatSymbols_ar_IQ', 'goog.labs.i18n.ListFormatSymbols_ar_JO', 'goog.labs.i18n.ListFormatSymbols_ar_KM', 'goog.labs.i18n.ListFormatSymbols_ar_KW', 'goog.labs.i18n.ListFormatSymbols_ar_LB', 'goog.labs.i18n.ListFormatSymbols_ar_LY', 'goog.labs.i18n.ListFormatSymbols_ar_MA', 'goog.labs.i18n.ListFormatSymbols_ar_MR', 'goog.labs.i18n.ListFormatSymbols_ar_OM', 'goog.labs.i18n.ListFormatSymbols_ar_PS', 'goog.labs.i18n.ListFormatSymbols_ar_QA', 'goog.labs.i18n.ListFormatSymbols_ar_SA', 'goog.labs.i18n.ListFormatSymbols_ar_SD', 'goog.labs.i18n.ListFormatSymbols_ar_SO', 'goog.labs.i18n.ListFormatSymbols_ar_SS', 'goog.labs.i18n.ListFormatSymbols_ar_SY', 'goog.labs.i18n.ListFormatSymbols_ar_TD', 'goog.labs.i18n.ListFormatSymbols_ar_TN', 'goog.labs.i18n.ListFormatSymbols_ar_XB', 'goog.labs.i18n.ListFormatSymbols_ar_YE', 'goog.labs.i18n.ListFormatSymbols_as', 'goog.labs.i18n.ListFormatSymbols_as_IN', 'goog.labs.i18n.ListFormatSymbols_asa', 'goog.labs.i18n.ListFormatSymbols_asa_TZ', 'goog.labs.i18n.ListFormatSymbols_ast', 'goog.labs.i18n.ListFormatSymbols_ast_ES', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl_AZ', 'goog.labs.i18n.ListFormatSymbols_az_Latn', 'goog.labs.i18n.ListFormatSymbols_az_Latn_AZ', 'goog.labs.i18n.ListFormatSymbols_bas', 'goog.labs.i18n.ListFormatSymbols_bas_CM', 'goog.labs.i18n.ListFormatSymbols_be_BY', 'goog.labs.i18n.ListFormatSymbols_bem', 'goog.labs.i18n.ListFormatSymbols_bem_ZM', 'goog.labs.i18n.ListFormatSymbols_bez', 'goog.labs.i18n.ListFormatSymbols_bez_TZ', 'goog.labs.i18n.ListFormatSymbols_bg_BG', 'goog.labs.i18n.ListFormatSymbols_bm', 'goog.labs.i18n.ListFormatSymbols_bm_ML', 'goog.labs.i18n.ListFormatSymbols_bn_BD', 'goog.labs.i18n.ListFormatSymbols_bn_IN', 'goog.labs.i18n.ListFormatSymbols_bo', 'goog.labs.i18n.ListFormatSymbols_bo_CN', 'goog.labs.i18n.ListFormatSymbols_bo_IN', 'goog.labs.i18n.ListFormatSymbols_br_FR', 'goog.labs.i18n.ListFormatSymbols_brx', 'goog.labs.i18n.ListFormatSymbols_brx_IN', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_bs_Latn', 'goog.labs.i18n.ListFormatSymbols_bs_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_ca_AD', 'goog.labs.i18n.ListFormatSymbols_ca_ES', 'goog.labs.i18n.ListFormatSymbols_ca_FR', 'goog.labs.i18n.ListFormatSymbols_ca_IT', 'goog.labs.i18n.ListFormatSymbols_ccp', 'goog.labs.i18n.ListFormatSymbols_ccp_BD', 'goog.labs.i18n.ListFormatSymbols_ccp_IN', 'goog.labs.i18n.ListFormatSymbols_ce', 'goog.labs.i18n.ListFormatSymbols_ce_RU', 'goog.labs.i18n.ListFormatSymbols_ceb', 'goog.labs.i18n.ListFormatSymbols_ceb_PH', 'goog.labs.i18n.ListFormatSymbols_cgg', 'goog.labs.i18n.ListFormatSymbols_cgg_UG', 'goog.labs.i18n.ListFormatSymbols_chr_US', 'goog.labs.i18n.ListFormatSymbols_ckb', 'goog.labs.i18n.ListFormatSymbols_ckb_IQ', 'goog.labs.i18n.ListFormatSymbols_ckb_IR', 'goog.labs.i18n.ListFormatSymbols_cs_CZ', 'goog.labs.i18n.ListFormatSymbols_cy_GB', 'goog.labs.i18n.ListFormatSymbols_da_DK', 'goog.labs.i18n.ListFormatSymbols_da_GL', 'goog.labs.i18n.ListFormatSymbols_dav', 'goog.labs.i18n.ListFormatSymbols_dav_KE', 'goog.labs.i18n.ListFormatSymbols_de_BE', 'goog.labs.i18n.ListFormatSymbols_de_DE', 'goog.labs.i18n.ListFormatSymbols_de_IT', 'goog.labs.i18n.ListFormatSymbols_de_LI', 'goog.labs.i18n.ListFormatSymbols_de_LU', 'goog.labs.i18n.ListFormatSymbols_dje', 'goog.labs.i18n.ListFormatSymbols_dje_NE', 'goog.labs.i18n.ListFormatSymbols_dsb', 'goog.labs.i18n.ListFormatSymbols_dsb_DE', 'goog.labs.i18n.ListFormatSymbols_dua', 'goog.labs.i18n.ListFormatSymbols_dua_CM', 'goog.labs.i18n.ListFormatSymbols_dyo', 'goog.labs.i18n.ListFormatSymbols_dyo_SN', 'goog.labs.i18n.ListFormatSymbols_dz', 'goog.labs.i18n.ListFormatSymbols_dz_BT', 'goog.labs.i18n.ListFormatSymbols_ebu', 'goog.labs.i18n.ListFormatSymbols_ebu_KE', 'goog.labs.i18n.ListFormatSymbols_ee', 'goog.labs.i18n.ListFormatSymbols_ee_GH', 'goog.labs.i18n.ListFormatSymbols_ee_TG', 'goog.labs.i18n.ListFormatSymbols_el_CY', 'goog.labs.i18n.ListFormatSymbols_el_GR', 'goog.labs.i18n.ListFormatSymbols_en_001', 'goog.labs.i18n.ListFormatSymbols_en_150', 'goog.labs.i18n.ListFormatSymbols_en_AE', 'goog.labs.i18n.ListFormatSymbols_en_AG', 'goog.labs.i18n.ListFormatSymbols_en_AI', 'goog.labs.i18n.ListFormatSymbols_en_AS', 'goog.labs.i18n.ListFormatSymbols_en_AT', 'goog.labs.i18n.ListFormatSymbols_en_BB', 'goog.labs.i18n.ListFormatSymbols_en_BE', 'goog.labs.i18n.ListFormatSymbols_en_BI', 'goog.labs.i18n.ListFormatSymbols_en_BM', 'goog.labs.i18n.ListFormatSymbols_en_BS', 'goog.labs.i18n.ListFormatSymbols_en_BW', 'goog.labs.i18n.ListFormatSymbols_en_BZ', 'goog.labs.i18n.ListFormatSymbols_en_CC', 'goog.labs.i18n.ListFormatSymbols_en_CH', 'goog.labs.i18n.ListFormatSymbols_en_CK', 'goog.labs.i18n.ListFormatSymbols_en_CM', 'goog.labs.i18n.ListFormatSymbols_en_CX', 'goog.labs.i18n.ListFormatSymbols_en_CY', 'goog.labs.i18n.ListFormatSymbols_en_DE', 'goog.labs.i18n.ListFormatSymbols_en_DG', 'goog.labs.i18n.ListFormatSymbols_en_DK', 'goog.labs.i18n.ListFormatSymbols_en_DM', 'goog.labs.i18n.ListFormatSymbols_en_ER', 'goog.labs.i18n.ListFormatSymbols_en_FI', 'goog.labs.i18n.ListFormatSymbols_en_FJ', 'goog.labs.i18n.ListFormatSymbols_en_FK', 'goog.labs.i18n.ListFormatSymbols_en_FM', 'goog.labs.i18n.ListFormatSymbols_en_GD', 'goog.labs.i18n.ListFormatSymbols_en_GG', 'goog.labs.i18n.ListFormatSymbols_en_GH', 'goog.labs.i18n.ListFormatSymbols_en_GI', 'goog.labs.i18n.ListFormatSymbols_en_GM', 'goog.labs.i18n.ListFormatSymbols_en_GU', 'goog.labs.i18n.ListFormatSymbols_en_GY', 'goog.labs.i18n.ListFormatSymbols_en_HK', 'goog.labs.i18n.ListFormatSymbols_en_IL', 'goog.labs.i18n.ListFormatSymbols_en_IM', 'goog.labs.i18n.ListFormatSymbols_en_IO', 'goog.labs.i18n.ListFormatSymbols_en_JE', 'goog.labs.i18n.ListFormatSymbols_en_JM', 'goog.labs.i18n.ListFormatSymbols_en_KE', 'goog.labs.i18n.ListFormatSymbols_en_KI', 'goog.labs.i18n.ListFormatSymbols_en_KN', 'goog.labs.i18n.ListFormatSymbols_en_KY', 'goog.labs.i18n.ListFormatSymbols_en_LC', 'goog.labs.i18n.ListFormatSymbols_en_LR', 'goog.labs.i18n.ListFormatSymbols_en_LS', 'goog.labs.i18n.ListFormatSymbols_en_MG', 'goog.labs.i18n.ListFormatSymbols_en_MH', 'goog.labs.i18n.ListFormatSymbols_en_MO', 'goog.labs.i18n.ListFormatSymbols_en_MP', 'goog.labs.i18n.ListFormatSymbols_en_MS', 'goog.labs.i18n.ListFormatSymbols_en_MT', 'goog.labs.i18n.ListFormatSymbols_en_MU', 'goog.labs.i18n.ListFormatSymbols_en_MW', 'goog.labs.i18n.ListFormatSymbols_en_MY', 'goog.labs.i18n.ListFormatSymbols_en_NA', 'goog.labs.i18n.ListFormatSymbols_en_NF', 'goog.labs.i18n.ListFormatSymbols_en_NG', 'goog.labs.i18n.ListFormatSymbols_en_NL', 'goog.labs.i18n.ListFormatSymbols_en_NR', 'goog.labs.i18n.ListFormatSymbols_en_NU', 'goog.labs.i18n.ListFormatSymbols_en_NZ', 'goog.labs.i18n.ListFormatSymbols_en_PG', 'goog.labs.i18n.ListFormatSymbols_en_PH', 'goog.labs.i18n.ListFormatSymbols_en_PK', 'goog.labs.i18n.ListFormatSymbols_en_PN', 'goog.labs.i18n.ListFormatSymbols_en_PR', 'goog.labs.i18n.ListFormatSymbols_en_PW', 'goog.labs.i18n.ListFormatSymbols_en_RW', 'goog.labs.i18n.ListFormatSymbols_en_SB', 'goog.labs.i18n.ListFormatSymbols_en_SC', 'goog.labs.i18n.ListFormatSymbols_en_SD', 'goog.labs.i18n.ListFormatSymbols_en_SE', 'goog.labs.i18n.ListFormatSymbols_en_SH', 'goog.labs.i18n.ListFormatSymbols_en_SI', 'goog.labs.i18n.ListFormatSymbols_en_SL', 'goog.labs.i18n.ListFormatSymbols_en_SS', 'goog.labs.i18n.ListFormatSymbols_en_SX', 'goog.labs.i18n.ListFormatSymbols_en_SZ', 'goog.labs.i18n.ListFormatSymbols_en_TC', 'goog.labs.i18n.ListFormatSymbols_en_TK', 'goog.labs.i18n.ListFormatSymbols_en_TO', 'goog.labs.i18n.ListFormatSymbols_en_TT', 'goog.labs.i18n.ListFormatSymbols_en_TV', 'goog.labs.i18n.ListFormatSymbols_en_TZ', 'goog.labs.i18n.ListFormatSymbols_en_UG', 'goog.labs.i18n.ListFormatSymbols_en_UM', 'goog.labs.i18n.ListFormatSymbols_en_US_POSIX', 'goog.labs.i18n.ListFormatSymbols_en_VC', 'goog.labs.i18n.ListFormatSymbols_en_VG', 'goog.labs.i18n.ListFormatSymbols_en_VI', 'goog.labs.i18n.ListFormatSymbols_en_VU', 'goog.labs.i18n.ListFormatSymbols_en_WS', 'goog.labs.i18n.ListFormatSymbols_en_XA', 'goog.labs.i18n.ListFormatSymbols_en_ZM', 'goog.labs.i18n.ListFormatSymbols_en_ZW', 'goog.labs.i18n.ListFormatSymbols_eo', 'goog.labs.i18n.ListFormatSymbols_eo_001', 'goog.labs.i18n.ListFormatSymbols_es_AR', 'goog.labs.i18n.ListFormatSymbols_es_BO', 'goog.labs.i18n.ListFormatSymbols_es_BR', 'goog.labs.i18n.ListFormatSymbols_es_BZ', 'goog.labs.i18n.ListFormatSymbols_es_CL', 'goog.labs.i18n.ListFormatSymbols_es_CO', 'goog.labs.i18n.ListFormatSymbols_es_CR', 'goog.labs.i18n.ListFormatSymbols_es_CU', 'goog.labs.i18n.ListFormatSymbols_es_DO', 'goog.labs.i18n.ListFormatSymbols_es_EA', 'goog.labs.i18n.ListFormatSymbols_es_EC', 'goog.labs.i18n.ListFormatSymbols_es_GQ', 'goog.labs.i18n.ListFormatSymbols_es_GT', 'goog.labs.i18n.ListFormatSymbols_es_HN', 'goog.labs.i18n.ListFormatSymbols_es_IC', 'goog.labs.i18n.ListFormatSymbols_es_NI', 'goog.labs.i18n.ListFormatSymbols_es_PA', 'goog.labs.i18n.ListFormatSymbols_es_PE', 'goog.labs.i18n.ListFormatSymbols_es_PH', 'goog.labs.i18n.ListFormatSymbols_es_PR', 'goog.labs.i18n.ListFormatSymbols_es_PY', 'goog.labs.i18n.ListFormatSymbols_es_SV', 'goog.labs.i18n.ListFormatSymbols_es_UY', 'goog.labs.i18n.ListFormatSymbols_es_VE', 'goog.labs.i18n.ListFormatSymbols_et_EE', 'goog.labs.i18n.ListFormatSymbols_eu_ES', 'goog.labs.i18n.ListFormatSymbols_ewo', 'goog.labs.i18n.ListFormatSymbols_ewo_CM', 'goog.labs.i18n.ListFormatSymbols_fa_AF', 'goog.labs.i18n.ListFormatSymbols_fa_IR', 'goog.labs.i18n.ListFormatSymbols_ff', 'goog.labs.i18n.ListFormatSymbols_ff_Latn', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_BF', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_CM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GH', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GN', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GW', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_MR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NE', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NG', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SL', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SN', 'goog.labs.i18n.ListFormatSymbols_fi_FI', 'goog.labs.i18n.ListFormatSymbols_fil_PH', 'goog.labs.i18n.ListFormatSymbols_fo', 'goog.labs.i18n.ListFormatSymbols_fo_DK', 'goog.labs.i18n.ListFormatSymbols_fo_FO', 'goog.labs.i18n.ListFormatSymbols_fr_BE', 'goog.labs.i18n.ListFormatSymbols_fr_BF', 'goog.labs.i18n.ListFormatSymbols_fr_BI', 'goog.labs.i18n.ListFormatSymbols_fr_BJ', 'goog.labs.i18n.ListFormatSymbols_fr_BL', 'goog.labs.i18n.ListFormatSymbols_fr_CD', 'goog.labs.i18n.ListFormatSymbols_fr_CF', 'goog.labs.i18n.ListFormatSymbols_fr_CG', 'goog.labs.i18n.ListFormatSymbols_fr_CH', 'goog.labs.i18n.ListFormatSymbols_fr_CI', 'goog.labs.i18n.ListFormatSymbols_fr_CM', 'goog.labs.i18n.ListFormatSymbols_fr_DJ', 'goog.labs.i18n.ListFormatSymbols_fr_DZ', 'goog.labs.i18n.ListFormatSymbols_fr_FR', 'goog.labs.i18n.ListFormatSymbols_fr_GA', 'goog.labs.i18n.ListFormatSymbols_fr_GF', 'goog.labs.i18n.ListFormatSymbols_fr_GN', 'goog.labs.i18n.ListFormatSymbols_fr_GP', 'goog.labs.i18n.ListFormatSymbols_fr_GQ', 'goog.labs.i18n.ListFormatSymbols_fr_HT', 'goog.labs.i18n.ListFormatSymbols_fr_KM', 'goog.labs.i18n.ListFormatSymbols_fr_LU', 'goog.labs.i18n.ListFormatSymbols_fr_MA', 'goog.labs.i18n.ListFormatSymbols_fr_MC', 'goog.labs.i18n.ListFormatSymbols_fr_MF', 'goog.labs.i18n.ListFormatSymbols_fr_MG', 'goog.labs.i18n.ListFormatSymbols_fr_ML', 'goog.labs.i18n.ListFormatSymbols_fr_MQ', 'goog.labs.i18n.ListFormatSymbols_fr_MR', 'goog.labs.i18n.ListFormatSymbols_fr_MU', 'goog.labs.i18n.ListFormatSymbols_fr_NC', 'goog.labs.i18n.ListFormatSymbols_fr_NE', 'goog.labs.i18n.ListFormatSymbols_fr_PF', 'goog.labs.i18n.ListFormatSymbols_fr_PM', 'goog.labs.i18n.ListFormatSymbols_fr_RE', 'goog.labs.i18n.ListFormatSymbols_fr_RW', 'goog.labs.i18n.ListFormatSymbols_fr_SC', 'goog.labs.i18n.ListFormatSymbols_fr_SN', 'goog.labs.i18n.ListFormatSymbols_fr_SY', 'goog.labs.i18n.ListFormatSymbols_fr_TD', 'goog.labs.i18n.ListFormatSymbols_fr_TG', 'goog.labs.i18n.ListFormatSymbols_fr_TN', 'goog.labs.i18n.ListFormatSymbols_fr_VU', 'goog.labs.i18n.ListFormatSymbols_fr_WF', 'goog.labs.i18n.ListFormatSymbols_fr_YT', 'goog.labs.i18n.ListFormatSymbols_fur', 'goog.labs.i18n.ListFormatSymbols_fur_IT', 'goog.labs.i18n.ListFormatSymbols_fy', 'goog.labs.i18n.ListFormatSymbols_fy_NL', 'goog.labs.i18n.ListFormatSymbols_ga_IE', 'goog.labs.i18n.ListFormatSymbols_gd', 'goog.labs.i18n.ListFormatSymbols_gd_GB', 'goog.labs.i18n.ListFormatSymbols_gl_ES', 'goog.labs.i18n.ListFormatSymbols_gsw_CH', 'goog.labs.i18n.ListFormatSymbols_gsw_FR', 'goog.labs.i18n.ListFormatSymbols_gsw_LI', 'goog.labs.i18n.ListFormatSymbols_gu_IN', 'goog.labs.i18n.ListFormatSymbols_guz', 'goog.labs.i18n.ListFormatSymbols_guz_KE', 'goog.labs.i18n.ListFormatSymbols_gv', 'goog.labs.i18n.ListFormatSymbols_gv_IM', 'goog.labs.i18n.ListFormatSymbols_ha', 'goog.labs.i18n.ListFormatSymbols_ha_GH', 'goog.labs.i18n.ListFormatSymbols_ha_NE', 'goog.labs.i18n.ListFormatSymbols_ha_NG', 'goog.labs.i18n.ListFormatSymbols_haw_US', 'goog.labs.i18n.ListFormatSymbols_he_IL', 'goog.labs.i18n.ListFormatSymbols_hi_IN', 'goog.labs.i18n.ListFormatSymbols_hr_BA', 'goog.labs.i18n.ListFormatSymbols_hr_HR', 'goog.labs.i18n.ListFormatSymbols_hsb', 'goog.labs.i18n.ListFormatSymbols_hsb_DE', 'goog.labs.i18n.ListFormatSymbols_hu_HU', 'goog.labs.i18n.ListFormatSymbols_hy_AM', 'goog.labs.i18n.ListFormatSymbols_ia', 'goog.labs.i18n.ListFormatSymbols_ia_001', 'goog.labs.i18n.ListFormatSymbols_id_ID', 'goog.labs.i18n.ListFormatSymbols_ig', 'goog.labs.i18n.ListFormatSymbols_ig_NG', 'goog.labs.i18n.ListFormatSymbols_ii', 'goog.labs.i18n.ListFormatSymbols_ii_CN', 'goog.labs.i18n.ListFormatSymbols_is_IS', 'goog.labs.i18n.ListFormatSymbols_it_CH', 'goog.labs.i18n.ListFormatSymbols_it_IT', 'goog.labs.i18n.ListFormatSymbols_it_SM', 'goog.labs.i18n.ListFormatSymbols_it_VA', 'goog.labs.i18n.ListFormatSymbols_ja_JP', 'goog.labs.i18n.ListFormatSymbols_jgo', 'goog.labs.i18n.ListFormatSymbols_jgo_CM', 'goog.labs.i18n.ListFormatSymbols_jmc', 'goog.labs.i18n.ListFormatSymbols_jmc_TZ', 'goog.labs.i18n.ListFormatSymbols_jv', 'goog.labs.i18n.ListFormatSymbols_jv_ID', 'goog.labs.i18n.ListFormatSymbols_ka_GE', 'goog.labs.i18n.ListFormatSymbols_kab', 'goog.labs.i18n.ListFormatSymbols_kab_DZ', 'goog.labs.i18n.ListFormatSymbols_kam', 'goog.labs.i18n.ListFormatSymbols_kam_KE', 'goog.labs.i18n.ListFormatSymbols_kde', 'goog.labs.i18n.ListFormatSymbols_kde_TZ', 'goog.labs.i18n.ListFormatSymbols_kea', 'goog.labs.i18n.ListFormatSymbols_kea_CV', 'goog.labs.i18n.ListFormatSymbols_khq', 'goog.labs.i18n.ListFormatSymbols_khq_ML', 'goog.labs.i18n.ListFormatSymbols_ki', 'goog.labs.i18n.ListFormatSymbols_ki_KE', 'goog.labs.i18n.ListFormatSymbols_kk_KZ', 'goog.labs.i18n.ListFormatSymbols_kkj', 'goog.labs.i18n.ListFormatSymbols_kkj_CM', 'goog.labs.i18n.ListFormatSymbols_kl', 'goog.labs.i18n.ListFormatSymbols_kl_GL', 'goog.labs.i18n.ListFormatSymbols_kln', 'goog.labs.i18n.ListFormatSymbols_kln_KE', 'goog.labs.i18n.ListFormatSymbols_km_KH', 'goog.labs.i18n.ListFormatSymbols_kn_IN', 'goog.labs.i18n.ListFormatSymbols_ko_KP', 'goog.labs.i18n.ListFormatSymbols_ko_KR', 'goog.labs.i18n.ListFormatSymbols_kok', 'goog.labs.i18n.ListFormatSymbols_kok_IN', 'goog.labs.i18n.ListFormatSymbols_ks', 'goog.labs.i18n.ListFormatSymbols_ks_IN', 'goog.labs.i18n.ListFormatSymbols_ksb', 'goog.labs.i18n.ListFormatSymbols_ksb_TZ', 'goog.labs.i18n.ListFormatSymbols_ksf', 'goog.labs.i18n.ListFormatSymbols_ksf_CM', 'goog.labs.i18n.ListFormatSymbols_ksh', 'goog.labs.i18n.ListFormatSymbols_ksh_DE', 'goog.labs.i18n.ListFormatSymbols_ku', 'goog.labs.i18n.ListFormatSymbols_ku_TR', 'goog.labs.i18n.ListFormatSymbols_kw', 'goog.labs.i18n.ListFormatSymbols_kw_GB', 'goog.labs.i18n.ListFormatSymbols_ky_KG', 'goog.labs.i18n.ListFormatSymbols_lag', 'goog.labs.i18n.ListFormatSymbols_lag_TZ', 'goog.labs.i18n.ListFormatSymbols_lb', 'goog.labs.i18n.ListFormatSymbols_lb_LU', 'goog.labs.i18n.ListFormatSymbols_lg', 'goog.labs.i18n.ListFormatSymbols_lg_UG', 'goog.labs.i18n.ListFormatSymbols_lkt', 'goog.labs.i18n.ListFormatSymbols_lkt_US', 'goog.labs.i18n.ListFormatSymbols_ln_AO', 'goog.labs.i18n.ListFormatSymbols_ln_CD', 'goog.labs.i18n.ListFormatSymbols_ln_CF', 'goog.labs.i18n.ListFormatSymbols_ln_CG', 'goog.labs.i18n.ListFormatSymbols_lo_LA', 'goog.labs.i18n.ListFormatSymbols_lrc', 'goog.labs.i18n.ListFormatSymbols_lrc_IQ', 'goog.labs.i18n.ListFormatSymbols_lrc_IR', 'goog.labs.i18n.ListFormatSymbols_lt_LT', 'goog.labs.i18n.ListFormatSymbols_lu', 'goog.labs.i18n.ListFormatSymbols_lu_CD', 'goog.labs.i18n.ListFormatSymbols_luo', 'goog.labs.i18n.ListFormatSymbols_luo_KE', 'goog.labs.i18n.ListFormatSymbols_luy', 'goog.labs.i18n.ListFormatSymbols_luy_KE', 'goog.labs.i18n.ListFormatSymbols_lv_LV', 'goog.labs.i18n.ListFormatSymbols_mas', 'goog.labs.i18n.ListFormatSymbols_mas_KE', 'goog.labs.i18n.ListFormatSymbols_mas_TZ', 'goog.labs.i18n.ListFormatSymbols_mer', 'goog.labs.i18n.ListFormatSymbols_mer_KE', 'goog.labs.i18n.ListFormatSymbols_mfe', 'goog.labs.i18n.ListFormatSymbols_mfe_MU', 'goog.labs.i18n.ListFormatSymbols_mg', 'goog.labs.i18n.ListFormatSymbols_mg_MG', 'goog.labs.i18n.ListFormatSymbols_mgh', 'goog.labs.i18n.ListFormatSymbols_mgh_MZ', 'goog.labs.i18n.ListFormatSymbols_mgo', 'goog.labs.i18n.ListFormatSymbols_mgo_CM', 'goog.labs.i18n.ListFormatSymbols_mi', 'goog.labs.i18n.ListFormatSymbols_mi_NZ', 'goog.labs.i18n.ListFormatSymbols_mk_MK', 'goog.labs.i18n.ListFormatSymbols_ml_IN', 'goog.labs.i18n.ListFormatSymbols_mn_MN', 'goog.labs.i18n.ListFormatSymbols_mr_IN', 'goog.labs.i18n.ListFormatSymbols_ms_BN', 'goog.labs.i18n.ListFormatSymbols_ms_MY', 'goog.labs.i18n.ListFormatSymbols_ms_SG', 'goog.labs.i18n.ListFormatSymbols_mt_MT', 'goog.labs.i18n.ListFormatSymbols_mua', 'goog.labs.i18n.ListFormatSymbols_mua_CM', 'goog.labs.i18n.ListFormatSymbols_my_MM', 'goog.labs.i18n.ListFormatSymbols_mzn', 'goog.labs.i18n.ListFormatSymbols_mzn_IR', 'goog.labs.i18n.ListFormatSymbols_naq', 'goog.labs.i18n.ListFormatSymbols_naq_NA', 'goog.labs.i18n.ListFormatSymbols_nb_NO', 'goog.labs.i18n.ListFormatSymbols_nb_SJ', 'goog.labs.i18n.ListFormatSymbols_nd', 'goog.labs.i18n.ListFormatSymbols_nd_ZW', 'goog.labs.i18n.ListFormatSymbols_nds', 'goog.labs.i18n.ListFormatSymbols_nds_DE', 'goog.labs.i18n.ListFormatSymbols_nds_NL', 'goog.labs.i18n.ListFormatSymbols_ne_IN', 'goog.labs.i18n.ListFormatSymbols_ne_NP', 'goog.labs.i18n.ListFormatSymbols_nl_AW', 'goog.labs.i18n.ListFormatSymbols_nl_BE', 'goog.labs.i18n.ListFormatSymbols_nl_BQ', 'goog.labs.i18n.ListFormatSymbols_nl_CW', 'goog.labs.i18n.ListFormatSymbols_nl_NL', 'goog.labs.i18n.ListFormatSymbols_nl_SR', 'goog.labs.i18n.ListFormatSymbols_nl_SX', 'goog.labs.i18n.ListFormatSymbols_nmg', 'goog.labs.i18n.ListFormatSymbols_nmg_CM', 'goog.labs.i18n.ListFormatSymbols_nn', 'goog.labs.i18n.ListFormatSymbols_nn_NO', 'goog.labs.i18n.ListFormatSymbols_nnh', 'goog.labs.i18n.ListFormatSymbols_nnh_CM', 'goog.labs.i18n.ListFormatSymbols_nus', 'goog.labs.i18n.ListFormatSymbols_nus_SS', 'goog.labs.i18n.ListFormatSymbols_nyn', 'goog.labs.i18n.ListFormatSymbols_nyn_UG', 'goog.labs.i18n.ListFormatSymbols_om', 'goog.labs.i18n.ListFormatSymbols_om_ET', 'goog.labs.i18n.ListFormatSymbols_om_KE', 'goog.labs.i18n.ListFormatSymbols_or_IN', 'goog.labs.i18n.ListFormatSymbols_os', 'goog.labs.i18n.ListFormatSymbols_os_GE', 'goog.labs.i18n.ListFormatSymbols_os_RU', 'goog.labs.i18n.ListFormatSymbols_pa_Arab', 'goog.labs.i18n.ListFormatSymbols_pa_Arab_PK', 'goog.labs.i18n.ListFormatSymbols_pa_Guru', 'goog.labs.i18n.ListFormatSymbols_pa_Guru_IN', 'goog.labs.i18n.ListFormatSymbols_pl_PL', 'goog.labs.i18n.ListFormatSymbols_ps', 'goog.labs.i18n.ListFormatSymbols_ps_AF', 'goog.labs.i18n.ListFormatSymbols_ps_PK', 'goog.labs.i18n.ListFormatSymbols_pt_AO', 'goog.labs.i18n.ListFormatSymbols_pt_CH', 'goog.labs.i18n.ListFormatSymbols_pt_CV', 'goog.labs.i18n.ListFormatSymbols_pt_GQ', 'goog.labs.i18n.ListFormatSymbols_pt_GW', 'goog.labs.i18n.ListFormatSymbols_pt_LU', 'goog.labs.i18n.ListFormatSymbols_pt_MO', 'goog.labs.i18n.ListFormatSymbols_pt_MZ', 'goog.labs.i18n.ListFormatSymbols_pt_ST', 'goog.labs.i18n.ListFormatSymbols_pt_TL', 'goog.labs.i18n.ListFormatSymbols_qu', 'goog.labs.i18n.ListFormatSymbols_qu_BO', 'goog.labs.i18n.ListFormatSymbols_qu_EC', 'goog.labs.i18n.ListFormatSymbols_qu_PE', 'goog.labs.i18n.ListFormatSymbols_rm', 'goog.labs.i18n.ListFormatSymbols_rm_CH', 'goog.labs.i18n.ListFormatSymbols_rn', 'goog.labs.i18n.ListFormatSymbols_rn_BI', 'goog.labs.i18n.ListFormatSymbols_ro_MD', 'goog.labs.i18n.ListFormatSymbols_ro_RO', 'goog.labs.i18n.ListFormatSymbols_rof', 'goog.labs.i18n.ListFormatSymbols_rof_TZ', 'goog.labs.i18n.ListFormatSymbols_ru_BY', 'goog.labs.i18n.ListFormatSymbols_ru_KG', 'goog.labs.i18n.ListFormatSymbols_ru_KZ', 'goog.labs.i18n.ListFormatSymbols_ru_MD', 'goog.labs.i18n.ListFormatSymbols_ru_RU', 'goog.labs.i18n.ListFormatSymbols_ru_UA', 'goog.labs.i18n.ListFormatSymbols_rw', 'goog.labs.i18n.ListFormatSymbols_rw_RW', 'goog.labs.i18n.ListFormatSymbols_rwk', 'goog.labs.i18n.ListFormatSymbols_rwk_TZ', 'goog.labs.i18n.ListFormatSymbols_sah', 'goog.labs.i18n.ListFormatSymbols_sah_RU', 'goog.labs.i18n.ListFormatSymbols_saq', 'goog.labs.i18n.ListFormatSymbols_saq_KE', 'goog.labs.i18n.ListFormatSymbols_sbp', 'goog.labs.i18n.ListFormatSymbols_sbp_TZ', 'goog.labs.i18n.ListFormatSymbols_sd', 'goog.labs.i18n.ListFormatSymbols_sd_PK', 'goog.labs.i18n.ListFormatSymbols_se', 'goog.labs.i18n.ListFormatSymbols_se_FI', 'goog.labs.i18n.ListFormatSymbols_se_NO', 'goog.labs.i18n.ListFormatSymbols_se_SE', 'goog.labs.i18n.ListFormatSymbols_seh', 'goog.labs.i18n.ListFormatSymbols_seh_MZ', 'goog.labs.i18n.ListFormatSymbols_ses', 'goog.labs.i18n.ListFormatSymbols_ses_ML', 'goog.labs.i18n.ListFormatSymbols_sg', 'goog.labs.i18n.ListFormatSymbols_sg_CF', 'goog.labs.i18n.ListFormatSymbols_shi', 'goog.labs.i18n.ListFormatSymbols_shi_Latn', 'goog.labs.i18n.ListFormatSymbols_shi_Latn_MA', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng_MA', 'goog.labs.i18n.ListFormatSymbols_si_LK', 'goog.labs.i18n.ListFormatSymbols_sk_SK', 'goog.labs.i18n.ListFormatSymbols_sl_SI', 'goog.labs.i18n.ListFormatSymbols_smn', 'goog.labs.i18n.ListFormatSymbols_smn_FI', 'goog.labs.i18n.ListFormatSymbols_sn', 'goog.labs.i18n.ListFormatSymbols_sn_ZW', 'goog.labs.i18n.ListFormatSymbols_so', 'goog.labs.i18n.ListFormatSymbols_so_DJ', 'goog.labs.i18n.ListFormatSymbols_so_ET', 'goog.labs.i18n.ListFormatSymbols_so_KE', 'goog.labs.i18n.ListFormatSymbols_so_SO', 'goog.labs.i18n.ListFormatSymbols_sq_AL', 'goog.labs.i18n.ListFormatSymbols_sq_MK', 'goog.labs.i18n.ListFormatSymbols_sq_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_XK', 'goog.labs.i18n.ListFormatSymbols_sv_AX', 'goog.labs.i18n.ListFormatSymbols_sv_FI', 'goog.labs.i18n.ListFormatSymbols_sv_SE', 'goog.labs.i18n.ListFormatSymbols_sw_CD', 'goog.labs.i18n.ListFormatSymbols_sw_KE', 'goog.labs.i18n.ListFormatSymbols_sw_TZ', 'goog.labs.i18n.ListFormatSymbols_sw_UG', 'goog.labs.i18n.ListFormatSymbols_ta_IN', 'goog.labs.i18n.ListFormatSymbols_ta_LK', 'goog.labs.i18n.ListFormatSymbols_ta_MY', 'goog.labs.i18n.ListFormatSymbols_ta_SG', 'goog.labs.i18n.ListFormatSymbols_te_IN', 'goog.labs.i18n.ListFormatSymbols_teo', 'goog.labs.i18n.ListFormatSymbols_teo_KE', 'goog.labs.i18n.ListFormatSymbols_teo_UG', 'goog.labs.i18n.ListFormatSymbols_tg', 'goog.labs.i18n.ListFormatSymbols_tg_TJ', 'goog.labs.i18n.ListFormatSymbols_th_TH', 'goog.labs.i18n.ListFormatSymbols_ti', 'goog.labs.i18n.ListFormatSymbols_ti_ER', 'goog.labs.i18n.ListFormatSymbols_ti_ET', 'goog.labs.i18n.ListFormatSymbols_tk', 'goog.labs.i18n.ListFormatSymbols_tk_TM', 'goog.labs.i18n.ListFormatSymbols_to', 'goog.labs.i18n.ListFormatSymbols_to_TO', 'goog.labs.i18n.ListFormatSymbols_tr_CY', 'goog.labs.i18n.ListFormatSymbols_tr_TR', 'goog.labs.i18n.ListFormatSymbols_tt', 'goog.labs.i18n.ListFormatSymbols_tt_RU', 'goog.labs.i18n.ListFormatSymbols_twq', 'goog.labs.i18n.ListFormatSymbols_twq_NE', 'goog.labs.i18n.ListFormatSymbols_tzm', 'goog.labs.i18n.ListFormatSymbols_tzm_MA', 'goog.labs.i18n.ListFormatSymbols_ug', 'goog.labs.i18n.ListFormatSymbols_ug_CN', 'goog.labs.i18n.ListFormatSymbols_uk_UA', 'goog.labs.i18n.ListFormatSymbols_ur_IN', 'goog.labs.i18n.ListFormatSymbols_ur_PK', 'goog.labs.i18n.ListFormatSymbols_uz_Arab', 'goog.labs.i18n.ListFormatSymbols_uz_Arab_AF', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl_UZ', 'goog.labs.i18n.ListFormatSymbols_uz_Latn', 'goog.labs.i18n.ListFormatSymbols_uz_Latn_UZ', 'goog.labs.i18n.ListFormatSymbols_vai', 'goog.labs.i18n.ListFormatSymbols_vai_Latn', 'goog.labs.i18n.ListFormatSymbols_vai_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii_LR', 'goog.labs.i18n.ListFormatSymbols_vi_VN', 'goog.labs.i18n.ListFormatSymbols_vun', 'goog.labs.i18n.ListFormatSymbols_vun_TZ', 'goog.labs.i18n.ListFormatSymbols_wae', 'goog.labs.i18n.ListFormatSymbols_wae_CH', 'goog.labs.i18n.ListFormatSymbols_wo', 'goog.labs.i18n.ListFormatSymbols_wo_SN', 'goog.labs.i18n.ListFormatSymbols_xh', 'goog.labs.i18n.ListFormatSymbols_xh_ZA', 'goog.labs.i18n.ListFormatSymbols_xog', 'goog.labs.i18n.ListFormatSymbols_xog_UG', 'goog.labs.i18n.ListFormatSymbols_yav', 'goog.labs.i18n.ListFormatSymbols_yav_CM', 'goog.labs.i18n.ListFormatSymbols_yi', 'goog.labs.i18n.ListFormatSymbols_yi_001', 'goog.labs.i18n.ListFormatSymbols_yo', 'goog.labs.i18n.ListFormatSymbols_yo_BJ', 'goog.labs.i18n.ListFormatSymbols_yo_NG', 'goog.labs.i18n.ListFormatSymbols_yue', 'goog.labs.i18n.ListFormatSymbols_yue_Hans', 'goog.labs.i18n.ListFormatSymbols_yue_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_yue_Hant', 'goog.labs.i18n.ListFormatSymbols_yue_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zgh', 'goog.labs.i18n.ListFormatSymbols_zgh_MA', 'goog.labs.i18n.ListFormatSymbols_zh_Hans', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_SG', 'goog.labs.i18n.ListFormatSymbols_zh_Hant', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_TW', 'goog.labs.i18n.ListFormatSymbols_zu_ZA'], ['goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/mock/mock.js', ['goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.functions', 'goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode', 'goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/mock/mock_test.js', ['goog.labs.mockTest'], ['goog.array', 'goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError', 'goog.labs.mock.timeout', 'goog.labs.mock.verification', 'goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.string', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('labs/mock/timeoutmode.js', ['goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode.js', ['goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode_test.js', ['goog.labs.mock.VerificationModeTest'], ['goog.labs.mock.verification', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/image.js', ['goog.labs.net.image'], ['goog.Promise', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.net.EventType', 'goog.userAgent'], {});
goog.addDependency('labs/net/image_test.js', ['goog.labs.net.imageTest'], ['goog.labs.net.image', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel.js', ['goog.net.WebChannel'], ['goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('labs/net/webchannel/basetestchannel.js', ['goog.labs.net.webChannel.BaseTestChannel'], ['goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel'], {});
goog.addDependency('labs/net/webchannel/channel.js', ['goog.labs.net.webChannel.Channel'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/channelrequest.js', ['goog.labs.net.webChannel.ChannelRequest'], ['goog.Timer', 'goog.async.Throttle', 'goog.events.EventHandler', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.environment', 'goog.labs.net.webChannel.requestStats', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.WebChannel', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/net/webchannel/channelrequest_test.js', ['goog.labs.net.webChannel.channelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/connectionstate.js', ['goog.labs.net.webChannel.ConnectionState'], [], {});
goog.addDependency('labs/net/webchannel/environment.js', ['goog.labs.net.webChannel.environment'], ['goog.userAgent'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/environment_test.js', ['goog.labs.net.webChannel.EnvironmentTest'], ['goog.labs.net.webChannel.environment', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool.js', ['goog.labs.net.webChannel.ForwardChannelRequestPool'], ['goog.array', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.Wire', 'goog.string', 'goog.structs.Set'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool_test.js', ['goog.labs.net.webChannel.ForwardChannelRequestPoolTest'], ['goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/netutils.js', ['goog.labs.net.webChannel.netUtils'], ['goog.Uri', 'goog.labs.net.webChannel.WebChannelDebug'], {});
goog.addDependency('labs/net/webchannel/requeststats.js', ['goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Event', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.labs.net.webChannel.requestStats.ServerReachabilityEvent', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.labs.net.webChannel.requestStats.StatEvent', 'goog.labs.net.webChannel.requestStats.TimingEvent'], ['goog.events.Event', 'goog.events.EventTarget'], {});
goog.addDependency('labs/net/webchannel/webchannelbase.js', ['goog.labs.net.webChannel.WebChannelBase'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.async.run', 'goog.json', 'goog.labs.net.webChannel.BaseTestChannel', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ConnectionState', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.WireV8', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel', 'goog.net.XhrIo', 'goog.net.XmlHttpFactory', 'goog.net.rpc.HttpCors', 'goog.object', 'goog.string', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/webchannelbase_test.js', ['goog.labs.net.webChannel.webChannelBaseTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchannelbasetransport.js', ['goog.labs.net.webChannel.WebChannelBaseTransport'], ['goog.asserts', 'goog.events.EventTarget', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.Wire', 'goog.log', 'goog.net.WebChannel', 'goog.net.WebChannelTransport', 'goog.object', 'goog.string', 'goog.string.path'], {});
goog.addDependency('labs/net/webchannel/webchannelbasetransport_test.js', ['goog.labs.net.webChannel.webChannelBaseTransportTest'], ['goog.events', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.Wire', 'goog.net.WebChannel', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchanneldebug.js', ['goog.labs.net.webChannel.WebChannelDebug'], ['goog.json', 'goog.log'], {});
goog.addDependency('labs/net/webchannel/wire.js', ['goog.labs.net.webChannel.Wire'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/wirev8.js', ['goog.labs.net.webChannel.WireV8'], ['goog.asserts', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.labs.net.webChannel.Wire', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/wirev8_test.js', ['goog.labs.net.webChannel.WireV8Test'], ['goog.labs.net.webChannel.WireV8', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchanneltransport.js', ['goog.net.WebChannelTransport'], [], {});
goog.addDependency('labs/net/webchanneltransportfactory.js', ['goog.net.createWebChannelTransport'], ['goog.functions', 'goog.labs.net.webChannel.WebChannelBaseTransport'], {});
goog.addDependency('labs/net/xhr.js', ['goog.labs.net.xhr', 'goog.labs.net.xhr.Error', 'goog.labs.net.xhr.HttpError', 'goog.labs.net.xhr.Options', 'goog.labs.net.xhr.PostData', 'goog.labs.net.xhr.ResponseType', 'goog.labs.net.xhr.TimeoutError'], ['goog.Promise', 'goog.asserts', 'goog.debug.Error', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('labs/net/xhr_test.js', ['goog.labs.net.xhrTest'], ['goog.Promise', 'goog.events', 'goog.events.EventType', 'goog.labs.net.xhr', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('labs/pubsub/broadcastpubsub.js', ['goog.labs.pubsub.BroadcastPubSub'], ['goog.Disposable', 'goog.Timer', 'goog.array', 'goog.async.run', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.log', 'goog.math', 'goog.pubsub.PubSub', 'goog.storage.Storage', 'goog.storage.mechanism.HTML5LocalStorage', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/pubsub/broadcastpubsub_test.js', ['goog.labs.pubsub.BroadcastPubSubTest'], ['goog.array', 'goog.debug.Logger', 'goog.json', 'goog.labs.pubsub.BroadcastPubSub', 'goog.storage.Storage', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/storage/boundedcollectablestorage.js', ['goog.labs.storage.BoundedCollectableStorage'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage'], {});
goog.addDependency('labs/storage/boundedcollectablestorage_test.js', ['goog.labs.storage.BoundedCollectableStorageTest'], ['goog.labs.storage.BoundedCollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/structs/multimap.js', ['goog.labs.structs.Multimap'], ['goog.array', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/structs/multimap_test.js', ['goog.labs.structs.MultimapTest'], ['goog.labs.structs.Multimap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/style/pixeldensitymonitor.js', ['goog.labs.style.PixelDensityMonitor', 'goog.labs.style.PixelDensityMonitor.Density', 'goog.labs.style.PixelDensityMonitor.EventType'], ['goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('labs/style/pixeldensitymonitor_test.js', ['goog.labs.style.PixelDensityMonitorTest'], ['goog.array', 'goog.dom.DomHelper', 'goog.events', 'goog.labs.style.PixelDensityMonitor', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/assertthat.js', ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat'], ['goog.debug.Error'], {});
goog.addDependency('labs/testing/assertthat_test.js', ['goog.labs.testing.assertThatTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/decoratormatcher.js', ['goog.labs.testing.AnythingMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/decoratormatcher_test.js', ['goog.labs.testing.decoratorMatcherTest'], ['goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/dictionarymatcher.js', ['goog.labs.testing.HasEntriesMatcher', 'goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.HasKeyMatcher', 'goog.labs.testing.HasValueMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.object'], {});
goog.addDependency('labs/testing/dictionarymatcher_test.js', ['goog.labs.testing.dictionaryMatcherTest'], ['goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/environment.js', ['goog.labs.testing.Environment'], ['goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Console', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('labs/testing/environment_test.js', ['goog.labs.testing.environmentTest'], ['goog.asserts', 'goog.labs.testing.Environment', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('labs/testing/environment_usage_test.js', ['goog.labs.testing.environmentUsageTest'], ['goog.labs.testing.Environment', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/json_fuzzing.js', ['goog.labs.testing.JsonFuzzing'], ['goog.string', 'goog.testing.PseudoRandom'], {});
goog.addDependency('labs/testing/json_fuzzing_test.js', ['goog.labs.testing.JsonFuzzingTest'], ['goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/logicmatcher.js', ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.AnyOfMatcher', 'goog.labs.testing.IsNotMatcher', 'goog.labs.testing.logicMatchers'], ['goog.array', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/logicmatcher_test.js', ['goog.labs.testing.logicMatcherTest'], ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/matcher.js', ['goog.labs.testing.Matcher'], [], {'lang': 'es6'});
goog.addDependency('labs/testing/numbermatcher.js', ['goog.labs.testing.AnyNumberMatcher', 'goog.labs.testing.CloseToMatcher', 'goog.labs.testing.EqualToMatcher', 'goog.labs.testing.GreaterThanEqualToMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.LessThanEqualToMatcher', 'goog.labs.testing.LessThanMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/numbermatcher_test.js', ['goog.labs.testing.numberMatcherTest'], ['goog.labs.testing.LessThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/objectmatcher.js', ['goog.labs.testing.AnyObjectMatcher', 'goog.labs.testing.HasPropertyMatcher', 'goog.labs.testing.InstanceOfMatcher', 'goog.labs.testing.IsNullMatcher', 'goog.labs.testing.IsNullOrUndefinedMatcher', 'goog.labs.testing.IsUndefinedMatcher', 'goog.labs.testing.ObjectEqualsMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/objectmatcher_test.js', ['goog.labs.testing.objectMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.ObjectEqualsMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/stringmatcher.js', ['goog.labs.testing.AnyStringMatcher', 'goog.labs.testing.ContainsStringMatcher', 'goog.labs.testing.EndsWithMatcher', 'goog.labs.testing.EqualToIgnoringWhitespaceMatcher', 'goog.labs.testing.EqualsMatcher', 'goog.labs.testing.RegexMatcher', 'goog.labs.testing.StartsWithMatcher', 'goog.labs.testing.StringContainsInOrderMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.string'], {});
goog.addDependency('labs/testing/stringmatcher_test.js', ['goog.labs.testing.stringMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.StringContainsInOrderMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/browser.js', ['goog.labs.userAgent.browser'], ['goog.array', 'goog.labs.userAgent.util', 'goog.object', 'goog.string.internal'], {});
goog.addDependency('labs/useragent/browser_test.js', ['goog.labs.userAgent.browserTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/device.js', ['goog.labs.userAgent.device'], ['goog.labs.userAgent.util'], {});
goog.addDependency('labs/useragent/device_test.js', ['goog.labs.userAgent.deviceTest'], ['goog.labs.userAgent.device', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/engine.js', ['goog.labs.userAgent.engine'], ['goog.array', 'goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/engine_test.js', ['goog.labs.userAgent.engineTest'], ['goog.labs.userAgent.engine', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra.js', ['goog.labs.userAgent.extra'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra_test.js', ['goog.labs.userAgent.extraTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.extra', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/platform.js', ['goog.labs.userAgent.platform'], ['goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/platform_test.js', ['goog.labs.userAgent.platformTest'], ['goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/test_agents.js', ['goog.labs.userAgent.testAgents'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/util.js', ['goog.labs.userAgent.util'], ['goog.string.internal'], {});
goog.addDependency('labs/useragent/util_test.js', ['goog.labs.userAgent.utilTest'], ['goog.functions', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/verifier.js', ['goog.labs.useragent.verifier'], [], {'lang': 'es6'});
goog.addDependency('labs/useragent/verifier_test.js', ['goog.labs.useragent.verifierTest'], ['goog.labs.userAgent.browser', 'goog.labs.useragent.verifier', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('loader/abstractmodulemanager.js', ['goog.loader.AbstractModuleManager', 'goog.loader.AbstractModuleManager.CallbackType', 'goog.loader.AbstractModuleManager.FailureType'], ['goog.module.AbstractModuleLoader', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('loader/activemodulemanager.js', ['goog.loader.activeModuleManager'], ['goog.asserts', 'goog.loader.AbstractModuleManager'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/countries.js', ['goog.locale.countries'], [], {});
goog.addDependency('locale/countrylanguagenames_test.js', ['goog.locale.countryLanguageNamesTest'], ['goog.locale', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/defaultlocalenameconstants.js', ['goog.locale.defaultLocaleNameConstants'], [], {});
goog.addDependency('locale/genericfontnames.js', ['goog.locale.genericFontNames'], [], {});
goog.addDependency('locale/genericfontnames_test.js', ['goog.locale.genericFontNamesTest'], ['goog.locale.genericFontNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/genericfontnamesdata.js', ['goog.locale.genericFontNamesData'], [], {});
goog.addDependency('locale/locale.js', ['goog.locale'], ['goog.locale.nativeNameConstants'], {});
goog.addDependency('locale/nativenameconstants.js', ['goog.locale.nativeNameConstants'], [], {});
goog.addDependency('locale/scriptToLanguages.js', ['goog.locale.scriptToLanguages'], ['goog.locale'], {});
goog.addDependency('locale/timezonedetection.js', ['goog.locale.timeZoneDetection'], ['goog.locale.TimeZoneFingerprint'], {});
goog.addDependency('locale/timezonedetection_test.js', ['goog.locale.timeZoneDetectionTest'], ['goog.locale.timeZoneDetection', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/timezonefingerprint.js', ['goog.locale.TimeZoneFingerprint'], [], {});
goog.addDependency('locale/timezonelist.js', ['goog.locale.TimeZoneList', 'goog.locale.getTimeZoneAllLongNames', 'goog.locale.getTimeZoneSelectedLongNames', 'goog.locale.getTimeZoneSelectedShortNames'], ['goog.locale'], {});
goog.addDependency('locale/timezonelist_test.js', ['goog.locale.TimeZoneListTest'], ['goog.locale', 'goog.locale.TimeZoneList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('log/log.js', ['goog.log', 'goog.log.Level', 'goog.log.LogRecord', 'goog.log.Logger'], ['goog.debug', 'goog.debug.LogManager', 'goog.debug.LogRecord', 'goog.debug.Logger'], {});
goog.addDependency('log/log_test.js', ['goog.logTest'], ['goog.debug.LogManager', 'goog.log', 'goog.log.Level', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/affinetransform.js', ['goog.math.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('math/affinetransform_test.js', ['goog.math.AffineTransformTest'], ['goog.array', 'goog.math', 'goog.math.AffineTransform', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/bezier.js', ['goog.math.Bezier'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/bezier_test.js', ['goog.math.BezierTest'], ['goog.math', 'goog.math.Bezier', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/box.js', ['goog.math.Box'], ['goog.asserts', 'goog.math.Coordinate'], {});
goog.addDependency('math/box_test.js', ['goog.math.BoxTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate.js', ['goog.math.Coordinate'], ['goog.math'], {});
goog.addDependency('math/coordinate3.js', ['goog.math.Coordinate3'], [], {'lang': 'es6'});
goog.addDependency('math/coordinate3_test.js', ['goog.math.Coordinate3Test'], ['goog.math.Coordinate3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate_test.js', ['goog.math.CoordinateTest'], ['goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/exponentialbackoff.js', ['goog.math.ExponentialBackoff'], ['goog.asserts'], {});
goog.addDependency('math/exponentialbackoff_test.js', ['goog.math.ExponentialBackoffTest'], ['goog.math.ExponentialBackoff', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/integer.js', ['goog.math.Integer'], ['goog.reflect'], {});
goog.addDependency('math/integer_test.js', ['goog.math.IntegerTest'], ['goog.math.Integer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/interpolator1.js', ['goog.math.interpolator.Interpolator1'], [], {});
goog.addDependency('math/interpolator/linear1.js', ['goog.math.interpolator.Linear1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1'], {});
goog.addDependency('math/interpolator/linear1_test.js', ['goog.math.interpolator.Linear1Test'], ['goog.math.interpolator.Linear1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/pchip1.js', ['goog.math.interpolator.Pchip1'], ['goog.math', 'goog.math.interpolator.Spline1'], {});
goog.addDependency('math/interpolator/pchip1_test.js', ['goog.math.interpolator.Pchip1Test'], ['goog.math.interpolator.Pchip1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/spline1.js', ['goog.math.interpolator.Spline1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1', 'goog.math.tdma'], {});
goog.addDependency('math/interpolator/spline1_test.js', ['goog.math.interpolator.Spline1Test'], ['goog.math.interpolator.Spline1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/irect.js', ['goog.math.IRect'], [], {});
goog.addDependency('math/line.js', ['goog.math.Line'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/line_test.js', ['goog.math.LineTest'], ['goog.math.Coordinate', 'goog.math.Line', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long.js', ['goog.math.Long'], ['goog.asserts', 'goog.reflect'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long_test.js', ['goog.math.LongTest'], ['goog.asserts', 'goog.math.Long', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/math.js', ['goog.math'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('math/math_test.js', ['goog.mathTest'], ['goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/matrix.js', ['goog.math.Matrix'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.Size', 'goog.string'], {});
goog.addDependency('math/matrix_test.js', ['goog.math.MatrixTest'], ['goog.math.Matrix', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/path.js', ['goog.math.Path', 'goog.math.Path.Segment'], ['goog.array', 'goog.math', 'goog.math.AffineTransform'], {});
goog.addDependency('math/path_test.js', ['goog.math.PathTest'], ['goog.array', 'goog.math.AffineTransform', 'goog.math.Path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/paths.js', ['goog.math.paths'], ['goog.math.Coordinate', 'goog.math.Path'], {});
goog.addDependency('math/paths_test.js', ['goog.math.pathsTest'], ['goog.math.Coordinate', 'goog.math.paths', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/range.js', ['goog.math.Range'], ['goog.asserts'], {});
goog.addDependency('math/range_test.js', ['goog.math.RangeTest'], ['goog.math.Range', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rangeset.js', ['goog.math.RangeSet'], ['goog.array', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.math.Range'], {});
goog.addDependency('math/rangeset_test.js', ['goog.math.RangeSetTest'], ['goog.iter', 'goog.math.Range', 'goog.math.RangeSet', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rect.js', ['goog.math.Rect'], ['goog.asserts', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.IRect', 'goog.math.Size'], {});
goog.addDependency('math/rect_test.js', ['goog.math.RectTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/size.js', ['goog.math.Size'], [], {'lang': 'es6'});
goog.addDependency('math/size_test.js', ['goog.math.SizeTest'], ['goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/tdma.js', ['goog.math.tdma'], [], {'lang': 'es6'});
goog.addDependency('math/tdma_test.js', ['goog.math.tdmaTest'], ['goog.math.tdma', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec2.js', ['goog.math.Vec2'], ['goog.math', 'goog.math.Coordinate'], {'lang': 'es6'});
goog.addDependency('math/vec2_test.js', ['goog.math.Vec2Test'], ['goog.math.Vec2', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec3.js', ['goog.math.Vec3'], ['goog.math', 'goog.math.Coordinate3'], {});
goog.addDependency('math/vec3_test.js', ['goog.math.Vec3Test'], ['goog.math.Coordinate3', 'goog.math.Vec3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('memoize/memoize.js', ['goog.memoize'], [], {'lang': 'es6'});
goog.addDependency('memoize/memoize_test.js', ['goog.memoizeTest'], ['goog.memoize', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/abstractchannel.js', ['goog.messaging.AbstractChannel'], ['goog.Disposable', 'goog.json', 'goog.log', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/abstractchannel_test.js', ['goog.messaging.AbstractChannelTest'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/bufferedchannel.js', ['goog.messaging.BufferedChannel'], ['goog.Disposable', 'goog.Timer', 'goog.events', 'goog.log', 'goog.messaging.MessageChannel', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/bufferedchannel_test.js', ['goog.messaging.BufferedChannelTest'], ['goog.debug.Console', 'goog.dom', 'goog.dom.TagName', 'goog.log', 'goog.log.Level', 'goog.messaging.BufferedChannel', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/deferredchannel.js', ['goog.messaging.DeferredChannel'], ['goog.Disposable', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/deferredchannel_test.js', ['goog.messaging.DeferredChannelTest'], ['goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerclient.js', ['goog.messaging.LoggerClient'], ['goog.Disposable', 'goog.debug', 'goog.debug.LogManager', 'goog.debug.Logger'], {});
goog.addDependency('messaging/loggerclient_test.js', ['goog.messaging.LoggerClientTest'], ['goog.debug', 'goog.debug.Logger', 'goog.messaging.LoggerClient', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerserver.js', ['goog.messaging.LoggerServer'], ['goog.Disposable', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('messaging/loggerserver_test.js', ['goog.messaging.LoggerServerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.log', 'goog.log.Level', 'goog.messaging.LoggerServer', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/messagechannel.js', ['goog.messaging.MessageChannel'], [], {});
goog.addDependency('messaging/messaging.js', ['goog.messaging'], [], {});
goog.addDependency('messaging/messaging_test.js', ['goog.testing.messaging.MockMessageChannelTest'], ['goog.messaging', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/multichannel.js', ['goog.messaging.MultiChannel', 'goog.messaging.MultiChannel.VirtualChannel'], ['goog.Disposable', 'goog.log', 'goog.messaging.MessageChannel', 'goog.object'], {});
goog.addDependency('messaging/multichannel_test.js', ['goog.messaging.MultiChannelTest'], ['goog.messaging.MultiChannel', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portcaller.js', ['goog.messaging.PortCaller'], ['goog.Disposable', 'goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portcaller_test.js', ['goog.messaging.PortCallerTest'], ['goog.events.EventTarget', 'goog.messaging.PortCaller', 'goog.messaging.PortNetwork', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portchannel.js', ['goog.messaging.PortChannel'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.debug', 'goog.events', 'goog.events.EventType', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.messaging.DeferredChannel', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('messaging/portchannel_test.js', ['goog.messaging.PortChannelTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.json', 'goog.messaging.PortChannel', 'goog.testing.MockControl', 'goog.testing.TestCase', 'goog.testing.messaging.MockMessageEvent', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portnetwork.js', ['goog.messaging.PortNetwork'], [], {});
goog.addDependency('messaging/portnetwork_test.js', ['goog.messaging.PortNetworkTest'], ['goog.Promise', 'goog.Timer', 'goog.labs.userAgent.browser', 'goog.messaging.PortChannel', 'goog.messaging.PortOperator', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portoperator.js', ['goog.messaging.PortOperator'], ['goog.Disposable', 'goog.asserts', 'goog.log', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portoperator_test.js', ['goog.messaging.PortOperatorTest'], ['goog.messaging.PortNetwork', 'goog.messaging.PortOperator', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.messaging.MockMessagePort', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/respondingchannel.js', ['goog.messaging.RespondingChannel'], ['goog.Disposable', 'goog.Promise', 'goog.log', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/respondingchannel_test.js', ['goog.messaging.RespondingChannelTest'], ['goog.Promise', 'goog.messaging.RespondingChannel', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/testdata/portchannel_worker.js', ['goog.messaging.testdata.portchannel_worker'], ['goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker1.js', ['goog.messaging.testdata.portnetwork_worker1'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker2.js', ['goog.messaging.testdata.portnetwork_worker2'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('module/abstractmoduleloader.js', ['goog.module.AbstractModuleLoader'], ['goog.module', 'goog.module.ModuleInfo'], {});
goog.addDependency('module/basemodule.js', ['goog.module.BaseModule'], ['goog.Disposable', 'goog.module'], {});
goog.addDependency('module/loader.js', ['goog.module.Loader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.module', 'goog.object'], {});
goog.addDependency('module/module.js', ['goog.module'], [], {});
goog.addDependency('module/moduleinfo.js', ['goog.module.ModuleInfo'], ['goog.Disposable', 'goog.async.throwException', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.module', 'goog.module.BaseModule', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('module/moduleinfo_test.js', ['goog.module.ModuleInfoTest'], ['goog.module.BaseModule', 'goog.module.ModuleInfo', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloadcallback.js', ['goog.module.ModuleLoadCallback'], ['goog.debug.entryPointRegistry', 'goog.module'], {});
goog.addDependency('module/moduleloadcallback_test.js', ['goog.module.ModuleLoadCallbackTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.functions', 'goog.module.ModuleLoadCallback', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloader.js', ['goog.module.ModuleLoader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.log', 'goog.module.AbstractModuleLoader', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.net.jsloader', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('module/moduleloader_test.js', ['goog.module.ModuleLoaderTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.loader.activeModuleManager', 'goog.module.ModuleLoader', 'goog.module.ModuleManager', 'goog.net.BulkLoader', 'goog.net.XmlHttp', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/modulemanager.js', ['goog.module.ModuleManager', 'goog.module.ModuleManager.CallbackType', 'goog.module.ModuleManager.FailureType'], ['goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.debug.Trace', 'goog.disposable.IDisposable', 'goog.disposeAll', 'goog.loader.AbstractModuleManager', 'goog.loader.activeModuleManager', 'goog.log', 'goog.module', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback', 'goog.object'], {'lang': 'es6'});
goog.addDependency('module/modulemanager_test.js', ['goog.module.ModuleManagerTest'], ['goog.array', 'goog.functions', 'goog.module.BaseModule', 'goog.module.ModuleManager', 'goog.testing', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/testdata/modA_1.js', ['goog.module.testdata.modA_1'], [], {});
goog.addDependency('module/testdata/modA_2.js', ['goog.module.testdata.modA_2'], ['goog.module.ModuleManager'], {});
goog.addDependency('module/testdata/modB_1.js', ['goog.module.testdata.modB_1'], ['goog.module.ModuleManager'], {});
goog.addDependency('net/browserchannel.js', ['goog.net.BrowserChannel', 'goog.net.BrowserChannel.Error', 'goog.net.BrowserChannel.Event', 'goog.net.BrowserChannel.Handler', 'goog.net.BrowserChannel.LogSaver', 'goog.net.BrowserChannel.QueuedMap', 'goog.net.BrowserChannel.ServerReachability', 'goog.net.BrowserChannel.ServerReachabilityEvent', 'goog.net.BrowserChannel.Stat', 'goog.net.BrowserChannel.StatEvent', 'goog.net.BrowserChannel.State', 'goog.net.BrowserChannel.TimingEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.TextFormatter', 'goog.events.Event', 'goog.events.EventTarget', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.log', 'goog.net.BrowserTestChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.XhrIo', 'goog.net.tmpnetwork', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.CircularBuffer'], {});
goog.addDependency('net/browserchannel_test.js', ['goog.net.BrowserChannelTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.tmpnetwork', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/browsertestchannel.js', ['goog.net.BrowserTestChannel'], ['goog.json.NativeJsonProcessor', 'goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error', 'goog.net.tmpnetwork', 'goog.string.Parser'], {});
goog.addDependency('net/bulkloader.js', ['goog.net.BulkLoader'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.log', 'goog.net.BulkLoaderHelper', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('net/bulkloader_test.js', ['goog.net.BulkLoaderTest'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/bulkloaderhelper.js', ['goog.net.BulkLoaderHelper'], ['goog.Disposable'], {});
goog.addDependency('net/channeldebug.js', ['goog.net.ChannelDebug'], ['goog.json', 'goog.log'], {'lang': 'es6'});
goog.addDependency('net/channelrequest.js', ['goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error'], ['goog.Timer', 'goog.async.Throttle', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('net/channelrequest_test.js', ['goog.net.ChannelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/cookies.js', ['goog.net.Cookies', 'goog.net.cookies'], ['goog.asserts', 'goog.string'], {'lang': 'es5'});
goog.addDependency('net/cookies_test.js', ['goog.net.cookiesTest'], ['goog.array', 'goog.net.Cookies', 'goog.net.cookies', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/corsxmlhttpfactory.js', ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter'], ['goog.net.HttpStatus', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/corsxmlhttpfactory_test.js', ['goog.net.CorsXmlHttpFactoryTest'], ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/crossdomainrpc.js', ['goog.net.CrossDomainRpc'], ['goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/crossdomainrpc_test.js', ['goog.net.CrossDomainRpcTest'], ['goog.Promise', 'goog.log', 'goog.net.CrossDomainRpc', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/errorcode.js', ['goog.net.ErrorCode'], [], {});
goog.addDependency('net/eventtype.js', ['goog.net.EventType'], [], {});
goog.addDependency('net/fetchxmlhttpfactory.js', ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory'], ['goog.asserts', 'goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {'lang': 'es5'});
goog.addDependency('net/fetchxmlhttpfactory_test.js', ['goog.net.FetchXmlHttpFactoryTest'], ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/filedownloader.js', ['goog.net.FileDownloader', 'goog.net.FileDownloader.Error'], ['goog.Disposable', 'goog.asserts', 'goog.async.Deferred', 'goog.crypt.hash32', 'goog.debug.Error', 'goog.events', 'goog.events.EventHandler', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.object'], {});
goog.addDependency('net/filedownloader_test.js', ['goog.net.FileDownloaderTest'], ['goog.fs.Error', 'goog.net.ErrorCode', 'goog.net.FileDownloader', 'goog.net.XhrIo', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.fs', 'goog.testing.fs.FileSystem', 'goog.testing.net.XhrIoPool', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/httpstatus.js', ['goog.net.HttpStatus'], [], {});
goog.addDependency('net/httpstatusname.js', ['goog.net.HttpStatusName'], [], {});
goog.addDependency('net/iframeio.js', ['goog.net.IframeIo', 'goog.net.IframeIo.IncrementalDataEvent'], ['goog.Timer', 'goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.HtmlFormatter', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.html.legacyconversions', 'goog.html.uncheckedconversions', 'goog.json', 'goog.log', 'goog.log.Level', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.structs', 'goog.userAgent'], {});
goog.addDependency('net/iframeio_test.js', ['goog.net.IframeIoTest'], ['goog.debug', 'goog.debug.DivConsole', 'goog.debug.LogManager', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.log.Level', 'goog.net.IframeIo', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('net/iframeloadmonitor.js', ['goog.net.IframeLoadMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('net/iframeloadmonitor_test.js', ['goog.net.IframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.net.IframeLoadMonitor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/imageloader.js', ['goog.net.ImageLoader'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.EventType', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('net/imageloader_test.js', ['goog.net.ImageLoaderTest'], ['goog.Promise', 'goog.Timer', 'goog.array', 'goog.dispose', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.net.EventType', 'goog.net.ImageLoader', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/ipaddress.js', ['goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address'], ['goog.array', 'goog.math.Integer', 'goog.object', 'goog.string'], {});
goog.addDependency('net/ipaddress_test.js', ['goog.net.IpAddressTest'], ['goog.array', 'goog.math.Integer', 'goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsloader.js', ['goog.net.jsloader', 'goog.net.jsloader.Error', 'goog.net.jsloader.ErrorCode', 'goog.net.jsloader.Options'], ['goog.array', 'goog.async.Deferred', 'goog.debug.Error', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.TrustedResourceUrl', 'goog.object'], {});
goog.addDependency('net/jsloader_test.js', ['goog.net.jsloaderTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.net.jsloader.ErrorCode', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsonp.js', ['goog.net.Jsonp'], ['goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.object'], {});
goog.addDependency('net/jsonp_test.js', ['goog.net.JsonpTest'], ['goog.html.TrustedResourceUrl', 'goog.net.Jsonp', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/mockiframeio.js', ['goog.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo'], {});
goog.addDependency('net/multiiframeloadmonitor.js', ['goog.net.MultiIframeLoadMonitor'], ['goog.events', 'goog.net.IframeLoadMonitor'], {});
goog.addDependency('net/multiiframeloadmonitor_test.js', ['goog.net.MultiIframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.net.MultiIframeLoadMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/networkstatusmonitor.js', ['goog.net.NetworkStatusMonitor'], ['goog.events.Listenable'], {});
goog.addDependency('net/networktester.js', ['goog.net.NetworkTester'], ['goog.Timer', 'goog.Uri', 'goog.dom.safe', 'goog.log'], {});
goog.addDependency('net/networktester_test.js', ['goog.net.NetworkTesterTest'], ['goog.Uri', 'goog.net.NetworkTester', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/rpc/httpcors.js', ['goog.net.rpc.HttpCors'], ['goog.Uri', 'goog.object', 'goog.string', 'goog.uri.utils'], {'module': 'goog'});
goog.addDependency('net/rpc/httpcors_test.js', ['goog.net.rpc.HttpCorsTest'], ['goog.Uri', 'goog.net.rpc.HttpCors', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser.js', ['goog.net.streams.Base64PbStreamParser'], ['goog.asserts', 'goog.net.streams.Base64StreamDecoder', 'goog.net.streams.PbStreamParser', 'goog.net.streams.StreamParser'], {'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser_test.js', ['goog.net.streams.Base64PbStreamParserTest'], ['goog.crypt.base64', 'goog.net.streams.Base64PbStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64streamdecoder.js', ['goog.net.streams.Base64StreamDecoder'], ['goog.asserts', 'goog.crypt.base64'], {});
goog.addDependency('net/streams/base64streamdecoder_test.js', ['goog.net.streams.Base64StreamDecoderTest'], ['goog.net.streams.Base64StreamDecoder', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/jsonstreamparser.js', ['goog.net.streams.JsonStreamParser', 'goog.net.streams.JsonStreamParser.Options'], ['goog.asserts', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {});
goog.addDependency('net/streams/jsonstreamparser_test.js', ['goog.net.streams.JsonStreamParserTest'], ['goog.array', 'goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.net.streams.JsonStreamParser', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/nodereadablestream.js', ['goog.net.streams.NodeReadableStream'], [], {});
goog.addDependency('net/streams/pbjsonstreamparser.js', ['goog.net.streams.PbJsonStreamParser'], ['goog.asserts', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {'module': 'goog'});
goog.addDependency('net/streams/pbjsonstreamparser_test.js', ['goog.net.streams.PbJsonStreamParserTest'], ['goog.net.streams.PbJsonStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/pbstreamparser.js', ['goog.net.streams.PbStreamParser'], ['goog.asserts', 'goog.net.streams.StreamParser'], {});
goog.addDependency('net/streams/pbstreamparser_test.js', ['goog.net.streams.PbStreamParserTest'], ['goog.net.streams.PbStreamParser', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/streamfactory.js', ['goog.net.streams.createXhrNodeReadableStream'], ['goog.asserts', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/streamparser.js', ['goog.net.streams.StreamParser'], [], {});
goog.addDependency('net/streams/utils.js', ['goog.net.streams.utils'], [], {'module': 'goog'});
goog.addDependency('net/streams/xhrnodereadablestream.js', ['goog.net.streams.XhrNodeReadableStream'], ['goog.array', 'goog.log', 'goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/xhrnodereadablestream_test.js', ['goog.net.streams.XhrNodeReadableStreamTest'], ['goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/xhrstreamreader.js', ['goog.net.streams.XhrStreamReader'], ['goog.events.EventHandler', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/streams/xhrstreamreader_test.js', ['goog.net.streams.XhrStreamReaderTest'], ['goog.net.ErrorCode', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.net.streams.XhrStreamReader', 'goog.object', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/testdata/jsloader_test1.js', ['goog.net.testdata.jsloader_test1'], [], {});
goog.addDependency('net/testdata/jsloader_test2.js', ['goog.net.testdata.jsloader_test2'], [], {});
goog.addDependency('net/testdata/jsloader_test3.js', ['goog.net.testdata.jsloader_test3'], [], {});
goog.addDependency('net/testdata/jsloader_test4.js', ['goog.net.testdata.jsloader_test4'], [], {});
goog.addDependency('net/tmpnetwork.js', ['goog.net.tmpnetwork'], ['goog.Uri', 'goog.dom.safe', 'goog.net.ChannelDebug'], {});
goog.addDependency('net/websocket.js', ['goog.net.WebSocket', 'goog.net.WebSocket.ErrorEvent', 'goog.net.WebSocket.EventType', 'goog.net.WebSocket.MessageEvent'], ['goog.Timer', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log'], {'lang': 'es5'});
goog.addDependency('net/websocket_test.js', ['goog.net.WebSocketTest'], ['goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.WebSocket', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/wrapperxmlhttpfactory.js', ['goog.net.WrapperXmlHttpFactory'], ['goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xhrio.js', ['goog.net.XhrIo', 'goog.net.XhrIo.ResponseType'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.EventTarget', 'goog.json.hybrid', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xhrio_test.js', ['goog.net.XhrIoTest'], ['goog.Uri', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.EventType', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('net/xhriopool.js', ['goog.net.XhrIoPool'], ['goog.net.XhrIo', 'goog.structs.PriorityPool'], {});
goog.addDependency('net/xhriopool_test.js', ['goog.net.XhrIoPoolTest'], ['goog.net.XhrIoPool', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xhrlike.js', ['goog.net.XhrLike'], [], {});
goog.addDependency('net/xhrmanager.js', ['goog.net.XhrManager', 'goog.net.XhrManager.Event', 'goog.net.XhrManager.Request'], ['goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.structs.Map'], {});
goog.addDependency('net/xhrmanager_test.js', ['goog.net.XhrManagerTest'], ['goog.events', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrManager', 'goog.testing.net.XhrIoPool', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xmlhttp.js', ['goog.net.DefaultXmlHttpFactory', 'goog.net.XmlHttp', 'goog.net.XmlHttp.OptionType', 'goog.net.XmlHttp.ReadyState', 'goog.net.XmlHttpDefines'], ['goog.asserts', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xmlhttpfactory.js', ['goog.net.XmlHttpFactory'], ['goog.net.XhrLike'], {});
goog.addDependency('net/xpc/crosspagechannel.js', ['goog.net.xpc.CrossPageChannel'], ['goog.Uri', 'goog.async.Deferred', 'goog.async.Delay', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.legacyconversions', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.DirectTransport', 'goog.net.xpc.NativeMessagingTransport', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xpc/crosspagechannel_test.js', ['goog.net.xpc.CrossPageChannelTest'], ['goog.Disposable', 'goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('net/xpc/crosspagechannelrole.js', ['goog.net.xpc.CrossPageChannelRole'], [], {});
goog.addDependency('net/xpc/directtransport.js', ['goog.net.xpc.DirectTransport'], ['goog.Timer', 'goog.async.Deferred', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.object'], {});
goog.addDependency('net/xpc/directtransport_test.js', ['goog.net.xpc.DirectTransportTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/iframepollingtransport.js', ['goog.net.xpc.IframePollingTransport', 'goog.net.xpc.IframePollingTransport.Receiver', 'goog.net.xpc.IframePollingTransport.Sender'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.userAgent'], {});
goog.addDependency('net/xpc/iframepollingtransport_test.js', ['goog.net.xpc.IframePollingTransportTest'], ['goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.IframePollingTransport', 'goog.object', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/nativemessagingtransport.js', ['goog.net.xpc.NativeMessagingTransport'], ['goog.Timer', 'goog.asserts', 'goog.async.Deferred', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes'], {});
goog.addDependency('net/xpc/nativemessagingtransport_test.js', ['goog.net.xpc.NativeMessagingTransportTest'], ['goog.dom', 'goog.events', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.NativeMessagingTransport', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/relay.js', ['goog.net.xpc.relay'], [], {'lang': 'es6'});
goog.addDependency('net/xpc/transport.js', ['goog.net.xpc.Transport'], ['goog.Disposable', 'goog.dom', 'goog.net.xpc.TransportNames'], {});
goog.addDependency('net/xpc/xpc.js', ['goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.TransportNames', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields'], ['goog.log'], {});
goog.addDependency('object/object.js', ['goog.object'], [], {'lang': 'es6'});
goog.addDependency('object/object_test.js', ['goog.objectTest'], ['goog.array', 'goog.functions', 'goog.object', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/absoluteposition.js', ['goog.positioning.AbsolutePosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/abstractposition.js', ['goog.positioning.AbstractPosition'], [], {});
goog.addDependency('positioning/anchoredposition.js', ['goog.positioning.AnchoredPosition'], ['goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/anchoredposition_test.js', ['goog.positioning.AnchoredPositionTest'], ['goog.dom', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/anchoredviewportposition.js', ['goog.positioning.AnchoredViewportPosition'], ['goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], {});
goog.addDependency('positioning/anchoredviewportposition_test.js', ['goog.positioning.AnchoredViewportPositionTest'], ['goog.dom', 'goog.math.Box', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/clientposition.js', ['goog.positioning.ClientPosition'], ['goog.asserts', 'goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.style'], {});
goog.addDependency('positioning/clientposition_test.js', ['goog.positioning.clientPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.ClientPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/menuanchoredposition.js', ['goog.positioning.MenuAnchoredPosition'], ['goog.positioning.AnchoredViewportPosition', 'goog.positioning.Overflow'], {});
goog.addDependency('positioning/menuanchoredposition_test.js', ['goog.positioning.MenuAnchoredPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/positioning.js', ['goog.positioning', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('positioning/positioning_test.js', ['goog.positioningTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Size', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportclientposition.js', ['goog.positioning.ViewportClientPosition'], ['goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.ClientPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style'], {});
goog.addDependency('positioning/viewportclientposition_test.js', ['goog.positioning.ViewportClientPositionTest'], ['goog.dom', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.style', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportposition.js', ['goog.positioning.ViewportPosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style'], {});
goog.addDependency('promise/nativeresolver.js', ['goog.promise.NativeResolver'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/nativeresolver_test.js', ['goog.promise.nativeResolverTest'], ['goog.promise.NativeResolver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/promise.js', ['goog.Promise'], ['goog.Thenable', 'goog.asserts', 'goog.async.FreeList', 'goog.async.run', 'goog.async.throwException', 'goog.debug.Error', 'goog.promise.Resolver'], {});
goog.addDependency('promise/promise_test.js', ['goog.PromiseTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('promise/resolver.js', ['goog.promise.Resolver'], [], {});
goog.addDependency('promise/testsuiteadapter.js', ['goog.promise.testSuiteAdapter'], ['goog.Promise'], {});
goog.addDependency('promise/thenable.js', ['goog.Thenable'], [], {});
goog.addDependency('proto2/descriptor.js', ['goog.proto2.Descriptor', 'goog.proto2.Metadata'], ['goog.array', 'goog.asserts', 'goog.object', 'goog.string'], {});
goog.addDependency('proto2/descriptor_test.js', ['goog.proto2.DescriptorTest'], ['goog.proto2.Descriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/fielddescriptor.js', ['goog.proto2.FieldDescriptor'], ['goog.asserts', 'goog.string'], {});
goog.addDependency('proto2/fielddescriptor_test.js', ['goog.proto2.FieldDescriptorTest'], ['goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/lazydeserializer.js', ['goog.proto2.LazyDeserializer'], ['goog.asserts', 'goog.proto2.Message', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/message.js', ['goog.proto2.Message'], ['goog.asserts', 'goog.proto2.Descriptor', 'goog.proto2.FieldDescriptor'], {});
goog.addDependency('proto2/message_test.js', ['goog.proto2.MessageTest'], ['goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/objectserializer.js', ['goog.proto2.ObjectSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/objectserializer_test.js', ['goog.proto2.ObjectSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.Serializer', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/package_test.pb.js', ['someprotopackage.TestPackageTypes'], ['goog.proto2.Message', 'proto2.TestAllTypes'], {'lang': 'es6'});
goog.addDependency('proto2/pbliteserializer.js', ['goog.proto2.PbLiteSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.LazyDeserializer', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/pbliteserializer_test.js', ['goog.proto2.PbLiteSerializerTest'], ['goog.proto2.PbLiteSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/proto_test.js', ['goog.proto2.messageTest'], ['goog.proto2.FieldDescriptor', 'goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestDefaultParent', 'someprotopackage.TestPackageTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/serializer.js', ['goog.proto2.Serializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message'], {});
goog.addDependency('proto2/test.pb.js', ['proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup', 'proto2.TestDefaultChild', 'proto2.TestDefaultParent'], ['goog.proto2.Message'], {});
goog.addDependency('proto2/textformatserializer.js', ['goog.proto2.TextFormatSerializer'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.object', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/textformatserializer_test.js', ['goog.proto2.TextFormatSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.TextFormatSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/util.js', ['goog.proto2.Util'], ['goog.asserts'], {});
goog.addDependency('pubsub/pubsub.js', ['goog.pubsub.PubSub'], ['goog.Disposable', 'goog.array', 'goog.async.run'], {});
goog.addDependency('pubsub/pubsub_test.js', ['goog.pubsub.PubSubTest'], ['goog.array', 'goog.pubsub.PubSub', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('pubsub/topicid.js', ['goog.pubsub.TopicId'], [], {});
goog.addDependency('pubsub/typedpubsub.js', ['goog.pubsub.TypedPubSub'], ['goog.Disposable', 'goog.pubsub.PubSub'], {});
goog.addDependency('pubsub/typedpubsub_test.js', ['goog.pubsub.TypedPubSubTest'], ['goog.array', 'goog.pubsub.TopicId', 'goog.pubsub.TypedPubSub', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('reflect/reflect.js', ['goog.reflect'], [], {'lang': 'es6'});
goog.addDependency('reflect/reflect_test.js', ['goog.reflectTest'], ['goog.object', 'goog.reflect', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/chain_test.js', ['goog.result.chainTest'], ['goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/combine_test.js', ['goog.result.combineTest'], ['goog.Timer', 'goog.array', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/deferredadaptor.js', ['goog.result.DeferredAdaptor'], ['goog.async.Deferred', 'goog.result', 'goog.result.Result'], {});
goog.addDependency('result/deferredadaptor_test.js', ['goog.result.DeferredAdaptorTest'], ['goog.async.Deferred', 'goog.result', 'goog.result.DeferredAdaptor', 'goog.result.SimpleResult', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/dependentresult.js', ['goog.result.DependentResult'], ['goog.result.Result'], {});
goog.addDependency('result/result_interface.js', ['goog.result.Result'], ['goog.Thenable'], {});
goog.addDependency('result/resultutil.js', ['goog.result'], ['goog.array', 'goog.result.DependentResult', 'goog.result.Result', 'goog.result.SimpleResult'], {});
goog.addDependency('result/resultutil_test.js', ['goog.resultTest'], ['goog.result', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/simpleresult.js', ['goog.result.SimpleResult', 'goog.result.SimpleResult.StateError'], ['goog.Promise', 'goog.Thenable', 'goog.debug.Error', 'goog.result.Result'], {});
goog.addDependency('result/simpleresult_test.js', ['goog.result.SimpleResultTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/transform_test.js', ['goog.result.transformTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/wait_test.js', ['goog.result.waitTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/data.js', ['goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedHtml', 'goog.soy.data.SanitizedHtmlAttribute', 'goog.soy.data.SanitizedJs', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.soy.data.SanitizedUri'], ['goog.Uri', 'goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const'], {});
goog.addDependency('soy/data_test.js', ['goog.soy.dataTest'], ['goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/renderer.js', ['goog.soy.InjectedDataSupplier', 'goog.soy.Renderer'], ['goog.asserts', 'goog.dom', 'goog.soy', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind'], {});
goog.addDependency('soy/renderer_test.js', ['goog.soy.RendererTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.i18n.bidi.Dir', 'goog.soy.Renderer', 'goog.soy.data.SanitizedContentKind', 'goog.soy.testHelper', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy.js', ['goog.soy'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.soy.data.SanitizedContent'], {});
goog.addDependency('soy/soy_test.js', ['goog.soyTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.soy', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy_testhelper.js', ['goog.soy.testHelper'], ['goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi.Dir', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.string', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('spell/spellcheck.js', ['goog.spell.SpellCheck', 'goog.spell.SpellCheck.WordChangedEvent'], ['goog.Timer', 'goog.events.Event', 'goog.events.EventTarget', 'goog.structs.Set'], {});
goog.addDependency('spell/spellcheck_test.js', ['goog.spell.SpellCheckTest'], ['goog.spell.SpellCheck', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('stats/basicstat.js', ['goog.stats.BasicStat'], ['goog.asserts', 'goog.log', 'goog.string.format', 'goog.structs.CircularBuffer'], {});
goog.addDependency('stats/basicstat_test.js', ['goog.stats.BasicStatTest'], ['goog.array', 'goog.stats.BasicStat', 'goog.string.format', 'goog.testing.PseudoRandom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestorage.js', ['goog.storage.CollectableStorage'], ['goog.array', 'goog.iter', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/collectablestorage_test.js', ['goog.storage.CollectableStorageTest'], ['goog.storage.CollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestoragetester.js', ['goog.storage.collectableStorageTester'], ['goog.testing.asserts'], {});
goog.addDependency('storage/encryptedstorage.js', ['goog.storage.EncryptedStorage'], ['goog.crypt', 'goog.crypt.Arc4', 'goog.crypt.Sha1', 'goog.crypt.base64', 'goog.json', 'goog.json.Serializer', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/encryptedstorage_test.js', ['goog.storage.EncryptedStorageTest'], ['goog.json', 'goog.storage.EncryptedStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.PseudoRandom', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/errorcode.js', ['goog.storage.ErrorCode'], [], {});
goog.addDependency('storage/expiringstorage.js', ['goog.storage.ExpiringStorage'], ['goog.storage.RichStorage'], {});
goog.addDependency('storage/expiringstorage_test.js', ['goog.storage.ExpiringStorageTest'], ['goog.storage.ExpiringStorage', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/errorcode.js', ['goog.storage.mechanism.ErrorCode'], [], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism.js', ['goog.storage.mechanism.ErrorHandlingMechanism'], ['goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism_test.js', ['goog.storage.mechanism.ErrorHandlingMechanismTest'], ['goog.storage.mechanism.ErrorHandlingMechanism', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5localstorage.js', ['goog.storage.mechanism.HTML5LocalStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5localstorage_test.js', ['goog.storage.mechanism.HTML5LocalStorageTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5sessionstorage.js', ['goog.storage.mechanism.HTML5SessionStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5sessionstorage_test.js', ['goog.storage.mechanism.HTML5SessionStorageTest'], ['goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5webstorage.js', ['goog.storage.mechanism.HTML5WebStorage'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/html5webstorage_test.js', ['goog.storage.mechanism.HTML5WebStorageTest'], ['goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.HTML5WebStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/ieuserdata.js', ['goog.storage.mechanism.IEUserData'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism', 'goog.structs.Map', 'goog.userAgent'], {});
goog.addDependency('storage/mechanism/ieuserdata_test.js', ['goog.storage.mechanism.IEUserDataTest'], ['goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/iterablemechanism.js', ['goog.storage.mechanism.IterableMechanism'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/iterablemechanismtester.js', ['goog.storage.mechanism.iterableMechanismTester'], ['goog.iter', 'goog.iter.StopIteration', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanism.js', ['goog.storage.mechanism.Mechanism'], [], {});
goog.addDependency('storage/mechanism/mechanismfactory.js', ['goog.storage.mechanism.mechanismfactory'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.PrefixedMechanism'], {});
goog.addDependency('storage/mechanism/mechanismfactory_test.js', ['goog.storage.mechanism.mechanismfactoryTest'], ['goog.storage.mechanism.mechanismfactory', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/mechanismseparationtester.js', ['goog.storage.mechanism.mechanismSeparationTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismsharingtester.js', ['goog.storage.mechanism.mechanismSharingTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismtestdefinition.js', ['goog.storage.mechanism.mechanismTestDefinition'], [], {});
goog.addDependency('storage/mechanism/mechanismtester.js', ['goog.storage.mechanism.mechanismTester'], ['goog.storage.mechanism.ErrorCode', 'goog.testing.asserts', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('storage/mechanism/prefixedmechanism.js', ['goog.storage.mechanism.PrefixedMechanism'], ['goog.iter.Iterator', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/prefixedmechanism_test.js', ['goog.storage.mechanism.PrefixedMechanismTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.PrefixedMechanism', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/richstorage.js', ['goog.storage.RichStorage', 'goog.storage.RichStorage.Wrapper'], ['goog.storage.ErrorCode', 'goog.storage.Storage'], {});
goog.addDependency('storage/richstorage_test.js', ['goog.storage.RichStorageTest'], ['goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.storageTester', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storage.js', ['goog.storage.Storage'], ['goog.json', 'goog.storage.ErrorCode'], {});
goog.addDependency('storage/storage_test.js', ['goog.storage.storage_test'], ['goog.functions', 'goog.storage.ErrorCode', 'goog.storage.Storage', 'goog.storage.storageTester', 'goog.testing.asserts', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storagetester.js', ['goog.storage.storageTester'], ['goog.storage.Storage', 'goog.structs.Map', 'goog.testing.asserts'], {});
goog.addDependency('streams/defines.js', ['goog.streams.defines'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full.js', ['goog.streams.full'], ['goog.streams.defines', 'goog.streams.fullImpl', 'goog.streams.fullNativeImpl', 'goog.streams.fullTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl.js', ['goog.streams.fullImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.fullTypes', 'goog.streams.liteImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl_test.js', ['goog.streams.fullImplTest'], ['goog.streams.fullImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl.js', ['goog.streams.fullNativeImpl'], ['goog.streams.fullTypes', 'goog.streams.liteNativeImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl_test.js', ['goog.streams.fullNativeImplTest'], ['goog.streams.fullNativeImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_test_cases.js', ['goog.streams.fullTestCases'], ['goog.streams.fullTypes', 'goog.streams.liteTestCases', 'goog.testing.recordFunction'], {'lang': 'es9', 'module': 'goog'});
goog.addDependency('streams/full_types.js', ['goog.streams.fullTypes'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite.js', ['goog.streams.lite'], ['goog.streams.defines', 'goog.streams.liteImpl', 'goog.streams.liteNativeImpl', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl.js', ['goog.streams.liteImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl_test.js', ['goog.streams.liteImplTest'], ['goog.streams.liteImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl.js', ['goog.streams.liteNativeImpl'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl_test.js', ['goog.streams.liteNativeImplTest'], ['goog.streams.liteNativeImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_test_cases.js', ['goog.streams.liteTestCases'], ['goog.streams.liteTypes', 'goog.testing.jsunit'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('streams/lite_types.js', ['goog.streams.liteTypes'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/const.js', ['goog.string.Const'], ['goog.asserts', 'goog.string.TypedString'], {});
goog.addDependency('string/const_test.js', ['goog.string.constTest'], ['goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/internal.js', ['goog.string.internal'], [], {'lang': 'es6'});
goog.addDependency('string/linkify.js', ['goog.string.linkify'], ['goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('string/linkify_test.js', ['goog.string.linkifyTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string', 'goog.string.linkify', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/newlines.js', ['goog.string.newlines', 'goog.string.newlines.Line'], ['goog.array'], {});
goog.addDependency('string/newlines_test.js', ['goog.string.newlinesTest'], ['goog.string.newlines', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/parser.js', ['goog.string.Parser'], [], {});
goog.addDependency('string/path.js', ['goog.string.path'], ['goog.array', 'goog.string'], {});
goog.addDependency('string/path_test.js', ['goog.string.pathTest'], ['goog.string.path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/string.js', ['goog.string', 'goog.string.Unicode'], ['goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('string/string_test.js', ['goog.stringTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringbuffer.js', ['goog.string.StringBuffer'], [], {'lang': 'es6'});
goog.addDependency('string/stringbuffer_test.js', ['goog.string.StringBufferTest'], ['goog.string.StringBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringformat.js', ['goog.string.format'], ['goog.string'], {});
goog.addDependency('string/stringformat_test.js', ['goog.string.formatTest'], ['goog.string.format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringifier.js', ['goog.string.Stringifier'], [], {});
goog.addDependency('string/typedstring.js', ['goog.string.TypedString'], [], {});
goog.addDependency('structs/avltree.js', ['goog.structs.AvlTree'], ['goog.asserts', 'goog.structs.Collection'], {'module': 'goog'});
goog.addDependency('structs/avltree_test.js', ['goog.structs.AvlTreeTest'], ['goog.array', 'goog.structs.AvlTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/circularbuffer.js', ['goog.structs.CircularBuffer'], [], {'lang': 'es6'});
goog.addDependency('structs/circularbuffer_test.js', ['goog.structs.CircularBufferTest'], ['goog.structs.CircularBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/collection.js', ['goog.structs.Collection'], [], {});
goog.addDependency('structs/collection_test.js', ['goog.structs.CollectionTest'], ['goog.structs.AvlTree', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/heap.js', ['goog.structs.Heap'], ['goog.array', 'goog.object', 'goog.structs.Node'], {});
goog.addDependency('structs/heap_test.js', ['goog.structs.HeapTest'], ['goog.structs', 'goog.structs.Heap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/inversionmap.js', ['goog.structs.InversionMap'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('structs/inversionmap_test.js', ['goog.structs.InversionMapTest'], ['goog.structs.InversionMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/linkedmap.js', ['goog.structs.LinkedMap'], ['goog.structs.Map'], {});
goog.addDependency('structs/linkedmap_test.js', ['goog.structs.LinkedMapTest'], ['goog.structs.LinkedMap', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/map.js', ['goog.structs.Map'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('structs/map_test.js', ['goog.structs.MapTest'], ['goog.iter', 'goog.structs', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/node.js', ['goog.structs.Node'], [], {});
goog.addDependency('structs/pool.js', ['goog.structs.Pool'], ['goog.Disposable', 'goog.structs.Queue', 'goog.structs.Set'], {});
goog.addDependency('structs/pool_test.js', ['goog.structs.PoolTest'], ['goog.structs.Pool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/prioritypool.js', ['goog.structs.PriorityPool'], ['goog.structs.Pool', 'goog.structs.PriorityQueue'], {});
goog.addDependency('structs/prioritypool_test.js', ['goog.structs.PriorityPoolTest'], ['goog.structs.PriorityPool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/priorityqueue.js', ['goog.structs.PriorityQueue'], ['goog.structs.Heap'], {});
goog.addDependency('structs/priorityqueue_test.js', ['goog.structs.PriorityQueueTest'], ['goog.structs', 'goog.structs.PriorityQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/quadtree.js', ['goog.structs.QuadTree', 'goog.structs.QuadTree.Node', 'goog.structs.QuadTree.Point'], ['goog.math.Coordinate'], {});
goog.addDependency('structs/quadtree_test.js', ['goog.structs.QuadTreeTest'], ['goog.structs', 'goog.structs.QuadTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/queue.js', ['goog.structs.Queue'], ['goog.array'], {});
goog.addDependency('structs/queue_test.js', ['goog.structs.QueueTest'], ['goog.structs.Queue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/set.js', ['goog.structs.Set'], ['goog.structs', 'goog.structs.Collection', 'goog.structs.Map'], {});
goog.addDependency('structs/set_test.js', ['goog.structs.SetTest'], ['goog.iter', 'goog.structs', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/simplepool.js', ['goog.structs.SimplePool'], ['goog.Disposable'], {});
goog.addDependency('structs/stringset.js', ['goog.structs.StringSet'], ['goog.asserts', 'goog.iter'], {});
goog.addDependency('structs/stringset_test.js', ['goog.structs.StringSetTest'], ['goog.array', 'goog.iter', 'goog.structs.StringSet', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/structs.js', ['goog.structs'], ['goog.array', 'goog.object'], {});
goog.addDependency('structs/structs_test.js', ['goog.structsTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.structs', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/treenode.js', ['goog.structs.TreeNode'], ['goog.array', 'goog.asserts', 'goog.structs.Node'], {});
goog.addDependency('structs/treenode_test.js', ['goog.structs.TreeNodeTest'], ['goog.structs.TreeNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/trie.js', ['goog.structs.Trie'], ['goog.object', 'goog.structs'], {});
goog.addDependency('structs/trie_test.js', ['goog.structs.TrieTest'], ['goog.object', 'goog.structs', 'goog.structs.Trie', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/bidi.js', ['goog.style.bidi'], ['goog.dom', 'goog.style', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/bidi_test.js', ['goog.style.bidiTest'], ['goog.dom', 'goog.style', 'goog.style.bidi', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/cursor.js', ['goog.style.cursor'], ['goog.userAgent'], {});
goog.addDependency('style/cursor_test.js', ['goog.style.cursorTest'], ['goog.style.cursor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style.js', ['goog.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.vendor', 'goog.html.SafeStyleSheet', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.reflect', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('style/style_document_scroll_test.js', ['goog.style.style_document_scroll_test'], ['goog.dom', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_test.js', ['goog.style_test'], ['goog.array', 'goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.html.testing', 'goog.labs.userAgent.util', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.MockUserAgent', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_webkit_scrollbars_test.js', ['goog.style.webkitScrollbarsTest'], ['goog.asserts', 'goog.style', 'goog.styleScrollbarTester', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/stylescrollbartester.js', ['goog.styleScrollbarTester'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.asserts'], {});
goog.addDependency('style/transform.js', ['goog.style.transform'], ['goog.functions', 'goog.math.Coordinate', 'goog.math.Coordinate3', 'goog.style', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/transform_test.js', ['goog.style.transformTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.style.transform', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/transition.js', ['goog.style.transition', 'goog.style.transition.Css3Property'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.vendor', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('style/transition_test.js', ['goog.style.transitionTest'], ['goog.style', 'goog.style.transition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('test_module.js', ['goog.test_module'], ['goog.test_module_dep'], {'module': 'goog'});
goog.addDependency('test_module_dep.js', ['goog.test_module_dep'], [], {'module': 'goog'});
goog.addDependency('testing/assertionfailure.js', ['goog.testing.safe.assertionFailure'], ['goog.asserts', 'goog.testing.asserts'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asserts.js', ['goog.testing.asserts'], ['goog.testing.JsUnitException'], {});
goog.addDependency('testing/asserts_test.js', ['goog.testing.assertsTest'], ['goog.Promise', 'goog.array', 'goog.async.Deferred', 'goog.dom', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/async/mockcontrol.js', ['goog.testing.async.MockControl'], ['goog.asserts', 'goog.async.Deferred', 'goog.debug', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.IgnoreArgument'], {});
goog.addDependency('testing/async/mockcontrol_test.js', ['goog.testing.async.MockControlTest'], ['goog.async.Deferred', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase.js', ['goog.testing.AsyncTestCase', 'goog.testing.AsyncTestCase.ControlBreakingException'], ['goog.asserts', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/asynctestcase_async_test.js', ['goog.testing.AsyncTestCaseAsyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_noasync_test.js', ['goog.testing.AsyncTestCaseSyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_test.js', ['goog.testing.AsyncTestCaseTest'], ['goog.debug.Error', 'goog.testing.AsyncTestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/benchmark.js', ['goog.testing.benchmark'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTable', 'goog.testing.PerformanceTimer', 'goog.testing.TestCase'], {});
goog.addDependency('testing/continuationtestcase.js', ['goog.testing.ContinuationTestCase', 'goog.testing.ContinuationTestCase.ContinuationTest', 'goog.testing.ContinuationTestCase.Step'], ['goog.array', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/continuationtestcase_test.js', ['goog.testing.ContinuationTestCaseTest'], ['goog.events', 'goog.events.EventTarget', 'goog.testing.ContinuationTestCase', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/deferredtestcase.js', ['goog.testing.DeferredTestCase'], ['goog.async.Deferred', 'goog.testing.AsyncTestCase', 'goog.testing.TestCase'], {});
goog.addDependency('testing/deferredtestcase_test.js', ['goog.testing.DeferredTestCaseTest'], ['goog.async.Deferred', 'goog.testing.DeferredTestCase', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/dom.js', ['goog.testing.dom'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.InputType', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.iter', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/dom_test.js', ['goog.testing.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/dom.js', ['goog.testing.editor.dom'], ['goog.dom.AbstractRange', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagWalkType', 'goog.iter', 'goog.string', 'goog.testing.asserts'], {});
goog.addDependency('testing/editor/dom_test.js', ['goog.testing.editor.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.testing.editor.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/fieldmock.js', ['goog.testing.editor.FieldMock'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.testing.LooseMock', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/editor/testhelper.js', ['goog.testing.editor.TestHelper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.node', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.testing.dom'], {});
goog.addDependency('testing/editor/testhelper_test.js', ['goog.testing.editor.TestHelperTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.node', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/eventobserver.js', ['goog.testing.events.EventObserver'], ['goog.array', 'goog.events.Event'], {});
goog.addDependency('testing/events/eventobserver_test.js', ['goog.testing.events.EventObserverTest'], ['goog.array', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.testing.events.EventObserver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/events.js', ['goog.testing.events', 'goog.testing.events.Event'], ['goog.Disposable', 'goog.asserts', 'goog.dom.NodeType', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('testing/events/events_test.js', ['goog.testing.eventsTest'], ['goog.array', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/matchers.js', ['goog.testing.events.EventMatcher'], ['goog.events.Event', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('testing/events/matchers_test.js', ['goog.testing.events.EventMatcherTest'], ['goog.events.Event', 'goog.testing.events.EventMatcher', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/onlinehandler.js', ['goog.testing.events.OnlineHandler'], ['goog.events.EventTarget', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('testing/events/onlinehandler_test.js', ['goog.testing.events.OnlineHandlerTest'], ['goog.events', 'goog.net.NetworkStatusMonitor', 'goog.testing.events.EventObserver', 'goog.testing.events.OnlineHandler', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/expectedfailures.js', ['goog.testing.ExpectedFailures'], ['goog.asserts', 'goog.debug.DivConsole', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.style', 'goog.testing.JsUnitException', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/expectedfailures_test.js', ['goog.testing.ExpectedFailuresTest'], ['goog.debug.Logger', 'goog.testing.ExpectedFailures', 'goog.testing.JsUnitException', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/blob.js', ['goog.testing.fs.Blob'], ['goog.crypt', 'goog.crypt.base64'], {});
goog.addDependency('testing/fs/blob_test.js', ['goog.testing.fs.BlobTest'], ['goog.dom', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/directoryentry_test.js', ['goog.testing.fs.DirectoryEntryTest'], ['goog.array', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/entry.js', ['goog.testing.fs.DirectoryEntry', 'goog.testing.fs.Entry', 'goog.testing.fs.FileEntry'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntryImpl', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.fs.File', 'goog.testing.fs.FileWriter'], {});
goog.addDependency('testing/fs/entry_test.js', ['goog.testing.fs.EntryTest'], ['goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/file.js', ['goog.testing.fs.File'], ['goog.testing.fs.Blob'], {});
goog.addDependency('testing/fs/fileentry_test.js', ['goog.testing.fs.FileEntryTest'], ['goog.testing.MockClock', 'goog.testing.fs.FileEntry', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filereader.js', ['goog.testing.fs.FileReader'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.testing.fs.Blob', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filereader_test.js', ['goog.testing.fs.FileReaderTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.object', 'goog.testing.events.EventObserver', 'goog.testing.fs.FileReader', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filesystem.js', ['goog.testing.fs.FileSystem'], ['goog.fs.FileSystem', 'goog.testing.fs.DirectoryEntry'], {});
goog.addDependency('testing/fs/filewriter.js', ['goog.testing.fs.FileWriter'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.fs.Blob', 'goog.testing.fs.File', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filewriter_test.js', ['goog.testing.fs.FileWriterTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.object', 'goog.testing.MockClock', 'goog.testing.events.EventObserver', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/fs.js', ['goog.testing.fs'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.fs', 'goog.testing.PropertyReplacer', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem'], {});
goog.addDependency('testing/fs/fs_test.js', ['goog.testing.fsTest'], ['goog.testing.fs', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/integration_test.js', ['goog.testing.fs.integrationTest'], ['goog.Promise', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.testing.PropertyReplacer', 'goog.testing.fs', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/progressevent.js', ['goog.testing.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('testing/functionmock.js', ['goog.testing', 'goog.testing.FunctionMock', 'goog.testing.GlobalFunctionMock', 'goog.testing.MethodMock'], ['goog.object', 'goog.testing.LooseMock', 'goog.testing.Mock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/functionmock_test.js', ['goog.testing.FunctionMockTest'], ['goog.array', 'goog.string', 'goog.testing', 'goog.testing.FunctionMock', 'goog.testing.Mock', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/graphics.js', ['goog.testing.graphics'], ['goog.graphics.Path', 'goog.testing.asserts'], {});
goog.addDependency('testing/i18n/asserts.js', ['goog.testing.i18n.asserts'], ['goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/i18n/asserts_test.js', ['goog.testing.i18n.assertsTest'], ['goog.testing.ExpectedFailures', 'goog.testing.i18n.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/jstdasyncwrapper.js', ['goog.testing.JsTdAsyncWrapper'], ['goog.Promise'], {});
goog.addDependency('testing/jstdtestcaseadapter.js', ['goog.testing.JsTdTestCaseAdapter'], ['goog.async.run', 'goog.functions', 'goog.testing.JsTdAsyncWrapper', 'goog.testing.TestCase', 'goog.testing.jsunit'], {});
goog.addDependency('testing/jsunit.js', ['goog.testing.jsunit'], ['goog.dom.TagName', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.userAgent'], {});
goog.addDependency('testing/jsunitexception.js', ['goog.testing.JsUnitException'], ['goog.testing.stacktrace'], {});
goog.addDependency('testing/loosemock.js', ['goog.testing.LooseExpectationCollection', 'goog.testing.LooseMock'], ['goog.array', 'goog.asserts', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/loosemock_test.js', ['goog.testing.LooseMockTest'], ['goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/messaging/mockmessagechannel.js', ['goog.testing.messaging.MockMessageChannel'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.asserts'], {});
goog.addDependency('testing/messaging/mockmessageevent.js', ['goog.testing.messaging.MockMessageEvent'], ['goog.events.BrowserEvent', 'goog.events.EventType', 'goog.testing.events.Event'], {});
goog.addDependency('testing/messaging/mockmessageport.js', ['goog.testing.messaging.MockMessagePort'], ['goog.events.EventTarget', 'goog.testing.MockControl'], {});
goog.addDependency('testing/messaging/mockportnetwork.js', ['goog.testing.messaging.MockPortNetwork'], ['goog.messaging.PortNetwork', 'goog.testing.messaging.MockMessageChannel'], {});
goog.addDependency('testing/mock.js', ['goog.testing.Mock', 'goog.testing.MockExpectation'], ['goog.Promise', 'goog.array', 'goog.asserts', 'goog.object', 'goog.promise.Resolver', 'goog.testing.JsUnitException', 'goog.testing.MockInterface', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mock_test.js', ['goog.testing.MockTest'], ['goog.array', 'goog.testing', 'goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.MockExpectation', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/mockclassfactory.js', ['goog.testing.MockClassFactory', 'goog.testing.MockClassRecord'], ['goog.array', 'goog.object', 'goog.testing.LooseMock', 'goog.testing.StrictMock', 'goog.testing.TestCase', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mockclassfactory_test.js', ['fake.BaseClass', 'fake.ChildClass', 'goog.testing.MockClassFactoryTest'], ['goog.testing', 'goog.testing.MockClassFactory', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/mockclock.js', ['goog.testing.MockClock'], ['goog.Disposable', 'goog.Promise', 'goog.Thenable', 'goog.async.run', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event'], {});
goog.addDependency('testing/mockclock_test.js', ['goog.testing.MockClockTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockcontrol.js', ['goog.testing.MockControl'], ['goog.Promise', 'goog.array', 'goog.testing', 'goog.testing.LooseMock', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/mockcontrol_test.js', ['goog.testing.MockControlTest'], ['goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockinterface.js', ['goog.testing.MockInterface'], ['goog.Promise'], {});
goog.addDependency('testing/mockmatchers.js', ['goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.mockmatchers.ObjectEquals', 'goog.testing.mockmatchers.RegexpMatch', 'goog.testing.mockmatchers.SaveArgument', 'goog.testing.mockmatchers.TypeOf'], ['goog.array', 'goog.dom', 'goog.testing.asserts'], {});
goog.addDependency('testing/mockmatchers_test.js', ['goog.testing.mockmatchersTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.jsunit', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher'], {'lang': 'es6'});
goog.addDependency('testing/mockrandom.js', ['goog.testing.MockRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/mockrandom_test.js', ['goog.testing.MockRandomTest'], ['goog.testing.MockRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockrange.js', ['goog.testing.MockRange'], ['goog.dom.AbstractRange', 'goog.testing.LooseMock'], {});
goog.addDependency('testing/mockrange_test.js', ['goog.testing.MockRangeTest'], ['goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockstorage.js', ['goog.testing.MockStorage'], ['goog.structs.Map'], {});
goog.addDependency('testing/mockstorage_test.js', ['goog.testing.MockStorageTest'], ['goog.testing.MockStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockuseragent.js', ['goog.testing.MockUserAgent'], ['goog.Disposable', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.userAgent'], {});
goog.addDependency('testing/mockuseragent_test.js', ['goog.testing.MockUserAgentTest'], ['goog.dispose', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/multitestrunner.js', ['goog.testing.MultiTestRunner', 'goog.testing.MultiTestRunner.TestFrame'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.ui.Component', 'goog.ui.ServerChart', 'goog.ui.TableSorter'], {});
goog.addDependency('testing/multitestrunner_test.js', ['goog.testing.MultiTestRunnerTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/mockiframeio.js', ['goog.testing.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo', 'goog.testing.TestQueue'], {});
goog.addDependency('testing/net/xhrio.js', ['goog.testing.net.XhrIo'], ['goog.Uri', 'goog.array', 'goog.dom.xml', 'goog.events', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.structs', 'goog.structs.Map', 'goog.testing.TestQueue', 'goog.uri.utils'], {});
goog.addDependency('testing/net/xhrio_test.js', ['goog.testing.net.XhrIoTest'], ['goog.dom.xml', 'goog.events', 'goog.events.Event', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/xhriopool.js', ['goog.testing.net.XhrIoPool'], ['goog.net.XhrIoPool', 'goog.testing.net.XhrIo'], {});
goog.addDependency('testing/objectpropertystring.js', ['goog.testing.ObjectPropertyString'], [], {});
goog.addDependency('testing/parallel_closure_test_suite.js', ['goog.testing.parallelClosureTestSuite'], ['goog.Promise', 'goog.asserts', 'goog.events', 'goog.json', 'goog.testing.MultiTestRunner', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/parallel_closure_test_suite_test.js', ['goog.testing.parallelClosureTestSuiteTest'], ['goog.dom', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.parallelClosureTestSuite', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/performancetable.js', ['goog.testing.PerformanceTable'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTimer'], {});
goog.addDependency('testing/performancetimer.js', ['goog.testing.PerformanceTimer', 'goog.testing.PerformanceTimer.Task'], ['goog.array', 'goog.async.Deferred', 'goog.math'], {'lang': 'es6'});
goog.addDependency('testing/performancetimer_test.js', ['goog.testing.PerformanceTimerTest'], ['goog.async.Deferred', 'goog.dom', 'goog.math', 'goog.testing.MockClock', 'goog.testing.PerformanceTimer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/propertyreplacer.js', ['goog.testing.PropertyReplacer'], ['goog.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/propertyreplacer_test.js', ['goog.testing.PropertyReplacerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/proto2/proto2.js', ['goog.testing.proto2'], ['goog.proto2.Message', 'goog.proto2.ObjectSerializer', 'goog.testing.asserts'], {});
goog.addDependency('testing/proto2/proto2_test.js', ['goog.testing.proto2Test'], ['goog.testing.proto2', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/pseudorandom.js', ['goog.testing.PseudoRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/pseudorandom_test.js', ['goog.testing.PseudoRandomTest'], ['goog.testing.PseudoRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/recordfunction.js', ['goog.testing.FunctionCall', 'goog.testing.recordConstructor', 'goog.testing.recordFunction'], ['goog.Promise', 'goog.promise.Resolver', 'goog.testing.asserts'], {});
goog.addDependency('testing/recordfunction_test.js', ['goog.testing.recordFunctionTest'], ['goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordConstructor', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/shardingtestcase.js', ['goog.testing.ShardingTestCase'], ['goog.asserts', 'goog.testing.TestCase'], {});
goog.addDependency('testing/shardingtestcase_test.js', ['goog.testing.ShardingTestCaseTest'], ['goog.testing.ShardingTestCase', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/singleton.js', ['goog.testing.singleton'], [], {'lang': 'es6'});
goog.addDependency('testing/singleton_test.js', ['goog.testing.singletonTest'], ['goog.testing.asserts', 'goog.testing.singleton', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/stacktrace.js', ['goog.testing.stacktrace', 'goog.testing.stacktrace.Frame'], [], {'lang': 'es6'});
goog.addDependency('testing/stacktrace_test.js', ['goog.testing.stacktraceTest'], ['goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.stacktrace', 'goog.testing.stacktrace.Frame', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/storage/fakemechanism.js', ['goog.testing.storage.FakeMechanism'], ['goog.storage.mechanism.IterableMechanism', 'goog.structs.Map'], {});
goog.addDependency('testing/strictmock.js', ['goog.testing.StrictMock'], ['goog.array', 'goog.asserts', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/strictmock_test.js', ['goog.testing.StrictMockTest'], ['goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/style/layoutasserts.js', ['goog.testing.style.layoutasserts'], ['goog.style', 'goog.testing.asserts', 'goog.testing.style'], {});
goog.addDependency('testing/style/layoutasserts_test.js', ['goog.testing.style.layoutassertsTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style.layoutasserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/style/style.js', ['goog.testing.style'], ['goog.dom', 'goog.math.Rect', 'goog.style'], {});
goog.addDependency('testing/style/style_test.js', ['goog.testing.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testcase.js', ['goog.testing.TestCase', 'goog.testing.TestCase.Error', 'goog.testing.TestCase.Order', 'goog.testing.TestCase.Result', 'goog.testing.TestCase.Test'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.JsUnitException', 'goog.testing.asserts'], {});
goog.addDependency('testing/testcase_test.js', ['goog.testing.TestCaseTest'], ['goog.Promise', 'goog.Timer', 'goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.FunctionMock', 'goog.testing.JsUnitException', 'goog.testing.MethodMock', 'goog.testing.MockRandom', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/testqueue.js', ['goog.testing.TestQueue'], [], {});
goog.addDependency('testing/testrunner.js', ['goog.testing.TestRunner'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.json', 'goog.testing.TestCase', 'goog.userAgent'], {});
goog.addDependency('testing/testrunner_test.js', ['goog.testing.TestRunnerTest'], ['goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testsuite.js', ['goog.testing.testSuite'], ['goog.labs.testing.Environment', 'goog.testing.TestCase'], {});
goog.addDependency('testing/testsuite_test.js', ['goog.testing.testSuiteTest'], ['goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererasserts.js', ['goog.testing.ui.rendererasserts'], ['goog.testing.asserts', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/rendererasserts_test.js', ['goog.testing.ui.rendererassertsTest'], ['goog.testing.asserts', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererharness.js', ['goog.testing.ui.RendererHarness'], ['goog.Disposable', 'goog.dom.NodeType', 'goog.testing.asserts', 'goog.testing.dom', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/style.js', ['goog.testing.ui.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.testing.asserts'], {});
goog.addDependency('testing/ui/style_test.js', ['goog.testing.ui.styleTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('timer/timer.js', ['goog.Timer'], ['goog.Promise', 'goog.events.EventTarget'], {});
goog.addDependency('timer/timer_test.js', ['goog.TimerTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/entries.js', ['goog.tweak.BaseEntry', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.object'], {});
goog.addDependency('tweak/entries_test.js', ['goog.tweak.BaseEntryTest'], ['goog.testing.MockControl', 'goog.testing.testSuite', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/registry.js', ['goog.tweak.Registry'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.string', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.uri.utils'], {});
goog.addDependency('tweak/registry_test.js', ['goog.tweak.RegistryTest'], ['goog.asserts.AssertionError', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/testhelpers.js', ['goog.tweak.testhelpers'], ['goog.tweak', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweak.js', ['goog.tweak', 'goog.tweak.ConfigParams'], ['goog.asserts', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweakui.js', ['goog.tweak.EntriesPanel', 'goog.tweak.TweakUi'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.style', 'goog.tweak', 'goog.tweak.BaseEntry', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.ui.Zippy', 'goog.userAgent'], {});
goog.addDependency('tweak/tweakui_test.js', ['goog.tweak.TweakUiTest'], ['goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.TweakUi', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/abstractspellchecker.js', ['goog.ui.AbstractSpellChecker', 'goog.ui.AbstractSpellChecker.AsyncResult'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.structs.Set', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/ac/ac.js', ['goog.ui.ac'], ['goog.ui.ac.ArrayMatcher', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/ac_test.js', ['goog.ui.acTest'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ac', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/arraymatcher.js', ['goog.ui.ac.ArrayMatcher'], ['goog.string'], {});
goog.addDependency('ui/ac/arraymatcher_test.js', ['goog.ui.ac.ArrayMatcherTest'], ['goog.testing.testSuite', 'goog.ui.ac.ArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/autocomplete.js', ['goog.ui.ac.AutoComplete', 'goog.ui.ac.AutoComplete.EventType'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.object', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/autocomplete_test.js', ['goog.ui.ac.AutoCompleteTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.string', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RenderOptions', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/cachingmatcher.js', ['goog.ui.ac.CachingMatcher'], ['goog.array', 'goog.async.Throttle', 'goog.ui.ac.ArrayMatcher', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/cachingmatcher_test.js', ['goog.ui.ac.CachingMatcherTest'], ['goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.CachingMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/inputhandler.js', ['goog.ui.ac.InputHandler'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.selection', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('ui/ac/inputhandler_test.js', ['goog.ui.ac.InputHandlerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.selection', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.object', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.ac.InputHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/remote.js', ['goog.ui.ac.Remote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RemoteArrayMatcher', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/remotearraymatcher.js', ['goog.ui.ac.RemoteArrayMatcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('ui/ac/remotearraymatcher_test.js', ['goog.ui.ac.RemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderer.js', ['goog.ui.ac.Renderer', 'goog.ui.ac.Renderer.CustomRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dispose', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.string', 'goog.style', 'goog.ui.IdGenerator', 'goog.ui.ac.AutoComplete'], {'lang': 'es6'});
goog.addDependency('ui/ac/renderer_test.js', ['goog.ui.ac.RendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderoptions.js', ['goog.ui.ac.RenderOptions'], [], {});
goog.addDependency('ui/ac/richinputhandler.js', ['goog.ui.ac.RichInputHandler'], ['goog.ui.ac.InputHandler'], {});
goog.addDependency('ui/ac/richremote.js', ['goog.ui.ac.RichRemote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.Remote', 'goog.ui.ac.Renderer', 'goog.ui.ac.RichInputHandler', 'goog.ui.ac.RichRemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher.js', ['goog.ui.ac.RichRemoteArrayMatcher'], ['goog.dom', 'goog.ui.ac.RemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher_test.js', ['goog.ui.ac.RichRemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RichRemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/activitymonitor.js', ['goog.ui.ActivityMonitor'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/activitymonitor_test.js', ['goog.ui.ActivityMonitorTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/advancedtooltip.js', ['goog.ui.AdvancedTooltip'], ['goog.events', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Tooltip', 'goog.userAgent'], {});
goog.addDependency('ui/advancedtooltip_test.js', ['goog.ui.AdvancedTooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AdvancedTooltip', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/animatedzippy.js', ['goog.ui.AnimatedZippy'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.ui.Zippy', 'goog.ui.ZippyEvent'], {});
goog.addDependency('ui/animatedzippy_test.js', ['goog.ui.AnimatedZippyTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.AnimatedZippy', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/attachablemenu.js', ['goog.ui.AttachableMenu'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.ItemEvent', 'goog.ui.MenuBase', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/bidiinput.js', ['goog.ui.BidiInput'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.InputHandler', 'goog.i18n.bidi', 'goog.ui.Component'], {});
goog.addDependency('ui/bidiinput_test.js', ['goog.ui.BidiInputTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.BidiInput'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/bubble.js', ['goog.ui.Bubble'], ['goog.Timer', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.math.Box', 'goog.positioning', 'goog.positioning.AbsolutePosition', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.string.Const', 'goog.style', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/button.js', ['goog.ui.Button', 'goog.ui.Button.Side'], ['goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.NativeButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/button_test.js', ['goog.ui.ButtonTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonrenderer.js', ['goog.ui.ButtonRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/buttonrenderer_test.js', ['goog.ui.ButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonside.js', ['goog.ui.ButtonSide'], [], {});
goog.addDependency('ui/charcounter.js', ['goog.ui.CharCounter', 'goog.ui.CharCounter.Display'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.InputHandler'], {});
goog.addDependency('ui/charcounter_test.js', ['goog.ui.CharCounterTest'], ['goog.dom', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.CharCounter', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/charpicker.js', ['goog.ui.CharPicker'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.i18n.CharListDecompressor', 'goog.i18n.CharPickerData', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.structs.Set', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.ContainerScroller', 'goog.ui.FlatButtonRenderer', 'goog.ui.HoverCard', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/charpicker_test.js', ['goog.ui.CharPickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.i18n.CharPickerData', 'goog.i18n.uChar.NameFetcher', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.CharPicker', 'goog.ui.FlatButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkbox.js', ['goog.ui.Checkbox', 'goog.ui.Checkbox.State'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.registry'], {});
goog.addDependency('ui/checkbox_test.js', ['goog.ui.CheckboxTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Checkbox', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.decorate'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkboxmenuitem.js', ['goog.ui.CheckBoxMenuItem'], ['goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/checkboxrenderer.js', ['goog.ui.CheckboxRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/colormenubutton.js', ['goog.ui.ColorMenuButton'], ['goog.array', 'goog.object', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.ColorPalette', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.registry'], {});
goog.addDependency('ui/colormenubuttonrenderer.js', ['goog.ui.ColorMenuButtonRenderer'], ['goog.asserts', 'goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/colormenubuttonrenderer_test.js', ['goog.ui.ColorMenuButtonTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ColorMenuButton', 'goog.ui.ColorMenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpalette.js', ['goog.ui.ColorPalette'], ['goog.array', 'goog.color', 'goog.dom.TagName', 'goog.style', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {});
goog.addDependency('ui/colorpalette_test.js', ['goog.ui.ColorPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.ColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpicker.js', ['goog.ui.ColorPicker', 'goog.ui.ColorPicker.EventType'], ['goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/combobox.js', ['goog.ui.ComboBox', 'goog.ui.ComboBoxItem'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.log', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ItemEvent', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/combobox_test.js', ['goog.ui.ComboBoxTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ComboBox', 'goog.ui.ComboBoxItem', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/component.js', ['goog.ui.Component', 'goog.ui.Component.Error', 'goog.ui.Component.EventType', 'goog.ui.Component.State'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.object', 'goog.style', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/component_test.js', ['goog.ui.ComponentTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/componentutil.js', ['goog.ui.ComponentUtil'], ['goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType'], {});
goog.addDependency('ui/componentutil_test.js', ['goog.ui.ComponentUtilTest'], ['goog.events.MouseAsMouseEventType', 'goog.events.PointerAsMouseEventType', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.ComponentUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/container.js', ['goog.ui.Container', 'goog.ui.Container.EventType', 'goog.ui.Container.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.object', 'goog.style', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ContainerRenderer', 'goog.ui.Control'], {});
goog.addDependency('ui/container_test.js', ['goog.ui.ContainerTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.events.PointerFallbackEventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Control'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerrenderer.js', ['goog.ui.ContainerRenderer'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/containerrenderer_test.js', ['goog.ui.ContainerRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerscroller.js', ['goog.ui.ContainerScroller'], ['goog.Disposable', 'goog.Timer', 'goog.events.EventHandler', 'goog.style', 'goog.ui.Component', 'goog.ui.Container'], {});
goog.addDependency('ui/containerscroller_test.js', ['goog.ui.ContainerScrollerTest'], ['goog.dom', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Container', 'goog.ui.ContainerScroller'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/control.js', ['goog.ui.Control'], ['goog.Disposable', 'goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ControlContent', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/control_test.js', ['goog.ui.ControlTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.events.PointerFallbackEventType', 'goog.html.testing', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/controlcontent.js', ['goog.ui.ControlContent'], [], {});
goog.addDependency('ui/controlrenderer.js', ['goog.ui.ControlRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ControlContent', 'goog.userAgent'], {});
goog.addDependency('ui/controlrenderer_test.js', ['goog.ui.ControlRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/cookieeditor.js', ['goog.ui.CookieEditor'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventType', 'goog.net.cookies', 'goog.string', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/cookieeditor_test.js', ['goog.ui.CookieEditorTest'], ['goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.net.cookies', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.CookieEditor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/css3buttonrenderer.js', ['goog.ui.Css3ButtonRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/css3menubuttonrenderer.js', ['goog.ui.Css3MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/cssnames.js', ['goog.ui.INLINE_BLOCK_CLASSNAME'], [], {});
goog.addDependency('ui/custombutton.js', ['goog.ui.CustomButton'], ['goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/custombuttonrenderer.js', ['goog.ui.CustomButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME'], {});
goog.addDependency('ui/customcolorpalette.js', ['goog.ui.CustomColorPalette'], ['goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/customcolorpalette_test.js', ['goog.ui.CustomColorPaletteTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.CustomColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepicker.js', ['goog.ui.DatePicker', 'goog.ui.DatePicker.Events', 'goog.ui.DatePickerEvent'], ['goog.a11y.aria', 'goog.asserts', 'goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimeSymbols', 'goog.style', 'goog.ui.Component', 'goog.ui.DefaultDatePickerRenderer', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/datepicker_test.js', ['goog.ui.DatePickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.date.Date', 'goog.date.DateRange', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepickerrenderer.js', ['goog.ui.DatePickerRenderer'], [], {});
goog.addDependency('ui/decorate.js', ['goog.ui.decorate'], ['goog.ui.registry'], {});
goog.addDependency('ui/decorate_test.js', ['goog.ui.decorateTest'], ['goog.testing.testSuite', 'goog.ui.decorate', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/defaultdatepickerrenderer.js', ['goog.ui.DefaultDatePickerRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.DatePickerRenderer'], {});
goog.addDependency('ui/dialog.js', ['goog.ui.Dialog', 'goog.ui.Dialog.ButtonSet', 'goog.ui.Dialog.ButtonSet.DefaultButtons', 'goog.ui.Dialog.DefaultButtonCaptions', 'goog.ui.Dialog.DefaultButtonKeys', 'goog.ui.Dialog.Event', 'goog.ui.Dialog.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.Keys', 'goog.fx.Dragger', 'goog.html.SafeHtml', 'goog.math.Rect', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.ModalPopup'], {});
goog.addDependency('ui/dialog_test.js', ['goog.ui.DialogTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.css3', 'goog.html.SafeHtml', 'goog.html.testing', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Dialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpicker.js', ['goog.ui.DimensionPicker'], ['goog.events.BrowserEvent.PointerType', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.Control', 'goog.ui.DimensionPickerRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/dimensionpicker_test.js', ['goog.ui.DimensionPickerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpickerrenderer.js', ['goog.ui.DimensionPickerRenderer'], ['goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/dimensionpickerrenderer_test.js', ['goog.ui.DimensionPickerRendererTest'], ['goog.a11y.aria.LivePriority', 'goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dragdropdetector.js', ['goog.ui.DragDropDetector', 'goog.ui.DragDropDetector.EventType', 'goog.ui.DragDropDetector.ImageDropEvent', 'goog.ui.DragDropDetector.LinkDropEvent'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/drilldownrow.js', ['goog.ui.DrilldownRow'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.ui.Component'], {});
goog.addDependency('ui/drilldownrow_test.js', ['goog.ui.DrilldownRowTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.testing.testSuite', 'goog.ui.DrilldownRow'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/abstractdialog.js', ['goog.ui.editor.AbstractDialog', 'goog.ui.editor.AbstractDialog.Builder', 'goog.ui.editor.AbstractDialog.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventTarget', 'goog.string', 'goog.ui.Dialog', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/editor/abstractdialog_test.js', ['goog.ui.editor.AbstractDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/bubble.js', ['goog.ui.editor.Bubble'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.ViewportSizeMonitor', 'goog.dom.classlist', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.functions', 'goog.log', 'goog.math.Box', 'goog.object', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/editor/bubble_test.js', ['goog.ui.editor.BubbleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/defaulttoolbar.js', ['goog.ui.editor.ButtonDescriptor', 'goog.ui.editor.DefaultToolbar'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Command', 'goog.style', 'goog.ui.editor.ToolbarFactory', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('ui/editor/linkdialog.js', ['goog.ui.editor.LinkDialog', 'goog.ui.editor.LinkDialog.BeforeTestLinkEvent', 'goog.ui.editor.LinkDialog.EventType', 'goog.ui.editor.LinkDialog.OkEvent'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.editor.focus', 'goog.editor.node', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.InputHandler', 'goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.LinkButtonRenderer', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.TabPane', 'goog.ui.editor.messages', 'goog.userAgent', 'goog.window'], {});
goog.addDependency('ui/editor/linkdialog_test.js', ['goog.ui.editor.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.ui.editor.messages', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/messages.js', ['goog.ui.editor.messages'], ['goog.html.SafeHtmlFormatter'], {});
goog.addDependency('ui/editor/tabpane.js', ['goog.ui.editor.TabPane'], ['goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.Tab', 'goog.ui.TabBar'], {});
goog.addDependency('ui/editor/toolbarcontroller.js', ['goog.ui.editor.ToolbarController'], ['goog.editor.Field', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/editor/toolbarfactory.js', ['goog.ui.editor.ToolbarFactory'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Option', 'goog.ui.Toolbar', 'goog.ui.ToolbarButton', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarMenuButton', 'goog.ui.ToolbarRenderer', 'goog.ui.ToolbarSelect', 'goog.userAgent'], {});
goog.addDependency('ui/editor/toolbarfactory_test.js', ['goog.ui.editor.ToolbarFactoryTest'], ['goog.dom', 'goog.testing.ExpectedFailures', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.ui.editor.ToolbarFactory', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/emoji.js', ['goog.ui.emoji.Emoji'], [], {});
goog.addDependency('ui/emoji/emojipalette.js', ['goog.ui.emoji.EmojiPalette'], ['goog.events.EventType', 'goog.net.ImageLoader', 'goog.ui.Palette', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipaletterenderer.js', ['goog.ui.emoji.EmojiPaletteRenderer'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.PaletteRenderer', 'goog.ui.emoji.Emoji'], {});
goog.addDependency('ui/emoji/emojipicker.js', ['goog.ui.emoji.EmojiPicker'], ['goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.TabPane', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPalette', 'goog.ui.emoji.EmojiPaletteRenderer', 'goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipicker_test.js', ['goog.ui.emoji.EmojiPickerTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_nonprogressive_emojipicker_test.js', ['goog.ui.emoji.FastNonProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_progressive_emojipicker_test.js', ['goog.ui.emoji.FastProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/popupemojipicker.js', ['goog.ui.emoji.PopupEmojiPicker'], ['goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.Component', 'goog.ui.Popup', 'goog.ui.emoji.EmojiPicker'], {});
goog.addDependency('ui/emoji/popupemojipicker_test.js', ['goog.ui.emoji.PopupEmojiPickerTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.emoji.PopupEmojiPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/progressiveemojipaletterenderer.js', ['goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], ['goog.dom.TagName', 'goog.style', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/spriteinfo.js', ['goog.ui.emoji.SpriteInfo'], [], {'lang': 'es6'});
goog.addDependency('ui/emoji/spriteinfo_test.js', ['goog.ui.emoji.SpriteInfoTest'], ['goog.testing.testSuite', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filteredmenu.js', ['goog.ui.FilteredMenu'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.FilterObservingMenuItem', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.userAgent'], {});
goog.addDependency('ui/filteredmenu_test.js', ['goog.ui.FilteredMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Rect', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.FilteredMenu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filterobservingmenuitem.js', ['goog.ui.FilterObservingMenuItem'], ['goog.ui.FilterObservingMenuItemRenderer', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/filterobservingmenuitemrenderer.js', ['goog.ui.FilterObservingMenuItemRenderer'], ['goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/flatbuttonrenderer.js', ['goog.ui.FlatButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/flatmenubuttonrenderer.js', ['goog.ui.FlatMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.FlatButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/formpost.js', ['goog.ui.FormPost'], ['goog.array', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.ui.Component'], {});
goog.addDependency('ui/formpost_test.js', ['goog.ui.FormPostTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.testSuite', 'goog.ui.FormPost', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/gauge.js', ['goog.ui.Gauge', 'goog.ui.GaugeColoredRange'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.graphics', 'goog.graphics.Font', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.math', 'goog.ui.Component', 'goog.ui.GaugeTheme'], {});
goog.addDependency('ui/gaugetheme.js', ['goog.ui.GaugeTheme'], ['goog.graphics.LinearGradient', 'goog.graphics.SolidFill', 'goog.graphics.Stroke'], {});
goog.addDependency('ui/hovercard.js', ['goog.ui.HoverCard', 'goog.ui.HoverCard.EventType', 'goog.ui.HoverCard.TriggerEvent'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.ui.AdvancedTooltip', 'goog.ui.PopupBase', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/hovercard_test.js', ['goog.ui.HoverCardTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.HoverCard'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvapalette.js', ['goog.ui.HsvaPalette'], ['goog.array', 'goog.color.alpha', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.HsvPalette'], {});
goog.addDependency('ui/hsvapalette_test.js', ['goog.ui.HsvaPaletteTest'], ['goog.color.alpha', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.HsvaPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvpalette.js', ['goog.ui.HsvPalette'], ['goog.color', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/hsvpalette_test.js', ['goog.ui.HsvPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.HsvPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/idgenerator.js', ['goog.ui.IdGenerator'], [], {});
goog.addDependency('ui/idletimer.js', ['goog.ui.IdleTimer'], ['goog.Timer', 'goog.events', 'goog.events.EventTarget', 'goog.structs.Set', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/idletimer_test.js', ['goog.ui.IdleTimerTest'], ['goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.IdleTimer', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/iframemask.js', ['goog.ui.IframeMask'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.dom.iframe', 'goog.events.EventHandler', 'goog.structs.Pool', 'goog.style'], {});
goog.addDependency('ui/iframemask_test.js', ['goog.ui.IframeMaskTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.structs.Pool', 'goog.style', 'goog.testing.MockClock', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.ui.IframeMask', 'goog.ui.Popup', 'goog.ui.PopupBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/imagelessbuttonrenderer.js', ['goog.ui.ImagelessButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/imagelessmenubuttonrenderer.js', ['goog.ui.ImagelessMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/inputdatepicker.js', ['goog.ui.InputDatePicker'], ['goog.date.DateTime', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.i18n.DateTimeParse', 'goog.string', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.LabelInput', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {});
goog.addDependency('ui/inputdatepicker_test.js', ['goog.ui.InputDatePickerTest'], ['goog.dom', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.testing.testSuite', 'goog.ui.InputDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/itemevent.js', ['goog.ui.ItemEvent'], ['goog.events.Event'], {});
goog.addDependency('ui/keyboardeventdata.js', ['goog.ui.KeyboardEventData'], ['goog.asserts', 'goog.events.BrowserEvent'], {'lang': 'es6'});
goog.addDependency('ui/keyboardshortcuthandler.js', ['goog.ui.KeyboardShortcutEvent', 'goog.ui.KeyboardShortcutHandler', 'goog.ui.KeyboardShortcutHandler.EventType', 'goog.ui.KeyboardShortcutHandler.Modifiers'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyNames', 'goog.events.Keys', 'goog.object', 'goog.ui.KeyboardEventData', 'goog.ui.SyntheticKeyboardEvent', 'goog.userAgent'], {});
goog.addDependency('ui/keyboardshortcuthandler_test.js', ['goog.ui.KeyboardShortcutHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.KeyboardShortcutHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/labelinput.js', ['goog.ui.LabelInput'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/labelinput_test.js', ['goog.ui.LabelInputTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.LabelInput', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/linkbuttonrenderer.js', ['goog.ui.LinkButtonRenderer'], ['goog.ui.Button', 'goog.ui.FlatButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/media/flashobject.js', ['goog.ui.media.FlashObject', 'goog.ui.media.FlashObject.ScriptAccessLevel', 'goog.ui.media.FlashObject.Wmodes'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.log', 'goog.object', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.userAgent', 'goog.userAgent.flash'], {});
goog.addDependency('ui/media/flashobject_test.js', ['goog.ui.media.FlashObjectTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.html.testing', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/flickr.js', ['goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/flickr_test.js', ['goog.ui.media.FlickrSetTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/googlevideo.js', ['goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/googlevideo_test.js', ['goog.ui.media.GoogleVideoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/media.js', ['goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/media/media_test.js', ['goog.ui.media.MediaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.math.Size', 'goog.testing.testSuite', 'goog.ui.ControlRenderer', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mediamodel.js', ['goog.ui.media.MediaModel', 'goog.ui.media.MediaModel.Category', 'goog.ui.media.MediaModel.Credit', 'goog.ui.media.MediaModel.Credit.Role', 'goog.ui.media.MediaModel.Credit.Scheme', 'goog.ui.media.MediaModel.Medium', 'goog.ui.media.MediaModel.MimeType', 'goog.ui.media.MediaModel.Player', 'goog.ui.media.MediaModel.SubTitle', 'goog.ui.media.MediaModel.Thumbnail'], ['goog.array', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('ui/media/mediamodel_test.js', ['goog.ui.media.MediaModelTest'], ['goog.testing.testSuite', 'goog.ui.media.MediaModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mp3.js', ['goog.ui.media.Mp3'], ['goog.string', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/mp3_test.js', ['goog.ui.media.Mp3Test'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.Mp3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/photo.js', ['goog.ui.media.Photo'], ['goog.dom.TagName', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/photo_test.js', ['goog.ui.media.PhotoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.MediaModel', 'goog.ui.media.Photo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/picasa.js', ['goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/picasa_test.js', ['goog.ui.media.PicasaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/vimeo.js', ['goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/vimeo_test.js', ['goog.ui.media.VimeoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/youtube.js', ['goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], ['goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.Component', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/youtube_test.js', ['goog.ui.media.YoutubeTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menu.js', ['goog.ui.Menu', 'goog.ui.Menu.EventType'], ['goog.dom.TagName', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.ui.Component.EventType', 'goog.ui.Component.State', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.MenuHeader', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.MenuSeparator'], {});
goog.addDependency('ui/menu_test.js', ['goog.ui.MenuTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubar.js', ['goog.ui.menuBar'], ['goog.ui.Container', 'goog.ui.MenuBarRenderer'], {});
goog.addDependency('ui/menubardecorator.js', ['goog.ui.menuBarDecorator'], ['goog.ui.MenuBarRenderer', 'goog.ui.menuBar', 'goog.ui.registry'], {});
goog.addDependency('ui/menubarrenderer.js', ['goog.ui.MenuBarRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Container', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/menubase.js', ['goog.ui.MenuBase'], ['goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.ui.Popup'], {});
goog.addDependency('ui/menubutton.js', ['goog.ui.MenuButton'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.Menu', 'goog.ui.MenuButtonRenderer', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SubMenu', 'goog.ui.registry', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('ui/menubutton_test.js', ['goog.ui.MenuButtonTest'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubuttonrenderer.js', ['goog.ui.MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuRenderer'], {});
goog.addDependency('ui/menubuttonrenderer_test.js', ['goog.ui.MenuButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuheader.js', ['goog.ui.MenuHeader'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuHeaderRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuheaderrenderer.js', ['goog.ui.MenuHeaderRenderer'], ['goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitem.js', ['goog.ui.MenuItem'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.classlist', 'goog.math.Coordinate', 'goog.string', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuitem_test.js', ['goog.ui.MenuItemTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuitemrenderer.js', ['goog.ui.MenuItemRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitemrenderer_test.js', ['goog.ui.MenuItemRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menurenderer.js', ['goog.ui.MenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.ui.ContainerRenderer', 'goog.ui.Separator'], {});
goog.addDependency('ui/menuseparator.js', ['goog.ui.MenuSeparator'], ['goog.ui.MenuSeparatorRenderer', 'goog.ui.Separator', 'goog.ui.registry'], {});
goog.addDependency('ui/menuseparatorrenderer.js', ['goog.ui.MenuSeparatorRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuseparatorrenderer_test.js', ['goog.ui.MenuSeparatorRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.MenuSeparator', 'goog.ui.MenuSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/mockactivitymonitor.js', ['goog.ui.MockActivityMonitor'], ['goog.events.EventType', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/mockactivitymonitor_test.js', ['goog.ui.MockActivityMonitorTest'], ['goog.events', 'goog.functions', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalariavisibilityhelper.js', ['goog.ui.ModalAriaVisibilityHelper'], ['goog.a11y.aria', 'goog.a11y.aria.State'], {});
goog.addDependency('ui/modalariavisibilityhelper_test.js', ['goog.ui.ModalAriaVisibilityHelperTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.string', 'goog.testing.testSuite', 'goog.ui.ModalAriaVisibilityHelper'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalpopup.js', ['goog.ui.ModalPopup'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.animationFrame', 'goog.dom.classlist', 'goog.dom.iframe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.fx.Transition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ModalAriaVisibilityHelper', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/modalpopup_test.js', ['goog.ui.ModalPopupTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Transition', 'goog.fx.css3', 'goog.string', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ModalPopup', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/nativebuttonrenderer.js', ['goog.ui.NativeButtonRenderer'], ['goog.asserts', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.ButtonRenderer', 'goog.ui.Component'], {});
goog.addDependency('ui/nativebuttonrenderer_test.js', ['goog.ui.NativeButtonRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/option.js', ['goog.ui.Option'], ['goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/palette.js', ['goog.ui.Palette'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.PaletteRenderer', 'goog.ui.SelectionModel'], {});
goog.addDependency('ui/palette_test.js', ['goog.ui.PaletteTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Palette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/paletterenderer.js', ['goog.ui.PaletteRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.dataset', 'goog.iter', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/paletterenderer_test.js', ['goog.ui.PaletteRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/plaintextspellchecker.js', ['goog.ui.PlainTextSpellChecker'], ['goog.Timer', 'goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.spell.SpellCheck', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/plaintextspellchecker_test.js', ['goog.ui.PlainTextSpellCheckerTest'], ['goog.Timer', 'goog.dom', 'goog.events.KeyCodes', 'goog.spell.SpellCheck', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AbstractSpellChecker', 'goog.ui.PlainTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popup.js', ['goog.ui.Popup'], ['goog.math.Box', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popup_test.js', ['goog.ui.PopupTest'], ['goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite', 'goog.ui.Popup', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupbase.js', ['goog.ui.PopupBase', 'goog.ui.PopupBase.EventType', 'goog.ui.PopupBase.Type'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/popupbase_test.js', ['goog.ui.PopupBaseTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.fx.css3', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupcolorpicker.js', ['goog.ui.PopupColorPicker'], ['goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.ColorPicker', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/popupcolorpicker_test.js', ['goog.ui.PopupColorPickerTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ColorPicker', 'goog.ui.PopupColorPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupdatepicker.js', ['goog.ui.PopupDatePicker'], ['goog.events.EventType', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupdatepicker_test.js', ['goog.ui.PopupDatePickerTest'], ['goog.date.Date', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.style', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupmenu.js', ['goog.ui.PopupMenu'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupmenu_test.js', ['goog.ui.PopupMenuTest'], ['goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning.Corner', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.PopupMenu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/progressbar.js', ['goog.ui.ProgressBar', 'goog.ui.ProgressBar.Orientation'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.RangeModel', 'goog.userAgent'], {});
goog.addDependency('ui/prompt.js', ['goog.ui.Prompt'], ['goog.Timer', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.html.SafeHtml', 'goog.ui.Component', 'goog.ui.Dialog', 'goog.userAgent'], {});
goog.addDependency('ui/prompt_test.js', ['goog.ui.PromptTest'], ['goog.dom.selection', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.functions', 'goog.string', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.BidiInput', 'goog.ui.Dialog', 'goog.ui.Prompt', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/rangemodel.js', ['goog.ui.RangeModel'], ['goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/rangemodel_test.js', ['goog.ui.RangeModelTest'], ['goog.testing.testSuite', 'goog.ui.RangeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ratings.js', ['goog.ui.Ratings', 'goog.ui.Ratings.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.Component'], {});
goog.addDependency('ui/registry.js', ['goog.ui.registry'], ['goog.asserts', 'goog.dom.classlist'], {});
goog.addDependency('ui/registry_test.js', ['goog.ui.registryTest'], ['goog.object', 'goog.testing.testSuite', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/richtextspellchecker.js', ['goog.ui.RichTextSpellChecker'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/richtextspellchecker_test.js', ['goog.ui.RichTextSpellCheckerTest'], ['goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.object', 'goog.spell.SpellCheck', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.RichTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedpanel.js', ['goog.ui.BaseRoundedPanel', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.ui.RoundedPanel.Corner'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.graphics', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/roundedpanel_test.js', ['goog.ui.RoundedPanelTest'], ['goog.testing.testSuite', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedtabrenderer.js', ['goog.ui.RoundedTabRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/scrollfloater.js', ['goog.ui.ScrollFloater', 'goog.ui.ScrollFloater.EventType'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/scrollfloater_test.js', ['goog.ui.ScrollFloaterTest'], ['goog.dom', 'goog.events', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ScrollFloater'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/select.js', ['goog.ui.Select'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SelectionModel', 'goog.ui.registry'], {});
goog.addDependency('ui/select_test.js', ['goog.ui.SelectTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.Select', 'goog.ui.Separator'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmenubutton.js', ['goog.ui.SelectionMenuButton', 'goog.ui.SelectionMenuButton.SelectionState'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/selectionmenubutton_test.js', ['goog.ui.SelectionMenuButtonTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SelectionMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmodel.js', ['goog.ui.SelectionModel'], ['goog.array', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/selectionmodel_test.js', ['goog.ui.SelectionModelTest'], ['goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.SelectionModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/separator.js', ['goog.ui.Separator'], ['goog.a11y.aria', 'goog.asserts', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/serverchart.js', ['goog.ui.ServerChart', 'goog.ui.ServerChart.AxisDisplayType', 'goog.ui.ServerChart.ChartType', 'goog.ui.ServerChart.EncodingType', 'goog.ui.ServerChart.Event', 'goog.ui.ServerChart.LegendPosition', 'goog.ui.ServerChart.MaximumValue', 'goog.ui.ServerChart.MultiAxisAlignment', 'goog.ui.ServerChart.MultiAxisType', 'goog.ui.ServerChart.UriParam', 'goog.ui.ServerChart.UriTooLongEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.string', 'goog.ui.Component'], {});
goog.addDependency('ui/serverchart_test.js', ['goog.ui.ServerChartTest'], ['goog.Uri', 'goog.events', 'goog.testing.testSuite', 'goog.ui.ServerChart'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/slider.js', ['goog.ui.Slider', 'goog.ui.Slider.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/sliderbase.js', ['goog.ui.SliderBase', 'goog.ui.SliderBase.AnimationFactory', 'goog.ui.SliderBase.Orientation'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.fx.AnimationParallelQueue', 'goog.fx.Dragger', 'goog.fx.Transition', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Slide', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.ui.RangeModel'], {});
goog.addDependency('ui/sliderbase_test.js', ['goog.ui.SliderBaseTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Animation', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SliderBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/splitpane.js', ['goog.ui.SplitPane', 'goog.ui.SplitPane.Orientation'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/splitpane_test.js', ['goog.ui.SplitPaneTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.math.Size', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SplitPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/buttonrenderer.js', ['goog.ui.style.app.ButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/style/app/buttonrenderer_test.js', ['goog.ui.style.app.ButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.ButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/menubuttonrenderer.js', ['goog.ui.style.app.MenuButtonRenderer'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuRenderer', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/menubuttonrenderer_test.js', ['goog.ui.style.app.MenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.style.app.MenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer.js', ['goog.ui.style.app.PrimaryActionButtonRenderer'], ['goog.ui.Button', 'goog.ui.registry', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer_test.js', ['goog.ui.style.app.PrimaryActionButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.PrimaryActionButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenu.js', ['goog.ui.SubMenu'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/submenu_test.js', ['goog.ui.SubMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.positioning', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.ui.SubMenuRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenurenderer.js', ['goog.ui.SubMenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/synthetickeyboardevent.js', ['goog.ui.SyntheticKeyboardEvent'], ['goog.events.Event', 'goog.ui.KeyboardEventData'], {});
goog.addDependency('ui/tab.js', ['goog.ui.Tab'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tab_test.js', ['goog.ui.TabTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbar.js', ['goog.ui.TabBar', 'goog.ui.TabBar.Location'], ['goog.ui.Component.EventType', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.Tab', 'goog.ui.TabBarRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tabbar_test.js', ['goog.ui.TabBarTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbarrenderer.js', ['goog.ui.TabBarRenderer'], ['goog.a11y.aria.Role', 'goog.object', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/tabbarrenderer_test.js', ['goog.ui.TabBarRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tablesorter.js', ['goog.ui.TableSorter', 'goog.ui.TableSorter.EventType'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.functions', 'goog.ui.Component'], {});
goog.addDependency('ui/tablesorter_test.js', ['goog.ui.TableSorterTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.TableSorter'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabpane.js', ['goog.ui.TabPane', 'goog.ui.TabPane.Events', 'goog.ui.TabPane.TabLocation', 'goog.ui.TabPane.TabPage', 'goog.ui.TabPaneEvent'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.html.SafeStyleSheet', 'goog.style'], {});
goog.addDependency('ui/tabpane_test.js', ['goog.ui.TabPaneTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.TabPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabrenderer.js', ['goog.ui.TabRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/tabrenderer_test.js', ['goog.ui.TabRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.classlist', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarea.js', ['goog.ui.Textarea', 'goog.ui.Textarea.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Control', 'goog.ui.TextareaRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/textarea_test.js', ['goog.ui.TextareaTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.ui.Textarea', 'goog.ui.TextareaRenderer', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarearenderer.js', ['goog.ui.TextareaRenderer'], ['goog.dom.TagName', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/togglebutton.js', ['goog.ui.ToggleButton'], ['goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbar.js', ['goog.ui.Toolbar'], ['goog.ui.Container', 'goog.ui.ToolbarRenderer'], {});
goog.addDependency('ui/toolbar_test.js', ['goog.ui.ToolbarTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events.EventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Toolbar', 'goog.ui.ToolbarMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarbutton.js', ['goog.ui.ToolbarButton'], ['goog.ui.Button', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarbuttonrenderer.js', ['goog.ui.ToolbarButtonRenderer'], ['goog.ui.CustomButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubutton.js', ['goog.ui.ToolbarColorMenuButton'], ['goog.ui.ColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer.js', ['goog.ui.ToolbarColorMenuButtonRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.MenuButtonRenderer', 'goog.ui.ToolbarMenuButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer_test.js', ['goog.ui.ToolbarColorMenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarmenubutton.js', ['goog.ui.ToolbarMenuButton'], ['goog.ui.MenuButton', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarmenubuttonrenderer.js', ['goog.ui.ToolbarMenuButtonRenderer'], ['goog.ui.MenuButtonRenderer'], {});
goog.addDependency('ui/toolbarrenderer.js', ['goog.ui.ToolbarRenderer'], ['goog.a11y.aria.Role', 'goog.dom.TagName', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer'], {});
goog.addDependency('ui/toolbarselect.js', ['goog.ui.ToolbarSelect'], ['goog.ui.Select', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparator.js', ['goog.ui.ToolbarSeparator'], ['goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparatorrenderer.js', ['goog.ui.ToolbarSeparatorRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuSeparatorRenderer'], {});
goog.addDependency('ui/toolbarseparatorrenderer_test.js', ['goog.ui.ToolbarSeparatorRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.ToolbarSeparator', 'goog.ui.ToolbarSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbartogglebutton.js', ['goog.ui.ToolbarToggleButton'], ['goog.ui.ToggleButton', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tooltip.js', ['goog.ui.Tooltip', 'goog.ui.Tooltip.CursorTooltipPosition', 'goog.ui.Tooltip.ElementTooltipPosition', 'goog.ui.Tooltip.State'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.positioning.ViewportPosition', 'goog.structs.Set', 'goog.style', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/tooltip_test.js', ['goog.ui.TooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.html.testing', 'goog.math.Coordinate', 'goog.positioning.AbsolutePosition', 'goog.style', 'goog.testing.MockClock', 'goog.testing.TestQueue', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.PopupBase', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/basenode.js', ['goog.ui.tree.BaseNode', 'goog.ui.tree.BaseNode.EventType'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom.safe', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/tree/basenode_test.js', ['goog.ui.tree.BaseNodeTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TreeNode'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treecontrol.js', ['goog.ui.tree.TreeControl'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.events.KeyHandler', 'goog.html.SafeHtml', 'goog.log', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeNode', 'goog.ui.tree.TypeAhead', 'goog.userAgent'], {});
goog.addDependency('ui/tree/treecontrol_test.js', ['goog.ui.tree.TreeControlTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treenode.js', ['goog.ui.tree.TreeNode'], ['goog.ui.tree.BaseNode'], {});
goog.addDependency('ui/tree/typeahead.js', ['goog.ui.tree.TypeAhead', 'goog.ui.tree.TypeAhead.Offset'], ['goog.array', 'goog.events.KeyCodes', 'goog.string', 'goog.structs.Trie'], {});
goog.addDependency('ui/tree/typeahead_test.js', ['goog.ui.tree.TypeAheadTest'], ['goog.dom', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TypeAhead'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tristatemenuitem.js', ['goog.ui.TriStateMenuItem', 'goog.ui.TriStateMenuItem.State'], ['goog.dom.classlist', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.TriStateMenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tristatemenuitemrenderer.js', ['goog.ui.TriStateMenuItemRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/twothumbslider.js', ['goog.ui.TwoThumbSlider'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/twothumbslider_test.js', ['goog.ui.TwoThumbSliderTest'], ['goog.testing.testSuite', 'goog.ui.SliderBase', 'goog.ui.TwoThumbSlider'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/zippy.js', ['goog.ui.Zippy', 'goog.ui.Zippy.Events', 'goog.ui.ZippyEvent'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.style'], {});
goog.addDependency('ui/zippy_test.js', ['goog.ui.ZippyTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/uri.js', ['goog.Uri', 'goog.Uri.QueryData'], ['goog.array', 'goog.asserts', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.StandardQueryParam'], {});
goog.addDependency('uri/uri_test.js', ['goog.UriTest'], ['goog.Uri', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/utils.js', ['goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.QueryArray', 'goog.uri.utils.QueryValue', 'goog.uri.utils.StandardQueryParam'], ['goog.array', 'goog.asserts', 'goog.string'], {});
goog.addDependency('uri/utils_test.js', ['goog.uri.utilsTest'], ['goog.functions', 'goog.string', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/adobereader.js', ['goog.userAgent.adobeReader'], ['goog.string', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('useragent/adobereader_test.js', ['goog.userAgent.adobeReaderTest'], ['goog.testing.testSuite', 'goog.userAgent.adobeReader'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/flash.js', ['goog.userAgent.flash'], ['goog.string'], {});
goog.addDependency('useragent/flash_test.js', ['goog.userAgent.flashTest'], ['goog.testing.testSuite', 'goog.userAgent.flash'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/iphoto.js', ['goog.userAgent.iphoto'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/jscript.js', ['goog.userAgent.jscript'], ['goog.string'], {});
goog.addDependency('useragent/jscript_test.js', ['goog.userAgent.jscriptTest'], ['goog.testing.testSuite', 'goog.userAgent.jscript'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/keyboard.js', ['goog.userAgent.keyboard'], ['goog.labs.userAgent.platform'], {});
goog.addDependency('useragent/keyboard_test.js', ['goog.userAgent.keyboardTest'], ['goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent.keyboard', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/platform.js', ['goog.userAgent.platform'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/platform_test.js', ['goog.userAgent.platformTest'], ['goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/product.js', ['goog.userAgent.product'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform', 'goog.userAgent'], {});
goog.addDependency('useragent/product_isversion.js', ['goog.userAgent.product.isVersion'], ['goog.labs.userAgent.platform', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('useragent/product_test.js', ['goog.userAgent.productTest'], ['goog.array', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent.js', ['goog.userAgent'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.util', 'goog.reflect', 'goog.string'], {});
goog.addDependency('useragent/useragent_quirks_test.js', ['goog.userAgentQuirksTest'], ['goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent_test.js', ['goog.userAgentTest'], ['goog.array', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragenttestutil.js', ['goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.object', 'goog.userAgent', 'goog.userAgent.keyboard', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('vec/float32array.js', ['goog.vec.Float32Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float32array_test.js', ['goog.vec.Float32ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float32Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/float64array.js', ['goog.vec.Float64Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float64array_test.js', ['goog.vec.Float64ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float64Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3.js', ['goog.vec.Mat3'], ['goog.vec'], {});
goog.addDependency('vec/mat3_test.js', ['goog.vec.Mat3Test'], ['goog.testing.testSuite', 'goog.vec.Mat3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3d.js', ['goog.vec.mat3d', 'goog.vec.mat3d.Type'], ['goog.vec', 'goog.vec.vec3d.Type'], {});
goog.addDependency('vec/mat3d_test.js', ['goog.vec.mat3dTest'], ['goog.testing.testSuite', 'goog.vec.mat3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3f.js', ['goog.vec.mat3f', 'goog.vec.mat3f.Type'], ['goog.vec', 'goog.vec.vec3f.Type'], {});
goog.addDependency('vec/mat3f_test.js', ['goog.vec.mat3fTest'], ['goog.testing.testSuite', 'goog.vec.mat3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4.js', ['goog.vec.Mat4'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/mat4_test.js', ['goog.vec.Mat4Test'], ['goog.testing.testSuite', 'goog.vec.Mat4', 'goog.vec.Vec3', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4d.js', ['goog.vec.mat4d', 'goog.vec.mat4d.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3d', 'goog.vec.vec4d'], {});
goog.addDependency('vec/mat4d_test.js', ['goog.vec.mat4dTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4d', 'goog.vec.vec3d', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4f.js', ['goog.vec.mat4f', 'goog.vec.mat4f.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3f', 'goog.vec.vec4f'], {});
goog.addDependency('vec/mat4f_test.js', ['goog.vec.mat4fTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4f', 'goog.vec.vec3f', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/quaternion.js', ['goog.vec.Quaternion', 'goog.vec.Quaternion.AnyType'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/quaternion_test.js', ['goog.vec.QuaternionTest'], ['goog.testing.testSuite', 'goog.vec.Mat3', 'goog.vec.Mat4', 'goog.vec.Quaternion', 'goog.vec.Vec3', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/ray.js', ['goog.vec.Ray'], ['goog.vec.Vec3'], {});
goog.addDependency('vec/ray_test.js', ['goog.vec.RayTest'], ['goog.testing.testSuite', 'goog.vec.Ray'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec.js', ['goog.vec', 'goog.vec.AnyType', 'goog.vec.ArrayType', 'goog.vec.Float32', 'goog.vec.Float64', 'goog.vec.Number'], ['goog.vec.Float32Array', 'goog.vec.Float64Array'], {});
goog.addDependency('vec/vec2.js', ['goog.vec.Vec2'], ['goog.vec'], {});
goog.addDependency('vec/vec2_test.js', ['goog.vec.Vec2Test'], ['goog.testing.testSuite', 'goog.vec.Vec2'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2d.js', ['goog.vec.vec2d', 'goog.vec.vec2d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2d_test.js', ['goog.vec.vec2dTest'], ['goog.testing.testSuite', 'goog.vec.vec2d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2f.js', ['goog.vec.vec2f', 'goog.vec.vec2f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2f_test.js', ['goog.vec.vec2fTest'], ['goog.testing.testSuite', 'goog.vec.vec2f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3.js', ['goog.vec.Vec3'], ['goog.vec'], {});
goog.addDependency('vec/vec3_test.js', ['goog.vec.Vec3Test'], ['goog.testing.testSuite', 'goog.vec.Vec3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3d.js', ['goog.vec.vec3d', 'goog.vec.vec3d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3d_test.js', ['goog.vec.vec3dTest'], ['goog.testing.testSuite', 'goog.vec.vec3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3f.js', ['goog.vec.vec3f', 'goog.vec.vec3f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3f_test.js', ['goog.vec.vec3fTest'], ['goog.testing.testSuite', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4.js', ['goog.vec.Vec4'], ['goog.vec'], {});
goog.addDependency('vec/vec4_test.js', ['goog.vec.Vec4Test'], ['goog.testing.testSuite', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4d.js', ['goog.vec.vec4d', 'goog.vec.vec4d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4d_test.js', ['goog.vec.vec4dTest'], ['goog.testing.testSuite', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4f.js', ['goog.vec.vec4f', 'goog.vec.vec4f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4f_test.js', ['goog.vec.vec4fTest'], ['goog.testing.testSuite', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('webgl/webgl.js', ['goog.webgl'], [], {});
goog.addDependency('window/window.js', ['goog.window'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.platform', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('window/window_test.js', ['goog.windowTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.SafeUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.window'], {'lang': 'es6', 'module': 'goog'});

window.polymerSkipLoadingFontRoboto = true;
/** vim: et:ts=4:sw=4:sts=4
 * @license RequireJS 2.3.6 Copyright jQuery Foundation and other contributors.
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
 */
//Not using strict: uneven strict support in browsers, #392, and causes
//problems with requirejs.exec()/transpiler plugins that may not be strict.
/*jslint regexp: true, nomen: true, sloppy: true */
/*global window, navigator, document, importScripts, setTimeout, opera */

var requirejs, require, define;
(function (global, setTimeout) {
    var req, s, head, baseElement, dataMain, src,
        interactiveScript, currentlyAddingScript, mainScript, subPath,
        version = '2.3.6',
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
        jsSuffixRegExp = /\.js$/,
        currDirRegExp = /^\.\//,
        op = Object.prototype,
        ostring = op.toString,
        hasOwn = op.hasOwnProperty,
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
        //PS3 indicates loaded and complete, but need to wait for complete
        //specifically. Sequence is 'loading', 'loaded', execution,
        // then 'complete'. The UA check is unfortunate, but not sure how
        //to feature test w/o causing perf issues.
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
                      /^complete$/ : /^(complete|loaded)$/,
        defContextName = '_',
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
        contexts = {},
        cfg = {},
        globalDefQueue = [],
        useInteractive = false;

    //Could match something like ')//comment', do not lose the prefix to comment.
    function commentReplace(match, singlePrefix) {
        return singlePrefix || '';
    }

    function isFunction(it) {
        return ostring.call(it) === '[object Function]';
    }

    function isArray(it) {
        return ostring.call(it) === '[object Array]';
    }

    /**
     * Helper function for iterating over an array. If the func returns
     * a true value, it will break out of the loop.
     */
    function each(ary, func) {
        if (ary) {
            var i;
            for (i = 0; i < ary.length; i += 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    /**
     * Helper function for iterating over an array backwards. If the func
     * returns a true value, it will break out of the loop.
     */
    function eachReverse(ary, func) {
        if (ary) {
            var i;
            for (i = ary.length - 1; i > -1; i -= 1) {
                if (ary[i] && func(ary[i], i, ary)) {
                    break;
                }
            }
        }
    }

    function hasProp(obj, prop) {
        return hasOwn.call(obj, prop);
    }

    function getOwn(obj, prop) {
        return hasProp(obj, prop) && obj[prop];
    }

    /**
     * Cycles over properties in an object and calls a function for each
     * property value. If the function returns a truthy value, then the
     * iteration is stopped.
     */
    function eachProp(obj, func) {
        var prop;
        for (prop in obj) {
            if (hasProp(obj, prop)) {
                if (func(obj[prop], prop)) {
                    break;
                }
            }
        }
    }

    /**
     * Simple function to mix in properties from source into target,
     * but only if target does not already have a property of the same name.
     */
    function mixin(target, source, force, deepStringMixin) {
        if (source) {
            eachProp(source, function (value, prop) {
                if (force || !hasProp(target, prop)) {
                    if (deepStringMixin && typeof value === 'object' && value &&
                        !isArray(value) && !isFunction(value) &&
                        !(value instanceof RegExp)) {

                        if (!target[prop]) {
                            target[prop] = {};
                        }
                        mixin(target[prop], value, force, deepStringMixin);
                    } else {
                        target[prop] = value;
                    }
                }
            });
        }
        return target;
    }

    //Similar to Function.prototype.bind, but the 'this' object is specified
    //first, since it is easier to read/figure out what 'this' will be.
    function bind(obj, fn) {
        return function () {
            return fn.apply(obj, arguments);
        };
    }

    function scripts() {
        return document.getElementsByTagName('script');
    }

    function defaultOnError(err) {
        throw err;
    }

    //Allow getting a global that is expressed in
    //dot notation, like 'a.b.c'.
    function getGlobal(value) {
        if (!value) {
            return value;
        }
        var g = global;
        each(value.split('.'), function (part) {
            g = g[part];
        });
        return g;
    }

    /**
     * Constructs an error with a pointer to an URL with more information.
     * @param {String} id the error ID that maps to an ID on a web page.
     * @param {String} message human readable error.
     * @param {Error} [err] the original error, if there is one.
     *
     * @returns {Error}
     */
    function makeError(id, msg, err, requireModules) {
        var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
        e.requireType = id;
        e.requireModules = requireModules;
        if (err) {
            e.originalError = err;
        }
        return e;
    }

    if (typeof define !== 'undefined') {
        //If a define is already in play via another AMD loader,
        //do not overwrite.
        return;
    }

    if (typeof requirejs !== 'undefined') {
        if (isFunction(requirejs)) {
            //Do not overwrite an existing requirejs instance.
            return;
        }
        cfg = requirejs;
        requirejs = undefined;
    }

    //Allow for a require config object
    if (typeof require !== 'undefined' && !isFunction(require)) {
        //assume it is a config object.
        cfg = require;
        require = undefined;
    }

    function newContext(contextName) {
        var inCheckLoaded, Module, context, handlers,
            checkLoadedTimeoutId,
            config = {
                //Defaults. Do not set a default for map
                //config to speed up normalize(), which
                //will run faster if there is no default.
                waitSeconds: 7,
                baseUrl: './',
                paths: {},
                bundles: {},
                pkgs: {},
                shim: {},
                config: {}
            },
            registry = {},
            //registry of just enabled modules, to speed
            //cycle breaking code when lots of modules
            //are registered, but not activated.
            enabledRegistry = {},
            undefEvents = {},
            defQueue = [],
            defined = {},
            urlFetched = {},
            bundlesMap = {},
            requireCounter = 1,
            unnormalizedCounter = 1;

        /**
         * Trims the . and .. from an array of path segments.
         * It will keep a leading path segment if a .. will become
         * the first path segment, to help with module name lookups,
         * which act like paths, but can be remapped. But the end result,
         * all paths that use this function should look normalized.
         * NOTE: this method MODIFIES the input array.
         * @param {Array} ary the array of path segments.
         */
        function trimDots(ary) {
            var i, part;
            for (i = 0; i < ary.length; i++) {
                part = ary[i];
                if (part === '.') {
                    ary.splice(i, 1);
                    i -= 1;
                } else if (part === '..') {
                    // If at the start, or previous value is still ..,
                    // keep them so that when converted to a path it may
                    // still work when converted to a path, even though
                    // as an ID it is less than ideal. In larger point
                    // releases, may be better to just kick out an error.
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
                        continue;
                    } else if (i > 0) {
                        ary.splice(i - 1, 2);
                        i -= 2;
                    }
                }
            }
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
        function normalize(name, baseName, applyMap) {
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
                baseParts = (baseName && baseName.split('/')),
                map = config.map,
                starMap = map && map['*'];

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                trimDots(name);
                name = name.join('/');
            }

            //Apply map config if available.
            if (applyMap && map && (baseParts || starMap)) {
                nameParts = name.split('/');

                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join('/');

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));

                            //baseName segment has config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = getOwn(mapValue, nameSegment);
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break outerLoop;
                                }
                            }
                        }
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
                        foundStarMap = getOwn(starMap, nameSegment);
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            // If the name points to a package's name, use
            // the package main instead.
            pkgMain = getOwn(config.pkgs, name);

            return pkgMain ? pkgMain : name;
        }

        function removeScript(name) {
            if (isBrowser) {
                each(scripts(), function (scriptNode) {
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
                        scriptNode.parentNode.removeChild(scriptNode);
                        return true;
                    }
                });
            }
        }

        function hasPathFallback(id) {
            var pathConfig = getOwn(config.paths, id);
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
                //Pop off the first array value, since it failed, and
                //retry
                pathConfig.shift();
                context.require.undef(id);

                //Custom require that does not do map translation, since
                //ID is "absolute", already mapped/resolved.
                context.makeRequire(null, {
                    skipMap: true
                })([id]);

                return true;
            }
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        /**
         * Creates a module mapping that includes plugin prefix, module
         * name, and path. If parentModuleMap is provided it will
         * also normalize the name via require.normalize()
         *
         * @param {String} name the module name
         * @param {String} [parentModuleMap] parent module map
         * for the module name, used to resolve relative names.
         * @param {Boolean} isNormalized: is the ID already normalized.
         * This is true if this call is done for a define() module ID.
         * @param {Boolean} applyMap: apply the map config to the ID.
         * Should only be true if this map is for a dependency.
         *
         * @returns {Object}
         */
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
            var url, pluginModule, suffix, nameParts,
                prefix = null,
                parentName = parentModuleMap ? parentModuleMap.name : null,
                originalName = name,
                isDefine = true,
                normalizedName = '';

            //If no name, then it means it is a require call, generate an
            //internal name.
            if (!name) {
                isDefine = false;
                name = '_@r' + (requireCounter += 1);
            }

            nameParts = splitPrefix(name);
            prefix = nameParts[0];
            name = nameParts[1];

            if (prefix) {
                prefix = normalize(prefix, parentName, applyMap);
                pluginModule = getOwn(defined, prefix);
            }

            //Account for relative paths if there is a base name.
            if (name) {
                if (prefix) {
                    if (isNormalized) {
                        normalizedName = name;
                    } else if (pluginModule && pluginModule.normalize) {
                        //Plugin is loaded, use its normalize method.
                        normalizedName = pluginModule.normalize(name, function (name) {
                            return normalize(name, parentName, applyMap);
                        });
                    } else {
                        // If nested plugin references, then do not try to
                        // normalize, as it will not normalize correctly. This
                        // places a restriction on resourceIds, and the longer
                        // term solution is not to normalize until plugins are
                        // loaded and all normalizations to allow for async
                        // loading of a loader plugin. But for now, fixes the
                        // common uses. Details in #1131
                        normalizedName = name.indexOf('!') === -1 ?
                                         normalize(name, parentName, applyMap) :
                                         name;
                    }
                } else {
                    //A regular module.
                    normalizedName = normalize(name, parentName, applyMap);

                    //Normalized name may be a plugin ID due to map config
                    //application in normalize. The map config values must
                    //already be normalized, so do not need to redo that part.
                    nameParts = splitPrefix(normalizedName);
                    prefix = nameParts[0];
                    normalizedName = nameParts[1];
                    isNormalized = true;

                    url = context.nameToUrl(normalizedName);
                }
            }

            //If the id is a plugin id that cannot be determined if it needs
            //normalization, stamp it with a unique ID so two matching relative
            //ids that may conflict can be separate.
            suffix = prefix && !pluginModule && !isNormalized ?
                     '_unnormalized' + (unnormalizedCounter += 1) :
                     '';

            return {
                prefix: prefix,
                name: normalizedName,
                parentMap: parentModuleMap,
                unnormalized: !!suffix,
                url: url,
                originalName: originalName,
                isDefine: isDefine,
                id: (prefix ?
                        prefix + '!' + normalizedName :
                        normalizedName) + suffix
            };
        }

        function getModule(depMap) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (!mod) {
                mod = registry[id] = new context.Module(depMap);
            }

            return mod;
        }

        function on(depMap, name, fn) {
            var id = depMap.id,
                mod = getOwn(registry, id);

            if (hasProp(defined, id) &&
                    (!mod || mod.defineEmitComplete)) {
                if (name === 'defined') {
                    fn(defined[id]);
                }
            } else {
                mod = getModule(depMap);
                if (mod.error && name === 'error') {
                    fn(mod.error);
                } else {
                    mod.on(name, fn);
                }
            }
        }

        function onError(err, errback) {
            var ids = err.requireModules,
                notified = false;

            if (errback) {
                errback(err);
            } else {
                each(ids, function (id) {
                    var mod = getOwn(registry, id);
                    if (mod) {
                        //Set error on module, so it skips timeout checks.
                        mod.error = err;
                        if (mod.events.error) {
                            notified = true;
                            mod.emit('error', err);
                        }
                    }
                });

                if (!notified) {
                    req.onError(err);
                }
            }
        }

        /**
         * Internal method to transfer globalQueue items to this context's
         * defQueue.
         */
        function takeGlobalQueue() {
            //Push all the globalDefQueue items into the context's defQueue
            if (globalDefQueue.length) {
                each(globalDefQueue, function(queueItem) {
                    var id = queueItem[0];
                    if (typeof id === 'string') {
                        context.defQueueMap[id] = true;
                    }
                    defQueue.push(queueItem);
                });
                globalDefQueue = [];
            }
        }

        handlers = {
            'require': function (mod) {
                if (mod.require) {
                    return mod.require;
                } else {
                    return (mod.require = context.makeRequire(mod.map));
                }
            },
            'exports': function (mod) {
                mod.usingExports = true;
                if (mod.map.isDefine) {
                    if (mod.exports) {
                        return (defined[mod.map.id] = mod.exports);
                    } else {
                        return (mod.exports = defined[mod.map.id] = {});
                    }
                }
            },
            'module': function (mod) {
                if (mod.module) {
                    return mod.module;
                } else {
                    return (mod.module = {
                        id: mod.map.id,
                        uri: mod.map.url,
                        config: function () {
                            return getOwn(config.config, mod.map.id) || {};
                        },
                        exports: mod.exports || (mod.exports = {})
                    });
                }
            }
        };

        function cleanRegistry(id) {
            //Clean up machinery used for waiting modules.
            delete registry[id];
            delete enabledRegistry[id];
        }

        function breakCycle(mod, traced, processed) {
            var id = mod.map.id;

            if (mod.error) {
                mod.emit('error', mod.error);
            } else {
                traced[id] = true;
                each(mod.depMaps, function (depMap, i) {
                    var depId = depMap.id,
                        dep = getOwn(registry, depId);

                    //Only force things that have not completed
                    //being defined, so still in the registry,
                    //and only if it has not been matched up
                    //in the module already.
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
                        if (getOwn(traced, depId)) {
                            mod.defineDep(i, defined[depId]);
                            mod.check(); //pass false?
                        } else {
                            breakCycle(dep, traced, processed);
                        }
                    }
                });
                processed[id] = true;
            }
        }

        function checkLoaded() {
            var err, usingPathFallback,
                waitInterval = config.waitSeconds * 1000,
                //It is possible to disable the wait interval by using waitSeconds of 0.
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
                noLoads = [],
                reqCalls = [],
                stillLoading = false,
                needCycleCheck = true;

            //Do not bother if this call was a result of a cycle break.
            if (inCheckLoaded) {
                return;
            }

            inCheckLoaded = true;

            //Figure out the state of all the modules.
            eachProp(enabledRegistry, function (mod) {
                var map = mod.map,
                    modId = map.id;

                //Skip things that are not enabled or in error state.
                if (!mod.enabled) {
                    return;
                }

                if (!map.isDefine) {
                    reqCalls.push(mod);
                }

                if (!mod.error) {
                    //If the module should be executed, and it has not
                    //been inited and time is up, remember it.
                    if (!mod.inited && expired) {
                        if (hasPathFallback(modId)) {
                            usingPathFallback = true;
                            stillLoading = true;
                        } else {
                            noLoads.push(modId);
                            removeScript(modId);
                        }
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
                        stillLoading = true;
                        if (!map.prefix) {
                            //No reason to keep looking for unfinished
                            //loading. If the only stillLoading is a
                            //plugin resource though, keep going,
                            //because it may be that a plugin resource
                            //is waiting on a non-plugin cycle.
                            return (needCycleCheck = false);
                        }
                    }
                }
            });

            if (expired && noLoads.length) {
                //If wait time expired, throw error of unloaded modules.
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
                err.contextName = context.contextName;
                return onError(err);
            }

            //Not expired, check for a cycle.
            if (needCycleCheck) {
                each(reqCalls, function (mod) {
                    breakCycle(mod, {}, {});
                });
            }

            //If still waiting on loads, and the waiting load is something
            //other than a plugin resource, or there are still outstanding
            //scripts, then just try back later.
            if ((!expired || usingPathFallback) && stillLoading) {
                //Something is still waiting to load. Wait for it, but only
                //if a timeout is not already in effect.
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
                    checkLoadedTimeoutId = setTimeout(function () {
                        checkLoadedTimeoutId = 0;
                        checkLoaded();
                    }, 50);
                }
            }

            inCheckLoaded = false;
        }

        Module = function (map) {
            this.events = getOwn(undefEvents, map.id) || {};
            this.map = map;
            this.shim = getOwn(config.shim, map.id);
            this.depExports = [];
            this.depMaps = [];
            this.depMatched = [];
            this.pluginMaps = {};
            this.depCount = 0;

            /* this.exports this.factory
               this.depMaps = [],
               this.enabled, this.fetched
            */
        };

        Module.prototype = {
            init: function (depMaps, factory, errback, options) {
                options = options || {};

                //Do not do more inits if already done. Can happen if there
                //are multiple define calls for the same module. That is not
                //a normal, common case, but it is also not unexpected.
                if (this.inited) {
                    return;
                }

                this.factory = factory;

                if (errback) {
                    //Register for errors on this module.
                    this.on('error', errback);
                } else if (this.events.error) {
                    //If no errback already, but there are error listeners
                    //on this module, set up an errback to pass to the deps.
                    errback = bind(this, function (err) {
                        this.emit('error', err);
                    });
                }

                //Do a copy of the dependency array, so that
                //source inputs are not modified. For example
                //"shim" deps are passed in here directly, and
                //doing a direct modification of the depMaps array
                //would affect that config.
                this.depMaps = depMaps && depMaps.slice(0);

                this.errback = errback;

                //Indicate this module has be initialized
                this.inited = true;

                this.ignore = options.ignore;

                //Could have option to init this module in enabled mode,
                //or could have been previously marked as enabled. However,
                //the dependencies are not known until init is called. So
                //if enabled previously, now trigger dependencies as enabled.
                if (options.enabled || this.enabled) {
                    //Enable this module and dependencies.
                    //Will call this.check()
                    this.enable();
                } else {
                    this.check();
                }
            },

            defineDep: function (i, depExports) {
                //Because of cycles, defined callback for a given
                //export can be called more than once.
                if (!this.depMatched[i]) {
                    this.depMatched[i] = true;
                    this.depCount -= 1;
                    this.depExports[i] = depExports;
                }
            },

            fetch: function () {
                if (this.fetched) {
                    return;
                }
                this.fetched = true;

                context.startTime = (new Date()).getTime();

                var map = this.map;

                //If the manager is for a plugin managed resource,
                //ask the plugin to load it now.
                if (this.shim) {
                    context.makeRequire(this.map, {
                        enableBuildCallback: true
                    })(this.shim.deps || [], bind(this, function () {
                        return map.prefix ? this.callPlugin() : this.load();
                    }));
                } else {
                    //Regular dependency.
                    return map.prefix ? this.callPlugin() : this.load();
                }
            },

            load: function () {
                var url = this.map.url;

                //Regular dependency.
                if (!urlFetched[url]) {
                    urlFetched[url] = true;
                    context.load(this.map.id, url);
                }
            },

            /**
             * Checks if the module is ready to define itself, and if so,
             * define it.
             */
            check: function () {
                if (!this.enabled || this.enabling) {
                    return;
                }

                var err, cjsModule,
                    id = this.map.id,
                    depExports = this.depExports,
                    exports = this.exports,
                    factory = this.factory;

                if (!this.inited) {
                    // Only fetch if not already in the defQueue.
                    if (!hasProp(context.defQueueMap, id)) {
                        this.fetch();
                    }
                } else if (this.error) {
                    this.emit('error', this.error);
                } else if (!this.defining) {
                    //The factory could trigger another require call
                    //that would result in checking this module to
                    //define itself again. If already in the process
                    //of doing that, skip this work.
                    this.defining = true;

                    if (this.depCount < 1 && !this.defined) {
                        if (isFunction(factory)) {
                            //If there is an error listener, favor passing
                            //to that instead of throwing an error. However,
                            //only do it for define()'d  modules. require
                            //errbacks should not be called for failures in
                            //their callbacks (#699). However if a global
                            //onError is set, use that.
                            if ((this.events.error && this.map.isDefine) ||
                                req.onError !== defaultOnError) {
                                try {
                                    exports = context.execCb(id, factory, depExports, exports);
                                } catch (e) {
                                    err = e;
                                }
                            } else {
                                exports = context.execCb(id, factory, depExports, exports);
                            }

                            // Favor return value over exports. If node/cjs in play,
                            // then will not have a return value anyway. Favor
                            // module.exports assignment over exports object.
                            if (this.map.isDefine && exports === undefined) {
                                cjsModule = this.module;
                                if (cjsModule) {
                                    exports = cjsModule.exports;
                                } else if (this.usingExports) {
                                    //exports already set the defined value.
                                    exports = this.exports;
                                }
                            }

                            if (err) {
                                err.requireMap = this.map;
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
                                err.requireType = this.map.isDefine ? 'define' : 'require';
                                return onError((this.error = err));
                            }

                        } else {
                            //Just a literal value
                            exports = factory;
                        }

                        this.exports = exports;

                        if (this.map.isDefine && !this.ignore) {
                            defined[id] = exports;

                            if (req.onResourceLoad) {
                                var resLoadMaps = [];
                                each(this.depMaps, function (depMap) {
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
                                });
                                req.onResourceLoad(context, this.map, resLoadMaps);
                            }
                        }

                        //Clean up
                        cleanRegistry(id);

                        this.defined = true;
                    }

                    //Finished the define stage. Allow calling check again
                    //to allow define notifications below in the case of a
                    //cycle.
                    this.defining = false;

                    if (this.defined && !this.defineEmitted) {
                        this.defineEmitted = true;
                        this.emit('defined', this.exports);
                        this.defineEmitComplete = true;
                    }

                }
            },

            callPlugin: function () {
                var map = this.map,
                    id = map.id,
                    //Map already normalized the prefix.
                    pluginMap = makeModuleMap(map.prefix);

                //Mark this as a dependency for this plugin, so it
                //can be traced for cycles.
                this.depMaps.push(pluginMap);

                on(pluginMap, 'defined', bind(this, function (plugin) {
                    var load, normalizedMap, normalizedMod,
                        bundleId = getOwn(bundlesMap, this.map.id),
                        name = this.map.name,
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
                        localRequire = context.makeRequire(map.parentMap, {
                            enableBuildCallback: true
                        });

                    //If current map is not normalized, wait for that
                    //normalized name to load instead of continuing.
                    if (this.map.unnormalized) {
                        //Normalize the ID if the plugin allows it.
                        if (plugin.normalize) {
                            name = plugin.normalize(name, function (name) {
                                return normalize(name, parentName, true);
                            }) || '';
                        }

                        //prefix and name should already be normalized, no need
                        //for applying map config again either.
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
                                                      this.map.parentMap,
                                                      true);
                        on(normalizedMap,
                            'defined', bind(this, function (value) {
                                this.map.normalizedMap = normalizedMap;
                                this.init([], function () { return value; }, null, {
                                    enabled: true,
                                    ignore: true
                                });
                            }));

                        normalizedMod = getOwn(registry, normalizedMap.id);
                        if (normalizedMod) {
                            //Mark this as a dependency for this plugin, so it
                            //can be traced for cycles.
                            this.depMaps.push(normalizedMap);

                            if (this.events.error) {
                                normalizedMod.on('error', bind(this, function (err) {
                                    this.emit('error', err);
                                }));
                            }
                            normalizedMod.enable();
                        }

                        return;
                    }

                    //If a paths config, then just load that file instead to
                    //resolve the plugin, as it is built into that paths layer.
                    if (bundleId) {
                        this.map.url = context.nameToUrl(bundleId);
                        this.load();
                        return;
                    }

                    load = bind(this, function (value) {
                        this.init([], function () { return value; }, null, {
                            enabled: true
                        });
                    });

                    load.error = bind(this, function (err) {
                        this.inited = true;
                        this.error = err;
                        err.requireModules = [id];

                        //Remove temp unnormalized modules for this module,
                        //since they will never be resolved otherwise now.
                        eachProp(registry, function (mod) {
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
                                cleanRegistry(mod.map.id);
                            }
                        });

                        onError(err);
                    });

                    //Allow plugins to load other code without having to know the
                    //context or how to 'complete' the load.
                    load.fromText = bind(this, function (text, textAlt) {
                        /*jslint evil: true */
                        var moduleName = map.name,
                            moduleMap = makeModuleMap(moduleName),
                            hasInteractive = useInteractive;

                        //As of 2.1.0, support just passing the text, to reinforce
                        //fromText only being called once per resource. Still
                        //support old style of passing moduleName but discard
                        //that moduleName in favor of the internal ref.
                        if (textAlt) {
                            text = textAlt;
                        }

                        //Turn off interactive script matching for IE for any define
                        //calls in the text, then turn it back on at the end.
                        if (hasInteractive) {
                            useInteractive = false;
                        }

                        //Prime the system by creating a module instance for
                        //it.
                        getModule(moduleMap);

                        //Transfer any config to this other module.
                        if (hasProp(config.config, id)) {
                            config.config[moduleName] = config.config[id];
                        }

                        try {
                            req.exec(text);
                        } catch (e) {
                            return onError(makeError('fromtexteval',
                                             'fromText eval for ' + id +
                                            ' failed: ' + e,
                                             e,
                                             [id]));
                        }

                        if (hasInteractive) {
                            useInteractive = true;
                        }

                        //Mark this as a dependency for the plugin
                        //resource
                        this.depMaps.push(moduleMap);

                        //Support anonymous modules.
                        context.completeLoad(moduleName);

                        //Bind the value of that module to the value for this
                        //resource ID.
                        localRequire([moduleName], load);
                    });

                    //Use parentName here since the plugin's name is not reliable,
                    //could be some weird string with no path that actually wants to
                    //reference the parentName's path.
                    plugin.load(map.name, localRequire, load, config);
                }));

                context.enable(pluginMap, this);
                this.pluginMaps[pluginMap.id] = pluginMap;
            },

            enable: function () {
                enabledRegistry[this.map.id] = this;
                this.enabled = true;

                //Set flag mentioning that the module is enabling,
                //so that immediate calls to the defined callbacks
                //for dependencies do not trigger inadvertent load
                //with the depCount still being zero.
                this.enabling = true;

                //Enable each dependency
                each(this.depMaps, bind(this, function (depMap, i) {
                    var id, mod, handler;

                    if (typeof depMap === 'string') {
                        //Dependency needs to be converted to a depMap
                        //and wired up to this module.
                        depMap = makeModuleMap(depMap,
                                               (this.map.isDefine ? this.map : this.map.parentMap),
                                               false,
                                               !this.skipMap);
                        this.depMaps[i] = depMap;

                        handler = getOwn(handlers, depMap.id);

                        if (handler) {
                            this.depExports[i] = handler(this);
                            return;
                        }

                        this.depCount += 1;

                        on(depMap, 'defined', bind(this, function (depExports) {
                            if (this.undefed) {
                                return;
                            }
                            this.defineDep(i, depExports);
                            this.check();
                        }));

                        if (this.errback) {
                            on(depMap, 'error', bind(this, this.errback));
                        } else if (this.events.error) {
                            // No direct errback on this module, but something
                            // else is listening for errors, so be sure to
                            // propagate the error correctly.
                            on(depMap, 'error', bind(this, function(err) {
                                this.emit('error', err);
                            }));
                        }
                    }

                    id = depMap.id;
                    mod = registry[id];

                    //Skip special modules like 'require', 'exports', 'module'
                    //Also, don't call enable if it is already enabled,
                    //important in circular dependency cases.
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
                        context.enable(depMap, this);
                    }
                }));

                //Enable each plugin that is used in
                //a dependency
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
                    var mod = getOwn(registry, pluginMap.id);
                    if (mod && !mod.enabled) {
                        context.enable(pluginMap, this);
                    }
                }));

                this.enabling = false;

                this.check();
            },

            on: function (name, cb) {
                var cbs = this.events[name];
                if (!cbs) {
                    cbs = this.events[name] = [];
                }
                cbs.push(cb);
            },

            emit: function (name, evt) {
                each(this.events[name], function (cb) {
                    cb(evt);
                });
                if (name === 'error') {
                    //Now that the error handler was triggered, remove
                    //the listeners, since this broken Module instance
                    //can stay around for a while in the registry.
                    delete this.events[name];
                }
            }
        };

        function callGetModule(args) {
            //Skip modules already defined.
            if (!hasProp(defined, args[0])) {
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
            }
        }

        function removeListener(node, func, name, ieName) {
            //Favor detachEvent because of IE9
            //issue, see attachEvent/addEventListener comment elsewhere
            //in this file.
            if (node.detachEvent && !isOpera) {
                //Probably IE. If not it will throw an error, which will be
                //useful to know.
                if (ieName) {
                    node.detachEvent(ieName, func);
                }
            } else {
                node.removeEventListener(name, func, false);
            }
        }

        /**
         * Given an event from a script node, get the requirejs info from it,
         * and then removes the event listeners on the node.
         * @param {Event} evt
         * @returns {Object}
         */
        function getScriptData(evt) {
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
            //all old browsers will be supported, but this one was easy enough
            //to support and still makes sense.
            var node = evt.currentTarget || evt.srcElement;

            //Remove the listeners once here.
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
            removeListener(node, context.onScriptError, 'error');

            return {
                node: node,
                id: node && node.getAttribute('data-requiremodule')
            };
        }

        function intakeDefines() {
            var args;

            //Any defined modules in the global queue, intake them now.
            takeGlobalQueue();

            //Make sure any remaining defQueue items get properly processed.
            while (defQueue.length) {
                args = defQueue.shift();
                if (args[0] === null) {
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
                        args[args.length - 1]));
                } else {
                    //args are id, deps, factory. Should be normalized by the
                    //define() function.
                    callGetModule(args);
                }
            }
            context.defQueueMap = {};
        }

        context = {
            config: config,
            contextName: contextName,
            registry: registry,
            defined: defined,
            urlFetched: urlFetched,
            defQueue: defQueue,
            defQueueMap: {},
            Module: Module,
            makeModuleMap: makeModuleMap,
            nextTick: req.nextTick,
            onError: onError,

            /**
             * Set a configuration for the context.
             * @param {Object} cfg config object to integrate.
             */
            configure: function (cfg) {
                //Make sure the baseUrl ends in a slash.
                if (cfg.baseUrl) {
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
                        cfg.baseUrl += '/';
                    }
                }

                // Convert old style urlArgs string to a function.
                if (typeof cfg.urlArgs === 'string') {
                    var urlArgs = cfg.urlArgs;
                    cfg.urlArgs = function(id, url) {
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
                    };
                }

                //Save off the paths since they require special processing,
                //they are additive.
                var shim = config.shim,
                    objs = {
                        paths: true,
                        bundles: true,
                        config: true,
                        map: true
                    };

                eachProp(cfg, function (value, prop) {
                    if (objs[prop]) {
                        if (!config[prop]) {
                            config[prop] = {};
                        }
                        mixin(config[prop], value, true, true);
                    } else {
                        config[prop] = value;
                    }
                });

                //Reverse map the bundles
                if (cfg.bundles) {
                    eachProp(cfg.bundles, function (value, prop) {
                        each(value, function (v) {
                            if (v !== prop) {
                                bundlesMap[v] = prop;
                            }
                        });
                    });
                }

                //Merge shim
                if (cfg.shim) {
                    eachProp(cfg.shim, function (value, id) {
                        //Normalize the structure
                        if (isArray(value)) {
                            value = {
                                deps: value
                            };
                        }
                        if ((value.exports || value.init) && !value.exportsFn) {
                            value.exportsFn = context.makeShimExports(value);
                        }
                        shim[id] = value;
                    });
                    config.shim = shim;
                }

                //Adjust packages if necessary.
                if (cfg.packages) {
                    each(cfg.packages, function (pkgObj) {
                        var location, name;

                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;

                        name = pkgObj.name;
                        location = pkgObj.location;
                        if (location) {
                            config.paths[name] = pkgObj.location;
                        }

                        //Save pointer to main module ID for pkg name.
                        //Remove leading dot in main, so main paths are normalized,
                        //and remove any trailing .js, since different package
                        //envs have different conventions: some use a module name,
                        //some use a file name.
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
                                     .replace(currDirRegExp, '')
                                     .replace(jsSuffixRegExp, '');
                    });
                }

                //If there are any "waiting to execute" modules in the registry,
                //update the maps for them, since their info, like URLs to load,
                //may have changed.
                eachProp(registry, function (mod, id) {
                    //If module already has init called, since it is too
                    //late to modify them, and ignore unnormalized ones
                    //since they are transient.
                    if (!mod.inited && !mod.map.unnormalized) {
                        mod.map = makeModuleMap(id, null, true);
                    }
                });

                //If a deps array or a config callback is specified, then call
                //require with those args. This is useful when require is defined as a
                //config object before require.js is loaded.
                if (cfg.deps || cfg.callback) {
                    context.require(cfg.deps || [], cfg.callback);
                }
            },

            makeShimExports: function (value) {
                function fn() {
                    var ret;
                    if (value.init) {
                        ret = value.init.apply(global, arguments);
                    }
                    return ret || (value.exports && getGlobal(value.exports));
                }
                return fn;
            },

            makeRequire: function (relMap, options) {
                options = options || {};

                function localRequire(deps, callback, errback) {
                    var id, map, requireMod;

                    if (options.enableBuildCallback && callback && isFunction(callback)) {
                        callback.__requireJsBuild = true;
                    }

                    if (typeof deps === 'string') {
                        if (isFunction(callback)) {
                            //Invalid call
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
                        }

                        //If require|exports|module are requested, get the
                        //value for them from the special handlers. Caveat:
                        //this only works while module is being defined.
                        if (relMap && hasProp(handlers, deps)) {
                            return handlers[deps](registry[relMap.id]);
                        }

                        //Synchronous access to one module. If require.get is
                        //available (as in the Node adapter), prefer that.
                        if (req.get) {
                            return req.get(context, deps, relMap, localRequire);
                        }

                        //Normalize module name, if it contains . or ..
                        map = makeModuleMap(deps, relMap, false, true);
                        id = map.id;

                        if (!hasProp(defined, id)) {
                            return onError(makeError('notloaded', 'Module name "' +
                                        id +
                                        '" has not been loaded yet for context: ' +
                                        contextName +
                                        (relMap ? '' : '. Use require([])')));
                        }
                        return defined[id];
                    }

                    //Grab defines waiting in the global queue.
                    intakeDefines();

                    //Mark all the dependencies as needing to be loaded.
                    context.nextTick(function () {
                        //Some defines could have been added since the
                        //require call, collect them.
                        intakeDefines();

                        requireMod = getModule(makeModuleMap(null, relMap));

                        //Store if map config should be applied to this require
                        //call for dependencies.
                        requireMod.skipMap = options.skipMap;

                        requireMod.init(deps, callback, errback, {
                            enabled: true
                        });

                        checkLoaded();
                    });

                    return localRequire;
                }

                mixin(localRequire, {
                    isBrowser: isBrowser,

                    /**
                     * Converts a module name + .extension into an URL path.
                     * *Requires* the use of a module name. It does not support using
                     * plain URLs like nameToUrl.
                     */
                    toUrl: function (moduleNamePlusExt) {
                        var ext,
                            index = moduleNamePlusExt.lastIndexOf('.'),
                            segment = moduleNamePlusExt.split('/')[0],
                            isRelative = segment === '.' || segment === '..';

                        //Have a file extension alias, and it is not the
                        //dots from a relative path.
                        if (index !== -1 && (!isRelative || index > 1)) {
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
                        }

                        return context.nameToUrl(normalize(moduleNamePlusExt,
                                                relMap && relMap.id, true), ext,  true);
                    },

                    defined: function (id) {
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
                    },

                    specified: function (id) {
                        id = makeModuleMap(id, relMap, false, true).id;
                        return hasProp(defined, id) || hasProp(registry, id);
                    }
                });

                //Only allow undef on top level require calls
                if (!relMap) {
                    localRequire.undef = function (id) {
                        //Bind any waiting define() calls to this context,
                        //fix for #408
                        takeGlobalQueue();

                        var map = makeModuleMap(id, relMap, true),
                            mod = getOwn(registry, id);

                        mod.undefed = true;
                        removeScript(id);

                        delete defined[id];
                        delete urlFetched[map.url];
                        delete undefEvents[id];

                        //Clean queued defines too. Go backwards
                        //in array so that the splices do not
                        //mess up the iteration.
                        eachReverse(defQueue, function(args, i) {
                            if (args[0] === id) {
                                defQueue.splice(i, 1);
                            }
                        });
                        delete context.defQueueMap[id];

                        if (mod) {
                            //Hold on to listeners in case the
                            //module will be attempted to be reloaded
                            //using a different config.
                            if (mod.events.defined) {
                                undefEvents[id] = mod.events;
                            }

                            cleanRegistry(id);
                        }
                    };
                }

                return localRequire;
            },

            /**
             * Called to enable a module if it is still in the registry
             * awaiting enablement. A second arg, parent, the parent module,
             * is passed in for context, when this method is overridden by
             * the optimizer. Not shown here to keep code compact.
             */
            enable: function (depMap) {
                var mod = getOwn(registry, depMap.id);
                if (mod) {
                    getModule(depMap).enable();
                }
            },

            /**
             * Internal method used by environment adapters to complete a load event.
             * A load event could be a script load or just a load pass from a synchronous
             * load call.
             * @param {String} moduleName the name of the module to potentially complete.
             */
            completeLoad: function (moduleName) {
                var found, args, mod,
                    shim = getOwn(config.shim, moduleName) || {},
                    shExports = shim.exports;

                takeGlobalQueue();

                while (defQueue.length) {
                    args = defQueue.shift();
                    if (args[0] === null) {
                        args[0] = moduleName;
                        //If already found an anonymous module and bound it
                        //to this name, then this is some other anon module
                        //waiting for its completeLoad to fire.
                        if (found) {
                            break;
                        }
                        found = true;
                    } else if (args[0] === moduleName) {
                        //Found matching define call for this script!
                        found = true;
                    }

                    callGetModule(args);
                }
                context.defQueueMap = {};

                //Do this after the cycle of callGetModule in case the result
                //of those calls/init calls changes the registry.
                mod = getOwn(registry, moduleName);

                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
                        if (hasPathFallback(moduleName)) {
                            return;
                        } else {
                            return onError(makeError('nodefine',
                                             'No define call for ' + moduleName,
                                             null,
                                             [moduleName]));
                        }
                    } else {
                        //A script that does not call define(), so just simulate
                        //the call for it.
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
                    }
                }

                checkLoaded();
            },

            /**
             * Converts a module name to a file path. Supports cases where
             * moduleName may actually be just an URL.
             * Note that it **does not** call normalize on the moduleName,
             * it is assumed to have already been normalized. This is an
             * internal API, not a public one. Use toUrl for the public API.
             */
            nameToUrl: function (moduleName, ext, skipExt) {
                var paths, syms, i, parentModule, url,
                    parentPath, bundleId,
                    pkgMain = getOwn(config.pkgs, moduleName);

                if (pkgMain) {
                    moduleName = pkgMain;
                }

                bundleId = getOwn(bundlesMap, moduleName);

                if (bundleId) {
                    return context.nameToUrl(bundleId, ext, skipExt);
                }

                //If a colon is in the URL, it indicates a protocol is used and it is just
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
                //or ends with .js, then assume the user meant to use an url and not a module id.
                //The slash is important for protocol-less URLs as well as full paths.
                if (req.jsExtRegExp.test(moduleName)) {
                    //Just a plain path, not module name lookup, so just return it.
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
                    //an extension, this method probably needs to be reworked.
                    url = moduleName + (ext || '');
                } else {
                    //A module that needs to be converted to a path.
                    paths = config.paths;

                    syms = moduleName.split('/');
                    //For each module name segment, see if there is a path
                    //registered for it. Start with most specific name
                    //and work up from it.
                    for (i = syms.length; i > 0; i -= 1) {
                        parentModule = syms.slice(0, i).join('/');

                        parentPath = getOwn(paths, parentModule);
                        if (parentPath) {
                            //If an array, it means there are a few choices,
                            //Choose the one that is desired
                            if (isArray(parentPath)) {
                                parentPath = parentPath[0];
                            }
                            syms.splice(0, i, parentPath);
                            break;
                        }
                    }

                    //Join the path parts together, then figure out if baseUrl is needed.
                    url = syms.join('/');
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
                }

                return config.urlArgs && !/^blob\:/.test(url) ?
                       url + config.urlArgs(moduleName, url) : url;
            },

            //Delegates to req.load. Broken out as a separate function to
            //allow overriding in the optimizer.
            load: function (id, url) {
                req.load(context, id, url);
            },

            /**
             * Executes a module callback function. Broken out as a separate function
             * solely to allow the build system to sequence the files in the built
             * layer in the right sequence.
             *
             * @private
             */
            execCb: function (name, callback, args, exports) {
                return callback.apply(exports, args);
            },

            /**
             * callback for script loads, used to check status of loading.
             *
             * @param {Event} evt the event from the browser for the script
             * that was loaded.
             */
            onScriptLoad: function (evt) {
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
                //all old browsers will be supported, but this one was easy enough
                //to support and still makes sense.
                if (evt.type === 'load' ||
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
                    //Reset interactive script so a script node is not held onto for
                    //to long.
                    interactiveScript = null;

                    //Pull out the name of the module and the context.
                    var data = getScriptData(evt);
                    context.completeLoad(data.id);
                }
            },

            /**
             * Callback for script errors.
             */
            onScriptError: function (evt) {
                var data = getScriptData(evt);
                if (!hasPathFallback(data.id)) {
                    var parents = [];
                    eachProp(registry, function(value, key) {
                        if (key.indexOf('_@r') !== 0) {
                            each(value.depMaps, function(depMap) {
                                if (depMap.id === data.id) {
                                    parents.push(key);
                                    return true;
                                }
                            });
                        }
                    });
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
                                             (parents.length ?
                                             '", needed by: ' + parents.join(', ') :
                                             '"'), evt, [data.id]));
                }
            }
        };

        context.require = context.makeRequire();
        return context;
    }

    /**
     * Main entry point.
     *
     * If the only argument to require is a string, then the module that
     * is represented by that string is fetched for the appropriate context.
     *
     * If the first argument is an array, then it will be treated as an array
     * of dependency string names to fetch. An optional function callback can
     * be specified to execute when all of those dependencies are available.
     *
     * Make a local req variable to help Caja compliance (it assumes things
     * on a require that are not standardized), and to give a short
     * name for minification/local scope use.
     */
    req = requirejs = function (deps, callback, errback, optional) {

        //Find the right context, use default
        var context, config,
            contextName = defContextName;

        // Determine if have config object in the call.
        if (!isArray(deps) && typeof deps !== 'string') {
            // deps is a config object
            config = deps;
            if (isArray(callback)) {
                // Adjust args if there are dependencies
                deps = callback;
                callback = errback;
                errback = optional;
            } else {
                deps = [];
            }
        }

        if (config && config.context) {
            contextName = config.context;
        }

        context = getOwn(contexts, contextName);
        if (!context) {
            context = contexts[contextName] = req.s.newContext(contextName);
        }

        if (config) {
            context.configure(config);
        }

        return context.require(deps, callback, errback);
    };

    /**
     * Support require.config() to make it easier to cooperate with other
     * AMD loaders on globally agreed names.
     */
    req.config = function (config) {
        return req(config);
    };

    /**
     * Execute something after the current tick
     * of the event loop. Override for other envs
     * that have a better solution than setTimeout.
     * @param  {Function} fn function to execute later.
     */
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
        setTimeout(fn, 4);
    } : function (fn) { fn(); };

    /**
     * Export require as a global, but only if it does not already exist.
     */
    if (!require) {
        require = req;
    }

    req.version = version;

    //Used to filter out dependencies that are already paths.
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
    req.isBrowser = isBrowser;
    s = req.s = {
        contexts: contexts,
        newContext: newContext
    };

    //Create default context.
    req({});

    //Exports some context-sensitive methods on global require.
    each([
        'toUrl',
        'undef',
        'defined',
        'specified'
    ], function (prop) {
        //Reference from contexts instead of early binding to default context,
        //so that during builds, the latest instance of the default context
        //with its config gets used.
        req[prop] = function () {
            var ctx = contexts[defContextName];
            return ctx.require[prop].apply(ctx, arguments);
        };
    });

    if (isBrowser) {
        head = s.head = document.getElementsByTagName('head')[0];
        //If BASE tag is in play, using appendChild is a problem for IE6.
        //When that browser dies, this can be removed. Details in this jQuery bug:
        //http://dev.jquery.com/ticket/2709
        baseElement = document.getElementsByTagName('base')[0];
        if (baseElement) {
            head = s.head = baseElement.parentNode;
        }
    }

    /**
     * Any errors that require explicitly generates will be passed to this
     * function. Intercept/override it if you want custom error handling.
     * @param {Error} err the error object.
     */
    req.onError = defaultOnError;

    /**
     * Creates the node for the load command. Only used in browser envs.
     */
    req.createNode = function (config, moduleName, url) {
        var node = config.xhtml ?
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
                document.createElement('script');
        node.type = config.scriptType || 'text/javascript';
        node.charset = 'utf-8';
        node.async = true;
        return node;
    };

    /**
     * Does the request to load a module for the browser case.
     * Make this a separate function to allow other environments
     * to override it.
     *
     * @param {Object} context the require context to find state.
     * @param {String} moduleName the name of the module.
     * @param {Object} url the URL to the module.
     */
    req.load = function (context, moduleName, url) {
        var config = (context && context.config) || {},
            node;
        if (isBrowser) {
            //In the browser so use a script tag
            node = req.createNode(config, moduleName, url);

            node.setAttribute('data-requirecontext', context.contextName);
            node.setAttribute('data-requiremodule', moduleName);

            //Set up load listener. Test attachEvent first because IE9 has
            //a subtle issue in its addEventListener and script onload firings
            //that do not match the behavior of all other browsers with
            //addEventListener support, which fire the onload event for a
            //script right after the script execution. See:
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
            //script execution mode.
            if (node.attachEvent &&
                    //Check if node.attachEvent is artificially added by custom script or
                    //natively supported by browser
                    //read https://github.com/requirejs/requirejs/issues/187
                    //if we can NOT find [native code] then it must NOT natively supported.
                    //in IE8, node.attachEvent does not have toString()
                    //Note the test for "[native code" with no closing brace, see:
                    //https://github.com/requirejs/requirejs/issues/273
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
                    !isOpera) {
                //Probably IE. IE (at least 6-8) do not fire
                //script onload right after executing the script, so
                //we cannot tie the anonymous define call to a name.
                //However, IE reports the script as being in 'interactive'
                //readyState at the time of the define call.
                useInteractive = true;

                node.attachEvent('onreadystatechange', context.onScriptLoad);
                //It would be great to add an error handler here to catch
                //404s in IE9+. However, onreadystatechange will fire before
                //the error handler, so that does not help. If addEventListener
                //is used, then IE will fire error before load, but we cannot
                //use that pathway given the connect.microsoft.com issue
                //mentioned above about not doing the 'script execute,
                //then fire the script load event listener before execute
                //next script' that other browsers do.
                //Best hope: IE10 fixes the issues,
                //and then destroys all installs of IE 6-9.
                //node.attachEvent('onerror', context.onScriptError);
            } else {
                node.addEventListener('load', context.onScriptLoad, false);
                node.addEventListener('error', context.onScriptError, false);
            }
            node.src = url;

            //Calling onNodeCreated after all properties on the node have been
            //set, but before it is placed in the DOM.
            if (config.onNodeCreated) {
                config.onNodeCreated(node, config, moduleName, url);
            }

            //For some cache cases in IE 6-8, the script executes before the end
            //of the appendChild execution, so to tie an anonymous define
            //call to the module name (which is stored on the node), hold on
            //to a reference to this node, but clear after the DOM insertion.
            currentlyAddingScript = node;
            if (baseElement) {
                head.insertBefore(node, baseElement);
            } else {
                head.appendChild(node);
            }
            currentlyAddingScript = null;

            return node;
        } else if (isWebWorker) {
            try {
                //In a web worker, use importScripts. This is not a very
                //efficient use of importScripts, importScripts will block until
                //its script is downloaded and evaluated. However, if web workers
                //are in play, the expectation is that a build has been done so
                //that only one script needs to be loaded anyway. This may need
                //to be reevaluated if other use cases become common.

                // Post a task to the event loop to work around a bug in WebKit
                // where the worker gets garbage-collected after calling
                // importScripts(): https://webkit.org/b/153317
                setTimeout(function() {}, 0);
                importScripts(url);

                //Account for anonymous modules
                context.completeLoad(moduleName);
            } catch (e) {
                context.onError(makeError('importscripts',
                                'importScripts failed for ' +
                                    moduleName + ' at ' + url,
                                e,
                                [moduleName]));
            }
        }
    };

    function getInteractiveScript() {
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
            return interactiveScript;
        }

        eachReverse(scripts(), function (script) {
            if (script.readyState === 'interactive') {
                return (interactiveScript = script);
            }
        });
        return interactiveScript;
    }

    //Look for a data-main script attribute, which could also adjust the baseUrl.
    if (isBrowser && !cfg.skipDataMain) {
        //Figure out baseUrl. Get it from the script tag with require.js in it.
        eachReverse(scripts(), function (script) {
            //Set the 'head' where we can append children by
            //using the script's parent.
            if (!head) {
                head = script.parentNode;
            }

            //Look for a data-main attribute to set main script for the page
            //to load. If it is there, the path to data main becomes the
            //baseUrl, if it is not already set.
            dataMain = script.getAttribute('data-main');
            if (dataMain) {
                //Preserve dataMain in case it is a path (i.e. contains '?')
                mainScript = dataMain;

                //Set final baseUrl if there is not already an explicit one,
                //but only do so if the data-main value is not a loader plugin
                //module ID.
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
                    //Pull off the directory of data-main for use as the
                    //baseUrl.
                    src = mainScript.split('/');
                    mainScript = src.pop();
                    subPath = src.length ? src.join('/')  + '/' : './';

                    cfg.baseUrl = subPath;
                }

                //Strip off any trailing .js since mainScript is now
                //like a module name.
                mainScript = mainScript.replace(jsSuffixRegExp, '');

                //If mainScript is still a path, fall back to dataMain
                if (req.jsExtRegExp.test(mainScript)) {
                    mainScript = dataMain;
                }

                //Put the data-main script in the files to load.
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];

                return true;
            }
        });
    }

    /**
     * The function that handles definitions of modules. Differs from
     * require() in that a string for the module should be the first argument,
     * and the function to execute after dependencies are loaded should
     * return a value to define the module corresponding to the first argument's
     * name.
     */
    define = function (name, deps, callback) {
        var node, context;

        //Allow for anonymous modules
        if (typeof name !== 'string') {
            //Adjust args appropriately
            callback = deps;
            deps = name;
            name = null;
        }

        //This module may not have dependencies
        if (!isArray(deps)) {
            callback = deps;
            deps = null;
        }

        //If no name, and callback is a function, then figure out if it a
        //CommonJS thing with dependencies.
        if (!deps && isFunction(callback)) {
            deps = [];
            //Remove comments from the callback string,
            //look for require calls, and pull them into the dependencies,
            //but only if there are function args.
            if (callback.length) {
                callback
                    .toString()
                    .replace(commentRegExp, commentReplace)
                    .replace(cjsRequireRegExp, function (match, dep) {
                        deps.push(dep);
                    });

                //May be a CommonJS thing even without require calls, but still
                //could use exports, and module. Avoid doing exports and module
                //work though if it just needs require.
                //REQUIRES the function to expect the CommonJS variables in the
                //order listed below.
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
            }
        }

        //If in IE 6-8 and hit an anonymous define() call, do the interactive
        //work.
        if (useInteractive) {
            node = currentlyAddingScript || getInteractiveScript();
            if (node) {
                if (!name) {
                    name = node.getAttribute('data-requiremodule');
                }
                context = contexts[node.getAttribute('data-requirecontext')];
            }
        }

        //Always save off evaluating the def call until the script onload handler.
        //This allows multiple modules to be in a file without prematurely
        //tracing dependencies, and allows for anonymous module support,
        //where the module name is not known until the script onload event
        //occurs. If no context, use the global queue, and get it processed
        //in the onscript load callback.
        if (context) {
            context.defQueue.push([name, deps, callback]);
            context.defQueueMap[name] = true;
        } else {
            globalDefQueue.push([name, deps, callback]);
        }
    };

    define.amd = {
        jQuery: true
    };

    /**
     * Executes the text. Normally just uses eval, but can be modified
     * to use a better, environment-specific call. Only used for transpiling
     * loader plugins, not for plain JS modules.
     * @param {String} text the text to execute/evaluate.
     */
    req.exec = function (text) {
        /*jslint evil: true */
        return eval(text);
    };

    //Set up with config info.
    req(cfg);
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));

// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
// limitations under the License.

!function(){var a={},b={},c={};!function(a,b){function c(a){if("number"==typeof a)return a;var b={};for(var c in a)b[c]=a[c];return b}function d(){this._delay=0,this._endDelay=0,this._fill="none",this._iterationStart=0,this._iterations=1,this._duration=0,this._playbackRate=1,this._direction="normal",this._easing="linear",this._easingFunction=x}function e(){return a.isDeprecated("Invalid timing inputs","2016-03-02","TypeError exceptions will be thrown instead.",!0)}function f(b,c,e){var f=new d;return c&&(f.fill="both",f.duration="auto"),"number"!=typeof b||isNaN(b)?void 0!==b&&Object.getOwnPropertyNames(b).forEach(function(c){if("auto"!=b[c]){if(("number"==typeof f[c]||"duration"==c)&&("number"!=typeof b[c]||isNaN(b[c])))return;if("fill"==c&&-1==v.indexOf(b[c]))return;if("direction"==c&&-1==w.indexOf(b[c]))return;if("playbackRate"==c&&1!==b[c]&&a.isDeprecated("AnimationEffectTiming.playbackRate","2014-11-28","Use Animation.playbackRate instead."))return;f[c]=b[c]}}):f.duration=b,f}function g(a){return"number"==typeof a&&(a=isNaN(a)?{duration:0}:{duration:a}),a}function h(b,c){return b=a.numericTimingToObject(b),f(b,c)}function i(a,b,c,d){return a<0||a>1||c<0||c>1?x:function(e){function f(a,b,c){return 3*a*(1-c)*(1-c)*c+3*b*(1-c)*c*c+c*c*c}if(e<=0){var g=0;return a>0?g=b/a:!b&&c>0&&(g=d/c),g*e}if(e>=1){var h=0;return c<1?h=(d-1)/(c-1):1==c&&a<1&&(h=(b-1)/(a-1)),1+h*(e-1)}for(var i=0,j=1;i<j;){var k=(i+j)/2,l=f(a,c,k);if(Math.abs(e-l)<1e-5)return f(b,d,k);l<e?i=k:j=k}return f(b,d,k)}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return(c+=b*d)-c%d}}function k(a){C||(C=document.createElement("div").style),C.animationTimingFunction="",C.animationTimingFunction=a;var b=C.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");return b}function l(a){if("linear"==a)return x;var b=E.exec(a);if(b)return i.apply(this,b.slice(1).map(Number));var c=F.exec(a);if(c)return j(Number(c[1]),A);var d=G.exec(a);return d?j(Number(d[1]),{start:y,middle:z,end:A}[d[2]]):B[a]||x}function m(a){return Math.abs(n(a)/a.playbackRate)}function n(a){return 0===a.duration||0===a.iterations?0:a.duration*a.iterations}function o(a,b,c){if(null==b)return H;var d=c.delay+a+c.endDelay;return b<Math.min(c.delay,d)?I:b>=Math.min(c.delay+a,d)?J:K}function p(a,b,c,d,e){switch(d){case I:return"backwards"==b||"both"==b?0:null;case K:return c-e;case J:return"forwards"==b||"both"==b?a:null;case H:return null}}function q(a,b,c,d,e){var f=e;return 0===a?b!==I&&(f+=c):f+=d/a,f}function r(a,b,c,d,e,f){var g=a===1/0?b%1:a%1;return 0!==g||c!==J||0===d||0===e&&0!==f||(g=1),g}function s(a,b,c,d){return a===J&&b===1/0?1/0:1===c?Math.floor(d)-1:Math.floor(d)}function t(a,b,c){var d=a;if("normal"!==a&&"reverse"!==a){var e=b;"alternate-reverse"===a&&(e+=1),d="normal",e!==1/0&&e%2!=0&&(d="reverse")}return"normal"===d?c:1-c}function u(a,b,c){var d=o(a,b,c),e=p(a,c.fill,b,d,c.delay);if(null===e)return null;var f=q(c.duration,d,c.iterations,e,c.iterationStart),g=r(f,c.iterationStart,d,c.iterations,e,c.duration),h=s(d,c.iterations,g,f),i=t(c.direction,h,g);return c._easingFunction(i)}var v="backwards|forwards|both|none".split("|"),w="reverse|alternate|alternate-reverse".split("|"),x=function(a){return a};d.prototype={_setMember:function(b,c){this["_"+b]=c,this._effect&&(this._effect._timingInput[b]=c,this._effect._timing=a.normalizeTimingInput(this._effect._timingInput),this._effect.activeDuration=a.calculateActiveDuration(this._effect._timing),this._effect._animation&&this._effect._animation._rebuildUnderlyingAnimation())},get playbackRate(){return this._playbackRate},set delay(a){this._setMember("delay",a)},get delay(){return this._delay},set endDelay(a){this._setMember("endDelay",a)},get endDelay(){return this._endDelay},set fill(a){this._setMember("fill",a)},get fill(){return this._fill},set iterationStart(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+a);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||a<0)&&e())throw new TypeError("duration must be non-negative or auto, received: "+a);this._setMember("duration",a)},get duration(){return this._duration},set direction(a){this._setMember("direction",a)},get direction(){return this._direction},set easing(a){this._easingFunction=l(k(a)),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||a<0)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var y=1,z=.5,A=0,B={ease:i(.25,.1,.25,1),"ease-in":i(.42,0,1,1),"ease-out":i(0,0,.58,1),"ease-in-out":i(.42,0,.58,1),"step-start":j(1,y),"step-middle":j(1,z),"step-end":j(1,A)},C=null,D="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",E=new RegExp("cubic-bezier\\("+D+","+D+","+D+","+D+"\\)"),F=/steps\(\s*(\d+)\s*\)/,G=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,H=0,I=1,J=2,K=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=m,a.calculateIterationProgress=u,a.calculatePhase=o,a.normalizeEasing=k,a.parseEasingFunction=l}(a),function(a,b){function c(a,b){return a in k?k[a][b]||b:b}function d(a){return"display"===a||0===a.lastIndexOf("animation",0)||0===a.lastIndexOf("transition",0)}function e(a,b,e){if(!d(a)){var f=h[a];if(f){i.style[a]=b;for(var g in f){var j=f[g],k=i.style[j];e[j]=c(j,k)}}else e[a]=c(a,b)}}function f(a){var b=[];for(var c in a)if(!(c in["easing","offset","composite"])){var d=a[c];Array.isArray(d)||(d=[d]);for(var e,f=d.length,g=0;g<f;g++)e={},e.offset="offset"in a?a.offset:1==f?1:g/(f-1),"easing"in a&&(e.easing=a.easing),"composite"in a&&(e.composite=a.composite),e[c]=d[g],b.push(e)}return b.sort(function(a,b){return a.offset-b.offset}),b}function g(b){function c(){var a=d.length;null==d[a-1].offset&&(d[a-1].offset=1),a>1&&null==d[0].offset&&(d[0].offset=0);for(var b=0,c=d[0].offset,e=1;e<a;e++){var f=d[e].offset;if(null!=f){for(var g=1;g<e-b;g++)d[b+g].offset=c+(f-c)*g/(e-b);b=e,c=f}}}if(null==b)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||(b=f(b));for(var d=b.map(function(b){var c={};for(var d in b){var f=b[d];if("offset"==d){if(null!=f){if(f=Number(f),!isFinite(f))throw new TypeError("Keyframe offsets must be numbers.");if(f<0||f>1)throw new TypeError("Keyframe offsets must be between 0 and 1.")}}else if("composite"==d){if("add"==f||"accumulate"==f)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};if("replace"!=f)throw new TypeError("Invalid composite mode "+f+".")}else f="easing"==d?a.normalizeEasing(f):""+f;e(d,f,c)}return void 0==c.offset&&(c.offset=null),void 0==c.easing&&(c.easing="linear"),c}),g=!0,h=-1/0,i=0;i<d.length;i++){var j=d[i].offset;if(null!=j){if(j<h)throw new TypeError("Keyframes are not loosely sorted by offset. Sort or specify offsets.");h=j}else g=!1}return d=d.filter(function(a){return a.offset>=0&&a.offset<=1}),g||c(),d}var h={background:["backgroundImage","backgroundPosition","backgroundSize","backgroundRepeat","backgroundAttachment","backgroundOrigin","backgroundClip","backgroundColor"],border:["borderTopColor","borderTopStyle","borderTopWidth","borderRightColor","borderRightStyle","borderRightWidth","borderBottomColor","borderBottomStyle","borderBottomWidth","borderLeftColor","borderLeftStyle","borderLeftWidth"],borderBottom:["borderBottomWidth","borderBottomStyle","borderBottomColor"],borderColor:["borderTopColor","borderRightColor","borderBottomColor","borderLeftColor"],borderLeft:["borderLeftWidth","borderLeftStyle","borderLeftColor"],borderRadius:["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],borderRight:["borderRightWidth","borderRightStyle","borderRightColor"],borderTop:["borderTopWidth","borderTopStyle","borderTopColor"],borderWidth:["borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth"],flex:["flexGrow","flexShrink","flexBasis"],font:["fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineHeight"],margin:["marginTop","marginRight","marginBottom","marginLeft"],outline:["outlineColor","outlineStyle","outlineWidth"],padding:["paddingTop","paddingRight","paddingBottom","paddingLeft"]},i=document.createElementNS("http://www.w3.org/1999/xhtml","div"),j={thin:"1px",medium:"3px",thick:"5px"},k={borderBottomWidth:j,borderLeftWidth:j,borderRightWidth:j,borderTopWidth:j,fontSize:{"xx-small":"60%","x-small":"75%",small:"89%",medium:"100%",large:"120%","x-large":"150%","xx-large":"200%"},fontWeight:{normal:"400",bold:"700"},outlineWidth:j,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=f,a.normalizeKeyframes=g}(a),function(a){var b={};a.isDeprecated=function(a,c,d,e){var f=e?"are":"is",g=new Date,h=new Date(c);return h.setMonth(h.getMonth()+3),!(g<h&&(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,1))},a.deprecated=function(b,c,d,e){var f=e?"are":"is";if(a.isDeprecated(b,c,d,e))throw new Error(b+" "+f+" no longer supported. "+d)}}(a),function(){if(document.documentElement.animate){var c=document.documentElement.animate([],0),d=!0;if(c&&(d=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(a){void 0===c[a]&&(d=!0)})),!d)return}!function(a,b,c){function d(a){for(var b={},c=0;c<a.length;c++)for(var d in a[c])if("offset"!=d&&"easing"!=d&&"composite"!=d){var e={offset:a[c].offset,easing:a[c].easing,value:a[c][d]};b[d]=b[d]||[],b[d].push(e)}for(var f in b){var g=b[f];if(0!=g[0].offset||1!=g[g.length-1].offset)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"Partial keyframes are not supported"}}return b}function e(c){var d=[];for(var e in c)for(var f=c[e],g=0;g<f.length-1;g++){var h=g,i=g+1,j=f[h].offset,k=f[i].offset,l=j,m=k;0==g&&(l=-1/0,0==k&&(i=h)),g==f.length-2&&(m=1/0,1==j&&(h=i)),d.push({applyFrom:l,applyTo:m,startOffset:f[h].offset,endOffset:f[i].offset,easingFunction:a.parseEasingFunction(f[h].easing),property:e,interpolation:b.propertyInterpolation(e,f[h].value,f[i].value)})}return d.sort(function(a,b){return a.startOffset-b.startOffset}),d}b.convertEffectInput=function(c){var f=a.normalizeKeyframes(c),g=d(f),h=e(g);return function(a,c){if(null!=c)h.filter(function(a){return c>=a.applyFrom&&c<a.applyTo}).forEach(function(d){var e=c-d.startOffset,f=d.endOffset-d.startOffset,g=0==f?0:d.easingFunction(e/f);b.apply(a,d.property,d.interpolation(g))});else for(var d in g)"offset"!=d&&"easing"!=d&&"composite"!=d&&b.clear(a,d)}}}(a,b),function(a,b,c){function d(a){return a.replace(/-(.)/g,function(a,b){return b.toUpperCase()})}function e(a,b,c){h[c]=h[c]||[],h[c].push([a,b])}function f(a,b,c){for(var f=0;f<c.length;f++){e(a,b,d(c[f]))}}function g(c,e,f){var g=c;/-/.test(c)&&!a.isDeprecated("Hyphenated property names","2016-03-22","Use camelCase instead.",!0)&&(g=d(c)),"initial"!=e&&"initial"!=f||("initial"==e&&(e=i[g]),"initial"==f&&(f=i[g]));for(var j=e==f?[]:h[g],k=0;j&&k<j.length;k++){var l=j[k][0](e),m=j[k][0](f);if(void 0!==l&&void 0!==m){var n=j[k][1](l,m);if(n){var o=b.Interpolation.apply(null,n);return function(a){return 0==a?e:1==a?f:o(a)}}}}return b.Interpolation(!1,!0,function(a){return a?f:e})}var h={};b.addPropertiesHandler=f;var i={backgroundColor:"transparent",backgroundPosition:"0% 0%",borderBottomColor:"currentColor",borderBottomLeftRadius:"0px",borderBottomRightRadius:"0px",borderBottomWidth:"3px",borderLeftColor:"currentColor",borderLeftWidth:"3px",borderRightColor:"currentColor",borderRightWidth:"3px",borderSpacing:"2px",borderTopColor:"currentColor",borderTopLeftRadius:"0px",borderTopRightRadius:"0px",borderTopWidth:"3px",bottom:"auto",clip:"rect(0px, 0px, 0px, 0px)",color:"black",fontSize:"100%",fontWeight:"400",height:"auto",left:"auto",letterSpacing:"normal",lineHeight:"120%",marginBottom:"0px",marginLeft:"0px",marginRight:"0px",marginTop:"0px",maxHeight:"none",maxWidth:"none",minHeight:"0px",minWidth:"0px",opacity:"1.0",outlineColor:"invert",outlineOffset:"0px",outlineWidth:"3px",paddingBottom:"0px",paddingLeft:"0px",paddingRight:"0px",paddingTop:"0px",right:"auto",strokeDasharray:"none",strokeDashoffset:"0px",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(a,b),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateIterationProgress(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d}b.KeyframeEffect=function(c,e,f,g){var h,i=d(a.normalizeTimingInput(f)),j=b.convertEffectInput(e),k=function(){j(c,h)};return k._update=function(a){return null!==(h=i(a))},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._target=c,k._totalDuration=i._totalDuration,k._id=g,k}}(a,b),function(a,b){a.apply=function(b,c,d){b.style[a.propertyName(c)]=d},a.clear=function(b,c){b.style[a.propertyName(c)]=""}}(b),function(a){window.Element.prototype.animate=function(b,c){var d="";return c&&c.id&&(d=c.id),a.timeline._play(a.KeyframeEffect(this,b,c,d))}}(b),function(a,b){function c(a,b,d){if("number"==typeof a&&"number"==typeof b)return a*(1-d)+b*d;if("boolean"==typeof a&&"boolean"==typeof b)return d<.5?a:b;if(a.length==b.length){for(var e=[],f=0;f<a.length;f++)e.push(c(a[f],b[f],d));return e}throw"Mismatched interpolation arguments "+a+":"+b}a.Interpolation=function(a,b,d){return function(e){return d(c(a,b,e))}}}(b),function(a,b,c){a.sequenceNumber=0;var d=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="finish",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()};b.Animation=function(b){this.id="",b&&b._id&&(this.id=b._id),this._sequenceNumber=a.sequenceNumber++,this._currentTime=0,this._startTime=null,this._paused=!1,this._playbackRate=1,this._inTimeline=!0,this._finishedFlag=!0,this.onfinish=null,this._finishHandlers=[],this._effect=b,this._inEffect=this._effect._update(0),this._idle=!0,this._currentTimePending=!1},b.Animation.prototype={_ensureAlive:function(){this.playbackRate<0&&0===this.currentTime?this._inEffect=this._effect._update(-1):this._inEffect=this._effect._update(this.currentTime),this._inTimeline||!this._inEffect&&this._finishedFlag||(this._inTimeline=!0,b.timeline._animations.push(this))},_tickCurrentTime:function(a,b){a!=this._currentTime&&(this._currentTime=a,this._isFinished&&!b&&(this._currentTime=this._playbackRate>0?this._totalDuration:0),this._ensureAlive())},get currentTime(){return this._idle||this._currentTimePending?null:this._currentTime},set currentTime(a){a=+a,isNaN(a)||(b.restart(),this._paused||null==this._startTime||(this._startTime=this._timeline.currentTime-a/this._playbackRate),this._currentTimePending=!1,this._currentTime!=a&&(this._idle&&(this._idle=!1,this._paused=!0),this._tickCurrentTime(a,!0),b.applyDirtiedAnimation(this)))},get startTime(){return this._startTime},set startTime(a){a=+a,isNaN(a)||this._paused||this._idle||(this._startTime=a,this._tickCurrentTime((this._timeline.currentTime-this._startTime)*this.playbackRate),b.applyDirtiedAnimation(this))},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var c=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&(this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)),null!=c&&(this.currentTime=c)}},get _isFinished(){return!this._idle&&(this._playbackRate>0&&this._currentTime>=this._totalDuration||this._playbackRate<0&&this._currentTime<=0)},get _totalDuration(){return this._effect._totalDuration},get playState(){return this._idle?"idle":null==this._startTime&&!this._paused&&0!=this.playbackRate||this._currentTimePending?"pending":this._paused?"paused":this._isFinished?"finished":"running"},_rewind:function(){if(this._playbackRate>=0)this._currentTime=0;else{if(!(this._totalDuration<1/0))throw new DOMException("Unable to rewind negative playback rate animation with infinite duration","InvalidStateError");this._currentTime=this._totalDuration}},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._rewind(),this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.applyDirtiedAnimation(this)},pause:function(){this._isFinished||this._paused||this._idle?this._idle&&(this._rewind(),this._idle=!1):this._currentTimePending=!0,this._startTime=null,this._paused=!0},finish:function(){this._idle||(this.currentTime=this._playbackRate>0?this._totalDuration:0,this._startTime=this._totalDuration-this.currentTime,this._currentTimePending=!1,b.applyDirtiedAnimation(this))},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._paused=!1,this._finishedFlag=!0,this._currentTime=0,this._startTime=null,this._effect._update(null),b.applyDirtiedAnimation(this))},reverse:function(){this.playbackRate*=-1,this.play()},addEventListener:function(a,b){"function"==typeof b&&"finish"==a&&this._finishHandlers.push(b)},removeEventListener:function(a,b){if("finish"==a){var c=this._finishHandlers.indexOf(b);c>=0&&this._finishHandlers.splice(c,1)}},_fireEvents:function(a){if(this._isFinished){if(!this._finishedFlag){var b=new d(this,this._currentTime,a),c=this._finishHandlers.concat(this.onfinish?[this.onfinish]:[]);setTimeout(function(){c.forEach(function(a){a.call(b.target,b)})},0),this._finishedFlag=!0}}else this._finishedFlag=!1},_tick:function(a,b){this._idle||this._paused||(null==this._startTime?b&&(this.startTime=a-this._currentTime/this.playbackRate):this._isFinished||this._tickCurrentTime((a-this._startTime)*this.playbackRate)),b&&(this._currentTimePending=!1,this._fireEvents(a))},get _needsTick(){return this.playState in{pending:1,running:1}||!this._finishedFlag},_targetAnimations:function(){var a=this._effect._target;return a._activeAnimations||(a._activeAnimations=[]),a._activeAnimations},_markTarget:function(){var a=this._targetAnimations();-1===a.indexOf(this)&&a.push(this)},_unmarkTarget:function(){var a=this._targetAnimations(),b=a.indexOf(this);-1!==b&&a.splice(b,1)}}}(a,b),function(a,b,c){function d(a){var b=j;j=[],a<q.currentTime&&(a=q.currentTime),q._animations.sort(e),q._animations=h(a,!0,q._animations)[0],b.forEach(function(b){b[1](a)}),g(),l=void 0}function e(a,b){return a._sequenceNumber-b._sequenceNumber}function f(){this._animations=[],this.currentTime=window.performance&&performance.now?performance.now():0}function g(){o.forEach(function(a){a()}),o.length=0}function h(a,c,d){p=!0,n=!1,b.timeline.currentTime=a,m=!1;var e=[],f=[],g=[],h=[];return d.forEach(function(b){b._tick(a,c),b._inEffect?(f.push(b._effect),b._markTarget()):(e.push(b._effect),b._unmarkTarget()),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;b._inTimeline=d,d?g.push(b):h.push(b)}),o.push.apply(o,e),o.push.apply(o,f),m&&requestAnimationFrame(function(){}),p=!1,[g,h]}var i=window.requestAnimationFrame,j=[],k=0;window.requestAnimationFrame=function(a){var b=k++;return 0==j.length&&i(d),j.push([b,a]),b},window.cancelAnimationFrame=function(a){j.forEach(function(b){b[0]==a&&(b[1]=function(){})})},f.prototype={_play:function(c){c._timing=a.normalizeTimingInput(c.timing);var d=new b.Animation(c);return d._idle=!1,d._timeline=this,this._animations.push(d),b.restart(),b.applyDirtiedAnimation(d),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.applyDirtiedAnimation=function(a){if(!p){a._markTarget();var c=a._targetAnimations();c.sort(e),h(b.timeline.currentTime,!1,c.slice())[1].forEach(function(a){var b=q._animations.indexOf(a);-1!==b&&q._animations.splice(b,1)}),g()}};var o=[],p=!1,q=new f;b.timeline=q}(a,b),function(a){function b(a,b){var c=a.exec(b);if(c)return c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);if(c)return[c[0],c[1].replace(/^\s*/,"")]}function d(a,d,e){a=c.bind(null,a);for(var f=[];;){var g=a(e);if(!g)return[f,e];if(f.push(g[0]),e=g[1],!(g=b(d,e))||""==g[1])return[f,e];e=g[1]}}function e(a,b){for(var c=0,d=0;d<b.length&&(!/\s|,/.test(b[d])||0!=c);d++)if("("==b[d])c++;else if(")"==b[d]&&(c--,0==c&&d++,c<=0))break;var e=a(b.substr(0,d));return void 0==e?void 0:[e,b.substr(d)]}function f(a,b){for(var c=a,d=b;c&&d;)c>d?c%=d:d%=c;return c=a*b/(c+d)}function g(a){return function(b){var c=a(b);return c&&(c[0]=void 0),c}}function h(a,b){return function(c){return a(c)||[b,c]}}function i(b,c){for(var d=[],e=0;e<b.length;e++){var f=a.consumeTrimmed(b[e],c);if(!f||""==f[0])return;void 0!==f[0]&&d.push(f[0]),c=f[1]}if(""==c)return d}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;k<j;k++){var l=b(d[k%d.length],e[k%e.length]);if(!l)return;g.push(l[0]),h.push(l[1]),i.push(l[2])}return[g,h,function(b){var d=b.map(function(a,b){return i[b](a)}).join(c);return a?a(d):d}]}function k(a,b,c){for(var d=[],e=[],f=[],g=0,h=0;h<c.length;h++)if("function"==typeof c[h]){var i=c[h](a[g],b[g++]);d.push(i[0]),e.push(i[1]),f.push(i[2])}else!function(a){d.push(!1),e.push(!1),f.push(function(){return c[a]})}(h);return[d,e,function(a){for(var b="",c=0;c<a.length;c++)b+=f[c](a[c]);return b}]}a.consumeToken=b,a.consumeTrimmed=c,a.consumeRepeated=d,a.consumeParenthesised=e,a.ignore=g,a.optional=h,a.consumeList=i,a.mergeNestedRepeated=j.bind(null,null),a.mergeWrappedNestedRepeated=j,a.mergeList=k}(b),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);return c?(d.inset=!0,c):(c=a.consumeLengthOrPercent(b))?(d.lengths.push(c[0]),c):(c=a.consumeColor(b),c?(d.color=c[0],c):void 0)}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);if(e&&e[0].length)return[d,e[1]]}function c(c){var d=a.consumeRepeated(b,/^,/,c);if(d&&""==d[1])return d[0]}function d(b,c){for(;b.lengths.length<Math.max(b.lengths.length,c.lengths.length);)b.lengths.push({px:0});for(;c.lengths.length<Math.max(b.lengths.length,c.lengths.length);)c.lengths.push({px:0});if(b.inset==c.inset&&!!b.color==!!c.color){for(var d,e=[],f=[[],0],g=[[],0],h=0;h<b.lengths.length;h++){var i=a.mergeDimensions(b.lengths[h],c.lengths[h],2==h);f[0].push(i[0]),g[0].push(i[1]),e.push(i[2])}if(b.color&&c.color){var j=a.mergeColors(b.color,c.color);f[1]=j[0],g[1]=j[1],d=j[2]}return[f,g,function(a){for(var c=b.inset?"inset ":" ",f=0;f<e.length;f++)c+=e[f](a[0][f])+" ";return d&&(c+=d(a[1])),c}]}}function e(b,c,d,e){function f(a){return{inset:a,color:[0,0,0,0],lengths:[{px:0},{px:0},{px:0},{px:0}]}}for(var g=[],h=[],i=0;i<d.length||i<e.length;i++){var j=d[i]||f(e[i].inset),k=e[i]||f(d[i].inset);g.push(j),h.push(k)}return a.mergeNestedRepeated(b,c,g,h)}var f=e.bind(null,d,", ");a.addPropertiesHandler(c,f,["box-shadow","text-shadow"])}(b),function(a,b){function c(a){return a.toFixed(3).replace(/0+$/,"").replace(/\.$/,"")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){if(/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a))return Number(a)}function f(a,b){return[a,b,c]}function g(a,b){if(0!=a)return i(0,1/0)(a,b)}function h(a,b){return[a,b,function(a){return Math.round(d(1,1/0,a))}]}function i(a,b){return function(e,f){return[e,f,function(e){return c(d(a,b,e))}]}}function j(a){var b=a.trim().split(/\s*[\s,]\s*/);if(0!==b.length){for(var c=[],d=0;d<b.length;d++){var f=e(b[d]);if(void 0===f)return;c.push(f)}return c}}function k(a,b){if(a.length==b.length)return[a,b,function(a){return a.map(c).join(" ")}]}function l(a,b){return[a,b,Math.round]}a.clamp=d,a.addPropertiesHandler(j,k,["stroke-dasharray"]),a.addPropertiesHandler(e,i(0,1/0),["border-image-width","line-height"]),a.addPropertiesHandler(e,i(0,1),["opacity","shape-image-threshold"]),a.addPropertiesHandler(e,g,["flex-grow","flex-shrink"]),a.addPropertiesHandler(e,h,["orphans","widows"]),a.addPropertiesHandler(e,l,["z-index"]),a.parseNumber=e,a.parseNumberList=j,a.mergeNumbers=f,a.numberToString=c}(b),function(a,b){function c(a,b){if("visible"==a||"visible"==b)return[0,1,function(c){return c<=0?a:c>=1?b:"visible"}]}a.addPropertiesHandler(String,c,["visibility"])}(b),function(a,b){function c(a){a=a.trim(),f.fillStyle="#000",f.fillStyle=a;var b=f.fillStyle;if(f.fillStyle="#fff",f.fillStyle=a,b==f.fillStyle){f.fillRect(0,0,1,1);var c=f.getImageData(0,0,1,1).data;f.clearRect(0,0,1,1);var d=c[3]/255;return[c[0]*d,c[1]*d,c[2]*d,d]}}function d(b,c){return[b,c,function(b){function c(a){return Math.max(0,Math.min(255,a))}if(b[3])for(var d=0;d<3;d++)b[d]=Math.round(c(b[d]/b[3]));return b[3]=a.numberToString(a.clamp(0,1,b[3])),"rgba("+b.join(",")+")"}]}var e=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");e.width=e.height=1;var f=e.getContext("2d");a.addPropertiesHandler(c,d,["background-color","border-bottom-color","border-left-color","border-right-color","border-top-color","color","fill","flood-color","lighting-color","outline-color","stop-color","stroke","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(b),function(a,b){function c(a){function b(){var b=h.exec(a);g=b?b[0]:void 0}function c(){var a=Number(g);return b(),a}function d(){if("("!==g)return c();b();var a=f();return")"!==g?NaN:(b(),a)}function e(){for(var a=d();"*"===g||"/"===g;){var c=g;b();var e=d();"*"===c?a*=e:a/=e}return a}function f(){for(var a=e();"+"===g||"-"===g;){var c=g;b();var d=e();"+"===c?a+=d:a-=d}return a}var g,h=/([\+\-\w\.]+|[\(\)\*\/])/g;return b(),f()}function d(a,b){if("0"==(b=b.trim().toLowerCase())&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var d={};b=b.replace(a,function(a){return d[a]=null,"U"+a});for(var e="U("+a.source+")",f=b.replace(/[-+]?(\d*\.)?\d+([Ee][-+]?\d+)?/g,"N").replace(new RegExp("N"+e,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),g=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],h=0;h<g.length;)g[h].test(f)?(f=f.replace(g[h],"$1"),h=0):h++;if("D"==f){for(var i in d){var j=c(b.replace(new RegExp("U"+i,"g"),"").replace(new RegExp(e,"g"),"*0"));if(!isFinite(j))return;d[i]=j}return d}}}function e(a,b){return f(a,b,!0)}function f(b,c,d){var e,f=[];for(e in b)f.push(e);for(e in c)f.indexOf(e)<0&&f.push(e);return b=f.map(function(a){return b[a]||0}),c=f.map(function(a){return c[a]||0}),[b,c,function(b){var c=b.map(function(c,e){return 1==b.length&&d&&(c=Math.max(c,0)),a.numberToString(c)+f[e]}).join(" + ");return b.length>1?"calc("+c+")":c}]}var g="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",h=d.bind(null,new RegExp(g,"g")),i=d.bind(null,new RegExp(g+"|%","g")),j=d.bind(null,/deg|rad|grad|turn/g);a.parseLength=h,a.parseLengthOrPercent=i,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,i),a.parseAngle=j,a.mergeDimensions=f;var k=a.consumeParenthesised.bind(null,h),l=a.consumeRepeated.bind(void 0,k,/^/),m=a.consumeRepeated.bind(void 0,l,/^,/);a.consumeSizePairList=m;var n=function(a){var b=m(a);if(b&&""==b[1])return b[0]},o=a.mergeNestedRepeated.bind(void 0,e," "),p=a.mergeNestedRepeated.bind(void 0,o,",");a.mergeNonNegativeSizePair=o,a.addPropertiesHandler(n,p,["background-size"]),a.addPropertiesHandler(i,e,["border-bottom-width","border-image-width","border-left-width","border-right-width","border-top-width","flex-basis","font-size","height","line-height","max-height","max-width","outline-width","width"]),a.addPropertiesHandler(i,f,["border-bottom-left-radius","border-bottom-right-radius","border-top-left-radius","border-top-right-radius","bottom","left","letter-spacing","margin-bottom","margin-left","margin-right","margin-top","min-height","min-width","outline-offset","padding-bottom","padding-left","padding-right","padding-top","perspective","right","shape-margin","stroke-dashoffset","text-indent","top","vertical-align","word-spacing"])}(b),function(a,b){function c(b){return a.consumeLengthOrPercent(b)||a.consumeToken(/^auto/,b)}function d(b){var d=a.consumeList([a.ignore(a.consumeToken.bind(null,/^rect/)),a.ignore(a.consumeToken.bind(null,/^\(/)),a.consumeRepeated.bind(null,c,/^,/),a.ignore(a.consumeToken.bind(null,/^\)/))],b);if(d&&4==d[0].length)return d[0]}function e(b,c){return"auto"==b||"auto"==c?[!0,!1,function(d){var e=d?b:c;if("auto"==e)return"auto";var f=a.mergeDimensions(e,e);return f[2](f[0])}]:a.mergeDimensions(b,c)}function f(a){return"rect("+a+")"}var g=a.mergeWrappedNestedRepeated.bind(null,f,e,", ");a.parseBox=d,a.mergeBoxes=g,a.addPropertiesHandler(d,g,["clip"])}(b),function(a,b){function c(a){return function(b){var c=0;return a.map(function(a){return a===k?b[c++]:a})}}function d(a){return a}function e(b){if("none"==(b=b.toLowerCase().trim()))return[];for(var c,d=/\s*(\w+)\(([^)]*)\)/g,e=[],f=0;c=d.exec(b);){if(c.index!=f)return;f=c.index+c[0].length;var g=c[1],h=n[g];if(!h)return;var i=c[2].split(","),j=h[0];if(j.length<i.length)return;for(var k=[],o=0;o<j.length;o++){var p,q=i[o],r=j[o];if(void 0===(p=q?{A:function(b){return"0"==b.trim()?m:a.parseAngle(b)},N:a.parseNumber,T:a.parseLengthOrPercent,L:a.parseLength}[r.toUpperCase()](q):{a:m,n:k[0],t:l}[r]))return;k.push(p)}if(e.push({t:g,d:k}),d.lastIndex==b.length)return e}}function f(a){return a.toFixed(6).replace(".000000","")}function g(b,c){if(b.decompositionPair!==c){b.decompositionPair=c;var d=a.makeMatrixDecomposition(b)}if(c.decompositionPair!==b){c.decompositionPair=b;var e=a.makeMatrixDecomposition(c)}return null==d[0]||null==e[0]?[[!1],[!0],function(a){return a?c[0].d:b[0].d}]:(d[0].push(0),e[0].push(1),[d,e,function(b){var c=a.quat(d[0][3],e[0][3],b[5]);return a.composeMatrix(b[0],b[1],b[2],c,b[4]).map(f).join(",")}])}function h(a){return a.replace(/[xy]/,"")}function i(a){return a.replace(/(x|y|z|3d)?$/,"3d")}function j(b,c){var d=a.makeMatrixDecomposition&&!0,e=!1;if(!b.length||!c.length){b.length||(e=!0,b=c,c=[]);for(var f=0;f<b.length;f++){var j=b[f].t,k=b[f].d,l="scale"==j.substr(0,5)?1:0;c.push({t:j,d:k.map(function(a){if("number"==typeof a)return l;var b={};for(var c in a)b[c]=l;return b})})}}var m=function(a,b){return"perspective"==a&&"perspective"==b||("matrix"==a||"matrix3d"==a)&&("matrix"==b||"matrix3d"==b)},o=[],p=[],q=[];if(b.length!=c.length){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]]}else for(var f=0;f<b.length;f++){var j,s=b[f].t,t=c[f].t,u=b[f].d,v=c[f].d,w=n[s],x=n[t];if(m(s,t)){if(!d)return;var r=g([b[f]],[c[f]]);o.push(r[0]),p.push(r[1]),q.push(["matrix",[r[2]]])}else{if(s==t)j=s;else if(w[2]&&x[2]&&h(s)==h(t))j=h(s),u=w[2](u),v=x[2](v);else{if(!w[1]||!x[1]||i(s)!=i(t)){if(!d)return;var r=g(b,c);o=[r[0]],p=[r[1]],q=[["matrix",[r[2]]]];break}j=i(s),u=w[1](u),v=x[1](v)}for(var y=[],z=[],A=[],B=0;B<u.length;B++){var C="number"==typeof u[B]?a.mergeNumbers:a.mergeDimensions,r=C(u[B],v[B]);y[B]=r[0],z[B]=r[1],A.push(r[2])}o.push(y),p.push(z),q.push([j,A])}}if(e){var D=o;o=p,p=D}return[o,p,function(a){return a.map(function(a,b){var c=a.map(function(a,c){return q[b][1][c](a)}).join(",");return"matrix"==q[b][0]&&16==c.split(",").length&&(q[b][0]="matrix3d"),q[b][0]+"("+c+")"}).join(" ")}]}var k=null,l={px:0},m={deg:0},n={matrix:["NNNNNN",[k,k,0,0,k,k,0,0,0,0,1,0,k,k,0,1],d],matrix3d:["NNNNNNNNNNNNNNNN",d],rotate:["A"],rotatex:["A"],rotatey:["A"],rotatez:["A"],rotate3d:["NNNA"],perspective:["L"],scale:["Nn",c([k,k,1]),d],scalex:["N",c([k,1,1]),c([k,1])],scaley:["N",c([1,k,1]),c([1,k])],scalez:["N",c([1,1,k])],scale3d:["NNN",d],skew:["Aa",null,d],skewx:["A",null,c([k,m])],skewy:["A",null,c([m,k])],translate:["Tt",c([k,k,l]),d],translatex:["T",c([k,l,l]),c([k,l])],translatey:["T",c([l,k,l]),c([l,k])],translatez:["L",c([l,l,k])],translate3d:["TTL",d]};a.addPropertiesHandler(e,j,["transform"]),a.transformToSvgMatrix=function(b){var c=a.transformListToMatrix(e(b));return"matrix("+f(c[0])+" "+f(c[1])+" "+f(c[4])+" "+f(c[5])+" "+f(c[12])+" "+f(c[13])+")"}}(b),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b),e[b]=a})}var d={},e={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a},a.unprefixedPropertyName=function(a){return e[a]||a}}(b)}(),function(){if(void 0===document.createElement("div").animate([]).oncancel){var a;if(window.performance&&performance.now)var a=function(){return performance.now()};else var a=function(){return Date.now()};var b=function(a,b,c){this.target=a,this.currentTime=b,this.timelineTime=c,this.type="cancel",this.bubbles=!1,this.cancelable=!1,this.currentTarget=a,this.defaultPrevented=!1,this.eventPhase=Event.AT_TARGET,this.timeStamp=Date.now()},c=window.Element.prototype.animate;window.Element.prototype.animate=function(d,e){var f=c.call(this,d,e);f._cancelHandlers=[],f.oncancel=null;var g=f.cancel;f.cancel=function(){g.call(this);var c=new b(this,null,a()),d=this._cancelHandlers.concat(this.oncancel?[this.oncancel]:[]);setTimeout(function(){d.forEach(function(a){a.call(c.target,c)})},0)};var h=f.addEventListener;f.addEventListener=function(a,b){"function"==typeof b&&"cancel"==a?this._cancelHandlers.push(b):h.call(this,a,b)};var i=f.removeEventListener;return f.removeEventListener=function(a,b){if("cancel"==a){var c=this._cancelHandlers.indexOf(b);c>=0&&this._cancelHandlers.splice(c,1)}else i.call(this,a,b)},f}}}(),function(a){var b=document.documentElement,c=null,d=!1;try{var e=getComputedStyle(b).getPropertyValue("opacity"),f="0"==e?"1":"0";c=b.animate({opacity:[f,f]},{duration:1}),c.currentTime=0,d=getComputedStyle(b).getPropertyValue("opacity")==f}catch(a){}finally{c&&c.cancel()}if(!d){var g=window.Element.prototype.animate;window.Element.prototype.animate=function(b,c){return window.Symbol&&Symbol.iterator&&Array.prototype.from&&b[Symbol.iterator]&&(b=Array.from(b)),Array.isArray(b)||null===b||(b=a.convertToArrayForm(b)),g.call(this,b,c)}}}(a),function(a,b,c){function d(a){var c=b.timeline;c.currentTime=a,c._discardAnimations(),0==c._animations.length?f=!1:requestAnimationFrame(d)}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(c){b.timeline._updateAnimationsPromises(),a(c),b.timeline._updateAnimationsPromises()})},b.AnimationTimeline=function(){this._animations=[],this.currentTime=void 0},b.AnimationTimeline.prototype={getAnimations:function(){return this._discardAnimations(),this._animations.slice()},_updateAnimationsPromises:function(){b.animationsWithPromises=b.animationsWithPromises.filter(function(a){return a._updatePromises()})},_discardAnimations:function(){this._updateAnimationsPromises(),this._animations=this._animations.filter(function(a){return"finished"!=a.playState&&"idle"!=a.playState})},_play:function(a){var c=new b.Animation(a,this);return this._animations.push(c),b.restartWebAnimationsNextTick(),c._updatePromises(),c._animation.play(),c._updatePromises(),c},play:function(a){return a&&a.remove(),this._play(a)}};var f=!1;b.restartWebAnimationsNextTick=function(){f||(f=!0,requestAnimationFrame(d))};var g=new b.AnimationTimeline;b.timeline=g;try{Object.defineProperty(window.document,"timeline",{configurable:!0,get:function(){return g}})}catch(a){}try{window.document.timeline=g}catch(a){}}(0,c),function(a,b,c){b.animationsWithPromises=[],b.Animation=function(b,c){if(this.id="",b&&b._id&&(this.id=b._id),this.effect=b,b&&(b._animation=this),!c)throw new Error("Animation with null timeline is not supported");this._timeline=c,this._sequenceNumber=a.sequenceNumber++,this._holdTime=0,this._paused=!1,this._isGroup=!1,this._animation=null,this._childAnimations=[],this._callback=null,this._oldPlayState="idle",this._rebuildUnderlyingAnimation(),this._animation.cancel(),this._updatePromises()},b.Animation.prototype={_updatePromises:function(){var a=this._oldPlayState,b=this.playState;return this._readyPromise&&b!==a&&("idle"==b?(this._rejectReadyPromise(),this._readyPromise=void 0):"pending"==a?this._resolveReadyPromise():"pending"==b&&(this._readyPromise=void 0)),this._finishedPromise&&b!==a&&("idle"==b?(this._rejectFinishedPromise(),this._finishedPromise=void 0):"finished"==b?this._resolveFinishedPromise():"finished"==a&&(this._finishedPromise=void 0)),this._oldPlayState=this.playState,this._readyPromise||this._finishedPromise},_rebuildUnderlyingAnimation:function(){this._updatePromises();var a,c,d,e,f=!!this._animation;f&&(a=this.playbackRate,c=this._paused,d=this.startTime,e=this.currentTime,this._animation.cancel(),this._animation._wrapper=null,this._animation=null),(!this.effect||this.effect instanceof window.KeyframeEffect)&&(this._animation=b.newUnderlyingAnimationForKeyframeEffect(this.effect),b.bindAnimationForKeyframeEffect(this)),(this.effect instanceof window.SequenceEffect||this.effect instanceof window.GroupEffect)&&(this._animation=b.newUnderlyingAnimationForGroup(this.effect),b.bindAnimationForGroup(this)),this.effect&&this.effect._onsample&&b.bindAnimationForCustomEffect(this),f&&(1!=a&&(this.playbackRate=a),null!==d?this.startTime=d:null!==e?this.currentTime=e:null!==this._holdTime&&(this.currentTime=this._holdTime),c&&this.pause()),this._updatePromises()},_updateChildren:function(){if(this.effect&&"idle"!=this.playState){var a=this.effect._timing.delay;this._childAnimations.forEach(function(c){this._arrangeChildren(c,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c.effect))}.bind(this))}},_setExternalAnimation:function(a){if(this.effect&&this._isGroup)for(var b=0;b<this.effect.children.length;b++)this.effect.children[b]._animation=a,this._childAnimations[b]._setExternalAnimation(a)},_constructChildAnimations:function(){if(this.effect&&this._isGroup){var a=this.effect._timing.delay;this._removeChildAnimations(),this.effect.children.forEach(function(c){var d=b.timeline._play(c);this._childAnimations.push(d),d.playbackRate=this.playbackRate,this._paused&&d.pause(),c._animation=this.effect._animation,this._arrangeChildren(d,a),this.effect instanceof window.SequenceEffect&&(a+=b.groupChildDuration(c))}.bind(this))}},_arrangeChildren:function(a,b){null===this.startTime?a.currentTime=this.currentTime-b/this.playbackRate:a.startTime!==this.startTime+b/this.playbackRate&&(a.startTime=this.startTime+b/this.playbackRate)},get timeline(){return this._timeline},get playState(){return this._animation?this._animation.playState:"idle"},get finished(){return window.Promise?(this._finishedPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._finishedPromise=new Promise(function(a,b){this._resolveFinishedPromise=function(){a(this)},this._rejectFinishedPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"finished"==this.playState&&this._resolveFinishedPromise()),this._finishedPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get ready(){return window.Promise?(this._readyPromise||(-1==b.animationsWithPromises.indexOf(this)&&b.animationsWithPromises.push(this),this._readyPromise=new Promise(function(a,b){this._resolveReadyPromise=function(){a(this)},this._rejectReadyPromise=function(){b({type:DOMException.ABORT_ERR,name:"AbortError"})}}.bind(this)),"pending"!==this.playState&&this._resolveReadyPromise()),this._readyPromise):(console.warn("Animation Promises require JavaScript Promise constructor"),null)},get onfinish(){return this._animation.onfinish},set onfinish(a){this._animation.onfinish="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get oncancel(){return this._animation.oncancel},set oncancel(a){this._animation.oncancel="function"==typeof a?function(b){b.target=this,a.call(this,b)}.bind(this):a},get currentTime(){this._updatePromises();var a=this._animation.currentTime;return this._updatePromises(),a},set currentTime(a){this._updatePromises(),this._animation.currentTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.currentTime=a-c}),this._updatePromises()},get startTime(){return this._animation.startTime},set startTime(a){this._updatePromises(),this._animation.startTime=isFinite(a)?a:Math.sign(a)*Number.MAX_VALUE,this._register(),this._forEachChild(function(b,c){b.startTime=a+c}),this._updatePromises()},get playbackRate(){return this._animation.playbackRate},set playbackRate(a){this._updatePromises();var b=this.currentTime;this._animation.playbackRate=a,this._forEachChild(function(b){b.playbackRate=a}),null!==b&&(this.currentTime=b),this._updatePromises()},play:function(){this._updatePromises(),this._paused=!1,this._animation.play(),-1==this._timeline._animations.indexOf(this)&&this._timeline._animations.push(this),this._register(),b.awaitStartTime(this),this._forEachChild(function(a){var b=a.currentTime;a.play(),a.currentTime=b}),this._updatePromises()},pause:function(){this._updatePromises(),this.currentTime&&(this._holdTime=this.currentTime),this._animation.pause(),this._register(),this._forEachChild(function(a){a.pause()}),this._paused=!0,this._updatePromises()},finish:function(){this._updatePromises(),this._animation.finish(),this._register(),this._updatePromises()},cancel:function(){this._updatePromises(),this._animation.cancel(),this._register(),this._removeChildAnimations(),this._updatePromises()},reverse:function(){this._updatePromises();var a=this.currentTime;this._animation.reverse(),this._forEachChild(function(a){a.reverse()}),null!==a&&(this.currentTime=a),this._updatePromises()},addEventListener:function(a,b){var c=b;"function"==typeof b&&(c=function(a){a.target=this,b.call(this,a)}.bind(this),b._wrapper=c),this._animation.addEventListener(a,c)},removeEventListener:function(a,b){this._animation.removeEventListener(a,b&&b._wrapper||b)},_removeChildAnimations:function(){for(;this._childAnimations.length;)this._childAnimations.pop().cancel()},_forEachChild:function(b){var c=0;if(this.effect.children&&this._childAnimations.length<this.effect.children.length&&this._constructChildAnimations(),this._childAnimations.forEach(function(a){b.call(this,a,c),this.effect instanceof window.SequenceEffect&&(c+=a.effect.activeDuration)}.bind(this)),"pending"!=this.playState){var d=this.effect._timing,e=this.currentTime;null!==e&&(e=a.calculateIterationProgress(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(a,c),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;)i.shift()._updateChildren(),a=!0;return a}var f=function(a){if(a._animation=void 0,a instanceof window.SequenceEffect||a instanceof window.GroupEffect)for(var b=0;b<a.children.length;b++)f(a.children[b])};b.removeMulti=function(a){for(var b=[],c=0;c<a.length;c++){var d=a[c];d._parent?(-1==b.indexOf(d._parent)&&b.push(d._parent),d._parent.children.splice(d._parent.children.indexOf(d),1),d._parent=null,f(d)):d._animation&&d._animation.effect==d&&(d._animation.cancel(),d._animation.effect=new KeyframeEffect(null,[]),d._animation._callback&&(d._animation._callback._animation=null),d._animation._rebuildUnderlyingAnimation(),f(d))}for(c=0;c<b.length;c++)b[c]._rebuild()},b.KeyframeEffect=function(b,c,e,f){return this.target=b,this._parent=null,e=a.numericTimingToObject(e),this._timingInput=a.cloneTimingInput(e),this._timing=a.normalizeTimingInput(e),this.timing=a.makeTiming(e,!1,this),this.timing._effect=this,"function"==typeof c?(a.deprecated("Custom KeyframeEffect","2015-06-22","Use KeyframeEffect.onsample instead."),this._normalizedKeyframes=c):this._normalizedKeyframes=new d(c),this._keyframes=c,this.activeDuration=a.calculateActiveDuration(this._timing),this._id=f,this},b.KeyframeEffect.prototype={getFrames:function(){return"function"==typeof this._normalizedKeyframes?this._normalizedKeyframes:this._normalizedKeyframes._frames},set onsample(a){if("function"==typeof this.getFrames())throw new Error("Setting onsample on custom effect KeyframeEffect is not supported.");this._onsample=a,this._animation&&this._animation._rebuildUnderlyingAnimation()},get parent(){return this._parent},clone:function(){if("function"==typeof this.getFrames())throw new Error("Cloning custom effects is not supported.");var b=new KeyframeEffect(this.target,[],a.cloneTimingInput(this._timingInput),this._id);return b._normalizedKeyframes=this._normalizedKeyframes,b._keyframes=this._keyframes,b},remove:function(){b.removeMulti([this])}};var g=Element.prototype.animate;Element.prototype.animate=function(a,c){var d="";return c&&c.id&&(d=c.id),b.timeline._play(new b.KeyframeEffect(this,a,c,d))};var h=document.createElementNS("http://www.w3.org/1999/xhtml","div");b.newUnderlyingAnimationForKeyframeEffect=function(a){if(a){var b=a.target||h,c=a._keyframes;"function"==typeof c&&(c=[]);var d=a._timingInput;d.id=a._id}else var b=h,c=[],d=0;return g.apply(b,[c,d])},b.bindAnimationForKeyframeEffect=function(a){a.effect&&"function"==typeof a.effect._normalizedKeyframes&&b.bindAnimationForCustomEffect(a)};var i=[];b.awaitStartTime=function(a){null===a.startTime&&a._isGroup&&(0==i.length&&requestAnimationFrame(e),i.push(a))};var j=window.getComputedStyle;Object.defineProperty(window,"getComputedStyle",{configurable:!0,enumerable:!0,value:function(){b.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),b.timeline._updateAnimationsPromises(),a}}),window.KeyframeEffect=b.KeyframeEffect,window.Element.prototype.getAnimations=function(){return document.timeline.getAnimations().filter(function(a){return null!==a.effect&&a.effect.target==this}.bind(this))}}(a,c),function(a,b,c){function d(a){a._registered||(a._registered=!0,g.push(a),h||(h=!0,requestAnimationFrame(e)))}function e(a){var b=g;g=[],b.sort(function(a,b){return a._sequenceNumber-b._sequenceNumber}),b=b.filter(function(a){a();var b=a._animation?a._animation.playState:"idle";return"running"!=b&&"pending"!=b&&(a._registered=!1),a._registered}),g.push.apply(g,b),g.length?(h=!0,requestAnimationFrame(e)):h=!1}var f=(document.createElementNS("http://www.w3.org/1999/xhtml","div"),0);b.bindAnimationForCustomEffect=function(b){var c,e=b.effect.target,g="function"==typeof b.effect.getFrames();c=g?b.effect.getFrames():b.effect._onsample;var h=b.effect.timing,i=null;h=a.normalizeTimingInput(h);var j=function(){var d=j._animation?j._animation.currentTime:null;null!==d&&(d=a.calculateIterationProgress(a.calculateActiveDuration(h),d,h),isNaN(d)&&(d=null)),d!==i&&(g?c(d,e,b.effect):c(d,b.effect,b.effect._animation)),i=d};j._animation=b,j._registered=!1,j._sequenceNumber=f++,b._callback=j,d(j)};var g=[],h=!1;b.Animation.prototype._register=function(){this._callback&&d(this._callback)}}(a,c),function(a,b,c){function d(a){return a._timing.delay+a.activeDuration+a._timing.endDelay}function e(b,c,d){this._id=d,this._parent=null,this.children=b||[],this._reparent(this.children),c=a.numericTimingToObject(c),this._timingInput=a.cloneTimingInput(c),this._timing=a.normalizeTimingInput(c,!0),this.timing=a.makeTiming(c,!0,this),this.timing._effect=this,"auto"===this._timing.duration&&(this._timing.duration=this.activeDuration)}window.SequenceEffect=function(){e.apply(this,arguments)},window.GroupEffect=function(){e.apply(this,arguments)},e.prototype={_isAncestor:function(a){for(var b=this;null!==b;){if(b==a)return!0;b=b._parent}return!1},_rebuild:function(){for(var a=this;a;)"auto"===a.timing.duration&&(a._timing.duration=a.activeDuration),a=a._parent;this._animation&&this._animation._rebuildUnderlyingAnimation()},_reparent:function(a){b.removeMulti(a);for(var c=0;c<a.length;c++)a[c]._parent=this},_putChild:function(a,b){for(var c=b?"Cannot append an ancestor or self":"Cannot prepend an ancestor or self",d=0;d<a.length;d++)if(this._isAncestor(a[d]))throw{type:DOMException.HIERARCHY_REQUEST_ERR,name:"HierarchyRequestError",message:c};for(var d=0;d<a.length;d++)b?this.children.push(a[d]):this.children.unshift(a[d]);this._reparent(a),this._rebuild()},append:function(){this._putChild(arguments,!0)},prepend:function(){this._putChild(arguments,!1)},get parent(){return this._parent},get firstChild(){return this.children.length?this.children[0]:null},get lastChild(){return this.children.length?this.children[this.children.length-1]:null},clone:function(){for(var b=a.cloneTimingInput(this._timingInput),c=[],d=0;d<this.children.length;d++)c.push(this.children[d].clone());return this instanceof GroupEffect?new GroupEffect(c,b):new SequenceEffect(c,b)},remove:function(){b.removeMulti([this])}},window.SequenceEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.SequenceEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a+=d(b)}),Math.max(a,0)}}),window.GroupEffect.prototype=Object.create(e.prototype),Object.defineProperty(window.GroupEffect.prototype,"activeDuration",{get:function(){var a=0;return this.children.forEach(function(b){a=Math.max(a,d(b))}),a}}),b.newUnderlyingAnimationForGroup=function(c){var d,e=null,f=function(b){var c=d._wrapper;if(c&&"pending"!=c.playState&&c.effect)return null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateIterationProgress(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0},g=new KeyframeEffect(null,[],c._timing,c._id);return g.onsample=f,d=b.timeline._play(g)},b.bindAnimationForGroup=function(a){a._animation._wrapper=a,a._isGroup=!0,b.awaitStartTime(a),a._constructChildAnimations(),a._setExternalAnimation(a)},b.groupChildDuration=d}(a,c)}();

!(function(){
/*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
function t(t,e,n,i){var r,o=arguments.length,a=o<3?e:null===i?i=Object.getOwnPropertyDescriptor(e,n):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)a=Reflect.decorate(t,e,n,i);else for(var s=t.length-1;s>=0;s--)(r=t[s])&&(a=(o<3?r(a):o>3?r(e,n,a):r(e,n))||a);return o>3&&a&&Object.defineProperty(e,n,a),a}function e(t,e){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(t,e)}function n(t,e,n,i){return new(n||(n=Promise))((function(r,o){function a(t){try{l(i.next(t))}catch(t){o(t)}}function s(t){try{l(i.throw(t))}catch(t){o(t)}}function l(t){t.done?r(t.value):(function e(t){return t instanceof n?t:new n((function(e){e(t)}))})(t.value).then(a,s)}l((i=i.apply(t,e||[])).next())}))}
/**
     * @license
     * Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
     * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
     * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
     * Google as part of the polymer project is also subject to an additional IP
     * rights grant found at http://polymer.github.io/PATENTS.txt
     */function i(t){return e=>{if(t)if(e.hasOwnProperty("is")){if(t!==e.is)throw new Error(`custom element tag names do not match: (${t} !== ${e.is})`)}else Object.defineProperty(e,"is",{value:t});window.customElements.define(e.is,e)}}function r(t,e,n){t.constructor.hasOwnProperty("properties")||Object.defineProperty(t.constructor,"properties",{value:{}}),t.constructor.properties[e]=Object.assign({},t.constructor.properties[e],n)}function o(t){return(e,n)=>{r(e,n,t)}}function a(...t){return(e,n)=>{e.constructor.hasOwnProperty("observers")||Object.defineProperty(e.constructor,"observers",{value:[]}),e.constructor.observers.push(`${n}(${t.join(",")})`)}}function s(t,...e){return(n,i,o)=>{const a=`__compute${i}`;Object.defineProperty(n,a,{value:o.get}),o.get=void 0,r(n,i,{computed:`${a}(${[t,...e].join(",")})`})}}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */window.JSCompiler_renameProperty=function(t,e){return t};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let l,c,u=/(url\()([^)]*)(\))/g,h=/(^\/[^\/])|(^#)|(^[\w-\d]*:)/;function d(t,e){if(t&&h.test(t))return t;if("//"===t)return t;if(void 0===l){l=!1;try{const t=new URL("b","http://a");t.pathname="c%20d",l="http://a/c%20d"===t.href}catch(t){}}if(e||(e=document.baseURI||window.location.href),l)try{return new URL(t,e).href}catch(e){return t}return c||(c=document.implementation.createHTMLDocument("temp"),c.base=c.createElement("base"),c.head.appendChild(c.base),c.anchor=c.createElement("a"),c.body.appendChild(c.anchor)),c.base.href=e,c.anchor.href=t,c.anchor.href||t}function p(t,e){return t.replace(u,(function(t,n,i,r){return n+"'"+d(i.replace(/["']/g,""),e)+"'"+r}))}function f(t){return t.substring(0,t.lastIndexOf("/")+1)}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const m=!window.ShadyDOM||!window.ShadyDOM.inUse;Boolean(!window.ShadyCSS||window.ShadyCSS.nativeCss);const g=m&&"adoptedStyleSheets"in Document.prototype&&"replaceSync"in CSSStyleSheet.prototype&&(()=>{try{const t=new CSSStyleSheet;t.replaceSync("");const e=document.createElement("div");return e.attachShadow({mode:"open"}),e.shadowRoot.adoptedStyleSheets=[t],e.shadowRoot.adoptedStyleSheets[0]===t}catch(t){return!1}})();let _=window.Polymer&&window.Polymer.rootPath||f(document.baseURI||window.location.href),y=window.Polymer&&window.Polymer.sanitizeDOMValue||void 0,v=window.Polymer&&window.Polymer.setPassiveTouchGestures||!1,b=window.Polymer&&window.Polymer.strictTemplatePolicy||!1,x=window.Polymer&&window.Polymer.allowTemplateFromDomModule||!1,w=window.Polymer&&window.Polymer.legacyOptimizations||!1,S=window.Polymer&&window.Polymer.legacyWarnings||!1,M=window.Polymer&&window.Polymer.syncInitialRender||!1,E=window.Polymer&&window.Polymer.legacyUndefined||!1,T=window.Polymer&&window.Polymer.orderedComputed||!1,A=window.Polymer&&window.Polymer.removeNestedTemplates||!1,C=window.Polymer&&window.Polymer.fastDomIf||!1,k=window.Polymer&&window.Polymer.suppressTemplateNotifications||!1,L=window.Polymer&&window.Polymer.legacyNoObservedAttributes||!1,P=window.Polymer&&window.Polymer.useAdoptedStyleSheetsWithBuiltCSS||!1,I=0;const N=function(t){let e=t.__mixinApplications;e||(e=new WeakMap,t.__mixinApplications=e);let n=I++;return function i(r){let o=r.__mixinSet;if(o&&o[n])return r;let a=e,s=a.get(r);if(!s){s=t(r),a.set(r,s);let e=Object.create(s.__mixinSet||o||null);e[n]=!0,s.__mixinSet=e}return s}};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let O={},R={};function z(t,e){O[t]=R[t.toLowerCase()]=e}function D(t){return O[t]||R[t.toLowerCase()]}class B extends HTMLElement{static get observedAttributes(){return["id"]}static import(t,e){if(t){let n=D(t);return n&&e?n.querySelector(e):n}return null}attributeChangedCallback(t,e,n,i){e!==n&&this.register()}get assetpath(){if(!this.__assetpath){const t=window.HTMLImports&&HTMLImports.importForElement?HTMLImports.importForElement(this)||document:this.ownerDocument,e=d(this.getAttribute("assetpath")||"",t.baseURI);this.__assetpath=f(e)}return this.__assetpath}register(t){if(t=t||this.id){if(b&&void 0!==D(t))throw z(t,null),new Error(`strictTemplatePolicy: dom-module ${t} re-registered`);this.id=t,z(t,this),(function e(t){t.querySelector("style")&&console.warn("dom-module %s has style outside template",t.id)})(this)}}}B.prototype.modules=O,customElements.define("dom-module",B);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const H="shady-unscoped";function F(t){return B.import(t)}function V(t){const e=p((t.body?t.body:t).textContent,t.baseURI),n=document.createElement("style");return n.textContent=e,n}function j(t){const e=t.trim().split(/\s+/),n=[];for(let t=0;t<e.length;t++)n.push(...U(e[t]));return n}function U(t){const e=F(t);if(!e)return console.warn("Could not find style data in module named",t),[];if(void 0===e._styles){const t=[];t.push(...W(e));const n=e.querySelector("template");n&&t.push(...G(n,e.assetpath)),e._styles=t}return e._styles}function G(t,e){if(!t._styles){const n=[],i=t.content.querySelectorAll("style");for(let t=0;t<i.length;t++){let r=i[t],o=r.getAttribute("include");o&&n.push(...j(o).filter((function(t,e,n){return n.indexOf(t)===e}))),e&&(r.textContent=p(r.textContent,e)),n.push(r)}t._styles=n}return t._styles}function W(t){const e=[],n=t.querySelectorAll("link[rel=import][type~=css]");for(let t=0;t<n.length;t++){let i=n[t];if(i.import){const t=i.import,n=i.hasAttribute(H);if(n&&!t._unscopedStyle){const e=V(t);e.setAttribute(H,""),t._unscopedStyle=e}else t._style||(t._style=V(t));e.push(n?t._unscopedStyle:t._style)}}return e}function q(t){let e=F(t);if(e&&void 0===e._cssText){let t=(function n(t){let e="",n=W(t);for(let t=0;t<n.length;t++)e+=n[t].textContent;return e}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */)(e),n=e.querySelector("template");n&&(t+=(function i(t,e){let n="";const i=G(t,e);for(let t=0;t<i.length;t++){let e=i[t];e.parentNode&&e.parentNode.removeChild(e),n+=e.textContent}return n})(n,e.assetpath)),e._cssText=t||null}return e||console.warn("Could not find style data in module named",t),e&&e._cssText||""}const Y=window.ShadyDOM&&window.ShadyDOM.noPatch&&window.ShadyDOM.wrap?window.ShadyDOM.wrap:window.ShadyDOM?t=>ShadyDOM.patch(t):t=>t;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function X(t){return t.indexOf(".")>=0}function $(t){let e=t.indexOf(".");return-1===e?t:t.slice(0,e)}function K(t,e){return 0===t.indexOf(e+".")}function Z(t,e){return 0===e.indexOf(t+".")}function J(t,e,n){return e+n.slice(t.length)}function Q(t,e){return t===e||K(t,e)||Z(t,e)}function tt(t){if(Array.isArray(t)){let e=[];for(let n=0;n<t.length;n++){let i=t[n].toString().split(".");for(let t=0;t<i.length;t++)e.push(i[t])}return e.join(".")}return t}function et(t){return Array.isArray(t)?tt(t).split("."):t.toString().split(".")}function nt(t,e,n){let i=t,r=et(e);for(let t=0;t<r.length;t++){if(!i)return;i=i[r[t]]}return n&&(n.path=r.join(".")),i}function it(t,e,n){let i=t,r=et(e),o=r[r.length-1];if(r.length>1){for(let t=0;t<r.length-1;t++)if(i=i[r[t]],!i)return;i[o]=n}else i[e]=n;return r.join(".")}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const rt={},ot=/-[a-z]/g,at=/([A-Z])/g;function st(t){return rt[t]||(rt[t]=t.indexOf("-")<0?t:t.replace(ot,(t=>t[1].toUpperCase())))}function lt(t){return rt[t]||(rt[t]=t.replace(at,"-$1").toLowerCase())}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let ct=0,ut=0,ht=[],dt=0,pt=!1,ft=document.createTextNode("");new window.MutationObserver((function mt(){pt=!1;const t=ht.length;for(let e=0;e<t;e++){let t=ht[e];if(t)try{t()}catch(t){setTimeout((()=>{throw t}))}}ht.splice(0,t),ut+=t})).observe(ft,{characterData:!0});const gt={after:t=>({run:e=>window.setTimeout(e,t),cancel(t){window.clearTimeout(t)}}),run:(t,e)=>window.setTimeout(t,e),cancel(t){window.clearTimeout(t)}},_t={run:t=>window.requestAnimationFrame(t),cancel(t){window.cancelAnimationFrame(t)}},yt={run:t=>window.requestIdleCallback?window.requestIdleCallback(t):window.setTimeout(t,16),cancel(t){window.cancelIdleCallback?window.cancelIdleCallback(t):window.clearTimeout(t)}},vt={run:t=>(pt||(pt=!0,ft.textContent=dt++),ht.push(t),ct++),cancel(t){const e=t-ut;if(e>=0){if(!ht[e])throw new Error("invalid async handle: "+t);ht[e]=null}}},bt=vt,xt=N((t=>class extends t{static createProperties(t){const e=this.prototype;for(let n in t)n in e||e._createPropertyAccessor(n)}static attributeNameForProperty(t){return t.toLowerCase()}static typeForProperty(t){}_createPropertyAccessor(t,e){this._addPropertyToAttributeMap(t),this.hasOwnProperty(JSCompiler_renameProperty("__dataHasAccessor",this))||(this.__dataHasAccessor=Object.assign({},this.__dataHasAccessor)),this.__dataHasAccessor[t]||(this.__dataHasAccessor[t]=!0,this._definePropertyAccessor(t,e))}_addPropertyToAttributeMap(t){this.hasOwnProperty(JSCompiler_renameProperty("__dataAttributes",this))||(this.__dataAttributes=Object.assign({},this.__dataAttributes));let e=this.__dataAttributes[t];return e||(e=this.constructor.attributeNameForProperty(t),this.__dataAttributes[e]=t),e}_definePropertyAccessor(t,e){Object.defineProperty(this,t,{get(){return this.__data[t]},set:e?function(){}:function(e){this._setPendingProperty(t,e,!0)&&this._invalidateProperties()}})}constructor(){super(),this.__dataEnabled=!1,this.__dataReady=!1,this.__dataInvalid=!1,this.__data={},this.__dataPending=null,this.__dataOld=null,this.__dataInstanceProps=null,this.__dataCounter=0,this.__serializing=!1,this._initializeProperties()}ready(){this.__dataReady=!0,this._flushProperties()}_initializeProperties(){for(let t in this.__dataHasAccessor)this.hasOwnProperty(t)&&(this.__dataInstanceProps=this.__dataInstanceProps||{},this.__dataInstanceProps[t]=this[t],delete this[t])}_initializeInstanceProperties(t){Object.assign(this,t)}_setProperty(t,e){this._setPendingProperty(t,e)&&this._invalidateProperties()}_getProperty(t){return this.__data[t]}_setPendingProperty(t,e,n){let i=this.__data[t],r=this._shouldPropertyChange(t,e,i);return r&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),this.__dataOld&&!(t in this.__dataOld)&&(this.__dataOld[t]=i),this.__data[t]=e,this.__dataPending[t]=e),r}_isPropertyPending(t){return!(!this.__dataPending||!this.__dataPending.hasOwnProperty(t))}_invalidateProperties(){!this.__dataInvalid&&this.__dataReady&&(this.__dataInvalid=!0,bt.run((()=>{this.__dataInvalid&&(this.__dataInvalid=!1,this._flushProperties())})))}_enableProperties(){this.__dataEnabled||(this.__dataEnabled=!0,this.__dataInstanceProps&&(this._initializeInstanceProperties(this.__dataInstanceProps),this.__dataInstanceProps=null),this.ready())}_flushProperties(){this.__dataCounter++;const t=this.__data,e=this.__dataPending,n=this.__dataOld;this._shouldPropertiesChange(t,e,n)&&(this.__dataPending=null,this.__dataOld=null,this._propertiesChanged(t,e,n)),this.__dataCounter--}_shouldPropertiesChange(t,e,n){return Boolean(e)}_propertiesChanged(t,e,n){}_shouldPropertyChange(t,e,n){return n!==e&&(n==n||e==e)}attributeChangedCallback(t,e,n,i){e!==n&&this._attributeToProperty(t,n),super.attributeChangedCallback&&super.attributeChangedCallback(t,e,n,i)}_attributeToProperty(t,e,n){if(!this.__serializing){const i=this.__dataAttributes,r=i&&i[t]||t;this[r]=this._deserializeValue(e,n||this.constructor.typeForProperty(r))}}_propertyToAttribute(t,e,n){this.__serializing=!0,this._valueToNodeAttribute(this,n=arguments.length<3?this[t]:n,e||this.constructor.attributeNameForProperty(t)),this.__serializing=!1}_valueToNodeAttribute(t,e,n){const i=this._serializeValue(e);"class"!==n&&"name"!==n&&"slot"!==n||(t=Y(t)),void 0===i?t.removeAttribute(n):t.setAttribute(n,i)}_serializeValue(t){switch(typeof t){case"boolean":return t?"":void 0;default:return null!=t?t.toString():void 0}}_deserializeValue(t,e){switch(e){case Boolean:return null!==t;case Number:return Number(t);default:return t}}})),wt={};let St=HTMLElement.prototype;for(;St;){let t=Object.getOwnPropertyNames(St);for(let e=0;e<t.length;e++)wt[t[e]]=!0;St=Object.getPrototypeOf(St)}const Mt=N((t=>{const e=xt(t);return class extends e{static createPropertiesForAttributes(){let t=this.observedAttributes;for(let e=0;e<t.length;e++)this.prototype._createPropertyAccessor(st(t[e]))}static attributeNameForProperty(t){return lt(t)}_initializeProperties(){this.__dataProto&&(this._initializeProtoProperties(this.__dataProto),this.__dataProto=null),super._initializeProperties()}_initializeProtoProperties(t){for(let e in t)this._setProperty(e,t[e])}_ensureAttribute(t,e){this.hasAttribute(t)||this._valueToNodeAttribute(this,e,t)}_serializeValue(t){switch(typeof t){case"object":if(t instanceof Date)return t.toString();if(t)try{return JSON.stringify(t)}catch(t){return""}default:return super._serializeValue(t)}}_deserializeValue(t,e){let n;switch(e){case Object:try{n=JSON.parse(t)}catch(e){n=t}break;case Array:try{n=JSON.parse(t)}catch(e){n=null,console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${t}`)}break;case Date:n=isNaN(t)?String(t):Number(t),n=new Date(n);break;default:n=super._deserializeValue(t,e)}return n}_definePropertyAccessor(t,e){!(function n(t,e){if(!wt[e]){let n=t[e];void 0!==n&&(t.__data?t._setPendingProperty(e,n):(t.__dataProto?t.hasOwnProperty(JSCompiler_renameProperty("__dataProto",t))||(t.__dataProto=Object.create(t.__dataProto)):t.__dataProto={},t.__dataProto[e]=n))}})(this,t),super._definePropertyAccessor(t,e)}_hasAccessor(t){return this.__dataHasAccessor&&this.__dataHasAccessor[t]}_isPropertyPending(t){return Boolean(this.__dataPending&&t in this.__dataPending)}}})),Et={"dom-if":!0,"dom-repeat":!0};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let Tt=!1,At=!1;function Ct(t){let e=t.getAttribute("is");if(e&&Et[e]){let n=t;for(n.removeAttribute("is"),t=n.ownerDocument.createElement(e),n.parentNode.replaceChild(t,n),t.appendChild(n);n.attributes.length;)t.setAttribute(n.attributes[0].name,n.attributes[0].value),n.removeAttribute(n.attributes[0].name)}return t}function kt(t,e){let n=e.parentInfo&&kt(t,e.parentInfo);if(!n)return t;for(let t=n.firstChild,i=0;t;t=t.nextSibling)if(e.parentIndex===i++)return t}function Lt(t,e,n,i){i.id&&(e[i.id]=n)}function Pt(t,e,n){if(n.events&&n.events.length)for(let i,r=0,o=n.events;r<o.length&&(i=o[r]);r++)t._addMethodEventListenerToNode(e,i.name,i.value,t)}function It(t,e,n,i){n.templateInfo&&(e._templateInfo=n.templateInfo,e._parentTemplateInfo=i)}const Nt=N((t=>class extends t{static _parseTemplate(t,e){if(!t._templateInfo){let n=t._templateInfo={};n.nodeInfoList=[],n.nestedTemplate=Boolean(e),n.stripWhiteSpace=e&&e.stripWhiteSpace||t.hasAttribute("strip-whitespace"),this._parseTemplateContent(t,n,{parent:null})}return t._templateInfo}static _parseTemplateContent(t,e,n){return this._parseTemplateNode(t.content,e,n)}static _parseTemplateNode(t,e,n){let i=!1,r=t;return"template"!=r.localName||r.hasAttribute("preserve-content")?"slot"===r.localName&&(e.hasInsertionPoint=!0):i=this._parseTemplateNestedTemplate(r,e,n)||i,(function o(t){(function e(){if(!Tt){Tt=!0;const t=document.createElement("textarea");t.placeholder="a",At=t.placeholder===t.textContent}return At})()&&"textarea"===t.localName&&t.placeholder&&t.placeholder===t.textContent&&(t.textContent=null)})(r),r.firstChild&&this._parseTemplateChildNodes(r,e,n),r.hasAttributes&&r.hasAttributes()&&(i=this._parseTemplateNodeAttributes(r,e,n)||i),i||n.noted}static _parseTemplateChildNodes(t,e,n){if("script"!==t.localName&&"style"!==t.localName)for(let i,r=t.firstChild,o=0;r;r=i){if("template"==r.localName&&(r=Ct(r)),i=r.nextSibling,r.nodeType===Node.TEXT_NODE){let n=i;for(;n&&n.nodeType===Node.TEXT_NODE;)r.textContent+=n.textContent,i=n.nextSibling,t.removeChild(n),n=i;if(e.stripWhiteSpace&&!r.textContent.trim()){t.removeChild(r);continue}}let a={parentIndex:o,parentInfo:n};this._parseTemplateNode(r,e,a)&&(a.infoIndex=e.nodeInfoList.push(a)-1),r.parentNode&&o++}}static _parseTemplateNestedTemplate(t,e,n){let i=t,r=this._parseTemplate(i,e);return(r.content=i.content.ownerDocument.createDocumentFragment()).appendChild(i.content),n.templateInfo=r,!0}static _parseTemplateNodeAttributes(t,e,n){let i=!1,r=Array.from(t.attributes);for(let o,a=r.length-1;o=r[a];a--)i=this._parseTemplateNodeAttribute(t,e,n,o.name,o.value)||i;return i}static _parseTemplateNodeAttribute(t,e,n,i,r){return"on-"===i.slice(0,3)?(t.removeAttribute(i),n.events=n.events||[],n.events.push({name:i.slice(3),value:r}),!0):"id"===i&&(n.id=r,!0)}static _contentForTemplate(t){let e=t._templateInfo;return e&&e.content||t.content}_stampTemplate(t,e){t&&!t.content&&window.HTMLTemplateElement&&HTMLTemplateElement.decorate&&HTMLTemplateElement.decorate(t);let n=(e=e||this.constructor._parseTemplate(t)).nodeInfoList,i=document.importNode(e.content||t.content,!0);i.__noInsertionPoint=!e.hasInsertionPoint;let r=i.nodeList=new Array(n.length);i.$={};for(let t,o=0,a=n.length;o<a&&(t=n[o]);o++){let n=r[o]=kt(i,t);Lt(0,i.$,n,t),It(0,n,t,e),Pt(this,n,t)}return i=i,i}_addMethodEventListenerToNode(t,e,n,i){let r=(function o(t,e,n){return t=t._methodHost||t,function(e){t[n]?t[n](e,e.detail):console.warn("listener method `"+n+"` not defined")}})(i=i||t,0,n);return this._addEventListenerToNode(t,e,r),r}_addEventListenerToNode(t,e,n){t.addEventListener(e,n)}_removeEventListenerFromNode(t,e,n){t.removeEventListener(e,n)}}));
/**
     * @fileoverview
     * @suppress {checkPrototypalTypes}
     * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
     * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
     * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
     * Google as part of the polymer project is also subject to an additional IP
     * rights grant found at http://polymer.github.io/PATENTS.txt
     */let Ot=0;const Rt=[],zt={COMPUTE:"__computeEffects",REFLECT:"__reflectEffects",NOTIFY:"__notifyEffects",PROPAGATE:"__propagateEffects",OBSERVE:"__observeEffects",READ_ONLY:"__readOnly"},Dt=/[A-Z]/;function Bt(t,e,n){let i=t[e];if(i){if(!t.hasOwnProperty(e)&&(i=t[e]=Object.create(t[e]),n))for(let t in i){let e=i[t],n=i[t]=Array(e.length);for(let t=0;t<e.length;t++)n[t]=e[t]}}else i=t[e]={};return i}function Ht(t,e,n,i,r,o){if(e){let a=!1;const s=Ot++;for(let l in n){let c=e[r?$(l):l];if(c)for(let e,u=0,h=c.length;u<h&&(e=c[u]);u++)e.info&&e.info.lastRun===s||r&&!Vt(l,e.trigger)||(e.info&&(e.info.lastRun=s),e.fn(t,l,n,i,e.info,r,o),a=!0)}return a}return!1}function Ft(t,e,n,i,r,o,a,s){let l=!1,c=e[a?$(i):i];if(c)for(let e,u=0,h=c.length;u<h&&(e=c[u]);u++)e.info&&e.info.lastRun===n||a&&!Vt(i,e.trigger)||(e.info&&(e.info.lastRun=n),e.fn(t,i,r,o,e.info,a,s),l=!0);return l}function Vt(t,e){if(e){let n=e.name;return n==t||!(!e.structured||!K(n,t))||!(!e.wildcard||!Z(n,t))}return!0}function jt(t,e,n,i,r){let o="string"==typeof r.method?t[r.method]:r.method,a=r.property;o?o.call(t,t.__data[a],i[a]):r.dynamicFn||console.warn("observer method `"+r.method+"` not defined")}function Ut(t,e,n){let i=$(e);return i!==e&&(Gt(t,lt(i)+"-changed",n[e],e),!0)}function Gt(t,e,n,i){let r={value:n,queueProperty:!0};i&&(r.path=i),Y(t).dispatchEvent(new CustomEvent(e,{detail:r}))}function Wt(t,e,n,i,r,o){let a=(o?$(e):e)!=e?e:null,s=a?nt(t,a):t.__data[e];a&&void 0===s&&(s=n[e]),Gt(t,r.eventName,s,a)}function qt(t,e,n,i,r){let o=t.__data[e];y&&(o=y(o,r.attrName,"attribute",t)),t._propertyToAttribute(e,r.attrName,o)}const Yt=(t,e,n)=>{let i=0,r=e.length-1,o=-1;for(;i<=r;){const a=i+r>>1,s=n.get(e[a].methodInfo)-n.get(t.methodInfo);if(s<0)i=a+1;else{if(!(s>0)){o=a;break}r=a-1}}o<0&&(o=r+1),e.splice(o,0,t)},Xt=(t,e,n,i,r)=>{const o=e[r?$(t):t];if(o)for(let e=0;e<o.length;e++){const a=o[e];a.info.lastRun===Ot||r&&!Vt(t,a.trigger)||(a.info.lastRun=Ot,Yt(a.info,n,i))}};function $t(t,e,n,i,r){let o=ne(t,e,n,0,r);if(o===Rt)return!1;let a=r.methodInfo;return t.__dataHasAccessor&&t.__dataHasAccessor[a]?t._setPendingProperty(a,o,!0):(t[a]=o,!1)}function Kt(t,e,n,i,r,o,a){n.bindings=n.bindings||[];let s={kind:i,target:r,parts:o,literal:a,isCompound:1!==o.length};if(n.bindings.push(s),(function l(t){return Boolean(t.target)&&"attribute"!=t.kind&&"text"!=t.kind&&!t.isCompound&&"{"===t.parts[0].mode})(s)){let{event:t,negate:e}=s.parts[0];s.listenerEvent=t||lt(r)+"-changed",s.listenerNegate=e}let c=e.nodeInfoList.length;for(let n=0;n<s.parts.length;n++){let i=s.parts[n];i.compoundIndex=n,Zt(t,e,s,i,c)}}function Zt(t,e,n,i,r){if(!i.literal)if("attribute"===n.kind&&"-"===n.target[0])console.warn("Cannot set attribute "+n.target+' because "-" is not a valid attribute starting character');else{let o=i.dependencies,a={index:r,binding:n,part:i,evaluator:t};for(let n=0;n<o.length;n++){let i=o[n];"string"==typeof i&&(i=se(i),i.wildcard=!0),t._addTemplatePropertyEffect(e,i.rootProperty,{fn:Jt,info:a,trigger:i})}}}function Jt(t,e,n,i,r,o,a){let s=a[r.index],l=r.binding,c=r.part;if(o&&c.source&&e.length>c.source.length&&"property"==l.kind&&!l.isCompound&&s.__isPropertyEffectsClient&&s.__dataHasAccessor&&s.__dataHasAccessor[l.target]){let i=n[e];e=J(c.source,l.target,e),s._setPendingPropertyOrPath(e,i,!1,!0)&&t._enqueueClient(s)}else{let a=r.evaluator._evaluateBinding(t,c,e,n,i,o);a!==Rt&&(function u(t,e,n,i,r){if(r=(function o(t,e,n,i){if(n.isCompound){let r=t.__dataCompoundStorage[n.target];r[i.compoundIndex]=e,e=r.join("")}return"attribute"!==n.kind&&("textContent"!==n.target&&("value"!==n.target||"input"!==t.localName&&"textarea"!==t.localName)||(e=null==e?"":e)),e})(e,r,n,i),y&&(r=y(r,n.target,n.kind,e)),"attribute"==n.kind)t._valueToNodeAttribute(e,r,n.target);else{let i=n.target;e.__isPropertyEffectsClient&&e.__dataHasAccessor&&e.__dataHasAccessor[i]?e[zt.READ_ONLY]&&e[zt.READ_ONLY][i]||e._setPendingProperty(i,r)&&t._enqueueClient(e):t._setUnmanagedPropertyToNode(e,i,r)}})(t,s,l,c,a)}}function Qt(t,e){if(e.isCompound){let n=t.__dataCompoundStorage||(t.__dataCompoundStorage={}),i=e.parts,r=new Array(i.length);for(let t=0;t<i.length;t++)r[t]=i[t].literal;let o=e.target;n[o]=r,e.literal&&"property"==e.kind&&("className"===o&&(t=Y(t)),t[o]=e.literal)}}function te(t,e,n){if(n.listenerEvent){let i=n.parts[0];t.addEventListener(n.listenerEvent,(function(t){!(function r(t,e,n,i,o){let a,s=t.detail,l=s&&s.path;l?(i=J(n,i,l),a=s&&s.value):a=t.currentTarget[n],a=o?!a:a,e[zt.READ_ONLY]&&e[zt.READ_ONLY][i]||!e._setPendingPropertyOrPath(i,a,!0,Boolean(l))||s&&s.queueProperty||e._invalidateProperties()})(t,e,n.target,i.source,i.negate)}))}}function ee(t,e,n,i,r,o){let a={methodName:e.methodName,args:e.args,methodInfo:r,dynamicFn:o=e.static||o&&("object"!=typeof o||o[e.methodName])};for(let r,o=0;o<e.args.length&&(r=e.args[o]);o++)r.literal||t._addPropertyEffect(r.rootProperty,n,{fn:i,info:a,trigger:r});return o&&t._addPropertyEffect(e.methodName,n,{fn:i,info:a}),a}function ne(t,e,n,i,r){let o=t._methodHost||t,a=o[r.methodName];if(a){let i=t._marshalArgs(r.args,e,n);return i===Rt?Rt:a.apply(o,i)}r.dynamicFn||console.warn("method `"+r.methodName+"` not defined")}const ie=[],re=new RegExp("(\\[\\[|{{)\\s*(?:(!)\\s*)?((?:[a-zA-Z_$][\\w.:$\\-*]*)\\s*(?:\\(\\s*(?:(?:(?:((?:[a-zA-Z_$][\\w.:$\\-*]*)|(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)|(?:(?:'(?:[^'\\\\]|\\\\.)*')|(?:\"(?:[^\"\\\\]|\\\\.)*\")))\\s*)(?:,\\s*(?:((?:[a-zA-Z_$][\\w.:$\\-*]*)|(?:[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?)|(?:(?:'(?:[^'\\\\]|\\\\.)*')|(?:\"(?:[^\"\\\\]|\\\\.)*\")))\\s*))*)?)\\)\\s*)?)(?:]]|}})","g");function oe(t){let e="";for(let n=0;n<t.length;n++)e+=t[n].literal||"";return e}function ae(t){let e=t.match(/([^\s]+?)\(([\s\S]*)\)/);if(e){let t={methodName:e[1],static:!0,args:ie};return e[2].trim()?(function n(t,e){return e.args=t.map((function(t){let n=se(t);return n.literal||(e.static=!1),n}),this),e})(e[2].replace(/\\,/g,"&comma;").split(","),t):t}return null}function se(t){let e=t.trim().replace(/&comma;/g,",").replace(/\\(.)/g,"$1"),n={name:e,value:"",literal:!1},i=e[0];switch("-"===i&&(i=e[1]),i>="0"&&i<="9"&&(i="#"),i){case"'":case'"':n.value=e.slice(1,-1),n.literal=!0;break;case"#":n.value=Number(e),n.literal=!0}return n.literal||(n.rootProperty=$(e),n.structured=X(e),n.structured&&(n.wildcard=".*"==e.slice(-2),n.wildcard&&(n.name=e.slice(0,-2)))),n}function le(t,e,n){let i=nt(t,n);return void 0===i&&(i=e[n]),i}function ce(t,e,n,i){const r={indexSplices:i};E&&!t._overrideLegacyUndefined&&(e.splices=r),t.notifyPath(n+".splices",r),t.notifyPath(n+".length",e.length),E&&!t._overrideLegacyUndefined&&(r.indexSplices=[])}function ue(t,e,n,i,r,o){ce(t,e,n,[{index:i,addedCount:r,removed:o,object:e,type:"splice"}])}const he=N((t=>{const e=Nt(Mt(t));return class extends e{constructor(){super(),this.__isPropertyEffectsClient=!0}get PROPERTY_EFFECT_TYPES(){return zt}_initializeProperties(){super._initializeProperties(),this._registerHost(),this.__dataClientsReady=!1,this.__dataPendingClients=null,this.__dataToNotify=null,this.__dataLinkedPaths=null,this.__dataHasPaths=!1,this.__dataCompoundStorage=this.__dataCompoundStorage||null,this.__dataHost=this.__dataHost||null,this.__dataTemp={},this.__dataClientsInitialized=!1}_registerHost(){if(de.length){let t=de[de.length-1];t._enqueueClient(this),this.__dataHost=t}}_initializeProtoProperties(t){this.__data=Object.create(t),this.__dataPending=Object.create(t),this.__dataOld={}}_initializeInstanceProperties(t){let e=this[zt.READ_ONLY];for(let n in t)e&&e[n]||(this.__dataPending=this.__dataPending||{},this.__dataOld=this.__dataOld||{},this.__data[n]=this.__dataPending[n]=t[n])}_addPropertyEffect(t,e,n){this._createPropertyAccessor(t,e==zt.READ_ONLY);let i=Bt(this,e,!0)[t];i||(i=this[e][t]=[]),i.push(n)}_removePropertyEffect(t,e,n){let i=Bt(this,e,!0)[t],r=i.indexOf(n);r>=0&&i.splice(r,1)}_hasPropertyEffect(t,e){let n=this[e];return Boolean(n&&n[t])}_hasReadOnlyEffect(t){return this._hasPropertyEffect(t,zt.READ_ONLY)}_hasNotifyEffect(t){return this._hasPropertyEffect(t,zt.NOTIFY)}_hasReflectEffect(t){return this._hasPropertyEffect(t,zt.REFLECT)}_hasComputedEffect(t){return this._hasPropertyEffect(t,zt.COMPUTE)}_setPendingPropertyOrPath(t,e,n,i){if(i||$(Array.isArray(t)?t[0]:t)!==t){if(!i){let n=nt(this,t);if(!(t=it(this,t,e))||!super._shouldPropertyChange(t,e,n))return!1}if(this.__dataHasPaths=!0,this._setPendingProperty(t,e,n))return(function r(t,e,n){let i=t.__dataLinkedPaths;if(i){let r;for(let o in i){let a=i[o];Z(o,e)?(r=J(o,a,e),t._setPendingPropertyOrPath(r,n,!0,!0)):Z(a,e)&&(r=J(a,o,e),t._setPendingPropertyOrPath(r,n,!0,!0))}}})(this,t,e),!0}else{if(this.__dataHasAccessor&&this.__dataHasAccessor[t])return this._setPendingProperty(t,e,n);this[t]=e}return!1}_setUnmanagedPropertyToNode(t,e,n){n===t[e]&&"object"!=typeof n||("className"===e&&(t=Y(t)),t[e]=n)}_setPendingProperty(t,e,n){let i=this.__dataHasPaths&&X(t);return!!this._shouldPropertyChange(t,e,(i?this.__dataTemp:this.__data)[t])&&(this.__dataPending||(this.__dataPending={},this.__dataOld={}),t in this.__dataOld||(this.__dataOld[t]=this.__data[t]),i?this.__dataTemp[t]=e:this.__data[t]=e,this.__dataPending[t]=e,(i||this[zt.NOTIFY]&&this[zt.NOTIFY][t])&&(this.__dataToNotify=this.__dataToNotify||{},this.__dataToNotify[t]=n),!0)}_setProperty(t,e){this._setPendingProperty(t,e,!0)&&this._invalidateProperties()}_invalidateProperties(){this.__dataReady&&this._flushProperties()}_enqueueClient(t){this.__dataPendingClients=this.__dataPendingClients||[],t!==this&&this.__dataPendingClients.push(t)}_flushClients(){this.__dataClientsReady?this.__enableOrFlushClients():(this.__dataClientsReady=!0,this._readyClients(),this.__dataReady=!0)}__enableOrFlushClients(){let t=this.__dataPendingClients;if(t){this.__dataPendingClients=null;for(let e=0;e<t.length;e++){let n=t[e];n.__dataEnabled?n.__dataPending&&n._flushProperties():n._enableProperties()}}}_readyClients(){this.__enableOrFlushClients()}setProperties(t,e){for(let n in t)!e&&this[zt.READ_ONLY]&&this[zt.READ_ONLY][n]||this._setPendingPropertyOrPath(n,t[n],!0);this._invalidateProperties()}ready(){this._flushProperties(),this.__dataClientsReady||this._flushClients(),this.__dataPending&&this._flushProperties()}_propertiesChanged(t,e,n){let i,r=this.__dataHasPaths;this.__dataHasPaths=!1,(function o(t,e,n,i){let r=t[zt.COMPUTE];if(r)if(T){Ot++;const o=(function o(t){let e=t.constructor.__orderedComputedDeps;if(!e){e=new Map;const n=t[zt.COMPUTE];let i,{counts:r,ready:o,total:a}=(function n(t){const e=t.__computeInfo,n={},i=t[zt.COMPUTE],r=[];let o=0;for(let t in e){const i=e[t];o+=n[t]=i.args.filter((t=>!t.literal)).length+(i.dynamicFn?1:0)}for(let t in i)e[t]||r.push(t);return{counts:n,ready:r,total:o}})(t);for(;i=o.shift();){e.set(i,e.size);const t=n[i];t&&t.forEach((t=>{const e=t.info.methodInfo;--a,0==--r[e]&&o.push(e)}))}0!==a&&console.warn(`Computed graph for ${t.localName} incomplete; circular?`),t.constructor.__orderedComputedDeps=e}return e})(t),a=[];for(let t in e)Xt(t,r,a,o,i);let s;for(;s=a.shift();)$t(t,"",e,0,s)&&Xt(s.methodInfo,r,a,o,i);Object.assign(n,t.__dataOld),Object.assign(e,t.__dataPending),t.__dataPending=null}else{let o=e;for(;Ht(t,r,o,n,i);)Object.assign(n,t.__dataOld),Object.assign(e,t.__dataPending),o=t.__dataPending,t.__dataPending=null}})(this,e,n,r),i=this.__dataToNotify,this.__dataToNotify=null,this._propagatePropertyChanges(e,n,r),this._flushClients(),Ht(this,this[zt.REFLECT],e,n,r),Ht(this,this[zt.OBSERVE],e,n,r),i&&(function a(t,e,n,i,r){let o,a,s=t[zt.NOTIFY],l=Ot++;for(let a in e)e[a]&&(s&&Ft(t,s,l,a,n,i,r)||r&&Ut(t,a,n))&&(o=!0);o&&(a=t.__dataHost)&&a._invalidateProperties&&a._invalidateProperties()})(this,i,e,n,r),1==this.__dataCounter&&(this.__dataTemp={})}_propagatePropertyChanges(t,e,n){this[zt.PROPAGATE]&&Ht(this,this[zt.PROPAGATE],t,e,n),this.__templateInfo&&this._runEffectsForTemplate(this.__templateInfo,t,e,n)}_runEffectsForTemplate(t,e,n,i){const r=(e,i)=>{Ht(this,t.propertyEffects,e,n,i,t.nodeList);for(let r=t.firstChild;r;r=r.nextSibling)this._runEffectsForTemplate(r,e,n,i)};t.runEffects?t.runEffects(r,e,i):r(e,i)}linkPaths(t,e){t=tt(t),e=tt(e),this.__dataLinkedPaths=this.__dataLinkedPaths||{},this.__dataLinkedPaths[t]=e}unlinkPaths(t){t=tt(t),this.__dataLinkedPaths&&delete this.__dataLinkedPaths[t]}notifySplices(t,e){let n={path:""};ce(this,nt(this,t,n),n.path,e)}get(t,e){return nt(e||this,t)}set(t,e,n){n?it(n,t,e):this[zt.READ_ONLY]&&this[zt.READ_ONLY][t]||this._setPendingPropertyOrPath(t,e,!0)&&this._invalidateProperties()}push(t,...e){let n={path:""},i=nt(this,t,n),r=i.length,o=i.push(...e);return e.length&&ue(this,i,n.path,r,e.length,[]),o}pop(t){let e={path:""},n=nt(this,t,e),i=Boolean(n.length),r=n.pop();return i&&ue(this,n,e.path,n.length,0,[r]),r}splice(t,e,n,...i){let r,o={path:""},a=nt(this,t,o);return e<0?e=a.length-Math.floor(-e):e&&(e=Math.floor(e)),r=2===arguments.length?a.splice(e):a.splice(e,n,...i),(i.length||r.length)&&ue(this,a,o.path,e,i.length,r),r}shift(t){let e={path:""},n=nt(this,t,e),i=Boolean(n.length),r=n.shift();return i&&ue(this,n,e.path,0,0,[r]),r}unshift(t,...e){let n={path:""},i=nt(this,t,n),r=i.unshift(...e);return e.length&&ue(this,i,n.path,0,e.length,[]),r}notifyPath(t,e){let n;if(1==arguments.length){let i={path:""};e=nt(this,t,i),n=i.path}else n=Array.isArray(t)?tt(t):t;this._setPendingPropertyOrPath(n,e,!0,!0)&&this._invalidateProperties()}_createReadOnlyProperty(t,e){this._addPropertyEffect(t,zt.READ_ONLY),e&&(this["_set"+(function n(t){return t[0].toUpperCase()+t.substring(1)})(t)]=function(e){this._setProperty(t,e)})}_createPropertyObserver(t,e,n){let i={property:t,method:e,dynamicFn:Boolean(n)};this._addPropertyEffect(t,zt.OBSERVE,{fn:jt,info:i,trigger:{name:t}}),n&&this._addPropertyEffect(e,zt.OBSERVE,{fn:jt,info:i,trigger:{name:e}})}_createMethodObserver(t,e){let n=ae(t);if(!n)throw new Error("Malformed observer expression '"+t+"'");ee(this,n,zt.OBSERVE,ne,null,e)}_createNotifyingProperty(t){this._addPropertyEffect(t,zt.NOTIFY,{fn:Wt,info:{eventName:lt(t)+"-changed",property:t}})}_createReflectedProperty(t){let e=this.constructor.attributeNameForProperty(t);"-"===e[0]?console.warn("Property "+t+" cannot be reflected to attribute "+e+' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.'):this._addPropertyEffect(t,zt.REFLECT,{fn:qt,info:{attrName:e}})}_createComputedProperty(t,e,n){let i=ae(e);if(!i)throw new Error("Malformed computed expression '"+e+"'");const r=ee(this,i,zt.COMPUTE,$t,t,n);Bt(this,"__computeInfo")[t]=r}_marshalArgs(t,e,n){const i=this.__data,r=[];for(let o=0,a=t.length;o<a;o++){let{name:a,structured:s,wildcard:l,value:c,literal:u}=t[o];if(!u)if(l){const t=Z(a,e),r=le(i,n,t?e:a);c={path:t?e:a,value:r,base:t?nt(i,a):r}}else c=s?le(i,n,a):i[a];if(E&&!this._overrideLegacyUndefined&&void 0===c&&t.length>1)return Rt;r[o]=c}return r}static addPropertyEffect(t,e,n){this.prototype._addPropertyEffect(t,e,n)}static createPropertyObserver(t,e,n){this.prototype._createPropertyObserver(t,e,n)}static createMethodObserver(t,e){this.prototype._createMethodObserver(t,e)}static createNotifyingProperty(t){this.prototype._createNotifyingProperty(t)}static createReadOnlyProperty(t,e){this.prototype._createReadOnlyProperty(t,e)}static createReflectedProperty(t){this.prototype._createReflectedProperty(t)}static createComputedProperty(t,e,n){this.prototype._createComputedProperty(t,e,n)}static bindTemplate(t){return this.prototype._bindTemplate(t)}_bindTemplate(t,e){let n=this.constructor._parseTemplate(t),i=this.__preBoundTemplateInfo==n;if(!i)for(let t in n.propertyEffects)this._createPropertyAccessor(t);if(e)if(n=Object.create(n),n.wasPreBound=i,this.__templateInfo){const e=t._parentTemplateInfo||this.__templateInfo,i=e.lastChild;n.parent=e,e.lastChild=n,n.previousSibling=i,i?i.nextSibling=n:e.firstChild=n}else this.__templateInfo=n;else this.__preBoundTemplateInfo=n;return n}static _addTemplatePropertyEffect(t,e,n){(t.hostProps=t.hostProps||{})[e]=!0;let i=t.propertyEffects=t.propertyEffects||{};(i[e]=i[e]||[]).push(n)}_stampTemplate(t,e){e=e||this._bindTemplate(t,!0),de.push(this);let n=super._stampTemplate(t,e);if(de.pop(),e.nodeList=n.nodeList,!e.wasPreBound){let t=e.childNodes=[];for(let e=n.firstChild;e;e=e.nextSibling)t.push(e)}return n.templateInfo=e,(function i(t,e){let{nodeList:n,nodeInfoList:i}=e;if(i.length)for(let e=0;e<i.length;e++){let r=n[e],o=i[e].bindings;if(o)for(let e=0;e<o.length;e++){let n=o[e];Qt(r,n),te(r,t,n)}r.__dataHost=t}})(this,e),this.__dataClientsReady&&(this._runEffectsForTemplate(e,this.__data,null,!1),this._flushClients()),n}_removeBoundDom(t){const e=t.templateInfo,{previousSibling:n,nextSibling:i,parent:r}=e;n?n.nextSibling=i:r&&(r.firstChild=i),i?i.previousSibling=n:r&&(r.lastChild=n),e.nextSibling=e.previousSibling=null;let o=e.childNodes;for(let t=0;t<o.length;t++){let e=o[t];Y(Y(e).parentNode).removeChild(e)}}static _parseTemplateNode(t,n,i){let r=e._parseTemplateNode.call(this,t,n,i);if(t.nodeType===Node.TEXT_NODE){let e=this._parseBindings(t.textContent,n);e&&(t.textContent=oe(e)||" ",Kt(this,n,i,"text","textContent",e),r=!0)}return r}static _parseTemplateNodeAttribute(t,n,i,r,o){let a=this._parseBindings(o,n);if(a){let e=r,o="property";Dt.test(r)?o="attribute":"$"==r[r.length-1]&&(r=r.slice(0,-1),o="attribute");let s=oe(a);return s&&"attribute"==o&&("class"==r&&t.hasAttribute("class")&&(s+=" "+t.getAttribute(r)),t.setAttribute(r,s)),"attribute"==o&&"disable-upgrade$"==e&&t.setAttribute(r,""),"input"===t.localName&&"value"===e&&t.setAttribute(e,""),t.removeAttribute(e),"property"===o&&(r=st(r)),Kt(this,n,i,o,r,a,s),!0}return e._parseTemplateNodeAttribute.call(this,t,n,i,r,o)}static _parseTemplateNestedTemplate(t,n,i){let r=e._parseTemplateNestedTemplate.call(this,t,n,i);const o=t.parentNode,a=i.templateInfo,s="dom-if"===o.localName;A&&(s||"dom-repeat"===o.localName)&&(o.removeChild(t),(i=i.parentInfo).templateInfo=a,i.noted=!0,r=!1);let l=a.hostProps;if(C&&s)l&&(n.hostProps=Object.assign(n.hostProps||{},l),A||(i.parentInfo.noted=!0));else{let t="{";for(let e in l)Kt(this,n,i,"property","_host_"+e,[{mode:t,source:e,dependencies:[e],hostProp:!0}])}return r}static _parseBindings(t,e){let n,i=[],r=0;for(;null!==(n=re.exec(t));){n.index>r&&i.push({literal:t.slice(r,n.index)});let o=n[1][0],a=Boolean(n[2]),s=n[3].trim(),l=!1,c="",u=-1;"{"==o&&(u=s.indexOf("::"))>0&&(c=s.substring(u+2),s=s.substring(0,u),l=!0);let h=ae(s),d=[];if(h){let{args:t,methodName:n}=h;for(let e=0;e<t.length;e++){let n=t[e];n.literal||d.push(n)}let i=e.dynamicFns;(i&&i[n]||h.static)&&(d.push(n),h.dynamicFn=!0)}else d.push(s);i.push({source:s,mode:o,negate:a,customEvent:l,signature:h,dependencies:d,event:c}),r=re.lastIndex}if(r&&r<t.length){let e=t.substring(r);e&&i.push({literal:e})}return i.length?i:null}static _evaluateBinding(t,e,n,i,r,o){let a;return a=e.signature?ne(t,n,i,0,e.signature):n!=e.source?nt(t,e.source):o&&X(n)?nt(t,n):t.__data[n],e.negate&&(a=!a),a}}})),de=[],pe=N((t=>{const e=xt(t);function n(t){const e=Object.getPrototypeOf(t);return e.prototype instanceof r?e:null}function i(t){if(!t.hasOwnProperty(JSCompiler_renameProperty("__ownProperties",t))){let e=null;if(t.hasOwnProperty(JSCompiler_renameProperty("properties",t))){const n=t.properties;n&&(e=(
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
function e(t){const e={};for(let n in t){const i=t[n];e[n]="function"==typeof i?{type:i}:i}return e})(n))}t.__ownProperties=e}return t.__ownProperties}class r extends e{static get observedAttributes(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))){const t=this._properties;this.__observedAttributes=t?Object.keys(t).map((t=>this.prototype._addPropertyToAttributeMap(t))):[]}return this.__observedAttributes}static finalize(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__finalized",this))){const t=n(this);t&&t.finalize(),this.__finalized=!0,this._finalizeClass()}}static _finalizeClass(){const t=i(this);t&&this.createProperties(t)}static get _properties(){if(!this.hasOwnProperty(JSCompiler_renameProperty("__properties",this))){const t=n(this);this.__properties=Object.assign({},t&&t._properties,i(this))}return this.__properties}static typeForProperty(t){const e=this._properties[t];return e&&e.type}_initializeProperties(){this.constructor.finalize(),super._initializeProperties()}connectedCallback(){super.connectedCallback&&super.connectedCallback(),this._enableProperties()}disconnectedCallback(){super.disconnectedCallback&&super.disconnectedCallback()}}return r})),fe=window.ShadyCSS&&window.ShadyCSS.cssBuild,me=N((t=>{const e=pe(he(t));function n(t,e,n,i){n.computed&&(n.readOnly=!0),n.computed&&(t._hasReadOnlyEffect(e)?console.warn(`Cannot redefine computed property '${e}'.`):t._createComputedProperty(e,n.computed,i)),n.readOnly&&!t._hasReadOnlyEffect(e)?t._createReadOnlyProperty(e,!n.computed):!1===n.readOnly&&t._hasReadOnlyEffect(e)&&console.warn(`Cannot make readOnly property '${e}' non-readOnly.`),n.reflectToAttribute&&!t._hasReflectEffect(e)?t._createReflectedProperty(e):!1===n.reflectToAttribute&&t._hasReflectEffect(e)&&console.warn(`Cannot make reflected property '${e}' non-reflected.`),n.notify&&!t._hasNotifyEffect(e)?t._createNotifyingProperty(e):!1===n.notify&&t._hasNotifyEffect(e)&&console.warn(`Cannot make notify property '${e}' non-notify.`),n.observer&&t._createPropertyObserver(e,n.observer,i[n.observer]),t._addPropertyToAttributeMap(e)}return class extends e{static get polymerElementVersion(){return"3.4.1"}static _finalizeClass(){e._finalizeClass.call(this);const t=(function n(t){return t.hasOwnProperty(JSCompiler_renameProperty("__ownObservers",t))||(t.__ownObservers=t.hasOwnProperty(JSCompiler_renameProperty("observers",t))?t.observers:null),t.__ownObservers})(this);t&&this.createObservers(t,this._properties),this._prepareTemplate()}static _prepareTemplate(){let t=this.template;t&&("string"==typeof t?(console.error("template getter must return HTMLTemplateElement"),t=null):w||(t=t.cloneNode(!0))),this.prototype._template=t}static createProperties(t){for(let e in t)n(this.prototype,e,t[e],t)}static createObservers(t,e){const n=this.prototype;for(let i=0;i<t.length;i++)n._createMethodObserver(t[i],e)}static get template(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_template",this))){const t=this.prototype.hasOwnProperty(JSCompiler_renameProperty("_template",this.prototype))?this.prototype._template:void 0;this._template=void 0!==t?t:this.hasOwnProperty(JSCompiler_renameProperty("is",this))&&(function t(e){let n=null;if(e&&(!b||x)&&(n=B.import(e,"template"),b&&!n))throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${e}`);return n})(this.is)||Object.getPrototypeOf(this.prototype).constructor.template}return this._template}static set template(t){this._template=t}static get importPath(){if(!this.hasOwnProperty(JSCompiler_renameProperty("_importPath",this))){const t=this.importMeta;if(t)this._importPath=f(t.url);else{const t=B.import(this.is);this._importPath=t&&t.assetpath||Object.getPrototypeOf(this.prototype).constructor.importPath}}return this._importPath}constructor(){super()}_initializeProperties(){this.constructor.finalize(),this.constructor._finalizeTemplate(this.localName),super._initializeProperties(),this.rootPath=_,this.importPath=this.constructor.importPath;let t=(function e(t){if(!t.hasOwnProperty(JSCompiler_renameProperty("__propertyDefaults",t))){t.__propertyDefaults=null;let e=t._properties;for(let n in e){let i=e[n];"value"in i&&(t.__propertyDefaults=t.__propertyDefaults||{},t.__propertyDefaults[n]=i)}}return t.__propertyDefaults})(this.constructor);if(t)for(let e in t){let n=t[e];if(this._canApplyPropertyDefault(e)){let t="function"==typeof n.value?n.value.call(this):n.value;this._hasAccessor(e)?this._setPendingProperty(e,t,!0):this[e]=t}}}_canApplyPropertyDefault(t){return!this.hasOwnProperty(t)}static _processStyleText(t,e){return p(t,e)}static _finalizeTemplate(t){const e=this.prototype._template;if(e&&!e.__polymerFinalized){e.__polymerFinalized=!0;const n=this.importPath;(function n(t,e,i,r){if(!fe){const n=e.content.querySelectorAll("style"),o=G(e),a=(function o(t){let e=F(t);return e?W(e):[]})(i),s=e.content.firstElementChild;for(let n=0;n<a.length;n++){let i=a[n];i.textContent=t._processStyleText(i.textContent,r),e.content.insertBefore(i,s)}let l=0;for(let e=0;e<o.length;e++){let i=o[e],a=n[l];a!==i?(i=i.cloneNode(!0),a.parentNode.insertBefore(i,a)):l++,i.textContent=t._processStyleText(i.textContent,r)}}if(window.ShadyCSS&&window.ShadyCSS.prepareTemplate(e,i),P&&fe&&g){const n=e.content.querySelectorAll("style");if(n){let e="";Array.from(n).forEach((t=>{e+=t.textContent,t.parentNode.removeChild(t)})),t._styleSheet=new CSSStyleSheet,t._styleSheet.replaceSync(e)}}})(this,e,t,n?d(n):""),this.prototype._bindTemplate(e)}}connectedCallback(){window.ShadyCSS&&this._template&&window.ShadyCSS.styleElement(this),super.connectedCallback()}ready(){this._template&&(this.root=this._stampTemplate(this._template),this.$=this.root.$),super.ready()}_readyClients(){this._template&&(this.root=this._attachDom(this.root)),super._readyClients()}_attachDom(t){const e=Y(this);if(e.attachShadow)return t?(e.shadowRoot||(e.attachShadow({mode:"open",shadyUpgradeFragment:t}),e.shadowRoot.appendChild(t),this.constructor._styleSheet&&(e.shadowRoot.adoptedStyleSheets=[this.constructor._styleSheet])),M&&window.ShadyDOM&&window.ShadyDOM.flushInitial(e.shadowRoot),e.shadowRoot):null;throw new Error("ShadowDOM not available. PolymerElement can create dom as children instead of in ShadowDOM by setting `this.root = this;` before `ready`.")}updateStyles(t){window.ShadyCSS&&window.ShadyCSS.styleSubtree(this,t)}resolveUrl(t,e){return!e&&this.importPath&&(e=d(this.importPath)),d(t,e)}static _parseTemplateContent(t,n,i){return n.dynamicFns=n.dynamicFns||this._properties,e._parseTemplateContent.call(this,t,n,i)}static _addTemplatePropertyEffect(t,n,i){return!S||n in this._properties||i.info.part.signature&&i.info.part.signature.static||i.info.part.hostProp||t.nestedTemplate||console.warn(`Property '${n}' used in template but not declared in 'properties'; attribute will not be observed.`),e._addTemplatePropertyEffect.call(this,t,n,i)}}}));
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
class ge{constructor(t){this.value=t.toString()}toString(){return this.value}}const _e=function t(e,...n){const i=document.createElement("template");return i.innerHTML=n.reduce(((t,n,i)=>t+(function r(t){if(t instanceof HTMLTemplateElement)return t.innerHTML;if(t instanceof ge)return(function e(t){if(t instanceof ge)return t.value;throw new Error(`non-literal value passed to Polymer's htmlLiteral function: ${t}`)})(t);throw new Error(`non-template value passed to Polymer's html function: ${t}`)})(n)+e[i+1]),e[0]),i},ye=me(HTMLElement);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */var ve="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function be(t,e,n){return t(n={path:e,exports:{},require:function(t,e){return(function n(){throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs")})()}},n.exports),n.exports}function xe(t){if(t.__esModule)return t;var e=Object.defineProperty({},"__esModule",{value:!0});return Object.keys(t).forEach((function(n){var i=Object.getOwnPropertyDescriptor(t,n);Object.defineProperty(e,n,i.get?i:{enumerable:!0,get:function(){return t[n]}})})),e}var we=be((function(t,e){(function(){var n,i="Expected a function",r="__lodash_hash_undefined__",o="__lodash_placeholder__",a=32,s=128,l=1/0,c=9007199254740991,u=NaN,h=4294967295,d=[["ary",s],["bind",1],["bindKey",2],["curry",8],["curryRight",16],["flip",512],["partial",a],["partialRight",64],["rearg",256]],p="[object Arguments]",f="[object Array]",m="[object Boolean]",g="[object Date]",_="[object Error]",y="[object Function]",v="[object GeneratorFunction]",b="[object Map]",x="[object Number]",w="[object Object]",S="[object Promise]",M="[object RegExp]",E="[object Set]",T="[object String]",A="[object Symbol]",C="[object WeakMap]",k="[object ArrayBuffer]",L="[object DataView]",P="[object Float32Array]",I="[object Float64Array]",N="[object Int8Array]",O="[object Int16Array]",R="[object Int32Array]",z="[object Uint8Array]",D="[object Uint8ClampedArray]",B="[object Uint16Array]",H="[object Uint32Array]",F=/\b__p \+= '';/g,V=/\b(__p \+=) '' \+/g,j=/(__e\(.*?\)|\b__t\)) \+\n'';/g,U=/&(?:amp|lt|gt|quot|#39);/g,G=/[&<>"']/g,W=RegExp(U.source),q=RegExp(G.source),Y=/<%-([\s\S]+?)%>/g,X=/<%([\s\S]+?)%>/g,$=/<%=([\s\S]+?)%>/g,K=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Z=/^\w*$/,J=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,Q=/[\\^$.*+?()[\]{}|]/g,tt=RegExp(Q.source),et=/^\s+/,nt=/\s/,it=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,rt=/\{\n\/\* \[wrapped with (.+)\] \*/,ot=/,? & /,at=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,st=/[()=,{}\[\]\/\s]/,lt=/\\(\\)?/g,ct=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,ut=/\w*$/,ht=/^[-+]0x[0-9a-f]+$/i,dt=/^0b[01]+$/i,pt=/^\[object .+?Constructor\]$/,ft=/^0o[0-7]+$/i,mt=/^(?:0|[1-9]\d*)$/,gt=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,_t=/($^)/,yt=/['\n\r\u2028\u2029\\]/g,vt="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",bt="a-z\\xdf-\\xf6\\xf8-\\xff",xt="A-Z\\xc0-\\xd6\\xd8-\\xde",wt="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",St="["+wt+"]",Mt="["+vt+"]",Et="\\d+",Tt="["+bt+"]",At="[^\\ud800-\\udfff"+wt+Et+"\\u2700-\\u27bf"+bt+xt+"]",Ct="\\ud83c[\\udffb-\\udfff]",kt="[^\\ud800-\\udfff]",Lt="(?:\\ud83c[\\udde6-\\uddff]){2}",Pt="[\\ud800-\\udbff][\\udc00-\\udfff]",It="["+xt+"]",Nt="(?:"+Tt+"|"+At+")",Ot="(?:"+It+"|"+At+")",Rt="(?:['’](?:d|ll|m|re|s|t|ve))?",zt="(?:['’](?:D|LL|M|RE|S|T|VE))?",Dt="(?:"+Mt+"|"+Ct+")?",Bt="[\\ufe0e\\ufe0f]?",Ht=Bt+Dt+"(?:\\u200d(?:"+[kt,Lt,Pt].join("|")+")"+Bt+Dt+")*",Ft="(?:"+["[\\u2700-\\u27bf]",Lt,Pt].join("|")+")"+Ht,Vt="(?:"+[kt+Mt+"?",Mt,Lt,Pt,"[\\ud800-\\udfff]"].join("|")+")",jt=RegExp("['’]","g"),Ut=RegExp(Mt,"g"),Gt=RegExp(Ct+"(?="+Ct+")|"+Vt+Ht,"g"),Wt=RegExp([It+"?"+Tt+"+"+Rt+"(?="+[St,It,"$"].join("|")+")",Ot+"+"+zt+"(?="+[St,It+Nt,"$"].join("|")+")",It+"?"+Nt+"+"+Rt,It+"+"+zt,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Et,Ft].join("|"),"g"),qt=RegExp("[\\u200d\\ud800-\\udfff"+vt+"\\ufe0e\\ufe0f]"),Yt=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Xt=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],$t=-1,Kt={};Kt[P]=Kt[I]=Kt[N]=Kt[O]=Kt[R]=Kt[z]=Kt[D]=Kt[B]=Kt[H]=!0,Kt[p]=Kt[f]=Kt[k]=Kt[m]=Kt[L]=Kt[g]=Kt[_]=Kt[y]=Kt[b]=Kt[x]=Kt[w]=Kt[M]=Kt[E]=Kt[T]=Kt[C]=!1;var Zt={};Zt[p]=Zt[f]=Zt[k]=Zt[L]=Zt[m]=Zt[g]=Zt[P]=Zt[I]=Zt[N]=Zt[O]=Zt[R]=Zt[b]=Zt[x]=Zt[w]=Zt[M]=Zt[E]=Zt[T]=Zt[A]=Zt[z]=Zt[D]=Zt[B]=Zt[H]=!0,Zt[_]=Zt[y]=Zt[C]=!1;var Jt={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Qt=parseFloat,te=parseInt,ee="object"==typeof ve&&ve&&ve.Object===Object&&ve,ne="object"==typeof self&&self&&self.Object===Object&&self,ie=ee||ne||Function("return this")(),re=e&&!e.nodeType&&e,oe=re&&t&&!t.nodeType&&t,ae=oe&&oe.exports===re,se=ae&&ee.process,le=(function(){try{return oe&&oe.require&&oe.require("util").types||se&&se.binding&&se.binding("util")}catch(t){}})(),ce=le&&le.isArrayBuffer,ue=le&&le.isDate,he=le&&le.isMap,de=le&&le.isRegExp,pe=le&&le.isSet,fe=le&&le.isTypedArray;function me(t,e,n){switch(n.length){case 0:return t.call(e);case 1:return t.call(e,n[0]);case 2:return t.call(e,n[0],n[1]);case 3:return t.call(e,n[0],n[1],n[2])}return t.apply(e,n)}function ge(t,e,n,i){for(var r=-1,o=null==t?0:t.length;++r<o;){var a=t[r];e(i,a,n(a),t)}return i}function _e(t,e){for(var n=-1,i=null==t?0:t.length;++n<i&&!1!==e(t[n],n,t););return t}function ye(t,e){for(var n=null==t?0:t.length;n--&&!1!==e(t[n],n,t););return t}function be(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(!e(t[n],n,t))return!1;return!0}function xe(t,e){for(var n=-1,i=null==t?0:t.length,r=0,o=[];++n<i;){var a=t[n];e(a,n,t)&&(o[r++]=a)}return o}function we(t,e){return!(null==t||!t.length)&&Ie(t,e,0)>-1}function Se(t,e,n){for(var i=-1,r=null==t?0:t.length;++i<r;)if(n(e,t[i]))return!0;return!1}function Me(t,e){for(var n=-1,i=null==t?0:t.length,r=Array(i);++n<i;)r[n]=e(t[n],n,t);return r}function Ee(t,e){for(var n=-1,i=e.length,r=t.length;++n<i;)t[r+n]=e[n];return t}function Te(t,e,n,i){var r=-1,o=null==t?0:t.length;for(i&&o&&(n=t[++r]);++r<o;)n=e(n,t[r],r,t);return n}function Ae(t,e,n,i){var r=null==t?0:t.length;for(i&&r&&(n=t[--r]);r--;)n=e(n,t[r],r,t);return n}function Ce(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(e(t[n],n,t))return!0;return!1}var ke=ze("length");function Le(t,e,n){var i;return n(t,(function(t,n,r){if(e(t,n,r))return i=n,!1})),i}function Pe(t,e,n,i){for(var r=t.length,o=n+(i?1:-1);i?o--:++o<r;)if(e(t[o],o,t))return o;return-1}function Ie(t,e,n){return e==e?(function i(t,e,n){for(var i=n-1,r=t.length;++i<r;)if(t[i]===e)return i;return-1})(t,e,n):Pe(t,Oe,n)}function Ne(t,e,n,i){for(var r=n-1,o=t.length;++r<o;)if(i(t[r],e))return r;return-1}function Oe(t){return t!=t}function Re(t,e){var n=null==t?0:t.length;return n?He(t,e)/n:u}function ze(t){return function(e){return null==e?n:e[t]}}function De(t){return function(e){return null==t?n:t[e]}}function Be(t,e,n,i,r){return r(t,(function(t,r,o){n=i?(i=!1,t):e(n,t,r,o)})),n}function He(t,e){for(var i,r=-1,o=t.length;++r<o;){var a=e(t[r]);a!==n&&(i=i===n?a:i+a)}return i}function Fe(t,e){for(var n=-1,i=Array(t);++n<t;)i[n]=e(n);return i}function Ve(t){return t?t.slice(0,an(t)+1).replace(et,""):t}function je(t){return function(e){return t(e)}}function Ue(t,e){return Me(e,(function(e){return t[e]}))}function Ge(t,e){return t.has(e)}function We(t,e){for(var n=-1,i=t.length;++n<i&&Ie(e,t[n],0)>-1;);return n}function qe(t,e){for(var n=t.length;n--&&Ie(e,t[n],0)>-1;);return n}function Ye(t,e){for(var n=t.length,i=0;n--;)t[n]===e&&++i;return i}var Xe=De({"À":"A","Á":"A","Â":"A","Ã":"A","Ä":"A","Å":"A","à":"a","á":"a","â":"a","ã":"a","ä":"a","å":"a","Ç":"C","ç":"c","Ð":"D","ð":"d","È":"E","É":"E","Ê":"E","Ë":"E","è":"e","é":"e","ê":"e","ë":"e","Ì":"I","Í":"I","Î":"I","Ï":"I","ì":"i","í":"i","î":"i","ï":"i","Ñ":"N","ñ":"n","Ò":"O","Ó":"O","Ô":"O","Õ":"O","Ö":"O","Ø":"O","ò":"o","ó":"o","ô":"o","õ":"o","ö":"o","ø":"o","Ù":"U","Ú":"U","Û":"U","Ü":"U","ù":"u","ú":"u","û":"u","ü":"u","Ý":"Y","ý":"y","ÿ":"y","Æ":"Ae","æ":"ae","Þ":"Th","þ":"th","ß":"ss","Ā":"A","Ă":"A","Ą":"A","ā":"a","ă":"a","ą":"a","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","ć":"c","ĉ":"c","ċ":"c","č":"c","Ď":"D","Đ":"D","ď":"d","đ":"d","Ē":"E","Ĕ":"E","Ė":"E","Ę":"E","Ě":"E","ē":"e","ĕ":"e","ė":"e","ę":"e","ě":"e","Ĝ":"G","Ğ":"G","Ġ":"G","Ģ":"G","ĝ":"g","ğ":"g","ġ":"g","ģ":"g","Ĥ":"H","Ħ":"H","ĥ":"h","ħ":"h","Ĩ":"I","Ī":"I","Ĭ":"I","Į":"I","İ":"I","ĩ":"i","ī":"i","ĭ":"i","į":"i","ı":"i","Ĵ":"J","ĵ":"j","Ķ":"K","ķ":"k","ĸ":"k","Ĺ":"L","Ļ":"L","Ľ":"L","Ŀ":"L","Ł":"L","ĺ":"l","ļ":"l","ľ":"l","ŀ":"l","ł":"l","Ń":"N","Ņ":"N","Ň":"N","Ŋ":"N","ń":"n","ņ":"n","ň":"n","ŋ":"n","Ō":"O","Ŏ":"O","Ő":"O","ō":"o","ŏ":"o","ő":"o","Ŕ":"R","Ŗ":"R","Ř":"R","ŕ":"r","ŗ":"r","ř":"r","Ś":"S","Ŝ":"S","Ş":"S","Š":"S","ś":"s","ŝ":"s","ş":"s","š":"s","Ţ":"T","Ť":"T","Ŧ":"T","ţ":"t","ť":"t","ŧ":"t","Ũ":"U","Ū":"U","Ŭ":"U","Ů":"U","Ű":"U","Ų":"U","ũ":"u","ū":"u","ŭ":"u","ů":"u","ű":"u","ų":"u","Ŵ":"W","ŵ":"w","Ŷ":"Y","ŷ":"y","Ÿ":"Y","Ź":"Z","Ż":"Z","Ž":"Z","ź":"z","ż":"z","ž":"z","Ĳ":"IJ","ĳ":"ij","Œ":"Oe","œ":"oe","ŉ":"'n","ſ":"s"}),$e=De({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"});function Ke(t){return"\\"+Jt[t]}function Ze(t){return qt.test(t)}function Je(t){var e=-1,n=Array(t.size);return t.forEach((function(t,i){n[++e]=[i,t]})),n}function Qe(t,e){return function(n){return t(e(n))}}function tn(t,e){for(var n=-1,i=t.length,r=0,a=[];++n<i;){var s=t[n];s!==e&&s!==o||(t[n]=o,a[r++]=n)}return a}function en(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=t})),n}function nn(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=[t,t]})),n}function rn(t){return Ze(t)?(function e(t){for(var e=Gt.lastIndex=0;Gt.test(t);)++e;return e})(t):ke(t)}function on(t){return Ze(t)?(function e(t){return t.match(Gt)||[]})(t):(function n(t){return t.split("")})(t)}function an(t){for(var e=t.length;e--&&nt.test(t.charAt(e)););return e}var sn=De({"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"}),ln=(function t(e){var nt,vt=(e=null==e?ie:ln.defaults(ie.Object(),e,ln.pick(ie,Xt))).Array,bt=e.Date,xt=e.Error,wt=e.Function,St=e.Math,Mt=e.Object,Et=e.RegExp,Tt=e.String,At=e.TypeError,Ct=vt.prototype,kt=Mt.prototype,Lt=e["__core-js_shared__"],Pt=wt.prototype.toString,It=kt.hasOwnProperty,Nt=0,Ot=(nt=/[^.]+$/.exec(Lt&&Lt.keys&&Lt.keys.IE_PROTO||""))?"Symbol(src)_1."+nt:"",Rt=kt.toString,zt=Pt.call(Mt),Dt=ie._,Bt=Et("^"+Pt.call(It).replace(Q,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Ht=ae?e.Buffer:n,Ft=e.Symbol,Vt=e.Uint8Array,Gt=Ht?Ht.allocUnsafe:n,qt=Qe(Mt.getPrototypeOf,Mt),Jt=Mt.create,ee=kt.propertyIsEnumerable,ne=Ct.splice,re=Ft?Ft.isConcatSpreadable:n,oe=Ft?Ft.iterator:n,se=Ft?Ft.toStringTag:n,le=(function(){try{var t=Po(Mt,"defineProperty");return t({},"",{}),t}catch(t){}})(),ve=e.clearTimeout!==ie.clearTimeout&&e.clearTimeout,ke=bt&&bt.now!==ie.Date.now&&bt.now,De=e.setTimeout!==ie.setTimeout&&e.setTimeout,cn=St.ceil,un=St.floor,hn=Mt.getOwnPropertySymbols,dn=Ht?Ht.isBuffer:n,pn=e.isFinite,fn=Ct.join,mn=Qe(Mt.keys,Mt),gn=St.max,_n=St.min,yn=bt.now,vn=e.parseInt,bn=St.random,xn=Ct.reverse,wn=Po(e,"DataView"),Sn=Po(e,"Map"),Mn=Po(e,"Promise"),En=Po(e,"Set"),Tn=Po(e,"WeakMap"),An=Po(Mt,"create"),Cn=Tn&&new Tn,kn={},Ln=oa(wn),Pn=oa(Sn),In=oa(Mn),Nn=oa(En),On=oa(Tn),Rn=Ft?Ft.prototype:n,zn=Rn?Rn.valueOf:n,Dn=Rn?Rn.toString:n;function Bn(t){if(Ms(t)&&!hs(t)&&!(t instanceof jn)){if(t instanceof Vn)return t;if(It.call(t,"__wrapped__"))return aa(t)}return new Vn(t)}var Hn=(function(){function t(){}return function(e){if(!Ss(e))return{};if(Jt)return Jt(e);t.prototype=e;var i=new t;return t.prototype=n,i}})();function Fn(){}function Vn(t,e){this.__wrapped__=t,this.__actions__=[],this.__chain__=!!e,this.__index__=0,this.__values__=n}function jn(t){this.__wrapped__=t,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=h,this.__views__=[]}function Un(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function Gn(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function Wn(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function qn(t){var e=-1,n=null==t?0:t.length;for(this.__data__=new Wn;++e<n;)this.add(t[e])}function Yn(t){var e=this.__data__=new Gn(t);this.size=e.size}function Xn(t,e){var n=hs(t),i=!n&&us(t),r=!n&&!i&&gs(t),o=!n&&!i&&!r&&Rs(t),a=n||i||r||o,s=a?Fe(t.length,Tt):[],l=s.length;for(var c in t)!e&&!It.call(t,c)||a&&("length"==c||r&&("offset"==c||"parent"==c)||o&&("buffer"==c||"byteLength"==c||"byteOffset"==c)||Bo(c,l))||s.push(c);return s}function $n(t){var e=t.length;return e?t[pr(0,e-1)]:n}function Kn(t,e){return ea(Xr(t),oi(e,0,t.length))}function Zn(t){return ea(Xr(t))}function Jn(t,e,i){(i!==n&&!ss(t[e],i)||i===n&&!(e in t))&&ii(t,e,i)}function Qn(t,e,i){var r=t[e];It.call(t,e)&&ss(r,i)&&(i!==n||e in t)||ii(t,e,i)}function ti(t,e){for(var n=t.length;n--;)if(ss(t[n][0],e))return n;return-1}function ei(t,e,n,i){return Ii(t,(function(t,r,o){e(i,t,n(t),o)})),i}function ni(t,e){return t&&$r(e,rl(e),t)}function ii(t,e,n){"__proto__"==e&&le?le(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n}function ri(t,e){for(var i=-1,r=e.length,o=vt(r),a=null==t;++i<r;)o[i]=a?n:Qs(t,e[i]);return o}function oi(t,e,i){return t==t&&(i!==n&&(t=t<=i?t:i),e!==n&&(t=t>=e?t:e)),t}function ai(t,e,i,r,o,a){var s,l=1&e,c=2&e,u=4&e;if(i&&(s=o?i(t,r,o,a):i(t)),s!==n)return s;if(!Ss(t))return t;var h=hs(t);if(h){if(s=(function d(t){var e=t.length,n=new t.constructor(e);return e&&"string"==typeof t[0]&&It.call(t,"index")&&(n.index=t.index,n.input=t.input),n})(t),!l)return Xr(t,s)}else{var f=Oo(t),_=f==y||f==v;if(gs(t))return jr(t,l);if(f==w||f==p||_&&!o){if(s=c||_?{}:zo(t),!l)return c?(function C(t,e){return $r(t,No(t),e)})(t,(function S(t,e){return t&&$r(e,ol(e),t)})(s,t)):(function F(t,e){return $r(t,Io(t),e)})(t,ni(s,t))}else{if(!Zt[f])return o?t:{};s=(function V(t,e,n){var i=t.constructor;switch(e){case k:return Ur(t);case m:case g:return new i(+t);case L:return(function r(t,e){var n=e?Ur(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.byteLength)})(t,n);case P:case I:case N:case O:case R:case z:case D:case B:case H:return Gr(t,n);case b:return new i;case x:case T:return new i(t);case M:return(function o(t){var e=new t.constructor(t.source,ut.exec(t));return e.lastIndex=t.lastIndex,e})(t);case E:return new i;case A:return(function a(t){return zn?Mt(zn.call(t)):{}})(t)}})(t,f,l)}}a||(a=new Yn);var j=a.get(t);if(j)return j;a.set(t,s),Ps(t)?t.forEach((function(n){s.add(ai(n,e,i,n,t,a))})):Es(t)&&t.forEach((function(n,r){s.set(r,ai(n,e,i,r,t,a))}));var U=h?n:(u?c?Mo:So:c?ol:rl)(t);return _e(U||t,(function(n,r){U&&(n=t[r=n]),Qn(s,r,ai(n,e,i,r,t,a))})),s}function si(t,e,i){var r=i.length;if(null==t)return!r;for(t=Mt(t);r--;){var o=i[r],a=t[o];if(a===n&&!(o in t)||!(0,e[o])(a))return!1}return!0}function li(t,e,r){if("function"!=typeof t)throw new At(i);return Zo((function(){t.apply(n,r)}),e)}function ci(t,e,n,i){var r=-1,o=we,a=!0,s=t.length,l=[],c=e.length;if(!s)return l;n&&(e=Me(e,je(n))),i?(o=Se,a=!1):e.length>=200&&(o=Ge,a=!1,e=new qn(e));t:for(;++r<s;){var u=t[r],h=null==n?u:n(u);if(u=i||0!==u?u:0,a&&h==h){for(var d=c;d--;)if(e[d]===h)continue t;l.push(u)}else o(e,h,i)||l.push(u)}return l}Bn.templateSettings={escape:Y,evaluate:X,interpolate:$,variable:"",imports:{_:Bn}},(Bn.prototype=Fn.prototype).constructor=Bn,(Vn.prototype=Hn(Fn.prototype)).constructor=Vn,(jn.prototype=Hn(Fn.prototype)).constructor=jn,Un.prototype.clear=function ui(){this.__data__=An?An(null):{},this.size=0},Un.prototype.delete=function hi(t){var e=this.has(t)&&delete this.__data__[t];return this.size-=e?1:0,e},Un.prototype.get=function di(t){var e=this.__data__;if(An){var i=e[t];return i===r?n:i}return It.call(e,t)?e[t]:n},Un.prototype.has=function pi(t){var e=this.__data__;return An?e[t]!==n:It.call(e,t)},Un.prototype.set=function fi(t,e){var i=this.__data__;return this.size+=this.has(t)?0:1,i[t]=An&&e===n?r:e,this},Gn.prototype.clear=function mi(){this.__data__=[],this.size=0},Gn.prototype.delete=function gi(t){var e=this.__data__,n=ti(e,t);return!(n<0||(n==e.length-1?e.pop():ne.call(e,n,1),--this.size,0))},Gn.prototype.get=function _i(t){var e=this.__data__,i=ti(e,t);return i<0?n:e[i][1]},Gn.prototype.has=function yi(t){return ti(this.__data__,t)>-1},Gn.prototype.set=function vi(t,e){var n=this.__data__,i=ti(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this},Wn.prototype.clear=function bi(){this.size=0,this.__data__={hash:new Un,map:new(Sn||Gn),string:new Un}},Wn.prototype.delete=function xi(t){var e=ko(this,t).delete(t);return this.size-=e?1:0,e},Wn.prototype.get=function wi(t){return ko(this,t).get(t)},Wn.prototype.has=function Si(t){return ko(this,t).has(t)},Wn.prototype.set=function Mi(t,e){var n=ko(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this},qn.prototype.add=qn.prototype.push=function Ei(t){return this.__data__.set(t,r),this},qn.prototype.has=function Ti(t){return this.__data__.has(t)},Yn.prototype.clear=function Ai(){this.__data__=new Gn,this.size=0},Yn.prototype.delete=function Ci(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n},Yn.prototype.get=function ki(t){return this.__data__.get(t)},Yn.prototype.has=function Li(t){return this.__data__.has(t)},Yn.prototype.set=function Pi(t,e){var n=this.__data__;if(n instanceof Gn){var i=n.__data__;if(!Sn||i.length<199)return i.push([t,e]),this.size=++n.size,this;n=this.__data__=new Wn(i)}return n.set(t,e),this.size=n.size,this};var Ii=Jr(Fi),Ni=Jr(Vi,!0);function Oi(t,e){var n=!0;return Ii(t,(function(t,i,r){return n=!!e(t,i,r)})),n}function Ri(t,e,i){for(var r=-1,o=t.length;++r<o;){var a=t[r],s=e(a);if(null!=s&&(l===n?s==s&&!Os(s):i(s,l)))var l=s,c=a}return c}function zi(t,e){var n=[];return Ii(t,(function(t,i,r){e(t,i,r)&&n.push(t)})),n}function Di(t,e,n,i,r){var o=-1,a=t.length;for(n||(n=Do),r||(r=[]);++o<a;){var s=t[o];e>0&&n(s)?e>1?Di(s,e-1,n,i,r):Ee(r,s):i||(r[r.length]=s)}return r}var Bi=Qr(),Hi=Qr(!0);function Fi(t,e){return t&&Bi(t,e,rl)}function Vi(t,e){return t&&Hi(t,e,rl)}function ji(t,e){return xe(e,(function(e){return bs(t[e])}))}function Ui(t,e){for(var i=0,r=(e=Br(e,t)).length;null!=t&&i<r;)t=t[ra(e[i++])];return i&&i==r?t:n}function Gi(t,e,n){var i=e(t);return hs(t)?i:Ee(i,n(t))}function Wi(t){return null==t?t===n?"[object Undefined]":"[object Null]":se&&se in Mt(t)?(function e(t){var e=It.call(t,se),i=t[se];try{t[se]=n;var r=!0}catch(t){}var o=Rt.call(t);return r&&(e?t[se]=i:delete t[se]),o})(t):(function i(t){return Rt.call(t)})(t)}function qi(t,e){return t>e}function Yi(t,e){return null!=t&&It.call(t,e)}function Xi(t,e){return null!=t&&e in Mt(t)}function $i(t,e,i){for(var r=i?Se:we,o=t[0].length,a=t.length,s=a,l=vt(a),c=1/0,u=[];s--;){var h=t[s];s&&e&&(h=Me(h,je(e))),c=_n(h.length,c),l[s]=!i&&(e||o>=120&&h.length>=120)?new qn(s&&h):n}h=t[0];var d=-1,p=l[0];t:for(;++d<o&&u.length<c;){var f=h[d],m=e?e(f):f;if(f=i||0!==f?f:0,!(p?Ge(p,m):r(u,m,i))){for(s=a;--s;){var g=l[s];if(!(g?Ge(g,m):r(t[s],m,i)))continue t}p&&p.push(m),u.push(f)}}return u}function Ki(t,e,i){var r=null==(t=Yo(t,e=Br(e,t)))?t:t[ra(_a(e))];return null==r?n:me(r,t,i)}function Zi(t){return Ms(t)&&Wi(t)==p}function Ji(t,e,i,r,o){return t===e||(null==t||null==e||!Ms(t)&&!Ms(e)?t!=t&&e!=e:(function a(t,e,i,r,o,s){var l=hs(t),c=hs(e),u=l?f:Oo(t),h=c?f:Oo(e),d=(u=u==p?w:u)==w,y=(h=h==p?w:h)==w,v=u==h;if(v&&gs(t)){if(!gs(e))return!1;l=!0,d=!1}if(v&&!d)return s||(s=new Yn),l||Rs(t)?xo(t,e,i,r,o,s):(function S(t,e,n,i,r,o,a){switch(n){case L:if(t.byteLength!=e.byteLength||t.byteOffset!=e.byteOffset)return!1;t=t.buffer,e=e.buffer;case k:return!(t.byteLength!=e.byteLength||!o(new Vt(t),new Vt(e)));case m:case g:case x:return ss(+t,+e);case _:return t.name==e.name&&t.message==e.message;case M:case T:return t==e+"";case b:var s=Je;case E:if(s||(s=en),t.size!=e.size&&!(1&i))return!1;var l=a.get(t);if(l)return l==e;i|=2,a.set(t,e);var c=xo(s(t),s(e),i,r,o,a);return a.delete(t),c;case A:if(zn)return zn.call(t)==zn.call(e)}return!1})(t,e,u,i,r,o,s);if(!(1&i)){var C=d&&It.call(t,"__wrapped__"),P=y&&It.call(e,"__wrapped__");if(C||P){var I=C?t.value():t,N=P?e.value():e;return s||(s=new Yn),o(I,N,i,r,s)}}return!!v&&(s||(s=new Yn),(function O(t,e,i,r,o,a){var s=1&i,l=So(t),c=l.length;if(c!=So(e).length&&!s)return!1;for(var u=c;u--;){var h=l[u];if(!(s?h in e:It.call(e,h)))return!1}var d=a.get(t),p=a.get(e);if(d&&p)return d==e&&p==t;var f=!0;a.set(t,e),a.set(e,t);for(var m=s;++u<c;){var g=t[h=l[u]],_=e[h];if(r)var y=s?r(_,g,h,e,t,a):r(g,_,h,t,e,a);if(!(y===n?g===_||o(g,_,i,r,a):y)){f=!1;break}m||(m="constructor"==h)}if(f&&!m){var v=t.constructor,b=e.constructor;v==b||!("constructor"in t)||!("constructor"in e)||"function"==typeof v&&v instanceof v&&"function"==typeof b&&b instanceof b||(f=!1)}return a.delete(t),a.delete(e),f})(t,e,i,r,o,s))})(t,e,i,r,Ji,o))}function Qi(t,e,i,r){var o=i.length,a=o,s=!r;if(null==t)return!a;for(t=Mt(t);o--;){var l=i[o];if(s&&l[2]?l[1]!==t[l[0]]:!(l[0]in t))return!1}for(;++o<a;){var c=(l=i[o])[0],u=t[c],h=l[1];if(s&&l[2]){if(u===n&&!(c in t))return!1}else{var d=new Yn;if(r)var p=r(u,h,c,t,e,d);if(!(p===n?Ji(h,u,3,r,d):p))return!1}}return!0}function tr(t){return!(!Ss(t)||(function e(t){return!!Ot&&Ot in t})(t))&&(bs(t)?Bt:pt).test(oa(t))}function er(t){return"function"==typeof t?t:null==t?Ll:"object"==typeof t?hs(t)?ar(t[0],t[1]):or(t):Hl(t)}function nr(t){if(!Uo(t))return mn(t);var e=[];for(var n in Mt(t))It.call(t,n)&&"constructor"!=n&&e.push(n);return e}function ir(t,e){return t<e}function rr(t,e){var n=-1,i=fs(t)?vt(t.length):[];return Ii(t,(function(t,r,o){i[++n]=e(t,r,o)})),i}function or(t){var e=Lo(t);return 1==e.length&&e[0][2]?Wo(e[0][0],e[0][1]):function(n){return n===t||Qi(n,t,e)}}function ar(t,e){return Fo(t)&&Go(e)?Wo(ra(t),e):function(i){var r=Qs(i,t);return r===n&&r===e?tl(i,t):Ji(e,r,3)}}function sr(t,e,i,r,o){t!==e&&Bi(e,(function(a,s){if(o||(o=new Yn),Ss(a))!(function l(t,e,i,r,o,a,s){var l=$o(t,i),c=$o(e,i),u=s.get(c);if(u)Jn(t,i,u);else{var h=a?a(l,c,i+"",t,e,s):n,d=h===n;if(d){var p=hs(c),f=!p&&gs(c),m=!p&&!f&&Rs(c);h=c,p||f||m?hs(l)?h=l:ms(l)?h=Xr(l):f?(d=!1,h=jr(c,!0)):m?(d=!1,h=Gr(c,!0)):h=[]:Cs(c)||us(c)?(h=l,us(l)?h=Gs(l):Ss(l)&&!bs(l)||(h=zo(c))):d=!1}d&&(s.set(c,h),o(h,c,r,a,s),s.delete(c)),Jn(t,i,h)}})(t,e,s,i,sr,r,o);else{var c=r?r($o(t,s),a,s+"",t,e,o):n;c===n&&(c=a),Jn(t,s,c)}}),ol)}function lr(t,e){var i=t.length;if(i)return Bo(e+=e<0?i:0,i)?t[e]:n}function cr(t,e,n){e=e.length?Me(e,(function(t){return hs(t)?function(e){return Ui(e,1===t.length?t[0]:t)}:t})):[Ll];var i=-1;return e=Me(e,je(Co())),(function r(t,e){var n=t.length;for(t.sort(e);n--;)t[n]=t[n].value;return t})(rr(t,(function(t,n,r){return{criteria:Me(e,(function(e){return e(t)})),index:++i,value:t}})),(function(t,e){return(function i(t,e,n){for(var i=-1,r=t.criteria,o=e.criteria,a=r.length,s=n.length;++i<a;){var l=Wr(r[i],o[i]);if(l)return i>=s?l:l*("desc"==n[i]?-1:1)}return t.index-e.index})(t,e,n)}))}function ur(t,e,n){for(var i=-1,r=e.length,o={};++i<r;){var a=e[i],s=Ui(t,a);n(s,a)&&yr(o,Br(a,t),s)}return o}function hr(t,e,n,i){var r=i?Ne:Ie,o=-1,a=e.length,s=t;for(t===e&&(e=Xr(e)),n&&(s=Me(t,je(n)));++o<a;)for(var l=0,c=e[o],u=n?n(c):c;(l=r(s,u,l,i))>-1;)s!==t&&ne.call(s,l,1),ne.call(t,l,1);return t}function dr(t,e){for(var n=t?e.length:0,i=n-1;n--;){var r=e[n];if(n==i||r!==o){var o=r;Bo(r)?ne.call(t,r,1):Lr(t,r)}}return t}function pr(t,e){return t+un(bn()*(e-t+1))}function fr(t,e){var n="";if(!t||e<1||e>c)return n;do{e%2&&(n+=t),(e=un(e/2))&&(t+=t)}while(e);return n}function mr(t,e){return Jo(qo(t,e,Ll),t+"")}function gr(t){return $n(pl(t))}function _r(t,e){var n=pl(t);return ea(n,oi(e,0,n.length))}function yr(t,e,i,r){if(!Ss(t))return t;for(var o=-1,a=(e=Br(e,t)).length,s=a-1,l=t;null!=l&&++o<a;){var c=ra(e[o]),u=i;if("__proto__"===c||"constructor"===c||"prototype"===c)return t;if(o!=s){var h=l[c];(u=r?r(h,c,l):n)===n&&(u=Ss(h)?h:Bo(e[o+1])?[]:{})}Qn(l,c,u),l=l[c]}return t}var vr=Cn?function(t,e){return Cn.set(t,e),t}:Ll,br=le?function(t,e){return le(t,"toString",{configurable:!0,enumerable:!1,value:Al(e),writable:!0})}:Ll;function xr(t){return ea(pl(t))}function wr(t,e,n){var i=-1,r=t.length;e<0&&(e=-e>r?0:r+e),(n=n>r?r:n)<0&&(n+=r),r=e>n?0:n-e>>>0,e>>>=0;for(var o=vt(r);++i<r;)o[i]=t[i+e];return o}function Sr(t,e){var n;return Ii(t,(function(t,i,r){return!(n=e(t,i,r))})),!!n}function Mr(t,e,n){var i=0,r=null==t?i:t.length;if("number"==typeof e&&e==e&&r<=2147483647){for(;i<r;){var o=i+r>>>1,a=t[o];null!==a&&!Os(a)&&(n?a<=e:a<e)?i=o+1:r=o}return r}return Er(t,e,Ll,n)}function Er(t,e,i,r){var o=0,a=null==t?0:t.length;if(0===a)return 0;for(var s=(e=i(e))!=e,l=null===e,c=Os(e),u=e===n;o<a;){var h=un((o+a)/2),d=i(t[h]),p=d!==n,f=null===d,m=d==d,g=Os(d);if(s)var _=r||m;else _=u?m&&(r||p):l?m&&p&&(r||!f):c?m&&p&&!f&&(r||!g):!f&&!g&&(r?d<=e:d<e);_?o=h+1:a=h}return _n(a,4294967294)}function Tr(t,e){for(var n=-1,i=t.length,r=0,o=[];++n<i;){var a=t[n],s=e?e(a):a;if(!n||!ss(s,l)){var l=s;o[r++]=0===a?0:a}}return o}function Ar(t){return"number"==typeof t?t:Os(t)?u:+t}function Cr(t){if("string"==typeof t)return t;if(hs(t))return Me(t,Cr)+"";if(Os(t))return Dn?Dn.call(t):"";var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}function kr(t,e,n){var i=-1,r=we,o=t.length,a=!0,s=[],l=s;if(n)a=!1,r=Se;else if(o>=200){var c=e?null:mo(t);if(c)return en(c);a=!1,r=Ge,l=new qn}else l=e?[]:s;t:for(;++i<o;){var u=t[i],h=e?e(u):u;if(u=n||0!==u?u:0,a&&h==h){for(var d=l.length;d--;)if(l[d]===h)continue t;e&&l.push(h),s.push(u)}else r(l,h,n)||(l!==s&&l.push(h),s.push(u))}return s}function Lr(t,e){return null==(t=Yo(t,e=Br(e,t)))||delete t[ra(_a(e))]}function Pr(t,e,n,i){return yr(t,e,n(Ui(t,e)),i)}function Ir(t,e,n,i){for(var r=t.length,o=i?r:-1;(i?o--:++o<r)&&e(t[o],o,t););return n?wr(t,i?0:o,i?o+1:r):wr(t,i?o+1:0,i?r:o)}function Nr(t,e){var n=t;return n instanceof jn&&(n=n.value()),Te(e,(function(t,e){return e.func.apply(e.thisArg,Ee([t],e.args))}),n)}function Or(t,e,n){var i=t.length;if(i<2)return i?kr(t[0]):[];for(var r=-1,o=vt(i);++r<i;)for(var a=t[r],s=-1;++s<i;)s!=r&&(o[r]=ci(o[r]||a,t[s],e,n));return kr(Di(o,1),e,n)}function Rr(t,e,i){for(var r=-1,o=t.length,a=e.length,s={};++r<o;)i(s,t[r],r<a?e[r]:n);return s}function zr(t){return ms(t)?t:[]}function Dr(t){return"function"==typeof t?t:Ll}function Br(t,e){return hs(t)?t:Fo(t,e)?[t]:na(Ws(t))}var Hr=mr;function Fr(t,e,i){var r=t.length;return i=i===n?r:i,!e&&i>=r?t:wr(t,e,i)}var Vr=ve||function(t){return ie.clearTimeout(t)};function jr(t,e){if(e)return t.slice();var n=t.length,i=Gt?Gt(n):new t.constructor(n);return t.copy(i),i}function Ur(t){var e=new t.constructor(t.byteLength);return new Vt(e).set(new Vt(t)),e}function Gr(t,e){var n=e?Ur(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.length)}function Wr(t,e){if(t!==e){var i=t!==n,r=null===t,o=t==t,a=Os(t),s=e!==n,l=null===e,c=e==e,u=Os(e);if(!l&&!u&&!a&&t>e||a&&s&&c&&!l&&!u||r&&s&&c||!i&&c||!o)return 1;if(!r&&!a&&!u&&t<e||u&&i&&o&&!r&&!a||l&&i&&o||!s&&o||!c)return-1}return 0}function qr(t,e,n,i){for(var r=-1,o=t.length,a=n.length,s=-1,l=e.length,c=gn(o-a,0),u=vt(l+c),h=!i;++s<l;)u[s]=e[s];for(;++r<a;)(h||r<o)&&(u[n[r]]=t[r]);for(;c--;)u[s++]=t[r++];return u}function Yr(t,e,n,i){for(var r=-1,o=t.length,a=-1,s=n.length,l=-1,c=e.length,u=gn(o-s,0),h=vt(u+c),d=!i;++r<u;)h[r]=t[r];for(var p=r;++l<c;)h[p+l]=e[l];for(;++a<s;)(d||r<o)&&(h[p+n[a]]=t[r++]);return h}function Xr(t,e){var n=-1,i=t.length;for(e||(e=vt(i));++n<i;)e[n]=t[n];return e}function $r(t,e,i,r){var o=!i;i||(i={});for(var a=-1,s=e.length;++a<s;){var l=e[a],c=r?r(i[l],t[l],l,i,t):n;c===n&&(c=t[l]),o?ii(i,l,c):Qn(i,l,c)}return i}function Kr(t,e){return function(n,i){var r=hs(n)?ge:ei,o=e?e():{};return r(n,t,Co(i,2),o)}}function Zr(t){return mr((function(e,i){var r=-1,o=i.length,a=o>1?i[o-1]:n,s=o>2?i[2]:n;for(a=t.length>3&&"function"==typeof a?(o--,a):n,s&&Ho(i[0],i[1],s)&&(a=o<3?n:a,o=1),e=Mt(e);++r<o;){var l=i[r];l&&t(e,l,r,a)}return e}))}function Jr(t,e){return function(n,i){if(null==n)return n;if(!fs(n))return t(n,i);for(var r=n.length,o=e?r:-1,a=Mt(n);(e?o--:++o<r)&&!1!==i(a[o],o,a););return n}}function Qr(t){return function(e,n,i){for(var r=-1,o=Mt(e),a=i(e),s=a.length;s--;){var l=a[t?s:++r];if(!1===n(o[l],l,o))break}return e}}function to(t){return function(e){var i=Ze(e=Ws(e))?on(e):n,r=i?i[0]:e.charAt(0),o=i?Fr(i,1).join(""):e.slice(1);return r[t]()+o}}function eo(t){return function(e){return Te(Ml(gl(e).replace(jt,"")),t,"")}}function no(t){return function(){var e=arguments;switch(e.length){case 0:return new t;case 1:return new t(e[0]);case 2:return new t(e[0],e[1]);case 3:return new t(e[0],e[1],e[2]);case 4:return new t(e[0],e[1],e[2],e[3]);case 5:return new t(e[0],e[1],e[2],e[3],e[4]);case 6:return new t(e[0],e[1],e[2],e[3],e[4],e[5]);case 7:return new t(e[0],e[1],e[2],e[3],e[4],e[5],e[6])}var n=Hn(t.prototype),i=t.apply(n,e);return Ss(i)?i:n}}function io(t){return function(e,i,r){var o=Mt(e);if(!fs(e)){var a=Co(i,3);e=rl(e),i=function(t){return a(o[t],t,o)}}var s=t(e,i,r);return s>-1?o[a?e[s]:s]:n}}function ro(t){return wo((function(e){var r=e.length,o=r,a=Vn.prototype.thru;for(t&&e.reverse();o--;){var s=e[o];if("function"!=typeof s)throw new At(i);if(a&&!l&&"wrapper"==To(s))var l=new Vn([],!0)}for(o=l?o:r;++o<r;){var c=To(s=e[o]),u="wrapper"==c?Eo(s):n;l=u&&Vo(u[0])&&424==u[1]&&!u[4].length&&1==u[9]?l[To(u[0])].apply(l,u[3]):1==s.length&&Vo(s)?l[c]():l.thru(s)}return function(){var t=arguments,n=t[0];if(l&&1==t.length&&hs(n))return l.plant(n).value();for(var i=0,o=r?e[i].apply(this,t):n;++i<r;)o=e[i].call(this,o);return o}}))}function oo(t,e,i,r,o,a,l,c,u,h){var d=e&s,p=1&e,f=2&e,m=24&e,g=512&e,_=f?n:no(t);return function n(){for(var s=arguments.length,y=vt(s),v=s;v--;)y[v]=arguments[v];if(m)var b=Ao(n),x=Ye(y,b);if(r&&(y=qr(y,r,o,m)),a&&(y=Yr(y,a,l,m)),s-=x,m&&s<h){var w=tn(y,b);return po(t,e,oo,n.placeholder,i,y,w,c,u,h-s)}var S=p?i:this,M=f?S[t]:t;return s=y.length,c?y=Xo(y,c):g&&s>1&&y.reverse(),d&&u<s&&(y.length=u),this&&this!==ie&&this instanceof n&&(M=_||no(M)),M.apply(S,y)}}function ao(t,e){return function(n,i){return(function r(t,e,n,i){return Fi(t,(function(t,r,o){e(i,n(t),r,o)})),i})(n,t,e(i),{})}}function so(t,e){return function(i,r){var o;if(i===n&&r===n)return e;if(i!==n&&(o=i),r!==n){if(o===n)return r;"string"==typeof i||"string"==typeof r?(i=Cr(i),r=Cr(r)):(i=Ar(i),r=Ar(r)),o=t(i,r)}return o}}function lo(t){return wo((function(e){return e=Me(e,je(Co())),mr((function(n){var i=this;return t(e,(function(t){return me(t,i,n)}))}))}))}function co(t,e){var i=(e=e===n?" ":Cr(e)).length;if(i<2)return i?fr(e,t):e;var r=fr(e,cn(t/rn(e)));return Ze(e)?Fr(on(r),0,t).join(""):r.slice(0,t)}function uo(t){return function(e,i,r){return r&&"number"!=typeof r&&Ho(e,i,r)&&(i=r=n),e=Fs(e),i===n?(i=e,e=0):i=Fs(i),(function o(t,e,n,i){for(var r=-1,o=gn(cn((e-t)/(n||1)),0),a=vt(o);o--;)a[i?o:++r]=t,t+=n;return a})(e,i,r=r===n?e<i?1:-1:Fs(r),t)}}function ho(t){return function(e,n){return"string"==typeof e&&"string"==typeof n||(e=Us(e),n=Us(n)),t(e,n)}}function po(t,e,i,r,o,s,l,c,u,h){var d=8&e;e|=d?a:64,4&(e&=~(d?64:a))||(e&=-4);var p=[t,e,o,d?s:n,d?l:n,d?n:s,d?n:l,c,u,h],f=i.apply(n,p);return Vo(t)&&Ko(f,p),f.placeholder=r,Qo(f,t,e)}function fo(t){var e=St[t];return function(t,n){if(t=Us(t),(n=null==n?0:_n(Vs(n),292))&&pn(t)){var i=(Ws(t)+"e").split("e");return+((i=(Ws(e(i[0]+"e"+(+i[1]+n)))+"e").split("e"))[0]+"e"+(+i[1]-n))}return e(t)}}var mo=En&&1/en(new En([,-0]))[1]==l?function(t){return new En(t)}:Rl;function go(t){return function(e){var n=Oo(e);return n==b?Je(e):n==E?nn(e):(function i(t,e){return Me(e,(function(e){return[e,t[e]]}))})(e,t(e))}}function _o(t,e,r,l,c,u,h,d){var p=2&e;if(!p&&"function"!=typeof t)throw new At(i);var f=l?l.length:0;if(f||(e&=-97,l=c=n),h=h===n?h:gn(Vs(h),0),d=d===n?d:Vs(d),f-=c?c.length:0,64&e){var m=l,g=c;l=c=n}var _=p?n:Eo(t),y=[t,e,r,l,c,m,g,u,h,d];if(_&&(function v(t,e){var n=t[1],i=e[1],r=n|i;if(!(r<131||i==s&&8==n||i==s&&256==n&&t[7].length<=e[8]||384==i&&e[7].length<=e[8]&&8==n))return t;1&i&&(t[2]=e[2],r|=1&n?0:4);var a=e[3];if(a){var l=t[3];t[3]=l?qr(l,a,e[4]):a,t[4]=l?tn(t[3],o):e[4]}(a=e[5])&&(t[5]=(l=t[5])?Yr(l,a,e[6]):a,t[6]=l?tn(t[5],o):e[6]),(a=e[7])&&(t[7]=a),i&s&&(t[8]=null==t[8]?e[8]:_n(t[8],e[8])),null==t[9]&&(t[9]=e[9]),t[0]=e[0],t[1]=r})(y,_),t=y[0],e=y[1],r=y[2],l=y[3],c=y[4],!(d=y[9]=y[9]===n?p?0:t.length:gn(y[9]-f,0))&&24&e&&(e&=-25),e&&1!=e)w=8==e||16==e?(function b(t,e,i){var r=no(t);return function o(){for(var a=arguments.length,s=vt(a),l=a,c=Ao(o);l--;)s[l]=arguments[l];var u=a<3&&s[0]!==c&&s[a-1]!==c?[]:tn(s,c);return(a-=u.length)<i?po(t,e,oo,o.placeholder,n,s,u,n,n,i-a):me(this&&this!==ie&&this instanceof o?r:t,this,s)}})(t,e,d):e!=a&&33!=e||c.length?oo.apply(n,y):(function x(t,e,n,i){var r=1&e,o=no(t);return function e(){for(var a=-1,s=arguments.length,l=-1,c=i.length,u=vt(c+s),h=this&&this!==ie&&this instanceof e?o:t;++l<c;)u[l]=i[l];for(;s--;)u[l++]=arguments[++a];return me(h,r?n:this,u)}})(t,e,r,l);else var w=(function S(t,e,n){var i=1&e,r=no(t);return function e(){return(this&&this!==ie&&this instanceof e?r:t).apply(i?n:this,arguments)}})(t,e,r);return Qo((_?vr:Ko)(w,y),t,e)}function yo(t,e,i,r){return t===n||ss(t,kt[i])&&!It.call(r,i)?e:t}function vo(t,e,i,r,o,a){return Ss(t)&&Ss(e)&&(a.set(e,t),sr(t,e,n,vo,a),a.delete(e)),t}function bo(t){return Cs(t)?n:t}function xo(t,e,i,r,o,a){var s=1&i,l=t.length,c=e.length;if(l!=c&&!(s&&c>l))return!1;var u=a.get(t),h=a.get(e);if(u&&h)return u==e&&h==t;var d=-1,p=!0,f=2&i?new qn:n;for(a.set(t,e),a.set(e,t);++d<l;){var m=t[d],g=e[d];if(r)var _=s?r(g,m,d,e,t,a):r(m,g,d,t,e,a);if(_!==n){if(_)continue;p=!1;break}if(f){if(!Ce(e,(function(t,e){if(!Ge(f,e)&&(m===t||o(m,t,i,r,a)))return f.push(e)}))){p=!1;break}}else if(m!==g&&!o(m,g,i,r,a)){p=!1;break}}return a.delete(t),a.delete(e),p}function wo(t){return Jo(qo(t,n,da),t+"")}function So(t){return Gi(t,rl,Io)}function Mo(t){return Gi(t,ol,No)}var Eo=Cn?function(t){return Cn.get(t)}:Rl;function To(t){for(var e=t.name+"",n=kn[e],i=It.call(kn,e)?n.length:0;i--;){var r=n[i],o=r.func;if(null==o||o==t)return r.name}return e}function Ao(t){return(It.call(Bn,"placeholder")?Bn:t).placeholder}function Co(){var t=Bn.iteratee||Pl;return t=t===Pl?er:t,arguments.length?t(arguments[0],arguments[1]):t}function ko(t,e){var n=t.__data__;return(function i(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t})(e)?n["string"==typeof e?"string":"hash"]:n.map}function Lo(t){for(var e=rl(t),n=e.length;n--;){var i=e[n],r=t[i];e[n]=[i,r,Go(r)]}return e}function Po(t,e){var i=(function r(t,e){return null==t?n:t[e]})(t,e);return tr(i)?i:n}var Io=hn?function(t){return null==t?[]:(t=Mt(t),xe(hn(t),(function(e){return ee.call(t,e)})))}:jl,No=hn?function(t){for(var e=[];t;)Ee(e,Io(t)),t=qt(t);return e}:jl,Oo=Wi;function Ro(t,e,n){for(var i=-1,r=(e=Br(e,t)).length,o=!1;++i<r;){var a=ra(e[i]);if(!(o=null!=t&&n(t,a)))break;t=t[a]}return o||++i!=r?o:!!(r=null==t?0:t.length)&&ws(r)&&Bo(a,r)&&(hs(t)||us(t))}function zo(t){return"function"!=typeof t.constructor||Uo(t)?{}:Hn(qt(t))}function Do(t){return hs(t)||us(t)||!!(re&&t&&t[re])}function Bo(t,e){var n=typeof t;return!!(e=null==e?c:e)&&("number"==n||"symbol"!=n&&mt.test(t))&&t>-1&&t%1==0&&t<e}function Ho(t,e,n){if(!Ss(n))return!1;var i=typeof e;return!!("number"==i?fs(n)&&Bo(e,n.length):"string"==i&&e in n)&&ss(n[e],t)}function Fo(t,e){if(hs(t))return!1;var n=typeof t;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=t&&!Os(t))||Z.test(t)||!K.test(t)||null!=e&&t in Mt(e)}function Vo(t){var e=To(t),n=Bn[e];if("function"!=typeof n||!(e in jn.prototype))return!1;if(t===n)return!0;var i=Eo(n);return!!i&&t===i[0]}(wn&&Oo(new wn(new ArrayBuffer(1)))!=L||Sn&&Oo(new Sn)!=b||Mn&&Oo(Mn.resolve())!=S||En&&Oo(new En)!=E||Tn&&Oo(new Tn)!=C)&&(Oo=function(t){var e=Wi(t),i=e==w?t.constructor:n,r=i?oa(i):"";if(r)switch(r){case Ln:return L;case Pn:return b;case In:return S;case Nn:return E;case On:return C}return e});var jo=Lt?bs:Ul;function Uo(t){var e=t&&t.constructor;return t===("function"==typeof e&&e.prototype||kt)}function Go(t){return t==t&&!Ss(t)}function Wo(t,e){return function(i){return null!=i&&i[t]===e&&(e!==n||t in Mt(i))}}function qo(t,e,i){return e=gn(e===n?t.length-1:e,0),function(){for(var n=arguments,r=-1,o=gn(n.length-e,0),a=vt(o);++r<o;)a[r]=n[e+r];r=-1;for(var s=vt(e+1);++r<e;)s[r]=n[r];return s[e]=i(a),me(t,this,s)}}function Yo(t,e){return e.length<2?t:Ui(t,wr(e,0,-1))}function Xo(t,e){for(var i=t.length,r=_n(e.length,i),o=Xr(t);r--;){var a=e[r];t[r]=Bo(a,i)?o[a]:n}return t}function $o(t,e){if(("constructor"!==e||"function"!=typeof t[e])&&"__proto__"!=e)return t[e]}var Ko=ta(vr),Zo=De||function(t,e){return ie.setTimeout(t,e)},Jo=ta(br);function Qo(t,e,n){var i=e+"";return Jo(t,(function a(t,e){var n=e.length;if(!n)return t;var i=n-1;return e[i]=(n>1?"& ":"")+e[i],e=e.join(n>2?", ":" "),t.replace(it,"{\n/* [wrapped with "+e+"] */\n")})(i,(function o(t,e){return _e(d,(function(n){var i="_."+n[0];e&n[1]&&!we(t,i)&&t.push(i)})),t.sort()})((function r(t){var e=t.match(rt);return e?e[1].split(ot):[]})(i),n)))}function ta(t){var e=0,i=0;return function(){var r=yn(),o=16-(r-i);if(i=r,o>0){if(++e>=800)return arguments[0]}else e=0;return t.apply(n,arguments)}}function ea(t,e){var i=-1,r=t.length,o=r-1;for(e=e===n?r:e;++i<e;){var a=pr(i,o),s=t[a];t[a]=t[i],t[i]=s}return t.length=e,t}var na=(function ia(t){var e=es(t,(function(t){return 500===n.size&&n.clear(),t})),n=e.cache;return e})((function(t){var e=[];return 46===t.charCodeAt(0)&&e.push(""),t.replace(J,(function(t,n,i,r){e.push(i?r.replace(lt,"$1"):n||t)})),e}));function ra(t){if("string"==typeof t||Os(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}function oa(t){if(null!=t){try{return Pt.call(t)}catch(t){}try{return t+""}catch(t){}}return""}function aa(t){if(t instanceof jn)return t.clone();var e=new Vn(t.__wrapped__,t.__chain__);return e.__actions__=Xr(t.__actions__),e.__index__=t.__index__,e.__values__=t.__values__,e}var sa=mr((function(t,e){return ms(t)?ci(t,Di(e,1,ms,!0)):[]})),la=mr((function(t,e){var i=_a(e);return ms(i)&&(i=n),ms(t)?ci(t,Di(e,1,ms,!0),Co(i,2)):[]})),ca=mr((function(t,e){var i=_a(e);return ms(i)&&(i=n),ms(t)?ci(t,Di(e,1,ms,!0),n,i):[]}));function ua(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var r=null==n?0:Vs(n);return r<0&&(r=gn(i+r,0)),Pe(t,Co(e,3),r)}function ha(t,e,i){var r=null==t?0:t.length;if(!r)return-1;var o=r-1;return i!==n&&(o=Vs(i),o=i<0?gn(r+o,0):_n(o,r-1)),Pe(t,Co(e,3),o,!0)}function da(t){return null!=t&&t.length?Di(t,1):[]}function pa(t){return t&&t.length?t[0]:n}var fa=mr((function(t){var e=Me(t,zr);return e.length&&e[0]===t[0]?$i(e):[]})),ma=mr((function(t){var e=_a(t),i=Me(t,zr);return e===_a(i)?e=n:i.pop(),i.length&&i[0]===t[0]?$i(i,Co(e,2)):[]})),ga=mr((function(t){var e=_a(t),i=Me(t,zr);return(e="function"==typeof e?e:n)&&i.pop(),i.length&&i[0]===t[0]?$i(i,n,e):[]}));function _a(t){var e=null==t?0:t.length;return e?t[e-1]:n}var ya=mr(va);function va(t,e){return t&&t.length&&e&&e.length?hr(t,e):t}var ba=wo((function(t,e){var n=null==t?0:t.length,i=ri(t,e);return dr(t,Me(e,(function(t){return Bo(t,n)?+t:t})).sort(Wr)),i}));function xa(t){return null==t?t:xn.call(t)}var wa=mr((function(t){return kr(Di(t,1,ms,!0))})),Sa=mr((function(t){var e=_a(t);return ms(e)&&(e=n),kr(Di(t,1,ms,!0),Co(e,2))})),Ma=mr((function(t){var e=_a(t);return e="function"==typeof e?e:n,kr(Di(t,1,ms,!0),n,e)}));function Ea(t){if(!t||!t.length)return[];var e=0;return t=xe(t,(function(t){if(ms(t))return e=gn(t.length,e),!0})),Fe(e,(function(e){return Me(t,ze(e))}))}function Ta(t,e){if(!t||!t.length)return[];var i=Ea(t);return null==e?i:Me(i,(function(t){return me(e,n,t)}))}var Aa=mr((function(t,e){return ms(t)?ci(t,e):[]})),Ca=mr((function(t){return Or(xe(t,ms))})),ka=mr((function(t){var e=_a(t);return ms(e)&&(e=n),Or(xe(t,ms),Co(e,2))})),La=mr((function(t){var e=_a(t);return e="function"==typeof e?e:n,Or(xe(t,ms),n,e)})),Pa=mr(Ea),Ia=mr((function(t){var e=t.length,i=e>1?t[e-1]:n;return i="function"==typeof i?(t.pop(),i):n,Ta(t,i)}));function Na(t){var e=Bn(t);return e.__chain__=!0,e}function Oa(t,e){return e(t)}var Ra=wo((function(t){var e=t.length,i=e?t[0]:0,r=this.__wrapped__,o=function(e){return ri(e,t)};return!(e>1||this.__actions__.length)&&r instanceof jn&&Bo(i)?((r=r.slice(i,+i+(e?1:0))).__actions__.push({func:Oa,args:[o],thisArg:n}),new Vn(r,this.__chain__).thru((function(t){return e&&!t.length&&t.push(n),t}))):this.thru(o)})),za=Kr((function(t,e,n){It.call(t,n)?++t[n]:ii(t,n,1)})),Da=io(ua),Ba=io(ha);function Ha(t,e){return(hs(t)?_e:Ii)(t,Co(e,3))}function Fa(t,e){return(hs(t)?ye:Ni)(t,Co(e,3))}var Va=Kr((function(t,e,n){It.call(t,n)?t[n].push(e):ii(t,n,[e])})),ja=mr((function(t,e,n){var i=-1,r="function"==typeof e,o=fs(t)?vt(t.length):[];return Ii(t,(function(t){o[++i]=r?me(e,t,n):Ki(t,e,n)})),o})),Ua=Kr((function(t,e,n){ii(t,n,e)}));function Ga(t,e){return(hs(t)?Me:rr)(t,Co(e,3))}var Wa=Kr((function(t,e,n){t[n?0:1].push(e)}),(function(){return[[],[]]})),qa=mr((function(t,e){if(null==t)return[];var n=e.length;return n>1&&Ho(t,e[0],e[1])?e=[]:n>2&&Ho(e[0],e[1],e[2])&&(e=[e[0]]),cr(t,Di(e,1),[])})),Ya=ke||function(){return ie.Date.now()};function Xa(t,e,i){return e=i?n:e,_o(t,s,n,n,n,n,e=t&&null==e?t.length:e)}function $a(t,e){var r;if("function"!=typeof e)throw new At(i);return t=Vs(t),function(){return--t>0&&(r=e.apply(this,arguments)),t<=1&&(e=n),r}}var Ka=mr((function(t,e,n){var i=1;if(n.length){var r=tn(n,Ao(Ka));i|=a}return _o(t,i,e,n,r)})),Za=mr((function(t,e,n){var i=3;if(n.length){var r=tn(n,Ao(Za));i|=a}return _o(e,i,t,n,r)}));function Ja(t,e,r){var o,a,s,l,c,u,h=0,d=!1,p=!1,f=!0;if("function"!=typeof t)throw new At(i);function m(e){var i=o,r=a;return o=a=n,h=e,l=t.apply(r,i)}function g(t){return h=t,c=Zo(y,e),d?m(t):l}function _(t){var i=t-u;return u===n||i>=e||i<0||p&&t-h>=s}function y(){var t=Ya();if(_(t))return v(t);c=Zo(y,(function n(t){var n=e-(t-u);return p?_n(n,s-(t-h)):n})(t))}function v(t){return c=n,f&&o?m(t):(o=a=n,l)}function b(){var t=Ya(),i=_(t);if(o=arguments,a=this,u=t,i){if(c===n)return g(u);if(p)return Vr(c),c=Zo(y,e),m(u)}return c===n&&(c=Zo(y,e)),l}return e=Us(e)||0,Ss(r)&&(d=!!r.leading,s=(p="maxWait"in r)?gn(Us(r.maxWait)||0,e):s,f="trailing"in r?!!r.trailing:f),b.cancel=function x(){c!==n&&Vr(c),h=0,o=u=a=c=n},b.flush=function w(){return c===n?l:v(Ya())},b}var Qa=mr((function(t,e){return li(t,1,e)})),ts=mr((function(t,e,n){return li(t,Us(e)||0,n)}));function es(t,e){if("function"!=typeof t||null!=e&&"function"!=typeof e)throw new At(i);var n=function(){var i=arguments,r=e?e.apply(this,i):i[0],o=n.cache;if(o.has(r))return o.get(r);var a=t.apply(this,i);return n.cache=o.set(r,a)||o,a};return n.cache=new(es.Cache||Wn),n}function ns(t){if("function"!=typeof t)throw new At(i);return function(){var e=arguments;switch(e.length){case 0:return!t.call(this);case 1:return!t.call(this,e[0]);case 2:return!t.call(this,e[0],e[1]);case 3:return!t.call(this,e[0],e[1],e[2])}return!t.apply(this,e)}}es.Cache=Wn;var is=Hr((function(t,e){var n=(e=1==e.length&&hs(e[0])?Me(e[0],je(Co())):Me(Di(e,1),je(Co()))).length;return mr((function(i){for(var r=-1,o=_n(i.length,n);++r<o;)i[r]=e[r].call(this,i[r]);return me(t,this,i)}))})),rs=mr((function(t,e){var i=tn(e,Ao(rs));return _o(t,a,n,e,i)})),os=mr((function(t,e){var i=tn(e,Ao(os));return _o(t,64,n,e,i)})),as=wo((function(t,e){return _o(t,256,n,n,n,e)}));function ss(t,e){return t===e||t!=t&&e!=e}var ls=ho(qi),cs=ho((function(t,e){return t>=e})),us=Zi((function(){return arguments})())?Zi:function(t){return Ms(t)&&It.call(t,"callee")&&!ee.call(t,"callee")},hs=vt.isArray,ds=ce?je(ce):function ps(t){return Ms(t)&&Wi(t)==k};function fs(t){return null!=t&&ws(t.length)&&!bs(t)}function ms(t){return Ms(t)&&fs(t)}var gs=dn||Ul,_s=ue?je(ue):function ys(t){return Ms(t)&&Wi(t)==g};function vs(t){if(!Ms(t))return!1;var e=Wi(t);return e==_||"[object DOMException]"==e||"string"==typeof t.message&&"string"==typeof t.name&&!Cs(t)}function bs(t){if(!Ss(t))return!1;var e=Wi(t);return e==y||e==v||"[object AsyncFunction]"==e||"[object Proxy]"==e}function xs(t){return"number"==typeof t&&t==Vs(t)}function ws(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=c}function Ss(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}function Ms(t){return null!=t&&"object"==typeof t}var Es=he?je(he):function Ts(t){return Ms(t)&&Oo(t)==b};function As(t){return"number"==typeof t||Ms(t)&&Wi(t)==x}function Cs(t){if(!Ms(t)||Wi(t)!=w)return!1;var e=qt(t);if(null===e)return!0;var n=It.call(e,"constructor")&&e.constructor;return"function"==typeof n&&n instanceof n&&Pt.call(n)==zt}var ks=de?je(de):function Ls(t){return Ms(t)&&Wi(t)==M},Ps=pe?je(pe):function Is(t){return Ms(t)&&Oo(t)==E};function Ns(t){return"string"==typeof t||!hs(t)&&Ms(t)&&Wi(t)==T}function Os(t){return"symbol"==typeof t||Ms(t)&&Wi(t)==A}var Rs=fe?je(fe):function zs(t){return Ms(t)&&ws(t.length)&&!!Kt[Wi(t)]},Ds=ho(ir),Bs=ho((function(t,e){return t<=e}));function Hs(t){if(!t)return[];if(fs(t))return Ns(t)?on(t):Xr(t);if(oe&&t[oe])return(function e(t){for(var e,n=[];!(e=t.next()).done;)n.push(e.value);return n})(t[oe]());var n=Oo(t);return(n==b?Je:n==E?en:pl)(t)}function Fs(t){return t?(t=Us(t))===l||t===-1/0?17976931348623157e292*(t<0?-1:1):t==t?t:0:0===t?t:0}function Vs(t){var e=Fs(t),n=e%1;return e==e?n?e-n:e:0}function js(t){return t?oi(Vs(t),0,h):0}function Us(t){if("number"==typeof t)return t;if(Os(t))return u;if(Ss(t)){var e="function"==typeof t.valueOf?t.valueOf():t;t=Ss(e)?e+"":e}if("string"!=typeof t)return 0===t?t:+t;t=Ve(t);var n=dt.test(t);return n||ft.test(t)?te(t.slice(2),n?2:8):ht.test(t)?u:+t}function Gs(t){return $r(t,ol(t))}function Ws(t){return null==t?"":Cr(t)}var qs=Zr((function(t,e){if(Uo(e)||fs(e))$r(e,rl(e),t);else for(var n in e)It.call(e,n)&&Qn(t,n,e[n])})),Ys=Zr((function(t,e){$r(e,ol(e),t)})),Xs=Zr((function(t,e,n,i){$r(e,ol(e),t,i)})),$s=Zr((function(t,e,n,i){$r(e,rl(e),t,i)})),Ks=wo(ri),Zs=mr((function(t,e){t=Mt(t);var i=-1,r=e.length,o=r>2?e[2]:n;for(o&&Ho(e[0],e[1],o)&&(r=1);++i<r;)for(var a=e[i],s=ol(a),l=-1,c=s.length;++l<c;){var u=s[l],h=t[u];(h===n||ss(h,kt[u])&&!It.call(t,u))&&(t[u]=a[u])}return t})),Js=mr((function(t){return t.push(n,vo),me(sl,n,t)}));function Qs(t,e,i){var r=null==t?n:Ui(t,e);return r===n?i:r}function tl(t,e){return null!=t&&Ro(t,e,Xi)}var el=ao((function(t,e,n){null!=e&&"function"!=typeof e.toString&&(e=Rt.call(e)),t[e]=n}),Al(Ll)),nl=ao((function(t,e,n){null!=e&&"function"!=typeof e.toString&&(e=Rt.call(e)),It.call(t,e)?t[e].push(n):t[e]=[n]}),Co),il=mr(Ki);function rl(t){return fs(t)?Xn(t):nr(t)}function ol(t){return fs(t)?Xn(t,!0):(function e(t){if(!Ss(t))return(function e(t){var e=[];if(null!=t)for(var n in Mt(t))e.push(n);return e})(t);var n=Uo(t),i=[];for(var r in t)("constructor"!=r||!n&&It.call(t,r))&&i.push(r);return i})(t)}var al=Zr((function(t,e,n){sr(t,e,n)})),sl=Zr((function(t,e,n,i){sr(t,e,n,i)})),ll=wo((function(t,e){var n={};if(null==t)return n;var i=!1;e=Me(e,(function(e){return e=Br(e,t),i||(i=e.length>1),e})),$r(t,Mo(t),n),i&&(n=ai(n,7,bo));for(var r=e.length;r--;)Lr(n,e[r]);return n})),cl=wo((function(t,e){return null==t?{}:(function n(t,e){return ur(t,e,(function(e,n){return tl(t,n)}))})(t,e)}));function ul(t,e){if(null==t)return{};var n=Me(Mo(t),(function(t){return[t]}));return e=Co(e),ur(t,n,(function(t,n){return e(t,n[0])}))}var hl=go(rl),dl=go(ol);function pl(t){return null==t?[]:Ue(t,rl(t))}var fl=eo((function(t,e,n){return e=e.toLowerCase(),t+(n?ml(e):e)}));function ml(t){return Sl(Ws(t).toLowerCase())}function gl(t){return(t=Ws(t))&&t.replace(gt,Xe).replace(Ut,"")}var _l=eo((function(t,e,n){return t+(n?"-":"")+e.toLowerCase()})),yl=eo((function(t,e,n){return t+(n?" ":"")+e.toLowerCase()})),vl=to("toLowerCase"),bl=eo((function(t,e,n){return t+(n?"_":"")+e.toLowerCase()})),xl=eo((function(t,e,n){return t+(n?" ":"")+Sl(e)})),wl=eo((function(t,e,n){return t+(n?" ":"")+e.toUpperCase()})),Sl=to("toUpperCase");function Ml(t,e,i){return t=Ws(t),(e=i?n:e)===n?(function r(t){return Yt.test(t)})(t)?(function o(t){return t.match(Wt)||[]})(t):(function a(t){return t.match(at)||[]})(t):t.match(e)||[]}var El=mr((function(t,e){try{return me(t,n,e)}catch(t){return vs(t)?t:new xt(t)}})),Tl=wo((function(t,e){return _e(e,(function(e){e=ra(e),ii(t,e,Ka(t[e],t))})),t}));function Al(t){return function(){return t}}var Cl=ro(),kl=ro(!0);function Ll(t){return t}function Pl(t){return er("function"==typeof t?t:ai(t,1))}var Il=mr((function(t,e){return function(n){return Ki(n,t,e)}})),Nl=mr((function(t,e){return function(n){return Ki(t,n,e)}}));function Ol(t,e,n){var i=rl(e),r=ji(e,i);null!=n||Ss(e)&&(r.length||!i.length)||(n=e,e=t,t=this,r=ji(e,rl(e)));var o=!(Ss(n)&&"chain"in n&&!n.chain),a=bs(t);return _e(r,(function(n){var i=e[n];t[n]=i,a&&(t.prototype[n]=function(){var e=this.__chain__;if(o||e){var n=t(this.__wrapped__),r=n.__actions__=Xr(this.__actions__);return r.push({func:i,args:arguments,thisArg:t}),n.__chain__=e,n}return i.apply(t,Ee([this.value()],arguments))})})),t}function Rl(){}var zl=lo(Me),Dl=lo(be),Bl=lo(Ce);function Hl(t){return Fo(t)?ze(ra(t)):(function e(t){return function(e){return Ui(e,t)}})(t)}var Fl=uo(),Vl=uo(!0);function jl(){return[]}function Ul(){return!1}var Gl,Wl=so((function(t,e){return t+e}),0),ql=fo("ceil"),Yl=so((function(t,e){return t/e}),1),Xl=fo("floor"),$l=so((function(t,e){return t*e}),1),Kl=fo("round"),Zl=so((function(t,e){return t-e}),0);return Bn.after=function Jl(t,e){if("function"!=typeof e)throw new At(i);return t=Vs(t),function(){if(--t<1)return e.apply(this,arguments)}},Bn.ary=Xa,Bn.assign=qs,Bn.assignIn=Ys,Bn.assignInWith=Xs,Bn.assignWith=$s,Bn.at=Ks,Bn.before=$a,Bn.bind=Ka,Bn.bindAll=Tl,Bn.bindKey=Za,Bn.castArray=function Ql(){if(!arguments.length)return[];var t=arguments[0];return hs(t)?t:[t]},Bn.chain=Na,Bn.chunk=function tc(t,e,i){e=(i?Ho(t,e,i):e===n)?1:gn(Vs(e),0);var r=null==t?0:t.length;if(!r||e<1)return[];for(var o=0,a=0,s=vt(cn(r/e));o<r;)s[a++]=wr(t,o,o+=e);return s},Bn.compact=function ec(t){for(var e=-1,n=null==t?0:t.length,i=0,r=[];++e<n;){var o=t[e];o&&(r[i++]=o)}return r},Bn.concat=function nc(){var t=arguments.length;if(!t)return[];for(var e=vt(t-1),n=arguments[0],i=t;i--;)e[i-1]=arguments[i];return Ee(hs(n)?Xr(n):[n],Di(e,1))},Bn.cond=function ic(t){var e=null==t?0:t.length,n=Co();return t=e?Me(t,(function(t){if("function"!=typeof t[1])throw new At(i);return[n(t[0]),t[1]]})):[],mr((function(n){for(var i=-1;++i<e;){var r=t[i];if(me(r[0],this,n))return me(r[1],this,n)}}))},Bn.conforms=function rc(t){return(function e(t){var e=rl(t);return function(n){return si(n,t,e)}})(ai(t,1))},Bn.constant=Al,Bn.countBy=za,Bn.create=function oc(t,e){var n=Hn(t);return null==e?n:ni(n,e)},Bn.curry=function t(e,i,r){var o=_o(e,8,n,n,n,n,n,i=r?n:i);return o.placeholder=t.placeholder,o},Bn.curryRight=function t(e,i,r){var o=_o(e,16,n,n,n,n,n,i=r?n:i);return o.placeholder=t.placeholder,o},Bn.debounce=Ja,Bn.defaults=Zs,Bn.defaultsDeep=Js,Bn.defer=Qa,Bn.delay=ts,Bn.difference=sa,Bn.differenceBy=la,Bn.differenceWith=ca,Bn.drop=function ac(t,e,i){var r=null==t?0:t.length;return r?wr(t,(e=i||e===n?1:Vs(e))<0?0:e,r):[]},Bn.dropRight=function sc(t,e,i){var r=null==t?0:t.length;return r?wr(t,0,(e=r-(e=i||e===n?1:Vs(e)))<0?0:e):[]},Bn.dropRightWhile=function lc(t,e){return t&&t.length?Ir(t,Co(e,3),!0,!0):[]},Bn.dropWhile=function cc(t,e){return t&&t.length?Ir(t,Co(e,3),!0):[]},Bn.fill=function uc(t,e,i,r){var o=null==t?0:t.length;return o?(i&&"number"!=typeof i&&Ho(t,e,i)&&(i=0,r=o),(function a(t,e,i,r){var o=t.length;for((i=Vs(i))<0&&(i=-i>o?0:o+i),(r=r===n||r>o?o:Vs(r))<0&&(r+=o),r=i>r?0:js(r);i<r;)t[i++]=e;return t})(t,e,i,r)):[]},Bn.filter=function hc(t,e){return(hs(t)?xe:zi)(t,Co(e,3))},Bn.flatMap=function dc(t,e){return Di(Ga(t,e),1)},Bn.flatMapDeep=function pc(t,e){return Di(Ga(t,e),l)},Bn.flatMapDepth=function fc(t,e,i){return i=i===n?1:Vs(i),Di(Ga(t,e),i)},Bn.flatten=da,Bn.flattenDeep=function mc(t){return null!=t&&t.length?Di(t,l):[]},Bn.flattenDepth=function gc(t,e){return null!=t&&t.length?Di(t,e=e===n?1:Vs(e)):[]},Bn.flip=function _c(t){return _o(t,512)},Bn.flow=Cl,Bn.flowRight=kl,Bn.fromPairs=function yc(t){for(var e=-1,n=null==t?0:t.length,i={};++e<n;){var r=t[e];i[r[0]]=r[1]}return i},Bn.functions=function vc(t){return null==t?[]:ji(t,rl(t))},Bn.functionsIn=function bc(t){return null==t?[]:ji(t,ol(t))},Bn.groupBy=Va,Bn.initial=function xc(t){return null!=t&&t.length?wr(t,0,-1):[]},Bn.intersection=fa,Bn.intersectionBy=ma,Bn.intersectionWith=ga,Bn.invert=el,Bn.invertBy=nl,Bn.invokeMap=ja,Bn.iteratee=Pl,Bn.keyBy=Ua,Bn.keys=rl,Bn.keysIn=ol,Bn.map=Ga,Bn.mapKeys=function wc(t,e){var n={};return e=Co(e,3),Fi(t,(function(t,i,r){ii(n,e(t,i,r),t)})),n},Bn.mapValues=function Sc(t,e){var n={};return e=Co(e,3),Fi(t,(function(t,i,r){ii(n,i,e(t,i,r))})),n},Bn.matches=function Mc(t){return or(ai(t,1))},Bn.matchesProperty=function Ec(t,e){return ar(t,ai(e,1))},Bn.memoize=es,Bn.merge=al,Bn.mergeWith=sl,Bn.method=Il,Bn.methodOf=Nl,Bn.mixin=Ol,Bn.negate=ns,Bn.nthArg=function Tc(t){return t=Vs(t),mr((function(e){return lr(e,t)}))},Bn.omit=ll,Bn.omitBy=function Ac(t,e){return ul(t,ns(Co(e)))},Bn.once=function Cc(t){return $a(2,t)},Bn.orderBy=function kc(t,e,i,r){return null==t?[]:(hs(e)||(e=null==e?[]:[e]),hs(i=r?n:i)||(i=null==i?[]:[i]),cr(t,e,i))},Bn.over=zl,Bn.overArgs=is,Bn.overEvery=Dl,Bn.overSome=Bl,Bn.partial=rs,Bn.partialRight=os,Bn.partition=Wa,Bn.pick=cl,Bn.pickBy=ul,Bn.property=Hl,Bn.propertyOf=function Lc(t){return function(e){return null==t?n:Ui(t,e)}},Bn.pull=ya,Bn.pullAll=va,Bn.pullAllBy=function Pc(t,e,n){return t&&t.length&&e&&e.length?hr(t,e,Co(n,2)):t},Bn.pullAllWith=function Ic(t,e,i){return t&&t.length&&e&&e.length?hr(t,e,n,i):t},Bn.pullAt=ba,Bn.range=Fl,Bn.rangeRight=Vl,Bn.rearg=as,Bn.reject=function Nc(t,e){return(hs(t)?xe:zi)(t,ns(Co(e,3)))},Bn.remove=function Oc(t,e){var n=[];if(!t||!t.length)return n;var i=-1,r=[],o=t.length;for(e=Co(e,3);++i<o;){var a=t[i];e(a,i,t)&&(n.push(a),r.push(i))}return dr(t,r),n},Bn.rest=function Rc(t,e){if("function"!=typeof t)throw new At(i);return mr(t,e=e===n?e:Vs(e))},Bn.reverse=xa,Bn.sampleSize=function zc(t,e,i){return e=(i?Ho(t,e,i):e===n)?1:Vs(e),(hs(t)?Kn:_r)(t,e)},Bn.set=function Dc(t,e,n){return null==t?t:yr(t,e,n)},Bn.setWith=function Bc(t,e,i,r){return r="function"==typeof r?r:n,null==t?t:yr(t,e,i,r)},Bn.shuffle=function Hc(t){return(hs(t)?Zn:xr)(t)},Bn.slice=function Fc(t,e,i){var r=null==t?0:t.length;return r?(i&&"number"!=typeof i&&Ho(t,e,i)?(e=0,i=r):(e=null==e?0:Vs(e),i=i===n?r:Vs(i)),wr(t,e,i)):[]},Bn.sortBy=qa,Bn.sortedUniq=function Vc(t){return t&&t.length?Tr(t):[]},Bn.sortedUniqBy=function jc(t,e){return t&&t.length?Tr(t,Co(e,2)):[]},Bn.split=function Uc(t,e,i){return i&&"number"!=typeof i&&Ho(t,e,i)&&(e=i=n),(i=i===n?h:i>>>0)?(t=Ws(t))&&("string"==typeof e||null!=e&&!ks(e))&&!(e=Cr(e))&&Ze(t)?Fr(on(t),0,i):t.split(e,i):[]},Bn.spread=function Gc(t,e){if("function"!=typeof t)throw new At(i);return e=null==e?0:gn(Vs(e),0),mr((function(n){var i=n[e],r=Fr(n,0,e);return i&&Ee(r,i),me(t,this,r)}))},Bn.tail=function Wc(t){var e=null==t?0:t.length;return e?wr(t,1,e):[]},Bn.take=function qc(t,e,i){return t&&t.length?wr(t,0,(e=i||e===n?1:Vs(e))<0?0:e):[]},Bn.takeRight=function Yc(t,e,i){var r=null==t?0:t.length;return r?wr(t,(e=r-(e=i||e===n?1:Vs(e)))<0?0:e,r):[]},Bn.takeRightWhile=function Xc(t,e){return t&&t.length?Ir(t,Co(e,3),!1,!0):[]},Bn.takeWhile=function $c(t,e){return t&&t.length?Ir(t,Co(e,3)):[]},Bn.tap=function Kc(t,e){return e(t),t},Bn.throttle=function Zc(t,e,n){var r=!0,o=!0;if("function"!=typeof t)throw new At(i);return Ss(n)&&(r="leading"in n?!!n.leading:r,o="trailing"in n?!!n.trailing:o),Ja(t,e,{leading:r,maxWait:e,trailing:o})},Bn.thru=Oa,Bn.toArray=Hs,Bn.toPairs=hl,Bn.toPairsIn=dl,Bn.toPath=function Jc(t){return hs(t)?Me(t,ra):Os(t)?[t]:Xr(na(Ws(t)))},Bn.toPlainObject=Gs,Bn.transform=function Qc(t,e,n){var i=hs(t),r=i||gs(t)||Rs(t);if(e=Co(e,4),null==n){var o=t&&t.constructor;n=r?i?new o:[]:Ss(t)&&bs(o)?Hn(qt(t)):{}}return(r?_e:Fi)(t,(function(t,i,r){return e(n,t,i,r)})),n},Bn.unary=function tu(t){return Xa(t,1)},Bn.union=wa,Bn.unionBy=Sa,Bn.unionWith=Ma,Bn.uniq=function eu(t){return t&&t.length?kr(t):[]},Bn.uniqBy=function nu(t,e){return t&&t.length?kr(t,Co(e,2)):[]},Bn.uniqWith=function iu(t,e){return e="function"==typeof e?e:n,t&&t.length?kr(t,n,e):[]},Bn.unset=function ru(t,e){return null==t||Lr(t,e)},Bn.unzip=Ea,Bn.unzipWith=Ta,Bn.update=function ou(t,e,n){return null==t?t:Pr(t,e,Dr(n))},Bn.updateWith=function au(t,e,i,r){return r="function"==typeof r?r:n,null==t?t:Pr(t,e,Dr(i),r)},Bn.values=pl,Bn.valuesIn=function su(t){return null==t?[]:Ue(t,ol(t))},Bn.without=Aa,Bn.words=Ml,Bn.wrap=function lu(t,e){return rs(Dr(e),t)},Bn.xor=Ca,Bn.xorBy=ka,Bn.xorWith=La,Bn.zip=Pa,Bn.zipObject=function cu(t,e){return Rr(t||[],e||[],Qn)},Bn.zipObjectDeep=function uu(t,e){return Rr(t||[],e||[],yr)},Bn.zipWith=Ia,Bn.entries=hl,Bn.entriesIn=dl,Bn.extend=Ys,Bn.extendWith=Xs,Ol(Bn,Bn),Bn.add=Wl,Bn.attempt=El,Bn.camelCase=fl,Bn.capitalize=ml,Bn.ceil=ql,Bn.clamp=function hu(t,e,i){return i===n&&(i=e,e=n),i!==n&&(i=(i=Us(i))==i?i:0),e!==n&&(e=(e=Us(e))==e?e:0),oi(Us(t),e,i)},Bn.clone=function du(t){return ai(t,4)},Bn.cloneDeep=function pu(t){return ai(t,5)},Bn.cloneDeepWith=function fu(t,e){return ai(t,5,e="function"==typeof e?e:n)},Bn.cloneWith=function mu(t,e){return ai(t,4,e="function"==typeof e?e:n)},Bn.conformsTo=function gu(t,e){return null==e||si(t,e,rl(e))},Bn.deburr=gl,Bn.defaultTo=function _u(t,e){return null==t||t!=t?e:t},Bn.divide=Yl,Bn.endsWith=function yu(t,e,i){t=Ws(t),e=Cr(e);var r=t.length,o=i=i===n?r:oi(Vs(i),0,r);return(i-=e.length)>=0&&t.slice(i,o)==e},Bn.eq=ss,Bn.escape=function vu(t){return(t=Ws(t))&&q.test(t)?t.replace(G,$e):t},Bn.escapeRegExp=function bu(t){return(t=Ws(t))&&tt.test(t)?t.replace(Q,"\\$&"):t},Bn.every=function xu(t,e,i){var r=hs(t)?be:Oi;return i&&Ho(t,e,i)&&(e=n),r(t,Co(e,3))},Bn.find=Da,Bn.findIndex=ua,Bn.findKey=function wu(t,e){return Le(t,Co(e,3),Fi)},Bn.findLast=Ba,Bn.findLastIndex=ha,Bn.findLastKey=function Su(t,e){return Le(t,Co(e,3),Vi)},Bn.floor=Xl,Bn.forEach=Ha,Bn.forEachRight=Fa,Bn.forIn=function Mu(t,e){return null==t?t:Bi(t,Co(e,3),ol)},Bn.forInRight=function Eu(t,e){return null==t?t:Hi(t,Co(e,3),ol)},Bn.forOwn=function Tu(t,e){return t&&Fi(t,Co(e,3))},Bn.forOwnRight=function Au(t,e){return t&&Vi(t,Co(e,3))},Bn.get=Qs,Bn.gt=ls,Bn.gte=cs,Bn.has=function Cu(t,e){return null!=t&&Ro(t,e,Yi)},Bn.hasIn=tl,Bn.head=pa,Bn.identity=Ll,Bn.includes=function ku(t,e,n,i){t=fs(t)?t:pl(t),n=n&&!i?Vs(n):0;var r=t.length;return n<0&&(n=gn(r+n,0)),Ns(t)?n<=r&&t.indexOf(e,n)>-1:!!r&&Ie(t,e,n)>-1},Bn.indexOf=function Lu(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var r=null==n?0:Vs(n);return r<0&&(r=gn(i+r,0)),Ie(t,e,r)},Bn.inRange=function Pu(t,e,i){return e=Fs(e),i===n?(i=e,e=0):i=Fs(i),(function r(t,e,n){return t>=_n(e,n)&&t<gn(e,n)})(t=Us(t),e,i)},Bn.invoke=il,Bn.isArguments=us,Bn.isArray=hs,Bn.isArrayBuffer=ds,Bn.isArrayLike=fs,Bn.isArrayLikeObject=ms,Bn.isBoolean=function Iu(t){return!0===t||!1===t||Ms(t)&&Wi(t)==m},Bn.isBuffer=gs,Bn.isDate=_s,Bn.isElement=function Nu(t){return Ms(t)&&1===t.nodeType&&!Cs(t)},Bn.isEmpty=function Ou(t){if(null==t)return!0;if(fs(t)&&(hs(t)||"string"==typeof t||"function"==typeof t.splice||gs(t)||Rs(t)||us(t)))return!t.length;var e=Oo(t);if(e==b||e==E)return!t.size;if(Uo(t))return!nr(t).length;for(var n in t)if(It.call(t,n))return!1;return!0},Bn.isEqual=function Ru(t,e){return Ji(t,e)},Bn.isEqualWith=function zu(t,e,i){var r=(i="function"==typeof i?i:n)?i(t,e):n;return r===n?Ji(t,e,n,i):!!r},Bn.isError=vs,Bn.isFinite=function Du(t){return"number"==typeof t&&pn(t)},Bn.isFunction=bs,Bn.isInteger=xs,Bn.isLength=ws,Bn.isMap=Es,Bn.isMatch=function Bu(t,e){return t===e||Qi(t,e,Lo(e))},Bn.isMatchWith=function Hu(t,e,i){return i="function"==typeof i?i:n,Qi(t,e,Lo(e),i)},Bn.isNaN=function Fu(t){return As(t)&&t!=+t},Bn.isNative=function Vu(t){if(jo(t))throw new xt("Unsupported core-js use. Try https://npms.io/search?q=ponyfill.");return tr(t)},Bn.isNil=function ju(t){return null==t},Bn.isNull=function Uu(t){return null===t},Bn.isNumber=As,Bn.isObject=Ss,Bn.isObjectLike=Ms,Bn.isPlainObject=Cs,Bn.isRegExp=ks,Bn.isSafeInteger=function Gu(t){return xs(t)&&t>=-9007199254740991&&t<=c},Bn.isSet=Ps,Bn.isString=Ns,Bn.isSymbol=Os,Bn.isTypedArray=Rs,Bn.isUndefined=function Wu(t){return t===n},Bn.isWeakMap=function qu(t){return Ms(t)&&Oo(t)==C},Bn.isWeakSet=function Yu(t){return Ms(t)&&"[object WeakSet]"==Wi(t)},Bn.join=function Xu(t,e){return null==t?"":fn.call(t,e)},Bn.kebabCase=_l,Bn.last=_a,Bn.lastIndexOf=function $u(t,e,i){var r=null==t?0:t.length;if(!r)return-1;var o=r;return i!==n&&(o=(o=Vs(i))<0?gn(r+o,0):_n(o,r-1)),e==e?(function a(t,e,n){for(var i=n+1;i--;)if(t[i]===e)return i;return i})(t,e,o):Pe(t,Oe,o,!0)},Bn.lowerCase=yl,Bn.lowerFirst=vl,Bn.lt=Ds,Bn.lte=Bs,Bn.max=function Ku(t){return t&&t.length?Ri(t,Ll,qi):n},Bn.maxBy=function Zu(t,e){return t&&t.length?Ri(t,Co(e,2),qi):n},Bn.mean=function Ju(t){return Re(t,Ll)},Bn.meanBy=function Qu(t,e){return Re(t,Co(e,2))},Bn.min=function th(t){return t&&t.length?Ri(t,Ll,ir):n},Bn.minBy=function eh(t,e){return t&&t.length?Ri(t,Co(e,2),ir):n},Bn.stubArray=jl,Bn.stubFalse=Ul,Bn.stubObject=function nh(){return{}},Bn.stubString=function ih(){return""},Bn.stubTrue=function rh(){return!0},Bn.multiply=$l,Bn.nth=function oh(t,e){return t&&t.length?lr(t,Vs(e)):n},Bn.noConflict=function ah(){return ie._===this&&(ie._=Dt),this},Bn.noop=Rl,Bn.now=Ya,Bn.pad=function sh(t,e,n){t=Ws(t);var i=(e=Vs(e))?rn(t):0;if(!e||i>=e)return t;var r=(e-i)/2;return co(un(r),n)+t+co(cn(r),n)},Bn.padEnd=function lh(t,e,n){t=Ws(t);var i=(e=Vs(e))?rn(t):0;return e&&i<e?t+co(e-i,n):t},Bn.padStart=function ch(t,e,n){t=Ws(t);var i=(e=Vs(e))?rn(t):0;return e&&i<e?co(e-i,n)+t:t},Bn.parseInt=function uh(t,e,n){return n||null==e?e=0:e&&(e=+e),vn(Ws(t).replace(et,""),e||0)},Bn.random=function hh(t,e,i){if(i&&"boolean"!=typeof i&&Ho(t,e,i)&&(e=i=n),i===n&&("boolean"==typeof e?(i=e,e=n):"boolean"==typeof t&&(i=t,t=n)),t===n&&e===n?(t=0,e=1):(t=Fs(t),e===n?(e=t,t=0):e=Fs(e)),t>e){var r=t;t=e,e=r}if(i||t%1||e%1){var o=bn();return _n(t+o*(e-t+Qt("1e-"+((o+"").length-1))),e)}return pr(t,e)},Bn.reduce=function dh(t,e,n){var i=hs(t)?Te:Be,r=arguments.length<3;return i(t,Co(e,4),n,r,Ii)},Bn.reduceRight=function ph(t,e,n){var i=hs(t)?Ae:Be,r=arguments.length<3;return i(t,Co(e,4),n,r,Ni)},Bn.repeat=function fh(t,e,i){return e=(i?Ho(t,e,i):e===n)?1:Vs(e),fr(Ws(t),e)},Bn.replace=function mh(){var t=arguments,e=Ws(t[0]);return t.length<3?e:e.replace(t[1],t[2])},Bn.result=function gh(t,e,i){var r=-1,o=(e=Br(e,t)).length;for(o||(o=1,t=n);++r<o;){var a=null==t?n:t[ra(e[r])];a===n&&(r=o,a=i),t=bs(a)?a.call(t):a}return t},Bn.round=Kl,Bn.runInContext=t,Bn.sample=function _h(t){return(hs(t)?$n:gr)(t)},Bn.size=function yh(t){if(null==t)return 0;if(fs(t))return Ns(t)?rn(t):t.length;var e=Oo(t);return e==b||e==E?t.size:nr(t).length},Bn.snakeCase=bl,Bn.some=function vh(t,e,i){var r=hs(t)?Ce:Sr;return i&&Ho(t,e,i)&&(e=n),r(t,Co(e,3))},Bn.sortedIndex=function bh(t,e){return Mr(t,e)},Bn.sortedIndexBy=function xh(t,e,n){return Er(t,e,Co(n,2))},Bn.sortedIndexOf=function wh(t,e){var n=null==t?0:t.length;if(n){var i=Mr(t,e);if(i<n&&ss(t[i],e))return i}return-1},Bn.sortedLastIndex=function Sh(t,e){return Mr(t,e,!0)},Bn.sortedLastIndexBy=function Mh(t,e,n){return Er(t,e,Co(n,2),!0)},Bn.sortedLastIndexOf=function Eh(t,e){if(null!=t&&t.length){var n=Mr(t,e,!0)-1;if(ss(t[n],e))return n}return-1},Bn.startCase=xl,Bn.startsWith=function Th(t,e,n){return t=Ws(t),n=null==n?0:oi(Vs(n),0,t.length),e=Cr(e),t.slice(n,n+e.length)==e},Bn.subtract=Zl,Bn.sum=function Ah(t){return t&&t.length?He(t,Ll):0},Bn.sumBy=function Ch(t,e){return t&&t.length?He(t,Co(e,2)):0},Bn.template=function kh(t,e,i){var r=Bn.templateSettings;i&&Ho(t,e,i)&&(e=n),t=Ws(t),e=Xs({},e,r,yo);var o,a,s=Xs({},e.imports,r.imports,yo),l=rl(s),c=Ue(s,l),u=0,h=e.interpolate||_t,d="__p += '",p=Et((e.escape||_t).source+"|"+h.source+"|"+(h===$?ct:_t).source+"|"+(e.evaluate||_t).source+"|$","g"),f="//# sourceURL="+(It.call(e,"sourceURL")?(e.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++$t+"]")+"\n";t.replace(p,(function(e,n,i,r,s,l){return i||(i=r),d+=t.slice(u,l).replace(yt,Ke),n&&(o=!0,d+="' +\n__e("+n+") +\n'"),s&&(a=!0,d+="';\n"+s+";\n__p += '"),i&&(d+="' +\n((__t = ("+i+")) == null ? '' : __t) +\n'"),u=l+e.length,e})),d+="';\n";var m=It.call(e,"variable")&&e.variable;if(m){if(st.test(m))throw new xt("Invalid `variable` option passed into `_.template`")}else d="with (obj) {\n"+d+"\n}\n";d=(a?d.replace(F,""):d).replace(V,"$1").replace(j,"$1;"),d="function("+(m||"obj")+") {\n"+(m?"":"obj || (obj = {});\n")+"var __t, __p = ''"+(o?", __e = _.escape":"")+(a?", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n":";\n")+d+"return __p\n}";var g=El((function(){return wt(l,f+"return "+d).apply(n,c)}));if(g.source=d,vs(g))throw g;return g},Bn.times=function Lh(t,e){if((t=Vs(t))<1||t>c)return[];var n=h,i=_n(t,h);e=Co(e),t-=h;for(var r=Fe(i,e);++n<t;)e(n);return r},Bn.toFinite=Fs,Bn.toInteger=Vs,Bn.toLength=js,Bn.toLower=function Ph(t){return Ws(t).toLowerCase()},Bn.toNumber=Us,Bn.toSafeInteger=function Ih(t){return t?oi(Vs(t),-9007199254740991,c):0===t?t:0},Bn.toString=Ws,Bn.toUpper=function Nh(t){return Ws(t).toUpperCase()},Bn.trim=function Oh(t,e,i){if((t=Ws(t))&&(i||e===n))return Ve(t);if(!t||!(e=Cr(e)))return t;var r=on(t),o=on(e);return Fr(r,We(r,o),qe(r,o)+1).join("")},Bn.trimEnd=function Rh(t,e,i){if((t=Ws(t))&&(i||e===n))return t.slice(0,an(t)+1);if(!t||!(e=Cr(e)))return t;var r=on(t);return Fr(r,0,qe(r,on(e))+1).join("")},Bn.trimStart=function zh(t,e,i){if((t=Ws(t))&&(i||e===n))return t.replace(et,"");if(!t||!(e=Cr(e)))return t;var r=on(t);return Fr(r,We(r,on(e))).join("")},Bn.truncate=function Dh(t,e){var i=30,r="...";if(Ss(e)){var o="separator"in e?e.separator:o;i="length"in e?Vs(e.length):i,r="omission"in e?Cr(e.omission):r}var a=(t=Ws(t)).length;if(Ze(t)){var s=on(t);a=s.length}if(i>=a)return t;var l=i-rn(r);if(l<1)return r;var c=s?Fr(s,0,l).join(""):t.slice(0,l);if(o===n)return c+r;if(s&&(l+=c.length-l),ks(o)){if(t.slice(l).search(o)){var u,h=c;for(o.global||(o=Et(o.source,Ws(ut.exec(o))+"g")),o.lastIndex=0;u=o.exec(h);)var d=u.index;c=c.slice(0,d===n?l:d)}}else if(t.indexOf(Cr(o),l)!=l){var p=c.lastIndexOf(o);p>-1&&(c=c.slice(0,p))}return c+r},Bn.unescape=function Bh(t){return(t=Ws(t))&&W.test(t)?t.replace(U,sn):t},Bn.uniqueId=function Hh(t){var e=++Nt;return Ws(t)+e},Bn.upperCase=wl,Bn.upperFirst=Sl,Bn.each=Ha,Bn.eachRight=Fa,Bn.first=pa,Ol(Bn,(Gl={},Fi(Bn,(function(t,e){It.call(Bn.prototype,e)||(Gl[e]=t)})),Gl),{chain:!1}),Bn.VERSION="4.17.21",_e(["bind","bindKey","curry","curryRight","partial","partialRight"],(function(t){Bn[t].placeholder=Bn})),_e(["drop","take"],(function(t,e){jn.prototype[t]=function(i){i=i===n?1:gn(Vs(i),0);var r=this.__filtered__&&!e?new jn(this):this.clone();return r.__filtered__?r.__takeCount__=_n(i,r.__takeCount__):r.__views__.push({size:_n(i,h),type:t+(r.__dir__<0?"Right":"")}),r},jn.prototype[t+"Right"]=function(e){return this.reverse()[t](e).reverse()}})),_e(["filter","map","takeWhile"],(function(t,e){var n=e+1,i=1==n||3==n;jn.prototype[t]=function(t){var e=this.clone();return e.__iteratees__.push({iteratee:Co(t,3),type:n}),e.__filtered__=e.__filtered__||i,e}})),_e(["head","last"],(function(t,e){var n="take"+(e?"Right":"");jn.prototype[t]=function(){return this[n](1).value()[0]}})),_e(["initial","tail"],(function(t,e){var n="drop"+(e?"":"Right");jn.prototype[t]=function(){return this.__filtered__?new jn(this):this[n](1)}})),jn.prototype.compact=function(){return this.filter(Ll)},jn.prototype.find=function(t){return this.filter(t).head()},jn.prototype.findLast=function(t){return this.reverse().find(t)},jn.prototype.invokeMap=mr((function(t,e){return"function"==typeof t?new jn(this):this.map((function(n){return Ki(n,t,e)}))})),jn.prototype.reject=function(t){return this.filter(ns(Co(t)))},jn.prototype.slice=function(t,e){t=Vs(t);var i=this;return i.__filtered__&&(t>0||e<0)?new jn(i):(t<0?i=i.takeRight(-t):t&&(i=i.drop(t)),e!==n&&(i=(e=Vs(e))<0?i.dropRight(-e):i.take(e-t)),i)},jn.prototype.takeRightWhile=function(t){return this.reverse().takeWhile(t).reverse()},jn.prototype.toArray=function(){return this.take(h)},Fi(jn.prototype,(function(t,e){var i=/^(?:filter|find|map|reject)|While$/.test(e),r=/^(?:head|last)$/.test(e),o=Bn[r?"take"+("last"==e?"Right":""):e],a=r||/^find/.test(e);o&&(Bn.prototype[e]=function(){var e=this.__wrapped__,s=r?[1]:arguments,l=e instanceof jn,c=s[0],u=l||hs(e),h=function(t){var e=o.apply(Bn,Ee([t],s));return r&&d?e[0]:e};u&&i&&"function"==typeof c&&1!=c.length&&(l=u=!1);var d=this.__chain__,p=!!this.__actions__.length,f=a&&!d,m=l&&!p;if(!a&&u){e=m?e:new jn(this);var g=t.apply(e,s);return g.__actions__.push({func:Oa,args:[h],thisArg:n}),new Vn(g,d)}return f&&m?t.apply(this,s):(g=this.thru(h),f?r?g.value()[0]:g.value():g)})})),_e(["pop","push","shift","sort","splice","unshift"],(function(t){var e=Ct[t],n=/^(?:push|sort|unshift)$/.test(t)?"tap":"thru",i=/^(?:pop|shift)$/.test(t);Bn.prototype[t]=function(){var t=arguments;if(i&&!this.__chain__){var r=this.value();return e.apply(hs(r)?r:[],t)}return this[n]((function(n){return e.apply(hs(n)?n:[],t)}))}})),Fi(jn.prototype,(function(t,e){var n=Bn[e];if(n){var i=n.name+"";It.call(kn,i)||(kn[i]=[]),kn[i].push({name:e,func:n})}})),kn[oo(n,2).name]=[{name:"wrapper",func:n}],jn.prototype.clone=function Fh(){var t=new jn(this.__wrapped__);return t.__actions__=Xr(this.__actions__),t.__dir__=this.__dir__,t.__filtered__=this.__filtered__,t.__iteratees__=Xr(this.__iteratees__),t.__takeCount__=this.__takeCount__,t.__views__=Xr(this.__views__),t},jn.prototype.reverse=function Vh(){if(this.__filtered__){var t=new jn(this);t.__dir__=-1,t.__filtered__=!0}else(t=this.clone()).__dir__*=-1;return t},jn.prototype.value=function jh(){var t=this.__wrapped__.value(),e=this.__dir__,n=hs(t),i=e<0,r=n?t.length:0,o=(function a(t,e,n){for(var i=-1,r=n.length;++i<r;){var o=n[i],a=o.size;switch(o.type){case"drop":t+=a;break;case"dropRight":e-=a;break;case"take":e=_n(e,t+a);break;case"takeRight":t=gn(t,e-a)}}return{start:t,end:e}})(0,r,this.__views__),s=o.start,l=o.end,c=l-s,u=i?l:s-1,h=this.__iteratees__,d=h.length,p=0,f=_n(c,this.__takeCount__);if(!n||!i&&r==c&&f==c)return Nr(t,this.__actions__);var m=[];t:for(;c--&&p<f;){for(var g=-1,_=t[u+=e];++g<d;){var y=h[g],v=y.type,b=(0,y.iteratee)(_);if(2==v)_=b;else if(!b){if(1==v)continue t;break t}}m[p++]=_}return m},Bn.prototype.at=Ra,Bn.prototype.chain=function Uh(){return Na(this)},Bn.prototype.commit=function Gh(){return new Vn(this.value(),this.__chain__)},Bn.prototype.next=function Wh(){this.__values__===n&&(this.__values__=Hs(this.value()));var t=this.__index__>=this.__values__.length;return{done:t,value:t?n:this.__values__[this.__index__++]}},Bn.prototype.plant=function qh(t){for(var e,i=this;i instanceof Fn;){var r=aa(i);r.__index__=0,r.__values__=n,e?o.__wrapped__=r:e=r;var o=r;i=i.__wrapped__}return o.__wrapped__=t,e},Bn.prototype.reverse=function Yh(){var t=this.__wrapped__;if(t instanceof jn){var e=t;return this.__actions__.length&&(e=new jn(this)),(e=e.reverse()).__actions__.push({func:Oa,args:[xa],thisArg:n}),new Vn(e,this.__chain__)}return this.thru(xa)},Bn.prototype.toJSON=Bn.prototype.valueOf=Bn.prototype.value=function Xh(){return Nr(this.__wrapped__,this.__actions__)},Bn.prototype.first=Bn.prototype.head,oe&&(Bn.prototype[oe]=function $h(){return this}),Bn})();oe?((oe.exports=ln)._=ln,re._=ln):ie._=ln}).call(ve)}));
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const Se=!(window.ShadyDOM&&window.ShadyDOM.inUse);let Me,Ee;function Te(t){Me=(!t||!t.shimcssproperties)&&(Se||Boolean(!navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)&&window.CSS&&CSS.supports&&CSS.supports("box-shadow","0 0 0 var(--foo)")))}window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(Ee=window.ShadyCSS.cssBuild);const Ae=Boolean(window.ShadyCSS&&window.ShadyCSS.disableRuntime);window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?Me=window.ShadyCSS.nativeCss:window.ShadyCSS?(Te(window.ShadyCSS),window.ShadyCSS=void 0):Te(window.WebComponents&&window.WebComponents.flags);const Ce=Me;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */class ke{constructor(){this.start=0,this.end=0,this.previous=null,this.parent=null,this.rules=null,this.parsedCssText="",this.cssText="",this.atRule=!1,this.type=0,this.keyframesName="",this.selector="",this.parsedSelector=""}}function Le(t){return Pe((function n(t){let e=new ke;e.start=0,e.end=t.length;let n=e;for(let i=0,r=t.length;i<r;i++)if(t[i]===Oe){n.rules||(n.rules=[]);let t=n,e=t.rules[t.rules.length-1]||null;n=new ke,n.start=i+1,n.parent=t,n.previous=e,t.rules.push(n)}else t[i]===Re&&(n.end=i+1,n=n.parent||e);return e})(t=(function e(t){return t.replace(ze.comments,"").replace(ze.port,"")})(t)),t)}function Pe(t,e){let n=e.substring(t.start,t.end-1);if(t.parsedCssText=t.cssText=n.trim(),t.parent){n=e.substring(t.previous?t.previous.end:t.parent.start,t.start-1),n=(function i(t){return t.replace(/\\([0-9a-f]{1,6})\s/gi,(function(){let t=arguments[1],e=6-t.length;for(;e--;)t="0"+t;return"\\"+t}))})(n),n=n.replace(ze.multipleSpaces," "),n=n.substring(n.lastIndexOf(";")+1);let i=t.parsedSelector=t.selector=n.trim();t.atRule=0===i.indexOf(He),t.atRule?0===i.indexOf(Be)?t.type=Ne.MEDIA_RULE:i.match(ze.keyframesRule)&&(t.type=Ne.KEYFRAMES_RULE,t.keyframesName=t.selector.split(ze.multipleSpaces).pop()):t.type=0===i.indexOf(De)?Ne.MIXIN_RULE:Ne.STYLE_RULE}let r=t.rules;if(r)for(let t,n=0,i=r.length;n<i&&(t=r[n]);n++)Pe(t,e);return t}function Ie(t,e,n=""){let i="";if(t.cssText||t.rules){let n=t.rules;if(n&&!(function r(t){let e=t[0];return Boolean(e)&&Boolean(e.selector)&&0===e.selector.indexOf(De)})(n))for(let t,r=0,o=n.length;r<o&&(t=n[r]);r++)i=Ie(t,e,i);else i=e?t.cssText:(function o(t){return(function n(t){return t.replace(ze.mixinApply,"").replace(ze.varApply,"")})(t=(function e(t){return t.replace(ze.customProp,"").replace(ze.mixinProp,"")})(t))})(t.cssText),i=i.trim(),i&&(i="  "+i+"\n")}return i&&(t.selector&&(n+=t.selector+" "+Oe+"\n"),n+=i,t.selector&&(n+=Re+"\n\n")),n}const Ne={STYLE_RULE:1,KEYFRAMES_RULE:7,MEDIA_RULE:4,MIXIN_RULE:1e3},Oe="{",Re="}",ze={comments:/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,port:/@import[^;]*;/gim,customProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,mixinProp:/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,mixinApply:/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,varApply:/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,keyframesRule:/^@[^\s]*keyframes/,multipleSpaces:/\s+/g},De="--",Be="@media",He="@",Fe=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Ve=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi,je=/@media\s(.*)/,Ue=new Set;function Ge(t){const e=t.textContent;if(!Ue.has(e)){Ue.add(e);const t=document.createElement("style");t.setAttribute("shady-unscoped",""),t.textContent=e,document.head.appendChild(t)}}function We(t){return t.hasAttribute("shady-unscoped")}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function qe(t,e){return t?("string"==typeof t&&(t=Le(t)),e&&Xe(t,e),Ie(t,Ce)):""}function Ye(t){return!t.__cssRules&&t.textContent&&(t.__cssRules=Le(t.textContent)),t.__cssRules||null}function Xe(t,e,n,i){if(!t)return;let r=!1,o=t.type;if(i&&o===Ne.MEDIA_RULE){let e=t.selector.match(je);e&&(window.matchMedia(e[1]).matches||(r=!0))}o===Ne.STYLE_RULE?e(t):n&&o===Ne.KEYFRAMES_RULE?n(t):o===Ne.MIXIN_RULE&&(r=!0);let a=t.rules;if(a&&!r)for(let t,r=0,o=a.length;r<o&&(t=a[r]);r++)Xe(t,e,n,i)}function $e(t,e){let n=t.indexOf("var(");if(-1===n)return e(t,"","","");let i=(function r(t,e){let n=0;for(let i=e,r=t.length;i<r;i++)if("("===t[i])n++;else if(")"===t[i]&&0==--n)return i;return-1})(t,n+3),o=t.substring(n+4,i),a=t.substring(0,n),s=$e(t.substring(i+1),e),l=o.indexOf(",");return-1===l?e(a,o.trim(),"",s):e(a,o.substring(0,l).trim(),o.substring(l+1).trim(),s)}window.ShadyDOM&&window;const Ke="css-build";function Ze(t){return""!==(function e(t){if(void 0!==Ee)return Ee;if(void 0===t.__cssBuild){const e=t.getAttribute(Ke);if(e)t.__cssBuild=e;else{const e=(function e(t){const e="template"===t.localName?t.content.firstChild:t.firstChild;if(e instanceof Comment){const t=e.textContent.trim().split(":");if(t[0]===Ke)return t[1]}return""})(t);""!==e&&(function n(t){const e="template"===t.localName?t.content.firstChild:t.firstChild;e.parentNode.removeChild(e)}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */)(t),t.__cssBuild=e}}return t.__cssBuild||""})(t)}function Je(t,e){for(let n in e)null===n?t.style.removeProperty(n):t.style.setProperty(n,e[n])}function Qe(t,e){const n=window.getComputedStyle(t).getPropertyValue(e);return n?n.trim():""}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const tn=/;\s*/m,en=/^\s*(initial)|(inherit)\s*$/,nn=/\s*!important/;class rn{constructor(){this._map={}}set(t,e){t=t.trim(),this._map[t]={properties:e,dependants:{}}}get(t){return t=t.trim(),this._map[t]||null}}let on=null;class an{constructor(){this._currentElement=null,this._measureElement=null,this._map=new rn}detectMixin(t){return(function e(t){const e=Ve.test(t)||Fe.test(t);return Ve.lastIndex=0,Fe.lastIndex=0,e})(t)}gatherStyles(t){const e=(function n(t){const e=[],n=t.querySelectorAll("style");for(let t=0;t<n.length;t++){const i=n[t];We(i)?Se||(Ge(i),i.parentNode.removeChild(i)):(e.push(i.textContent),i.parentNode.removeChild(i))}return e.join("").trim()})(t.content);if(e){const n=document.createElement("style");return n.textContent=e,t.content.insertBefore(n,t.content.firstChild),n}return null}transformTemplate(t,e){void 0===t._gatheredStyle&&(t._gatheredStyle=this.gatherStyles(t));const n=t._gatheredStyle;return n?this.transformStyle(n,e):null}transformStyle(t,e=""){let n=Ye(t);return this.transformRules(n,e),t.textContent=qe(n),n}transformCustomStyle(t){let e=Ye(t);return Xe(e,(t=>{":root"===t.selector&&(t.selector="html"),this.transformRule(t)})),t.textContent=qe(e),e}transformRules(t,e){this._currentElement=e,Xe(t,(t=>{this.transformRule(t)})),this._currentElement=null}transformRule(t){t.cssText=this.transformCssText(t.parsedCssText,t),":root"===t.selector&&(t.selector=":host > *")}transformCssText(t,e){return t=t.replace(Fe,((t,n,i,r)=>this._produceCssProperties(t,n,i,r,e))),this._consumeCssProperties(t,e)}_getInitialValueForProperty(t){return this._measureElement||(this._measureElement=document.createElement("meta"),this._measureElement.setAttribute("apply-shim-measure",""),this._measureElement.style.all="initial",document.head.appendChild(this._measureElement)),window.getComputedStyle(this._measureElement).getPropertyValue(t)}_fallbacksFromPreviousRules(t){let e=t;for(;e.parent;)e=e.parent;const n={};let i=!1;return Xe(e,(e=>{i=i||e===t,i||e.selector===t.selector&&Object.assign(n,this._cssTextToMap(e.parsedCssText))})),n}_consumeCssProperties(t,e){let n=null;for(;n=Ve.exec(t);){let i=n[0],r=n[1],o=n.index,a=o+i.indexOf("@apply"),s=o+i.length,l=t.slice(0,a),c=t.slice(s),u=e?this._fallbacksFromPreviousRules(e):{};Object.assign(u,this._cssTextToMap(l));let h=this._atApplyToCssProperties(r,u);t=`${l}${h}${c}`,Ve.lastIndex=o+h.length}return t}_atApplyToCssProperties(t,e){t=t.replace(tn,"");let n=[],i=this._map.get(t);if(i||(this._map.set(t,{}),i=this._map.get(t)),i){let r,o,a;this._currentElement&&(i.dependants[this._currentElement]=!0);const s=i.properties;for(r in s)a=e&&e[r],o=[r,": var(",t,"_-_",r],a&&o.push(",",a.replace(nn,"")),o.push(")"),nn.test(s[r])&&o.push(" !important"),n.push(o.join(""))}return n.join("; ")}_replaceInitialOrInherit(t,e){let n=en.exec(e);return n&&(e=n[1]?this._getInitialValueForProperty(t):"apply-shim-inherit"),e}_cssTextToMap(t,e=!1){let n,i,r=t.split(";"),o={};for(let t,a,s=0;s<r.length;s++)t=r[s],t&&(a=t.split(":"),a.length>1&&(n=a[0].trim(),i=a.slice(1).join(":"),e&&(i=this._replaceInitialOrInherit(n,i)),o[n]=i));return o}_invalidateMixinEntry(t){if(on)for(let e in t.dependants)e!==this._currentElement&&on(e)}_produceCssProperties(t,e,n,i,r){if(n&&$e(n,((t,e)=>{e&&this._map.get(e)&&(i=`@apply ${e};`)})),!i)return t;let o=this._consumeCssProperties(""+i,r),a=t.slice(0,t.indexOf("--")),s=this._cssTextToMap(o,!0),l=s,c=this._map.get(e),u=c&&c.properties;u?l=Object.assign(Object.create(u),s):this._map.set(e,l);let h,d,p=[],f=!1;for(h in l)d=s[h],void 0===d&&(d="initial"),u&&!(h in u)&&(f=!0),p.push(`${e}_-_${h}: ${d}`);return f&&this._invalidateMixinEntry(c),c&&(c.properties=l),n&&(a=`${t};${a}`),`${a}${p.join("; ")};`}}an.prototype.detectMixin=an.prototype.detectMixin,an.prototype.transformStyle=an.prototype.transformStyle,an.prototype.transformCustomStyle=an.prototype.transformCustomStyle,an.prototype.transformRules=an.prototype.transformRules,an.prototype.transformRule=an.prototype.transformRule,an.prototype.transformTemplate=an.prototype.transformTemplate,an.prototype._separator="_-_",Object.defineProperty(an.prototype,"invalidCallback",{get:()=>on,set(t){on=t}});
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const sn={},ln="_applyShimCurrentVersion",cn="_applyShimNextVersion",un="_applyShimValidatingVersion",hn=Promise.resolve();
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function dn(t){let e=sn[t];e&&(function n(t){t[ln]=t[ln]||0,t[un]=t[un]||0,t[cn]=(t[cn]||0)+1})(e)}function pn(t){return t[ln]===t[cn]}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let fn,mn=null,gn=window.HTMLImports&&window.HTMLImports.whenReady||null;function _n(t){requestAnimationFrame((function(){gn?gn(t):(mn||(mn=new Promise((t=>{fn=t})),"complete"===document.readyState?fn():document.addEventListener("readystatechange",(()=>{"complete"===document.readyState&&fn()}))),mn.then((function(){t&&t()})))}))}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const yn="__seenByShadyCSS",vn="__shadyCSSCachedStyle";let bn=null,xn=null;class wn{constructor(){this.customStyles=[],this.enqueued=!1,_n((()=>{window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()}))}enqueueDocumentValidation(){!this.enqueued&&xn&&(this.enqueued=!0,_n(xn))}addCustomStyle(t){t[yn]||(t[yn]=!0,this.customStyles.push(t),this.enqueueDocumentValidation())}getStyleForCustomStyle(t){if(t[vn])return t[vn];let e;return e=t.getStyle?t.getStyle():t,e}processStyles(){const t=this.customStyles;for(let e=0;e<t.length;e++){const n=t[e];if(n[vn])continue;const i=this.getStyleForCustomStyle(n);if(i){const t=i.__appliedElement||i;bn&&bn(t),n[vn]=t}}return t}}wn.prototype.addCustomStyle=wn.prototype.addCustomStyle,wn.prototype.getStyleForCustomStyle=wn.prototype.getStyleForCustomStyle,wn.prototype.processStyles=wn.prototype.processStyles,Object.defineProperties(wn.prototype,{transformCallback:{get:()=>bn,set(t){bn=t}},validateCallback:{get:()=>xn,set(t){let e=!1;xn||(e=!0),xn=t,e&&this.enqueueDocumentValidation()}}});
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const Sn=new an;class Mn{constructor(){this.customStyleInterface=null,Sn.invalidCallback=dn}ensure(){this.customStyleInterface||window.ShadyCSS.CustomStyleInterface&&(this.customStyleInterface=window.ShadyCSS.CustomStyleInterface,this.customStyleInterface.transformCallback=t=>{Sn.transformCustomStyle(t)},this.customStyleInterface.validateCallback=()=>{requestAnimationFrame((()=>{this.customStyleInterface.enqueued&&this.flushCustomStyles()}))})}prepareTemplate(t,e){if(this.ensure(),Ze(t))return;sn[e]=t;let n=Sn.transformTemplate(t,e);t._styleAst=n}flushCustomStyles(){if(this.ensure(),!this.customStyleInterface)return;let t=this.customStyleInterface.processStyles();if(this.customStyleInterface.enqueued){for(let e=0;e<t.length;e++){let n=this.customStyleInterface.getStyleForCustomStyle(t[e]);n&&Sn.transformCustomStyle(n)}this.customStyleInterface.enqueued=!1}}styleSubtree(t,e){if(this.ensure(),e&&Je(t,e),t.shadowRoot){this.styleElement(t);let e=t.shadowRoot.children||t.shadowRoot.childNodes;for(let t=0;t<e.length;t++)this.styleSubtree(e[t])}else{let e=t.children||t.childNodes;for(let t=0;t<e.length;t++)this.styleSubtree(e[t])}}styleElement(t){this.ensure();let{is:e}=(function n(t){let e=t.localName,n="",i="";return e?e.indexOf("-")>-1?n=e:(i=e,n=t.getAttribute&&t.getAttribute("is")||""):(n=t.is,i=t.extends),{is:n,typeExtension:i}})(t),i=sn[e];if((!i||!Ze(i))&&i&&!pn(i)){(function r(t){return!pn(t)&&t[un]===t[cn]})(i)||(this.prepareTemplate(i,e),(function o(t){t[un]=t[cn],t._validating||(t._validating=!0,hn.then((function(){t[ln]=t[cn],t._validating=!1})))})(i));let n=t.shadowRoot;if(n){let t=n.querySelector("style");t&&(t.__cssRules=i._styleAst,t.textContent=qe(i._styleAst))}}}styleDocument(t){this.ensure(),this.styleSubtree(document.body,t)}}if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){const t=new Mn;let e=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate(e,n,i){t.flushCustomStyles(),t.prepareTemplate(e,n)},prepareTemplateStyles(t,e,n){window.ShadyCSS.prepareTemplate(t,e,n)},prepareTemplateDom(t,e){},styleSubtree(e,n){t.flushCustomStyles(),t.styleSubtree(e,n)},styleElement(e){t.flushCustomStyles(),t.styleElement(e)},styleDocument(e){t.flushCustomStyles(),t.styleDocument(e)},getComputedStyleValue:(t,e)=>Qe(t,e),flushCustomStyles(){t.flushCustomStyles()},nativeCss:Ce,nativeShadow:Se,cssBuild:Ee,disableRuntime:Ae},e&&(window.ShadyCSS.CustomStyleInterface=e)}window.ShadyCSS.ApplyShim=Sn;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
class En{constructor(){this._asyncModule=null,this._callback=null,this._timer=null}setConfig(t,e){this._asyncModule=t,this._callback=e,this._timer=this._asyncModule.run((()=>{this._timer=null,Tn.delete(this),this._callback()}))}cancel(){this.isActive()&&(this._cancelAsync(),Tn.delete(this))}_cancelAsync(){this.isActive()&&(this._asyncModule.cancel(this._timer),this._timer=null)}flush(){this.isActive()&&(this.cancel(),this._callback())}isActive(){return null!=this._timer}static debounce(t,e,n){return t instanceof En?t._cancelAsync():t=new En,t.setConfig(e,n),t}}let Tn=new Set;const An=function(t){Tn.add(t)},Cn=function(){const t=Boolean(Tn.size);return Tn.forEach((t=>{try{t.flush()}catch(t){setTimeout((()=>{throw t}))}})),t};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let kn="string"==typeof document.head.style.touchAction,Ln="__polymerGestures",Pn="__polymerGesturesHandled",In="__polymerGesturesTouchAction",Nn=["mousedown","mousemove","mouseup","click"],On=[0,1,4,2],Rn=(function(){try{return 1===new MouseEvent("test",{buttons:1}).buttons}catch(t){return!1}})();function zn(t){return Nn.indexOf(t)>-1}let Dn=!1;function Bn(t){if(!zn(t)&&"touchend"!==t)return kn&&Dn&&v?{passive:!0}:void 0}!(function(){try{let t=Object.defineProperty({},"passive",{get(){Dn=!0}});window.addEventListener("test",null,t),window.removeEventListener("test",null,t)}catch(t){}})();let Hn=navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/);const Fn=[],Vn={button:!0,input:!0,keygen:!0,meter:!0,output:!0,textarea:!0,progress:!0,select:!0},jn={button:!0,command:!0,fieldset:!0,input:!0,keygen:!0,optgroup:!0,option:!0,select:!0,textarea:!0};function Un(t){let e=Array.prototype.slice.call(t.labels||[]);if(!e.length){e=[];let n=t.getRootNode();if(t.id){let i=n.querySelectorAll(`label[for = ${t.id}]`);for(let t=0;t<i.length;t++)e.push(i[t])}}return e}let Gn=function(t){let e=t.sourceCapabilities;if((!e||e.firesTouchEvents)&&(t[Pn]={skip:!0},"click"===t.type)){let e=!1,n=Zn(t);for(let t=0;t<n.length;t++){if(n[t].nodeType===Node.ELEMENT_NODE)if("label"===n[t].localName)Fn.push(n[t]);else if(Vn[n[t].localName]){let i=Un(n[t]);for(let t=0;t<i.length;t++)e=e||Fn.indexOf(i[t])>-1}if(n[t]===Yn.mouse.target)return}if(e)return;t.preventDefault(),t.stopPropagation()}};function Wn(t){let e=Hn?["click"]:Nn;for(let n,i=0;i<e.length;i++)n=e[i],t?(Fn.length=0,document.addEventListener(n,Gn,!0)):document.removeEventListener(n,Gn,!0)}function qn(t){let e=t.type;if(!zn(e))return!1;if("mousemove"===e){let e=void 0===t.buttons?1:t.buttons;return t instanceof window.MouseEvent&&!Rn&&(e=On[t.which]||0),Boolean(1&e)}return 0===(void 0===t.button?0:t.button)}let Yn={mouse:{target:null,mouseIgnoreJob:null},touch:{x:0,y:0,id:-1,scrollDecided:!1}};function Xn(t,e,n){t.movefn=e,t.upfn=n,document.addEventListener("mousemove",e),document.addEventListener("mouseup",n)}function $n(t){document.removeEventListener("mousemove",t.movefn),document.removeEventListener("mouseup",t.upfn),t.movefn=null,t.upfn=null}document.addEventListener("touchend",(function Kn(t){Yn.mouse.mouseIgnoreJob||Wn(!0),Yn.mouse.target=Zn(t)[0],Yn.mouse.mouseIgnoreJob=En.debounce(Yn.mouse.mouseIgnoreJob,gt.after(2500),(function(){Wn(),Yn.mouse.target=null,Yn.mouse.mouseIgnoreJob=null}))}),!!Dn&&{passive:!0});const Zn=window.ShadyDOM&&window.ShadyDOM.noPatch?window.ShadyDOM.composedPath:t=>t.composedPath&&t.composedPath()||[],Jn={},Qn=[];function ti(t){const e=Zn(t);return e.length>0?e[0]:t.target}function ei(t){let e,n=t.type,i=t.currentTarget[Ln];if(!i)return;let r=i[n];if(r){if(!t[Pn]&&(t[Pn]={},"touch"===n.slice(0,5))){let e=(t=t).changedTouches[0];if("touchstart"===n&&1===t.touches.length&&(Yn.touch.id=e.identifier),Yn.touch.id!==e.identifier)return;kn||"touchstart"!==n&&"touchmove"!==n||(function o(t){let e=t.changedTouches[0],n=t.type;if("touchstart"===n)Yn.touch.x=e.clientX,Yn.touch.y=e.clientY,Yn.touch.scrollDecided=!1;else if("touchmove"===n){if(Yn.touch.scrollDecided)return;Yn.touch.scrollDecided=!0;let n=(function i(t){let e="auto",n=Zn(t);for(let t,i=0;i<n.length;i++)if(t=n[i],t[In]){e=t[In];break}return e})(t),i=!1,r=Math.abs(Yn.touch.x-e.clientX),o=Math.abs(Yn.touch.y-e.clientY);t.cancelable&&("none"===n?i=!0:"pan-x"===n?i=o>r:"pan-y"===n&&(i=r>o)),i?t.preventDefault():ai("track")}})(t)}if(e=t[Pn],!e.skip){for(let n,i=0;i<Qn.length;i++)n=Qn[i],r[n.name]&&!e[n.name]&&n.flow&&n.flow.start.indexOf(t.type)>-1&&n.reset&&n.reset();for(let i,o=0;o<Qn.length;o++)i=Qn[o],r[i.name]&&!e[i.name]&&(e[i.name]=!0,i[n](t))}}}function ni(t,e,n){return!!Jn[e]&&((function i(t,e,n){let i=Jn[e],r=i.deps,o=i.name,a=t[Ln];a||(t[Ln]=a={});for(let e,n,i=0;i<r.length;i++)e=r[i],Hn&&zn(e)&&"click"!==e||(n=a[e],n||(a[e]=n={_count:0}),0===n._count&&t.addEventListener(e,ei,Bn(e)),n[o]=(n[o]||0)+1,n._count=(n._count||0)+1);t.addEventListener(e,n),i.touchAction&&ri(t,i.touchAction)})(t,e,n),!0)}function ii(t){Qn.push(t);for(let e=0;e<t.emits.length;e++)Jn[t.emits[e]]=t}function ri(t,e){kn&&t instanceof HTMLElement&&vt.run((()=>{t.style.touchAction=e})),t[In]=e}function oi(t,e,n){let i=new Event(e,{bubbles:!0,cancelable:!0,composed:!0});if(i.detail=n,Y(t).dispatchEvent(i),i.defaultPrevented){let t=n.preventer||n.sourceEvent;t&&t.preventDefault&&t.preventDefault()}}function ai(t){let e=(function n(t){for(let e,n=0;n<Qn.length;n++){e=Qn[n];for(let n,i=0;i<e.emits.length;i++)if(n=e.emits[i],n===t)return e}return null})(t);e.info&&(e.info.prevent=!0)}function si(t,e,n,i){e&&oi(e,t,{x:n.clientX,y:n.clientY,sourceEvent:n,preventer:i,prevent:function(t){return ai(t)}})}function li(t,e,n){if(t.prevent)return!1;if(t.started)return!0;let i=Math.abs(t.x-e),r=Math.abs(t.y-n);return i>=5||r>=5}function ci(t,e,n){if(!e)return;let i,r=t.moves[t.moves.length-2],o=t.moves[t.moves.length-1],a=0;r&&(i=o.x-r.x,a=o.y-r.y),oi(e,"track",{state:t.state,x:n.clientX,y:n.clientY,dx:o.x-t.x,dy:o.y-t.y,ddx:i,ddy:a,sourceEvent:n,hover:function(){return(function t(e,n){let i=document.elementFromPoint(e,n),r=i;for(;r&&r.shadowRoot&&!window.ShadyDOM;){let t=r;if(r=r.shadowRoot.elementFromPoint(e,n),t===r)break;r&&(i=r)}return i})(n.clientX,n.clientY)}})}function ui(t,e,n){let i=Math.abs(e.clientX-t.x),r=Math.abs(e.clientY-t.y),o=ti(n||e);!o||jn[o.localName]&&o.hasAttribute("disabled")||(isNaN(i)||isNaN(r)||i<=25&&r<=25||(function a(t){if("click"===t.type){if(0===t.detail)return!0;let e=ti(t);if(!e.nodeType||e.nodeType!==Node.ELEMENT_NODE)return!0;let n=e.getBoundingClientRect(),i=t.pageX,r=t.pageY;return!(i>=n.left&&i<=n.right&&r>=n.top&&r<=n.bottom)}return!1})(e))&&(t.prevent||oi(o,"tap",{x:e.clientX,y:e.clientY,sourceEvent:e,preventer:n}))}ii({name:"downup",deps:["mousedown","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["down","up"],info:{movefn:null,upfn:null},reset:function(){$n(this.info)},mousedown:function(t){if(!qn(t))return;let e=ti(t),n=this;Xn(this.info,(function t(i){qn(i)||(si("up",e,i),$n(n.info))}),(function t(i){qn(i)&&si("up",e,i),$n(n.info)})),si("down",e,t)},touchstart:function(t){si("down",ti(t),t.changedTouches[0],t)},touchend:function(t){si("up",ti(t),t.changedTouches[0],t)}}),ii({name:"track",touchAction:"none",deps:["mousedown","touchstart","touchmove","touchend"],flow:{start:["mousedown","touchstart"],end:["mouseup","touchend"]},emits:["track"],info:{x:0,y:0,state:"start",started:!1,moves:[],addMove:function(t){this.moves.length>2&&this.moves.shift(),this.moves.push(t)},movefn:null,upfn:null,prevent:!1},reset:function(){this.info.state="start",this.info.started=!1,this.info.moves=[],this.info.x=0,this.info.y=0,this.info.prevent=!1,$n(this.info)},mousedown:function(t){if(!qn(t))return;let e=ti(t),n=this,i=function t(i){let r=i.clientX,o=i.clientY;li(n.info,r,o)&&(n.info.state=n.info.started?"mouseup"===i.type?"end":"track":"start","start"===n.info.state&&ai("tap"),n.info.addMove({x:r,y:o}),qn(i)||(n.info.state="end",$n(n.info)),e&&ci(n.info,e,i),n.info.started=!0)};Xn(this.info,i,(function t(e){n.info.started&&i(e),$n(n.info)})),this.info.x=t.clientX,this.info.y=t.clientY},touchstart:function(t){let e=t.changedTouches[0];this.info.x=e.clientX,this.info.y=e.clientY},touchmove:function(t){let e=ti(t),n=t.changedTouches[0],i=n.clientX,r=n.clientY;li(this.info,i,r)&&("start"===this.info.state&&ai("tap"),this.info.addMove({x:i,y:r}),ci(this.info,e,n),this.info.state="track",this.info.started=!0)},touchend:function(t){let e=ti(t),n=t.changedTouches[0];this.info.started&&(this.info.state="end",this.info.addMove({x:n.clientX,y:n.clientY}),ci(this.info,e,n))}}),ii({name:"tap",deps:["mousedown","click","touchstart","touchend"],flow:{start:["mousedown","touchstart"],end:["click","touchend"]},emits:["tap"],info:{x:NaN,y:NaN,prevent:!1},reset:function(){this.info.x=NaN,this.info.y=NaN,this.info.prevent=!1},mousedown:function(t){qn(t)&&(this.info.x=t.clientX,this.info.y=t.clientY)},click:function(t){qn(t)&&ui(this.info,t)},touchstart:function(t){const e=t.changedTouches[0];this.info.x=e.clientX,this.info.y=e.clientY},touchend:function(t){ui(this.info,t.changedTouches[0],t)}});const hi=ti,di=N((t=>class extends t{_addEventListenerToNode(t,e,n){ni(t,e,n)||super._addEventListenerToNode(t,e,n)}_removeEventListenerFromNode(t,e,n){(function i(t,e,n){return!!Jn[e]&&((function i(t,e,n){let i=Jn[e],r=i.deps,o=i.name,a=t[Ln];if(a)for(let e,n,i=0;i<r.length;i++)e=r[i],n=a[e],n&&n[o]&&(n[o]=(n[o]||1)-1,n._count=(n._count||1)-1,0===n._count&&t.removeEventListener(e,ei,Bn(e)));t.removeEventListener(e,n)})(t,e,n),!0)})(t,e,n)||super._removeEventListenerFromNode(t,e,n)}})),pi=/:host\(:dir\((ltr|rtl)\)\)/g,fi=/([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g,mi=/:dir\((?:ltr|rtl)\)/,gi=Boolean(window.ShadyDOM&&window.ShadyDOM.inUse),_i=[];
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let yi=null,vi="";function bi(){vi=document.documentElement.getAttribute("dir")}function xi(t){t.__autoDirOptOut||t.setAttribute("dir",vi)}function wi(){bi(),vi=document.documentElement.getAttribute("dir");for(let t=0;t<_i.length;t++)xi(_i[t])}const Si=N((t=>{gi||yi||(bi(),yi=new MutationObserver(wi),yi.observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]}));const e=Mt(t);class n extends e{static _processStyleText(t,n){return t=e._processStyleText.call(this,t,n),!gi&&mi.test(t)&&(t=this._replaceDirInCssText(t),this.__activateDir=!0),t}static _replaceDirInCssText(t){let e=t;return e=e.replace(pi,':host([dir="$1"])'),e=e.replace(fi,':host([dir="$2"]) $1'),e}constructor(){super(),this.__autoDirOptOut=!1}ready(){super.ready(),this.__autoDirOptOut=this.hasAttribute("dir")}connectedCallback(){e.prototype.connectedCallback&&super.connectedCallback(),this.constructor.__activateDir&&((function t(){yi&&yi.takeRecords().length&&wi()})(),_i.push(this),xi(this))}disconnectedCallback(){if(e.prototype.disconnectedCallback&&super.disconnectedCallback(),this.constructor.__activateDir){const t=_i.indexOf(this);t>-1&&_i.splice(t,1)}}}return n.__activateDir=!1,n}));
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let Mi=!1,Ei=[],Ti=[];function Ai(){Mi=!0,requestAnimationFrame((function(){Mi=!1,(function t(e){for(;e.length;)Ci(e.shift())})(Ei),setTimeout((function(){!(function t(e){for(let t=0,n=e.length;t<n;t++)Ci(e.shift())})(Ti)}))}))}function Ci(t){const e=t[0],n=t[1],i=t[2];try{n.apply(e,i)}catch(t){setTimeout((()=>{throw t}))}}function ki(t,e,n){Mi||Ai(),Ti.push([t,e,n])}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function Li(){document.body.removeAttribute("unresolved")}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
function Pi(t,e,n){return{index:t,removed:e,addedCount:n}}function Ii(t,e){return(function n(t,e,i,r,o,a){let s,l=0,c=0,u=Math.min(i-e,a-o);if(0==e&&0==o&&(l=(function h(t,e,n){for(let i=0;i<n;i++)if(!Ni(t[i],e[i]))return i;return n})(t,r,u)),i==t.length&&a==r.length&&(c=(function d(t,e,n){let i=t.length,r=e.length,o=0;for(;o<n&&Ni(t[--i],e[--r]);)o++;return o})(t,r,u-l)),o+=l,a-=c,(i-=c)-(e+=l)==0&&a-o==0)return[];if(e==i){for(s=Pi(e,[],0);o<a;)s.removed.push(r[o++]);return[s]}if(o==a)return[Pi(e,[],i-e)];let p=(function m(t){let e=t.length-1,n=t[0].length-1,i=t[e][n],r=[];for(;e>0||n>0;){if(0==e){r.push(2),n--;continue}if(0==n){r.push(3),e--;continue}let o,a=t[e-1][n-1],s=t[e-1][n],l=t[e][n-1];o=s<l?s<a?s:a:l<a?l:a,o==a?(a==i?r.push(0):(r.push(1),i=a),e--,n--):o==s?(r.push(3),e--,i=s):(r.push(2),n--,i=l)}return r.reverse(),r})((function f(t,e,n,i,r,o){let a=o-r+1,s=n-e+1,l=new Array(a);for(let t=0;t<a;t++)l[t]=new Array(s),l[t][0]=t;for(let t=0;t<s;t++)l[0][t]=t;for(let n=1;n<a;n++)for(let o=1;o<s;o++)if(Ni(t[e+o-1],i[r+n-1]))l[n][o]=l[n-1][o-1];else{let t=l[n-1][o]+1,e=l[n][o-1]+1;l[n][o]=t<e?t:e}return l})(t,e,i,r,o,a));s=void 0;let g=[],_=e,y=o;for(let t=0;t<p.length;t++)switch(p[t]){case 0:s&&(g.push(s),s=void 0),_++,y++;break;case 1:s||(s=Pi(_,[],0)),s.addedCount++,_++,s.removed.push(r[y]),y++;break;case 2:s||(s=Pi(_,[],0)),s.addedCount++,_++;break;case 3:s||(s=Pi(_,[],0)),s.removed.push(r[y]),y++}return s&&g.push(s),g})(t,0,t.length,e,0,e.length)}function Ni(t,e){return t===e}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function Oi(t){return"slot"===t.localName}"interactive"===document.readyState||"complete"===document.readyState?Li():window.addEventListener("DOMContentLoaded",Li);let Ri=class{static getFlattenedNodes(t){const e=Y(t);return Oi(t)?(t=t,e.assignedNodes({flatten:!0})):Array.from(e.childNodes).map((t=>Oi(t)?Y(t=t).assignedNodes({flatten:!0}):[t])).reduce(((t,e)=>t.concat(e)),[])}constructor(t,e){this._shadyChildrenObserver=null,this._nativeChildrenObserver=null,this._connected=!1,this._target=t,this.callback=e,this._effectiveNodes=[],this._observer=null,this._scheduled=!1,this._boundSchedule=()=>{this._schedule()},this.connect(),this._schedule()}connect(){Oi(this._target)?this._listenSlots([this._target]):Y(this._target).children&&(this._listenSlots(Y(this._target).children),window.ShadyDOM?this._shadyChildrenObserver=window.ShadyDOM.observeChildren(this._target,(t=>{this._processMutations(t)})):(this._nativeChildrenObserver=new MutationObserver((t=>{this._processMutations(t)})),this._nativeChildrenObserver.observe(this._target,{childList:!0}))),this._connected=!0}disconnect(){Oi(this._target)?this._unlistenSlots([this._target]):Y(this._target).children&&(this._unlistenSlots(Y(this._target).children),window.ShadyDOM&&this._shadyChildrenObserver?(window.ShadyDOM.unobserveChildren(this._shadyChildrenObserver),this._shadyChildrenObserver=null):this._nativeChildrenObserver&&(this._nativeChildrenObserver.disconnect(),this._nativeChildrenObserver=null)),this._connected=!1}_schedule(){this._scheduled||(this._scheduled=!0,vt.run((()=>this.flush())))}_processMutations(t){this._processSlotMutations(t),this.flush()}_processSlotMutations(t){if(t)for(let e=0;e<t.length;e++){let n=t[e];n.addedNodes&&this._listenSlots(n.addedNodes),n.removedNodes&&this._unlistenSlots(n.removedNodes)}}flush(){if(!this._connected)return!1;window.ShadyDOM&&ShadyDOM.flush(),this._nativeChildrenObserver?this._processSlotMutations(this._nativeChildrenObserver.takeRecords()):this._shadyChildrenObserver&&this._processSlotMutations(this._shadyChildrenObserver.takeRecords()),this._scheduled=!1;let t={target:this._target,addedNodes:[],removedNodes:[]},e=this.constructor.getFlattenedNodes(this._target),n=Ii(e,this._effectiveNodes);for(let e,i=0;i<n.length&&(e=n[i]);i++)for(let n,i=0;i<e.removed.length&&(n=e.removed[i]);i++)t.removedNodes.push(n);for(let i,r=0;r<n.length&&(i=n[r]);r++)for(let n=i.index;n<i.index+i.addedCount;n++)t.addedNodes.push(e[n]);this._effectiveNodes=e;let i=!1;return(t.addedNodes.length||t.removedNodes.length)&&(i=!0,this.callback.call(this._target,t)),i}_listenSlots(t){for(let e=0;e<t.length;e++){let n=t[e];Oi(n)&&n.addEventListener("slotchange",this._boundSchedule)}}_unlistenSlots(t){for(let e=0;e<t.length;e++){let n=t[e];Oi(n)&&n.removeEventListener("slotchange",this._boundSchedule)}}};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const zi=function(){let t,e;do{t=window.ShadyDOM&&ShadyDOM.flush(),window.ShadyCSS&&window.ShadyCSS.ScopingShim&&window.ShadyCSS.ScopingShim.flush(),e=Cn()}while(t||e)},Di=Element.prototype,Bi=Di.matches||Di.matchesSelector||Di.mozMatchesSelector||Di.msMatchesSelector||Di.oMatchesSelector||Di.webkitMatchesSelector,Hi=function(t,e){return Bi.call(t,e)};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */class Fi{constructor(t){window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.patch(t),this.node=t}observeNodes(t){return new Ri(this.node,t)}unobserveNodes(t){t.disconnect()}notifyObserver(){}deepContains(t){if(Y(this.node).contains(t))return!0;let e=t,n=t.ownerDocument;for(;e&&e!==n&&e!==this.node;)e=Y(e).parentNode||Y(e).host;return e===this.node}getOwnerRoot(){return Y(this.node).getRootNode()}getDistributedNodes(){return"slot"===this.node.localName?Y(this.node).assignedNodes({flatten:!0}):[]}getDestinationInsertionPoints(){let t=[],e=Y(this.node).assignedSlot;for(;e;)t.push(e),e=Y(e).assignedSlot;return t}importNode(t,e){let n=this.node instanceof Document?this.node:this.node.ownerDocument;return Y(n).importNode(t,e)}getEffectiveChildNodes(){return Ri.getFlattenedNodes(this.node)}queryDistributedElements(t){let e=this.getEffectiveChildNodes(),n=[];for(let i,r=0,o=e.length;r<o&&(i=e[r]);r++)i.nodeType===Node.ELEMENT_NODE&&Hi(i,t)&&n.push(i);return n}get activeElement(){let t=this.node;return void 0!==t._activeElement?t._activeElement:t.activeElement}}function Vi(t,e){for(let n=0;n<e.length;n++){let i=e[n];Object.defineProperty(t,i,{get:function(){return this.node[i]},configurable:!0})}}class ji{constructor(t){this.event=t}get rootTarget(){return this.path[0]}get localTarget(){return this.event.target}get path(){return this.event.composedPath()}}let Ui=Fi;if(window.ShadyDOM&&window.ShadyDOM.inUse&&window.ShadyDOM.noPatch&&window.ShadyDOM.Wrapper){class t extends window.ShadyDOM.Wrapper{}Object.getOwnPropertyNames(Fi.prototype).forEach((e=>{"activeElement"!=e&&(t.prototype[e]=Fi.prototype[e])})),Vi(t.prototype,["classList"]),Ui=t,Object.defineProperties(ji.prototype,{localTarget:{get(){const t=this.event.currentTarget,e=t&&qi(t).getOwnerRoot(),n=this.path;for(let t=0;t<n.length;t++){const i=n[t];if(qi(i).getOwnerRoot()===e)return i}},configurable:!0},path:{get(){return window.ShadyDOM.composedPath(this.event)},configurable:!0}})}else!(function Gi(t,e){for(let n=0;n<e.length;n++){let i=e[n];t[i]=function(){return this.node[i].apply(this.node,arguments)}}})(Fi.prototype,["cloneNode","appendChild","insertBefore","removeChild","replaceChild","setAttribute","removeAttribute","querySelector","querySelectorAll"]),Vi(Fi.prototype,["parentNode","firstChild","lastChild","nextSibling","previousSibling","firstElementChild","lastElementChild","nextElementSibling","previousElementSibling","childNodes","children","classList"]),(function Wi(t,e){for(let n=0;n<e.length;n++){let i=e[n];Object.defineProperty(t,i,{get:function(){return this.node[i]},set:function(t){this.node[i]=t},configurable:!0})}})(Fi.prototype,["textContent","innerHTML","className"]);const qi=function(t){if((t=t||document)instanceof Ui)return t;if(t instanceof ji)return t;let e=t.__domApi;return e||(e=t instanceof Event?new ji(t):new Ui(t),t.__domApi=e),e},Yi=window.ShadyDOM,Xi=window.ShadyCSS;
/**
    @license
    Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */function $i(t,e){return Y(t).getRootNode()===e}
/**
     * @fileoverview
     * @suppress {checkPrototypalTypes}
     * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
     * This code may only be used under the BSD style license found at
     * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
     * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
     * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
     * Google as part of the polymer project is also subject to an additional IP
     * rights grant found at http://polymer.github.io/PATENTS.txt
     */
const Ki="disable-upgrade",Zi=t=>{for(;t;){const e=Object.getOwnPropertyDescriptor(t,"observedAttributes");if(e)return e.get;t=Object.getPrototypeOf(t.prototype).constructor}return()=>[]};N((t=>{const e=me(t);let n=Zi(e);return class extends e{constructor(){super()}static get observedAttributes(){return n.call(this).concat(Ki)}_initializeProperties(){this.hasAttribute(Ki)?this.__isUpgradeDisabled=!0:super._initializeProperties()}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(t){return super._canApplyPropertyDefault(t)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(t))}attributeChangedCallback(t,e,n,i){t==Ki?this.__isUpgradeDisabled&&null==n&&(super._initializeProperties(),this.__isUpgradeDisabled=!1,Y(this).isConnected&&super.connectedCallback()):super.attributeChangedCallback(t,e,n,i)}connectedCallback(){this.__isUpgradeDisabled||super.connectedCallback()}disconnectedCallback(){this.__isUpgradeDisabled||super.disconnectedCallback()}}}));
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const Ji="disable-upgrade";let Qi=window.ShadyCSS;const tr=N((t=>{const e=di(me(t)),n=fe?e:Si(e),i=Zi(n),r={x:"pan-x",y:"pan-y",none:"none",all:"auto"};class o extends n{constructor(){super()}static get importMeta(){return this.prototype.importMeta}created(){}__attributeReaction(t,e,n){(this.__dataAttributes&&this.__dataAttributes[t]||t===Ji)&&this.attributeChangedCallback(t,e,n,null)}setAttribute(t,e){if(L&&!this._legacyForceObservedAttributes){const n=this.getAttribute(t);super.setAttribute(t,e),this.__attributeReaction(t,n,String(e))}else super.setAttribute(t,e)}removeAttribute(t){if(L&&!this._legacyForceObservedAttributes){const e=this.getAttribute(t);super.removeAttribute(t),this.__attributeReaction(t,e,null)}else super.removeAttribute(t)}static get observedAttributes(){return L&&!this.prototype._legacyForceObservedAttributes?(this.hasOwnProperty(JSCompiler_renameProperty("__observedAttributes",this))||(this.__observedAttributes=[]),this.__observedAttributes):i.call(this).concat(Ji)}_enableProperties(){this.__isUpgradeDisabled||super._enableProperties()}_canApplyPropertyDefault(t){return super._canApplyPropertyDefault(t)&&!(this.__isUpgradeDisabled&&this._isPropertyPending(t))}connectedCallback(){this.__needsAttributesAtConnected&&this._takeAttributes(),this.__isUpgradeDisabled||(super.connectedCallback(),this.isAttached=!0,this.attached())}attached(){}disconnectedCallback(){this.__isUpgradeDisabled||(super.disconnectedCallback(),this.isAttached=!1,this.detached())}detached(){}attributeChangedCallback(t,e,n,i){e!==n&&(t==Ji?this.__isUpgradeDisabled&&null==n&&(this._initializeProperties(),this.__isUpgradeDisabled=!1,Y(this).isConnected&&this.connectedCallback()):(super.attributeChangedCallback(t,e,n,i),this.attributeChanged(t,e,n)))}attributeChanged(t,e,n){}_initializeProperties(){if(w&&this.hasAttribute(Ji))this.__isUpgradeDisabled=!0;else{let t=Object.getPrototypeOf(this);t.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",t))||(this._registered(),t.__hasRegisterFinished=!0),super._initializeProperties(),this.root=this,this.created(),L&&!this._legacyForceObservedAttributes&&(this.hasAttributes()?this._takeAttributes():this.parentNode||(this.__needsAttributesAtConnected=!0)),this._applyListeners()}}_takeAttributes(){const t=this.attributes;for(let e=0,n=t.length;e<n;e++){const n=t[e];this.__attributeReaction(n.name,null,n.value)}}_registered(){}ready(){this._ensureAttributes(),super.ready()}_ensureAttributes(){}_applyListeners(){}serialize(t){return this._serializeValue(t)}deserialize(t,e){return this._deserializeValue(t,e)}reflectPropertyToAttribute(t,e,n){this._propertyToAttribute(t,e,n)}serializeValueToAttribute(t,e,n){this._valueToNodeAttribute(n||this,t,e)}extend(t,e){if(!t||!e)return t||e;let n=Object.getOwnPropertyNames(e);for(let i,r=0;r<n.length&&(i=n[r]);r++){let n=Object.getOwnPropertyDescriptor(e,i);n&&Object.defineProperty(t,i,n)}return t}mixin(t,e){for(let n in e)t[n]=e[n];return t}chainObject(t,e){return t&&e&&t!==e&&(t.__proto__=e),t}instanceTemplate(t){let e=this.constructor._contentForTemplate(t);return document.importNode(e,!0)}fire(t,e,n){n=n||{},e=null==e?{}:e;let i=new Event(t,{bubbles:void 0===n.bubbles||n.bubbles,cancelable:Boolean(n.cancelable),composed:void 0===n.composed||n.composed});return i.detail=e,Y(n.node||this).dispatchEvent(i),i}listen(t,e,n){t=t||this;let i=this.__boundListeners||(this.__boundListeners=new WeakMap),r=i.get(t);r||(r={},i.set(t,r));let o=e+n;r[o]||(r[o]=this._addMethodEventListenerToNode(t,e,n,this))}unlisten(t,e,n){t=t||this;let i=this.__boundListeners&&this.__boundListeners.get(t),r=e+n,o=i&&i[r];o&&(this._removeEventListenerFromNode(t,e,o),i[r]=null)}setScrollDirection(t,e){ri(e||this,r[t]||"auto")}$$(t){return this.root.querySelector(t)}get domHost(){let t=Y(this).getRootNode();return t instanceof DocumentFragment?t.host:t}distributeContent(){const t=qi(this);window.ShadyDOM&&t.shadowRoot&&ShadyDOM.flush()}getEffectiveChildNodes(){return qi(this).getEffectiveChildNodes()}queryDistributedElements(t){return qi(this).queryDistributedElements(t)}getEffectiveChildren(){return this.getEffectiveChildNodes().filter((function(t){return t.nodeType===Node.ELEMENT_NODE}))}getEffectiveTextContent(){let t=this.getEffectiveChildNodes(),e=[];for(let n,i=0;n=t[i];i++)n.nodeType!==Node.COMMENT_NODE&&e.push(n.textContent);return e.join("")}queryEffectiveChildren(t){let e=this.queryDistributedElements(t);return e&&e[0]}queryAllEffectiveChildren(t){return this.queryDistributedElements(t)}getContentChildNodes(t){let e=this.root.querySelector(t||"slot");return e?qi(e).getDistributedNodes():[]}getContentChildren(t){return this.getContentChildNodes(t).filter((function(t){return t.nodeType===Node.ELEMENT_NODE}))}isLightDescendant(t){const e=this;return e!==t&&Y(e).contains(t)&&Y(e).getRootNode()===Y(t).getRootNode()}isLocalDescendant(t){return this.root===Y(t).getRootNode()}scopeSubtree(t,e=!1){return(function n(t,e=!1){if(!Yi||!Xi)return null;if(!Yi.handlesDynamicScoping)return null;const n=Xi.ScopingShim;if(!n)return null;const i=n.scopeForNode(t),r=Y(t).getRootNode(),o=t=>{if(!$i(t,r))return;const e=Array.from(Yi.nativeMethods.querySelectorAll.call(t,"*"));e.push(t);for(let t=0;t<e.length;t++){const o=e[t];if(!$i(o,r))continue;const a=n.currentScopeForNode(o);a!==i&&(""!==a&&n.unscopeNode(o,a),n.scopeNode(o,i))}};if(o(t),e){const e=new MutationObserver((t=>{for(let e=0;e<t.length;e++){const n=t[e];for(let t=0;t<n.addedNodes.length;t++){const e=n.addedNodes[t];e.nodeType===Node.ELEMENT_NODE&&o(e)}}}));return e.observe(t,{childList:!0,subtree:!0}),e}return null})(t,e)}getComputedStyleValue(t){return Qi.getComputedStyleValue(this,t)}debounce(t,e,n){return this._debouncers=this._debouncers||{},this._debouncers[t]=En.debounce(this._debouncers[t],n>0?gt.after(n):vt,e.bind(this))}isDebouncerActive(t){this._debouncers=this._debouncers||{};let e=this._debouncers[t];return!(!e||!e.isActive())}flushDebouncer(t){this._debouncers=this._debouncers||{};let e=this._debouncers[t];e&&e.flush()}cancelDebouncer(t){this._debouncers=this._debouncers||{};let e=this._debouncers[t];e&&e.cancel()}async(t,e){return e>0?gt.run(t.bind(this),e):~vt.run(t.bind(this))}cancelAsync(t){t<0?vt.cancel(~t):gt.cancel(t)}create(t,e){let n=document.createElement(t);if(e)if(n.setProperties)n.setProperties(e);else for(let t in e)n[t]=e[t];return n}elementMatches(t,e){return Hi(e||this,t)}toggleAttribute(t,e){let n=this;return 3===arguments.length&&(n=arguments[2]),1==arguments.length&&(e=!n.hasAttribute(t)),e?(Y(n).setAttribute(t,""),!0):(Y(n).removeAttribute(t),!1)}toggleClass(t,e,n){n=n||this,1==arguments.length&&(e=!n.classList.contains(t)),e?n.classList.add(t):n.classList.remove(t)}transform(t,e){(e=e||this).style.webkitTransform=t,e.style.transform=t}translate3d(t,e,n,i){this.transform("translate3d("+t+","+e+","+n+")",i=i||this)}arrayDelete(t,e){let n;if(Array.isArray(t)){if(n=t.indexOf(e),n>=0)return t.splice(n,1)}else if(n=nt(this,t).indexOf(e),n>=0)return this.splice(t,n,1);return null}_logger(t,e){switch(Array.isArray(e)&&1===e.length&&Array.isArray(e[0])&&(e=e[0]),t){case"log":case"warn":case"error":console[t](...e)}}_log(...t){this._logger("log",t)}_warn(...t){this._logger("warn",t)}_error(...t){this._logger("error",t)}_logf(t,...e){return["[%s::%s]",this.is,t,...e]}}return o.prototype.is="",o}));function er(t,e){let n=0,i=0;for(;;){if(n===t.length)return i===e.length?0:-1;if(i===e.length)return 1;if(ir(t[n])&&ir(e[i])){const r=n,o=i;n=nr(t,n+1),i=nr(e,i+1);const a=parseFloat(t.slice(r,n)),s=parseFloat(e.slice(o,i));if(a<s)return-1;if(a>s)return 1}else{if(rr(t[n])){if(!rr(e[i]))return-1}else{if(rr(e[i]))return 1;if(t[n]<e[i])return-1;if(t[n]>e[i])return 1}n++,i++}}}function nr(t,e){let n;!(function(t){t[t.NATURAL=0]="NATURAL",t[t.REAL=1]="REAL",t[t.EXPONENT_SIGN=2]="EXPONENT_SIGN",t[t.EXPONENT=3]="EXPONENT"})(n||(n={}));let i=n.NATURAL;for(;e<t.length;e++)if(i===n.NATURAL){if("."===t[e])i=n.REAL;else if("e"===t[e]||"E"===t[e])i=n.EXPONENT_SIGN;else if(!ir(t[e]))break}else if(i===n.REAL){if("e"===t[e]||"E"===t[e])i=n.EXPONENT_SIGN;else if(!ir(t[e]))break}else if(i===n.EXPONENT_SIGN){if(!ir(t[e])&&"+"!==t[e]&&"-"!==t[e])break;i=n.EXPONENT}else if(i===n.EXPONENT&&!ir(t[e]))break;return e}function ir(t){return"0"<=t&&t<="9"}function rr(t){return"/"===t||"_"===t||ir(t)}function or(t){return we.union.apply(null,we.values(t)).sort(er)}class ar extends Error{constructor(){super(...arguments),this.name="RequestCancellationError"}}class sr extends Error{constructor(t){super(t),this.name="InvalidRequestOptionsError",Object.setPrototypeOf(this,sr.prototype)}}class lr extends Error{constructor(t,e){super(),this.message=`RequestNetworkError: ${t.status} at ${e}`,this.name="RequestNetworkError",this.req=t,this.url=e}}var cr;!(function(t){t.GET="GET",t.POST="POST"})(cr||(cr={}));class ur{validate(){if(this.methodType===cr.GET&&this.body)throw new sr("body must be missing for a GET request.")}}class hr{constructor(t=1e3,e=3){this._queue=[],this._nActiveRequests=0,this._nSimultaneousRequests=t,this._maxRetries=e}request(t,e){const n=(function i(t){const e=new ur;return t?(e.methodType=cr.POST,e.body=(function n(t){const e=new FormData;for(const[n,i]of Object.entries(t)){const t=Array.isArray(i)?i:[i];for(const i of t)e.append(n,i)}return e})(t),e):(e.methodType=cr.GET,e)})(e);return this.requestWithOptions(t,n)}requestWithOptions(t,e){return e.validate(),new Promise(((t,e)=>{this._queue.push({resolve:t,reject:e}),this.launchRequests()})).then((()=>this.promiseWithRetries(t,this._maxRetries,e))).then((t=>(this._nActiveRequests--,this.launchRequests(),t)),(t=>("RequestNetworkError"===t.name&&(this._nActiveRequests--,this.launchRequests()),Promise.reject(t))))}fetch(t,e){return new Promise(((t,e)=>{this._queue.push({resolve:t,reject:e}),this.launchRequests()})).then((()=>{let n=1;return new Promise((i=>{const r=()=>{fetch(t,e).then((t=>{if(!t.ok&&this._maxRetries>n)return n++,void r();i(t),this._nActiveRequests--,this.launchRequests()}))};r()}))}))}clearQueue(){for(;this._queue.length>0;)this._queue.pop().reject(new ar("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&this._queue.length>0;)this._nActiveRequests++,this._queue.pop().resolve(void 0)}promiseWithRetries(t,e,n){return this._promiseFromUrl(t,n).then((t=>t),(i=>e>0?this.promiseWithRetries(t,e-1,n):Promise.reject(i)))}_promiseFromUrl(t,e){return new Promise(((n,i)=>{const r=(function o(t,e,n,i){const r=new XMLHttpRequest;return r.open(t,e),n&&(r.withCredentials=n),i&&r.setRequestHeader("Content-Type",i),r})(e.methodType,t,e.withCredentials,e.contentType);r.onload=function(){200===r.status?n(JSON.parse(r.responseText)):i(new lr(r,t))},r.onerror=function(){i(new lr(r,t))},e.body?r.send(e.body):r.send()}))}}const dr="experimentalPlugin",pr=new URLSearchParams(window.location.search);let fr=mr();function mr(t="data",e=pr){return"/"===t[t.length-1]&&(t=t.slice(0,t.length-1)),{environment:()=>_r(t,"/environment"),experiments:()=>_r(t,"/experiments"),pluginRoute:(e,n,i)=>_r(t+"/plugin",`/${e}${n}`,i),pluginsListing:()=>_r(t,"/plugins_listing",yr({[dr]:e.getAll(dr)})),runs:()=>_r(t,"/runs"),runsForExperiment:e=>_r(t,"/experiment_runs",yr({experiment:String(e)}))}}function gr(){return fr}function _r(t,e,n=new URLSearchParams){let i=t+e;return String(n)&&(i+=(e.includes("?")?"&":"?")+String(n)),i}function yr(t={}){const e=Object.keys(t).sort().filter((e=>t[e])),n=new URLSearchParams;return e.forEach((e=>{const i=t[e];(Array.isArray(i)?i:[i]).forEach((t=>n.append(e,t)))})),n}var vr;function br(t,e){const n=(()=>{try{return new RegExp(e)}catch(t){return null}})();return{name:e,metadata:{type:vr.SEARCH_RESULTS,validRegex:!!n,universalRegex:".*"===e},items:n?t.filter((t=>t.match(n))):[]}}function xr(t,e,n){const i=(function r(t,e=""){const n=[br(t,e)],i=(function r(t,e="/"){const n=[],i={};return t.forEach((t=>{const r=t.indexOf(e),o=r>=0?t.slice(0,r):t;if(!i[o]){const t={name:o,metadata:{type:vr.PREFIX_GROUP},items:[]};i[o]=t,n.push(t)}i[o].items.push(t)})),n})(t);return[].concat(n,i)})(or(t),n),o=(function a(t){const e=new Map;return Object.keys(t).forEach((n=>{t[n].forEach((t=>{const i=e.get(t)||[];i.push(n),e.set(t,i)}))})),e})(we.pick(t,e));return i.map((({name:t,metadata:e,items:n})=>({name:t,metadata:e,items:n.map((t=>({tag:t,runs:(o.get(t)||[]).slice()})))})))}function wr(t,e){const n=er(t.tag,e.tag);return 0!=n?n:er(t.run,e.run)}function Sr(t,e,n){return xr(t,e,n).map((function i(t){const e=we.flatten(t.items.map((({tag:t,runs:e})=>e.map((e=>({tag:t,run:e}))))));return e.sort(wr),{name:t.name,metadata:t.metadata,items:e}}))}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */!(function(t){t[t.SEARCH_RESULTS=0]="SEARCH_RESULTS",t[t.PREFIX_GROUP=1]="PREFIX_GROUP"})(vr||(vr={}));const Mr={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,listeners:!0,hostAttributes:!0},Er={attached:!0,detached:!0,ready:!0,created:!0,beforeRegister:!0,registered:!0,attributeChanged:!0,behaviors:!0,_noAccessors:!0},Tr=Object.assign({listeners:!0,hostAttributes:!0,properties:!0,observers:!0},Er);function Ar(t,e,n,i){!(function r(t,e,n){const i=t._noAccessors,r=Object.getOwnPropertyNames(t);for(let o=0;o<r.length;o++){let a=r[o];if(!(a in n))if(i)e[a]=t[a];else{let n=Object.getOwnPropertyDescriptor(t,a);n&&(n.configurable=!0,Object.defineProperty(e,a,n))}}})(e,t,i);for(let t in Mr)e[t]&&(n[t]=n[t]||[],n[t].push(e[t]))}function Cr(t,e,n){e=e||[];for(let i=t.length-1;i>=0;i--){let r=t[i];r?Array.isArray(r)?Cr(r,e):e.indexOf(r)<0&&(!n||n.indexOf(r)<0)&&e.unshift(r):console.warn("behavior is null, check for missing or 404 import")}return e}function kr(t,e){for(const n in e){const i=t[n],r=e[n];t[n]=!("value"in r)&&i&&"value"in i?Object.assign({value:i.value},r):r}}const Lr=tr(HTMLElement);function Pr(t,e,n){let i;const r={};class o extends e{static _finalizeClass(){if(this.hasOwnProperty(JSCompiler_renameProperty("generatedFrom",this))){if(i)for(let t,e=0;e<i.length;e++)t=i[e],t.properties&&this.createProperties(t.properties),t.observers&&this.createObservers(t.observers,t.properties);t.properties&&this.createProperties(t.properties),t.observers&&this.createObservers(t.observers,t.properties),this._prepareTemplate()}else e._finalizeClass.call(this)}static get properties(){const e={};if(i)for(let t=0;t<i.length;t++)kr(e,i[t].properties);return kr(e,t.properties),e}static get observers(){let e=[];if(i)for(let t,n=0;n<i.length;n++)t=i[n],t.observers&&(e=e.concat(t.observers));return t.observers&&(e=e.concat(t.observers)),e}created(){super.created();const t=r.created;if(t)for(let e=0;e<t.length;e++)t[e].call(this)}_registered(){const t=o.prototype;if(!t.hasOwnProperty(JSCompiler_renameProperty("__hasRegisterFinished",t))){t.__hasRegisterFinished=!0,super._registered(),w&&a(t);const e=Object.getPrototypeOf(this);let n=r.beforeRegister;if(n)for(let t=0;t<n.length;t++)n[t].call(e);if(n=r.registered,n)for(let t=0;t<n.length;t++)n[t].call(e)}}_applyListeners(){super._applyListeners();const t=r.listeners;if(t)for(let e=0;e<t.length;e++){const n=t[e];if(n)for(let t in n)this._addMethodEventListenerToNode(this,t,n[t])}}_ensureAttributes(){const t=r.hostAttributes;if(t)for(let e=t.length-1;e>=0;e--){const n=t[e];for(let t in n)this._ensureAttribute(t,n[t])}super._ensureAttributes()}ready(){super.ready();let t=r.ready;if(t)for(let e=0;e<t.length;e++)t[e].call(this)}attached(){super.attached();let t=r.attached;if(t)for(let e=0;e<t.length;e++)t[e].call(this)}detached(){super.detached();let t=r.detached;if(t)for(let e=0;e<t.length;e++)t[e].call(this)}attributeChanged(t,e,n){super.attributeChanged();let i=r.attributeChanged;if(i)for(let r=0;r<i.length;r++)i[r].call(this,t,e,n)}}if(n){Array.isArray(n)||(n=[n]);let t=e.prototype.behaviors;i=Cr(n,null,t),o.prototype.behaviors=t?t.concat(n):i}const a=e=>{i&&(function n(t,e,i){for(let n=0;n<e.length;n++)Ar(t,e[n],i,Tr)})(e,i,r),Ar(e,t,r,Er)};return w||a(o.prototype),o.generatedFrom=t,o}const Ir=function(t,e){t||console.warn("Polymer.Class requires `info` argument");let n=e?e(Lr):Lr;return n=Pr(t,n,t.behaviors),n.is=n.prototype.is=t.is,n},Nr=function(t){let e;return e="function"==typeof t?t:Nr.Class(t),t._legacyForceObservedAttributes&&(e.prototype._legacyForceObservedAttributes=t._legacyForceObservedAttributes),customElements.define(e.is,e),e};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
function Or(t,e,n,i,r){let o;r&&(o="object"==typeof n&&null!==n,o&&(i=t.__dataTemp[e]));let a=i!==n&&(i==i||n==n);return o&&a&&(t.__dataTemp[e]=n),a}Nr.Class=Ir;const Rr=N((t=>class extends t{_shouldPropertyChange(t,e,n){return Or(this,t,e,n,!0)}})),zr=N((t=>class extends t{static get properties(){return{mutableData:Boolean}}_shouldPropertyChange(t,e,n){return Or(this,t,e,n,this.mutableData)}}));Rr._mutablePropertyChange=Or;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let Dr=null;function Br(){return Dr}Br.prototype=Object.create(HTMLTemplateElement.prototype,{constructor:{value:Br,writable:!0}});const Hr=he(Br),Fr=Rr(Hr),Vr=he(class{});function jr(t,e){for(let n=0;n<e.length;n++){let i=e[n];if(Boolean(t)!=Boolean(i.__hideTemplateChildren__))if(i.nodeType===Node.TEXT_NODE)t?(i.__polymerTextContent__=i.textContent,i.textContent=""):i.textContent=i.__polymerTextContent__;else if("slot"===i.localName)if(t)i.__polymerReplaced__=document.createComment("hidden-slot"),Y(Y(i).parentNode).replaceChild(i.__polymerReplaced__,i);else{const t=i.__polymerReplaced__;t&&Y(Y(t).parentNode).replaceChild(i,t)}else i.style&&(t?(i.__polymerDisplay__=i.style.display,i.style.display="none"):i.style.display=i.__polymerDisplay__);i.__hideTemplateChildren__=t,i._showHideChildren&&i._showHideChildren(t)}}class Ur extends Vr{constructor(t){super(),this._configureProperties(t),this.root=this._stampTemplate(this.__dataHost);let e=[];this.children=e;for(let t=this.root.firstChild;t;t=t.nextSibling)e.push(t),t.__templatizeInstance=this;this.__templatizeOwner&&this.__templatizeOwner.__hideTemplateChildren__&&this._showHideChildren(!0);let n=this.__templatizeOptions;(t&&n.instanceProps||!n.instanceProps)&&this._enableProperties()}_configureProperties(t){if(this.__templatizeOptions.forwardHostProp)for(let t in this.__hostProps)this._setPendingProperty(t,this.__dataHost["_host_"+t]);for(let e in t)this._setPendingProperty(e,t[e])}forwardHostProp(t,e){this._setPendingPropertyOrPath(t,e,!1,!0)&&this.__dataHost._enqueueClient(this)}_addEventListenerToNode(t,e,n){if(this._methodHost&&this.__templatizeOptions.parentModel)this._methodHost._addEventListenerToNode(t,e,(t=>{t.model=this,n(t)}));else{let i=this.__dataHost.__dataHost;i&&i._addEventListenerToNode(t,e,n)}}_showHideChildren(t){jr(t,this.children)}_setUnmanagedPropertyToNode(t,e,n){t.__hideTemplateChildren__&&t.nodeType==Node.TEXT_NODE&&"textContent"==e?t.__polymerTextContent__=n:super._setUnmanagedPropertyToNode(t,e,n)}get parentModel(){let t=this.__parentModel;if(!t){let e;t=this;do{t=t.__dataHost.__dataHost}while((e=t.__templatizeOptions)&&!e.parentModel);this.__parentModel=t}return t}dispatchEvent(t){return!0}}const Gr=Rr(Ur);function Wr(t){let e=t.__dataHost;return e&&e._methodHost||e}function qr(t,e){return function t(n,i,r){e.call(n.__templatizeOwner,i.substring("_host_".length),r[i])}}function Yr(t,e){return function t(n,i,r){e.call(n.__templatizeOwner,n,i,r[i])}}function Xr(t,e,n){if(b&&!Wr(t))throw new Error("strictTemplatePolicy: template owner not trusted");if(n=n||{},t.__templatizeOwner)throw new Error("A <template> can only be templatized once");t.__templatizeOwner=e;let i=(e?e.constructor:Ur)._parseTemplate(t),r=i.templatizeInstanceClass;r||(r=(function o(t,e,n){let i=n.mutableData?Gr:Ur;Xr.mixin&&(i=Xr.mixin(i));let r=class extends i{};return r.prototype.__templatizeOptions=n,r.prototype._bindTemplate(t),(function o(t,e,n,i){let r=n.hostProps||{};for(let e in i.instanceProps){delete r[e];let n=i.notifyInstanceProp;n&&t.prototype._addPropertyEffect(e,t.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:Yr(0,n)})}if(i.forwardHostProp&&e.__dataHost)for(let e in r)n.hasHostProps||(n.hasHostProps=!0),t.prototype._addPropertyEffect(e,t.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,{fn:function t(e,n,i){e.__dataHost._setPendingPropertyOrPath("_host_"+n,i[n],!0,!0)}})})(r,t,e,n),r})(t,i,n),i.templatizeInstanceClass=r);const a=Wr(t);!(function s(t,e,n,i){let r=n.forwardHostProp;if(r&&e.hasHostProps){const o="template"==t.localName;let a=e.templatizeTemplateClass;if(!a){if(o){let t=n.mutableData?Fr:Hr;class i extends t{}a=e.templatizeTemplateClass=i}else{const n=t.constructor;class i extends n{}a=e.templatizeTemplateClass=i}let s=e.hostProps;for(let t in s)a.prototype._addPropertyEffect("_host_"+t,a.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,{fn:qr(0,r)}),a.prototype._createNotifyingProperty("_host_"+t);S&&i&&(function o(t,e,n){const i=n.constructor._properties,{propertyEffects:r}=t,{instanceProps:o}=e;for(let t in r)if(!(i[t]||o&&o[t])){const e=r[t];for(let n=0;n<e.length;n++){const{part:i}=e[n].info;if(!i.signature||!i.signature.static){console.warn(`Property '${t}' used in template but not declared in 'properties'; attribute will not be observed.`);break}}}})(e,n,i)}if(t.__dataProto&&Object.assign(t.__data,t.__dataProto),o)!(function a(t,e){Dr=t,Object.setPrototypeOf(t,e.prototype),new e,Dr=null})(t,a),t.__dataTemp={},t.__dataPending=null,t.__dataOld=null,t._enableProperties();else{Object.setPrototypeOf(t,a.prototype);const n=e.hostProps;for(let e in n)if(e="_host_"+e,e in t){const n=t[e];delete t[e],t.__data[e]=n}}}})(t,i,n,a);let l=class extends r{};return l.prototype._methodHost=a,l.prototype.__dataHost=t,l.prototype.__templatizeOwner=e,l.prototype.__hostProps=i.hostProps,l=l,l}function $r(t,e){let n;for(;e;)if(n=e.__dataHost?e:e.__templatizeInstance){if(n.__dataHost==t)return n;e=n.__dataHost}else e=Y(e).parentNode;return null}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const Kr={templatize(t,e){this._templatizerTemplate=t,this.ctor=Xr(t,this,{mutableData:Boolean(e),parentModel:this._parentModel,instanceProps:this._instanceProps,forwardHostProp:this._forwardHostPropV2,notifyInstanceProp:this._notifyInstancePropV2})},stamp(t){return new this.ctor(t)},modelForElement(t){return $r(this._templatizerTemplate,t)}};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */let Zr=!1;function Jr(){if(w&&!m){if(!Zr){Zr=!0;const t=document.createElement("style");t.textContent="dom-bind,dom-if,dom-repeat{display:none;}",document.head.appendChild(t)}return!0}return!1}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */const Qr=di(zr(he(HTMLElement)));customElements.define("dom-bind",class extends Qr{static get observedAttributes(){return["mutable-data"]}constructor(){if(super(),b)throw new Error("strictTemplatePolicy: dom-bind not allowed");this.root=null,this.$=null,this.__children=null}attributeChangedCallback(t,e,n,i){this.mutableData=!0}connectedCallback(){Jr()||(this.style.display="none"),this.render()}disconnectedCallback(){this.__removeChildren()}__insertChildren(){Y(Y(this).parentNode).insertBefore(this.root,this)}__removeChildren(){if(this.__children)for(let t=0;t<this.__children.length;t++)this.root.appendChild(this.__children[t])}render(){let t;if(!this.__children){if(t=t||this.querySelector("template"),!t){let e=new MutationObserver((()=>{if(t=this.querySelector("template"),!t)throw new Error("dom-bind requires a <template> child");e.disconnect(),this.render()}));return void e.observe(this,{childList:!0})}this.root=this._stampTemplate(t),this.$=this.root.$,this.__children=[];for(let t=this.root.firstChild;t;t=t.nextSibling)this.__children[this.__children.length]=t;this._enableProperties()}this.__insertChildren(),this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}});
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const to=zr(ye);class eo extends to{static get is(){return"dom-repeat"}static get template(){return null}static get properties(){return{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},itemsIndexAs:{type:String,value:"itemsIndex"},sort:{type:Function,observer:"__sortChanged"},filter:{type:Function,observer:"__filterChanged"},observe:{type:String,observer:"__observeChanged"},delay:Number,renderedItemCount:{type:Number,notify:!k,readOnly:!0},initialCount:{type:Number},targetFramerate:{type:Number,value:20},_targetFrameTime:{type:Number,computed:"__computeFrameTime(targetFramerate)"},notifyDomChange:{type:Boolean},reuseChunkedInstances:{type:Boolean}}}static get observers(){return["__itemsChanged(items.*)"]}constructor(){super(),this.__instances=[],this.__renderDebouncer=null,this.__itemsIdxToInstIdx={},this.__chunkCount=null,this.__renderStartTime=null,this.__itemsArrayChanged=!1,this.__shouldMeasureChunk=!1,this.__shouldContinueChunking=!1,this.__chunkingId=0,this.__sortFn=null,this.__filterFn=null,this.__observePaths=null,this.__ctor=null,this.__isDetached=!0,this.template=null}disconnectedCallback(){super.disconnectedCallback(),this.__isDetached=!0;for(let t=0;t<this.__instances.length;t++)this.__detachInstance(t)}connectedCallback(){if(super.connectedCallback(),Jr()||(this.style.display="none"),this.__isDetached){this.__isDetached=!1;let t=Y(Y(this).parentNode);for(let e=0;e<this.__instances.length;e++)this.__attachInstance(e,t)}}__ensureTemplatized(){if(!this.__ctor){const t=this;let e=this.template=t._templateInfo?t:this.querySelector("template");if(!e){let t=new MutationObserver((()=>{if(!this.querySelector("template"))throw new Error("dom-repeat requires a <template> child");t.disconnect(),this.__render()}));return t.observe(this,{childList:!0}),!1}let n={};n[this.as]=!0,n[this.indexAs]=!0,n[this.itemsIndexAs]=!0,this.__ctor=Xr(e,this,{mutableData:this.mutableData,parentModel:!0,instanceProps:n,forwardHostProp:function(t,e){let n=this.__instances;for(let i,r=0;r<n.length&&(i=n[r]);r++)i.forwardHostProp(t,e)},notifyInstanceProp:function(t,e,n){if(Q(this.as,e)){let i=t[this.itemsIndexAs];e==this.as&&(this.items[i]=n);let r=J(this.as,`${JSCompiler_renameProperty("items",this)}.${i}`,e);this.notifyPath(r,n)}}})}return!0}__getMethodHost(){return this.__dataHost._methodHost||this.__dataHost}__functionFromPropertyValue(t){if("string"==typeof t){let e=t,n=this.__getMethodHost();return function(){return n[e].apply(n,arguments)}}return t}__sortChanged(t){this.__sortFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__filterChanged(t){this.__filterFn=this.__functionFromPropertyValue(t),this.items&&this.__debounceRender(this.__render)}__computeFrameTime(t){return Math.ceil(1e3/t)}__observeChanged(){this.__observePaths=this.observe&&this.observe.replace(".*",".").split(" ")}__handleObservedPaths(t){if(this.__sortFn||this.__filterFn)if(t){if(this.__observePaths){let e=this.__observePaths;for(let n=0;n<e.length;n++)0===t.indexOf(e[n])&&this.__debounceRender(this.__render,this.delay)}}else this.__debounceRender(this.__render,this.delay)}__itemsChanged(t){this.items&&!Array.isArray(this.items)&&console.warn("dom-repeat expected array for `items`, found",this.items),this.__handleItemPath(t.path,t.value)||("items"===t.path&&(this.__itemsArrayChanged=!0),this.__debounceRender(this.__render))}__debounceRender(t,e=0){this.__renderDebouncer=En.debounce(this.__renderDebouncer,e>0?gt.after(e):vt,t.bind(this)),An(this.__renderDebouncer)}render(){this.__debounceRender(this.__render),zi()}__render(){if(!this.__ensureTemplatized())return;let t=this.items||[];const e=this.__sortAndFilterItems(t),n=this.__calculateLimit(e.length);this.__updateInstances(t,n,e),this.initialCount&&(this.__shouldMeasureChunk||this.__shouldContinueChunking)&&(cancelAnimationFrame(this.__chunkingId),this.__chunkingId=requestAnimationFrame((()=>this.__continueChunking()))),this._setRenderedItemCount(this.__instances.length),k&&!this.notifyDomChange||this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0}))}__sortAndFilterItems(t){let e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=n;return this.__filterFn&&(e=e.filter(((e,n,i)=>this.__filterFn(t[e],n,i)))),this.__sortFn&&e.sort(((e,n)=>this.__sortFn(t[e],t[n]))),e}__calculateLimit(t){let e=t;const n=this.__instances.length;if(this.initialCount){let i;!this.__chunkCount||this.__itemsArrayChanged&&!this.reuseChunkedInstances?(e=Math.min(t,this.initialCount),i=Math.max(e-n,0),this.__chunkCount=i||1):(i=Math.min(Math.max(t-n,0),this.__chunkCount),e=Math.min(n+i,t)),this.__shouldMeasureChunk=i===this.__chunkCount,this.__shouldContinueChunking=e<t,this.__renderStartTime=performance.now()}return this.__itemsArrayChanged=!1,e}__continueChunking(){if(this.__shouldMeasureChunk){const t=performance.now()-this.__renderStartTime;this.__chunkCount=Math.round(this.__chunkCount*(this._targetFrameTime/t))||1}this.__shouldContinueChunking&&this.__debounceRender(this.__render)}__updateInstances(t,e,n){const i=this.__itemsIdxToInstIdx={};let r;for(r=0;r<e;r++){let e=this.__instances[r],o=n[r],a=t[o];i[o]=r,e?(e._setPendingProperty(this.as,a),e._setPendingProperty(this.indexAs,r),e._setPendingProperty(this.itemsIndexAs,o),e._flushProperties()):this.__insertInstance(a,r,o)}for(let t=this.__instances.length-1;t>=r;t--)this.__detachAndRemoveInstance(t)}__detachInstance(t){let e=this.__instances[t];const n=Y(e.root);for(let t=0;t<e.children.length;t++)n.appendChild(e.children[t]);return e}__attachInstance(t,e){e.insertBefore(this.__instances[t].root,this)}__detachAndRemoveInstance(t){this.__detachInstance(t),this.__instances.splice(t,1)}__stampInstance(t,e,n){let i={};return i[this.as]=t,i[this.indexAs]=e,i[this.itemsIndexAs]=n,new this.__ctor(i)}__insertInstance(t,e,n){const i=this.__stampInstance(t,e,n);let r=this.__instances[e+1],o=r?r.children[0]:this;return Y(Y(this).parentNode).insertBefore(i.root,o),this.__instances[e]=i,i}_showHideChildren(t){for(let e=0;e<this.__instances.length;e++)this.__instances[e]._showHideChildren(t)}__handleItemPath(t,e){let n=t.slice(6),i=n.indexOf("."),r=i<0?n:n.substring(0,i);if(r==parseInt(r,10)){let t=i<0?"":n.substring(i+1);this.__handleObservedPaths(t);let o=this.__instances[this.__itemsIdxToInstIdx[r]];return o&&(o._setPendingPropertyOrPath(this.as+(t?"."+t:""),e,!1,!0),o._flushProperties()),!0}}itemForElement(t){let e=this.modelForElement(t);return e&&e[this.as]}indexForElement(t){let e=this.modelForElement(t);return e&&e[this.indexAs]}modelForElement(t){return $r(this.template,t)}}customElements.define(eo.is,eo);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
class no extends ye{static get is(){return"dom-if"}static get template(){return null}static get properties(){return{if:{type:Boolean,observer:"__debounceRender"},restamp:{type:Boolean,observer:"__debounceRender"},notifyDomChange:{type:Boolean}}}constructor(){super(),this.__renderDebouncer=null,this._lastIf=!1,this.__hideTemplateChildren__=!1}__debounceRender(){this.__renderDebouncer=En.debounce(this.__renderDebouncer,vt,(()=>this.__render())),An(this.__renderDebouncer)}disconnectedCallback(){super.disconnectedCallback();const t=Y(this).parentNode;t&&(t.nodeType!=Node.DOCUMENT_FRAGMENT_NODE||Y(t).host)||this.__teardownInstance()}connectedCallback(){super.connectedCallback(),Jr()||(this.style.display="none"),this.if&&this.__debounceRender()}__ensureTemplate(){if(!this.__template){const t=this;let e=t._templateInfo?t:Y(t).querySelector("template");if(!e){let t=new MutationObserver((()=>{if(!Y(this).querySelector("template"))throw new Error("dom-if requires a <template> child");t.disconnect(),this.__render()}));return t.observe(this,{childList:!0}),!1}this.__template=e}return!0}__ensureInstance(){let t=Y(this).parentNode;if(this.__hasInstance()){let e=this.__getInstanceNodes();if(e&&e.length&&Y(this).previousSibling!==e[e.length-1])for(let n,i=0;i<e.length&&(n=e[i]);i++)Y(t).insertBefore(n,this)}else{if(!t)return!1;if(!this.__ensureTemplate())return!1;this.__createAndInsertInstance(t)}return!0}render(){zi()}__render(){if(this.if){if(!this.__ensureInstance())return}else this.restamp&&this.__teardownInstance();this._showHideChildren(),k&&!this.notifyDomChange||this.if==this._lastIf||(this.dispatchEvent(new CustomEvent("dom-change",{bubbles:!0,composed:!0})),this._lastIf=this.if)}__hasInstance(){}__getInstanceNodes(){}__createAndInsertInstance(t){}__teardownInstance(){}_showHideChildren(){}}const io=C?class extends no{constructor(){super(),this.__instance=null,this.__syncInfo=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.templateInfo.childNodes}__createAndInsertInstance(t){const e=this.__dataHost||this;if(b&&!this.__dataHost)throw new Error("strictTemplatePolicy: template owner not trusted");const n=e._bindTemplate(this.__template,!0);n.runEffects=(t,e,n)=>{let i=this.__syncInfo;if(this.if)i&&(this.__syncInfo=null,this._showHideChildren(),e=Object.assign(i.changedProps,e)),t(e,n);else if(this.__instance)if(i||(i=this.__syncInfo={runEffects:t,changedProps:{}}),n)for(const t in e){const e=$(t);i.changedProps[e]=this.__dataHost[e]}else Object.assign(i.changedProps,e)},this.__instance=e._stampTemplate(this.__template,n),Y(t).insertBefore(this.__instance,this)}__syncHostProperties(){const t=this.__syncInfo;t&&(this.__syncInfo=null,t.runEffects(t.changedProps,!1))}__teardownInstance(){this.__instance&&((this.__dataHost||this)._removeBoundDom(this.__instance),this.__instance=null,this.__syncInfo=null)}_showHideChildren(){const t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,jr(t,this.__instance.templateInfo.childNodes)),t||this.__syncHostProperties()}}:class extends no{constructor(){super(),this.__ctor=null,this.__instance=null,this.__invalidProps=null}__hasInstance(){return Boolean(this.__instance)}__getInstanceNodes(){return this.__instance.children}__createAndInsertInstance(t){this.__ctor||(this.__ctor=Xr(this.__template,this,{mutableData:!0,forwardHostProp:function(t,e){this.__instance&&(this.if?this.__instance.forwardHostProp(t,e):(this.__invalidProps=this.__invalidProps||Object.create(null),this.__invalidProps[$(t)]=!0))}})),this.__instance=new this.__ctor,Y(t).insertBefore(this.__instance.root,this)}__teardownInstance(){if(this.__instance){let t=this.__instance.children;if(t&&t.length){let e=Y(t[0]).parentNode;if(e){e=Y(e);for(let n,i=0;i<t.length&&(n=t[i]);i++)e.removeChild(n)}}this.__invalidProps=null,this.__instance=null}}__syncHostProperties(){let t=this.__invalidProps;if(t){this.__invalidProps=null;for(let e in t)this.__instance._setPendingProperty(e,this.__dataHost[e]);this.__instance._flushProperties()}}_showHideChildren(){const t=this.__hideTemplateChildren__||!this.if;this.__instance&&Boolean(this.__instance.__hidden)!==t&&(this.__instance.__hidden=t,this.__instance._showHideChildren(t)),t||this.__syncHostProperties()}};customElements.define(io.is,io);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let ro=N((t=>{let e=me(t);return class extends e{static get properties(){return{items:{type:Array},multi:{type:Boolean,value:!1},selected:{type:Object,notify:!0},selectedItem:{type:Object,notify:!0},toggle:{type:Boolean,value:!1}}}static get observers(){return["__updateSelection(multi, items.*)"]}constructor(){super(),this.__lastItems=null,this.__lastMulti=null,this.__selectedMap=null}__updateSelection(t,e){let n=e.path;if(n==JSCompiler_renameProperty("items",this)){let n=e.base||[],i=this.__lastItems;if(t!==this.__lastMulti&&this.clearSelection(),i){let t=Ii(n,i);this.__applySplices(t)}this.__lastItems=n,this.__lastMulti=t}else if(e.path==`${JSCompiler_renameProperty("items",this)}.splices`)this.__applySplices(e.value.indexSplices);else{let t=n.slice(`${JSCompiler_renameProperty("items",this)}.`.length),e=parseInt(t,10);t.indexOf(".")<0&&t==e&&this.__deselectChangedIdx(e)}}__applySplices(t){let e=this.__selectedMap;for(let n=0;n<t.length;n++){let i=t[n];e.forEach(((t,n)=>{t<i.index||e.set(n,t>=i.index+i.removed.length?t+i.addedCount-i.removed.length:-1)}));for(let t=0;t<i.addedCount;t++){let n=i.index+t;e.has(this.items[n])&&e.set(this.items[n],n)}}this.__updateLinks();let n=0;e.forEach(((t,i)=>{t<0?(this.multi?this.splice(JSCompiler_renameProperty("selected",this),n,1):this.selected=this.selectedItem=null,e.delete(i)):n++}))}__updateLinks(){if(this.__dataLinkedPaths={},this.multi){let t=0;this.__selectedMap.forEach((e=>{e>=0&&this.linkPaths(`${JSCompiler_renameProperty("items",this)}.${e}`,`${JSCompiler_renameProperty("selected",this)}.${t++}`)}))}else this.__selectedMap.forEach((t=>{this.linkPaths(JSCompiler_renameProperty("selected",this),`${JSCompiler_renameProperty("items",this)}.${t}`),this.linkPaths(JSCompiler_renameProperty("selectedItem",this),`${JSCompiler_renameProperty("items",this)}.${t}`)}))}clearSelection(){this.__dataLinkedPaths={},this.__selectedMap=new Map,this.selected=this.multi?[]:null,this.selectedItem=null}isSelected(t){return this.__selectedMap.has(t)}isIndexSelected(t){return this.isSelected(this.items[t])}__deselectChangedIdx(t){let e=this.__selectedIndexForItemIndex(t);if(e>=0){let t=0;this.__selectedMap.forEach(((n,i)=>{e==t++&&this.deselect(i)}))}}__selectedIndexForItemIndex(t){let e=this.__dataLinkedPaths[`${JSCompiler_renameProperty("items",this)}.${t}`];if(e)return parseInt(e.slice(`${JSCompiler_renameProperty("selected",this)}.`.length),10)}deselect(t){let e=this.__selectedMap.get(t);if(e>=0){let n;this.__selectedMap.delete(t),this.multi&&(n=this.__selectedIndexForItemIndex(e)),this.__updateLinks(),this.multi?this.splice(JSCompiler_renameProperty("selected",this),n,1):this.selected=this.selectedItem=null}}deselectIndex(t){this.deselect(this.items[t])}select(t){this.selectIndex(this.items.indexOf(t))}selectIndex(t){let e=this.items[t];this.isSelected(e)?this.toggle&&this.deselectIndex(t):(this.multi||this.__selectedMap.clear(),this.__selectedMap.set(e,t),this.__updateLinks(),this.multi?this.push(JSCompiler_renameProperty("selected",this),e):this.selected=this.selectedItem=e)}}}))(ye);class oo extends ro{static get is(){return"array-selector"}static get template(){return null}}customElements.define(oo.is,oo);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const ao=new wn;window.ShadyCSS||(window.ShadyCSS={prepareTemplate(t,e,n){},prepareTemplateDom(t,e){},prepareTemplateStyles(t,e,n){},styleSubtree(t,e){ao.processStyles(),Je(t,e)},styleElement(t){ao.processStyles()},styleDocument(t){ao.processStyles(),Je(document.body,t)},getComputedStyleValue:(t,e)=>Qe(t,e),flushCustomStyles(){},nativeCss:Ce,nativeShadow:Se,cssBuild:Ee,disableRuntime:Ae}),window.ShadyCSS.CustomStyleInterface=ao;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const so="include",lo=window.ShadyCSS.CustomStyleInterface;class co extends HTMLElement{constructor(){super(),this._style=null,lo.addCustomStyle(this)}getStyle(){if(this._style)return this._style;const t=this.querySelector("style");if(!t)return null;this._style=t;const e=t.getAttribute(so);return e&&(t.removeAttribute(so),t.textContent=(function n(t){let e=t.trim().split(/\s+/),n="";for(let t=0;t<e.length;t++)n+=q(e[t]);return n})(e)+t.textContent),this.ownerDocument!==window.document&&window.document.head.appendChild(this),this._style}}
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
let uo;window.customElements.define("custom-style",co),uo=Rr._mutablePropertyChange;const ho={properties:{mutableData:Boolean},_shouldPropertyChange(t,e,n){return uo(this,t,e,n,this.mutableData)}},po=tr(HTMLElement).prototype;
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var fo=new Set;const mo={properties:{_parentResizable:{type:Object,observer:"_parentResizableChanged"},_notifyingDescendant:{type:Boolean,value:!1}},listeners:{"iron-request-resize-notifications":"_onIronRequestResizeNotifications"},created:function(){this._interestedResizables=[],this._boundNotifyResize=this.notifyResize.bind(this),this._boundOnDescendantIronResize=this._onDescendantIronResize.bind(this)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):(fo.delete(this),window.removeEventListener("resize",this._boundNotifyResize)),this._parentResizable=null},notifyResize:function(){this.isAttached&&(this._interestedResizables.forEach((function(t){this.resizerShouldNotify(t)&&this._notifyDescendant(t)}),this),this._fireResize())},assignParentResizable:function(t){this._parentResizable&&this._parentResizable.stopResizeNotificationsFor(this),this._parentResizable=t,t&&-1===t._interestedResizables.indexOf(this)&&(t._interestedResizables.push(this),t._subscribeIronResize(this))},stopResizeNotificationsFor:function(t){var e=this._interestedResizables.indexOf(t);e>-1&&(this._interestedResizables.splice(e,1),this._unsubscribeIronResize(t))},_subscribeIronResize:function(t){t.addEventListener("iron-resize",this._boundOnDescendantIronResize)},_unsubscribeIronResize:function(t){t.removeEventListener("iron-resize",this._boundOnDescendantIronResize)},resizerShouldNotify:function(t){return!0},_onDescendantIronResize:function(t){this._notifyingDescendant?t.stopPropagation():m||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(t){var e=qi(t).rootTarget;e!==this&&(e.assignParentResizable(this),this._notifyDescendant(e),t.stopPropagation())},_parentResizableChanged:function(t){t&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(t){this.isAttached&&(this._notifyingDescendant=!0,t.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(this.isAttached)if("loading"===document.readyState){var t=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",(function e(){document.removeEventListener("readystatechange",e),t()}))}else this._findParent(),this._parentResizable?this._parentResizable._interestedResizables.forEach((function(t){t!==this&&t._findParent()}),this):(fo.forEach((function(t){t!==this&&t._findParent()}),this),window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())},_findParent:function(){this.assignParentResizable(null),this.fire("iron-request-resize-notifications",null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable?fo.delete(this):fo.add(this)}};var go=Object.freeze({__proto__:null,IronResizableBehavior:mo});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({_template:_e`
    <style>
      :host {
        display: block;
        transition-duration: var(--iron-collapse-transition-duration, 300ms);
        /* Safari 10 needs this property prefixed to correctly apply the custom property */
        -webkit-transition-duration: var(--iron-collapse-transition-duration, 300ms);
        overflow: visible;
      }

      :host(.iron-collapse-closed) {
        display: none;
      }

      :host(:not(.iron-collapse-opened)) {
        overflow: hidden;
      }
    </style>

    <slot></slot>
`,is:"iron-collapse",behaviors:[mo],properties:{horizontal:{type:Boolean,value:!1,observer:"_horizontalChanged"},opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},transitioning:{type:Boolean,notify:!0,readOnly:!0},noAnimation:{type:Boolean},_desiredSize:{type:String,value:""}},get dimension(){return this.horizontal?"width":"height"},get _dimensionMax(){return this.horizontal?"maxWidth":"maxHeight"},get _dimensionMaxCss(){return this.horizontal?"max-width":"max-height"},hostAttributes:{role:"group","aria-hidden":"true"},listeners:{transitionend:"_onTransitionEnd"},toggle:function(){this.opened=!this.opened},show:function(){this.opened=!0},hide:function(){this.opened=!1},updateSize:function(t,e){t="auto"===t?"":t;var n=e&&!this.noAnimation&&this.isAttached&&this._desiredSize!==t;if(this._desiredSize=t,this._updateTransition(!1),n){var i=this._calcSize();""===t&&(this.style[this._dimensionMax]="",t=this._calcSize()),this.style[this._dimensionMax]=i,this.scrollTop=this.scrollTop,this._updateTransition(!0),n=t!==i}this.style[this._dimensionMax]=t,n||this._transitionEnd()},enableTransition:function(t){po._warn("`enableTransition()` is deprecated, use `noAnimation` instead."),this.noAnimation=!t},_updateTransition:function(t){this.style.transitionDuration=t&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss,this.style["maxWidth"===this._dimensionMax?"maxHeight":"maxWidth"]="",this.updateSize(this.opened?"auto":"0px",!1)},_openedChanged:function(){this.setAttribute("aria-hidden",!this.opened),this._setTransitioning(!0),this.toggleClass("iron-collapse-closed",!1),this.toggleClass("iron-collapse-opened",!1),this.updateSize(this.opened?"auto":"0px",!0),this.opened&&this.focus()},_transitionEnd:function(){this.style[this._dimensionMax]=this._desiredSize,this.toggleClass("iron-collapse-closed",!this.opened),this.toggleClass("iron-collapse-opened",this.opened),this._updateTransition(!1),this.notifyResize(),this._setTransitioning(!1)},_onTransitionEnd:function(t){qi(t).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const _o=_e`
/* Most common used flex styles*/
<dom-module id="iron-flex">
  <template>
    <style>
      .layout.horizontal,
      .layout.vertical {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.inline {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      }

      .layout.horizontal {
        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      }

      .layout.vertical {
        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      }

      .layout.wrap {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      }

      .layout.no-wrap {
        -ms-flex-wrap: nowrap;
        -webkit-flex-wrap: nowrap;
        flex-wrap: nowrap;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .flex {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-auto {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      }

      .flex-none {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      }
    </style>
  </template>
</dom-module>
/* Basic flexbox reverse styles */
<dom-module id="iron-flex-reverse">
  <template>
    <style>
      .layout.horizontal-reverse,
      .layout.vertical-reverse {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      }

      .layout.horizontal-reverse {
        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      }

      .layout.vertical-reverse {
        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      }

      .layout.wrap-reverse {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      }
    </style>
  </template>
</dom-module>
/* Flexbox alignment */
<dom-module id="iron-flex-alignment">
  <template>
    <style>
      /**
       * Alignment in cross axis.
       */
      .layout.start {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      }

      .layout.center,
      .layout.center-center {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      }

      .layout.end {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      }

      .layout.baseline {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      }

      /**
       * Alignment in main axis.
       */
      .layout.start-justified {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      }

      .layout.center-justified,
      .layout.center-center {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      }

      .layout.end-justified {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      }

      .layout.around-justified {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      }

      .layout.justified {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      }

      /**
       * Self alignment.
       */
      .self-start {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      }

      .self-center {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      }

      .self-end {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      }

      .self-stretch {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      }

      .self-baseline {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      }

      /**
       * multi-line alignment in main axis.
       */
      .layout.start-aligned {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      }

      .layout.end-aligned {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      }

      .layout.center-aligned {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      }

      .layout.between-aligned {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      }

      .layout.around-aligned {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      }
    </style>
  </template>
</dom-module>
/* Non-flexbox positioning helper styles */
<dom-module id="iron-flex-factors">
  <template>
    <style>
      .flex,
      .flex-1 {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      }

      .flex-2 {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      }

      .flex-3 {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      }

      .flex-4 {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      }

      .flex-5 {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      }

      .flex-6 {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      }

      .flex-7 {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      }

      .flex-8 {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      }

      .flex-9 {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      }

      .flex-10 {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      }

      .flex-11 {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      }

      .flex-12 {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      }
    </style>
  </template>
</dom-module>
<dom-module id="iron-positioning">
  <template>
    <style>
      .block {
        display: block;
      }

      [hidden] {
        display: none !important;
      }

      .invisible {
        visibility: hidden !important;
      }

      .relative {
        position: relative;
      }

      .fit {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      body.fullbleed {
        margin: 0;
        height: 100vh;
      }

      .scroll {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      }

      /* fixed position */
      .fixed-bottom,
      .fixed-left,
      .fixed-right,
      .fixed-top {
        position: fixed;
      }

      .fixed-top {
        top: 0;
        left: 0;
        right: 0;
      }

      .fixed-right {
        top: 0;
        right: 0;
        bottom: 0;
      }

      .fixed-bottom {
        right: 0;
        bottom: 0;
        left: 0;
      }

      .fixed-left {
        top: 0;
        bottom: 0;
        left: 0;
      }
    </style>
  </template>
</dom-module>
`;_o.setAttribute("style","display: none;"),document.head.appendChild(_o.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const yo=_e`
<custom-style>
  <style is="custom-style">
    [hidden] {
      display: none !important;
    }
  </style>
</custom-style>
<custom-style>
  <style is="custom-style">
    html {

      --layout: {
        display: -ms-flexbox;
        display: -webkit-flex;
        display: flex;
      };

      --layout-inline: {
        display: -ms-inline-flexbox;
        display: -webkit-inline-flex;
        display: inline-flex;
      };

      --layout-horizontal: {
        @apply --layout;

        -ms-flex-direction: row;
        -webkit-flex-direction: row;
        flex-direction: row;
      };

      --layout-horizontal-reverse: {
        @apply --layout;

        -ms-flex-direction: row-reverse;
        -webkit-flex-direction: row-reverse;
        flex-direction: row-reverse;
      };

      --layout-vertical: {
        @apply --layout;

        -ms-flex-direction: column;
        -webkit-flex-direction: column;
        flex-direction: column;
      };

      --layout-vertical-reverse: {
        @apply --layout;

        -ms-flex-direction: column-reverse;
        -webkit-flex-direction: column-reverse;
        flex-direction: column-reverse;
      };

      --layout-wrap: {
        -ms-flex-wrap: wrap;
        -webkit-flex-wrap: wrap;
        flex-wrap: wrap;
      };

      --layout-wrap-reverse: {
        -ms-flex-wrap: wrap-reverse;
        -webkit-flex-wrap: wrap-reverse;
        flex-wrap: wrap-reverse;
      };

      --layout-flex-auto: {
        -ms-flex: 1 1 auto;
        -webkit-flex: 1 1 auto;
        flex: 1 1 auto;
      };

      --layout-flex-none: {
        -ms-flex: none;
        -webkit-flex: none;
        flex: none;
      };

      --layout-flex: {
        -ms-flex: 1 1 0.000000001px;
        -webkit-flex: 1;
        flex: 1;
        -webkit-flex-basis: 0.000000001px;
        flex-basis: 0.000000001px;
      };

      --layout-flex-2: {
        -ms-flex: 2;
        -webkit-flex: 2;
        flex: 2;
      };

      --layout-flex-3: {
        -ms-flex: 3;
        -webkit-flex: 3;
        flex: 3;
      };

      --layout-flex-4: {
        -ms-flex: 4;
        -webkit-flex: 4;
        flex: 4;
      };

      --layout-flex-5: {
        -ms-flex: 5;
        -webkit-flex: 5;
        flex: 5;
      };

      --layout-flex-6: {
        -ms-flex: 6;
        -webkit-flex: 6;
        flex: 6;
      };

      --layout-flex-7: {
        -ms-flex: 7;
        -webkit-flex: 7;
        flex: 7;
      };

      --layout-flex-8: {
        -ms-flex: 8;
        -webkit-flex: 8;
        flex: 8;
      };

      --layout-flex-9: {
        -ms-flex: 9;
        -webkit-flex: 9;
        flex: 9;
      };

      --layout-flex-10: {
        -ms-flex: 10;
        -webkit-flex: 10;
        flex: 10;
      };

      --layout-flex-11: {
        -ms-flex: 11;
        -webkit-flex: 11;
        flex: 11;
      };

      --layout-flex-12: {
        -ms-flex: 12;
        -webkit-flex: 12;
        flex: 12;
      };

      /* alignment in cross axis */

      --layout-start: {
        -ms-flex-align: start;
        -webkit-align-items: flex-start;
        align-items: flex-start;
      };

      --layout-center: {
        -ms-flex-align: center;
        -webkit-align-items: center;
        align-items: center;
      };

      --layout-end: {
        -ms-flex-align: end;
        -webkit-align-items: flex-end;
        align-items: flex-end;
      };

      --layout-baseline: {
        -ms-flex-align: baseline;
        -webkit-align-items: baseline;
        align-items: baseline;
      };

      /* alignment in main axis */

      --layout-start-justified: {
        -ms-flex-pack: start;
        -webkit-justify-content: flex-start;
        justify-content: flex-start;
      };

      --layout-center-justified: {
        -ms-flex-pack: center;
        -webkit-justify-content: center;
        justify-content: center;
      };

      --layout-end-justified: {
        -ms-flex-pack: end;
        -webkit-justify-content: flex-end;
        justify-content: flex-end;
      };

      --layout-around-justified: {
        -ms-flex-pack: distribute;
        -webkit-justify-content: space-around;
        justify-content: space-around;
      };

      --layout-justified: {
        -ms-flex-pack: justify;
        -webkit-justify-content: space-between;
        justify-content: space-between;
      };

      --layout-center-center: {
        @apply --layout-center;
        @apply --layout-center-justified;
      };

      /* self alignment */

      --layout-self-start: {
        -ms-align-self: flex-start;
        -webkit-align-self: flex-start;
        align-self: flex-start;
      };

      --layout-self-center: {
        -ms-align-self: center;
        -webkit-align-self: center;
        align-self: center;
      };

      --layout-self-end: {
        -ms-align-self: flex-end;
        -webkit-align-self: flex-end;
        align-self: flex-end;
      };

      --layout-self-stretch: {
        -ms-align-self: stretch;
        -webkit-align-self: stretch;
        align-self: stretch;
      };

      --layout-self-baseline: {
        -ms-align-self: baseline;
        -webkit-align-self: baseline;
        align-self: baseline;
      };

      /* multi-line alignment in main axis */

      --layout-start-aligned: {
        -ms-flex-line-pack: start;  /* IE10 */
        -ms-align-content: flex-start;
        -webkit-align-content: flex-start;
        align-content: flex-start;
      };

      --layout-end-aligned: {
        -ms-flex-line-pack: end;  /* IE10 */
        -ms-align-content: flex-end;
        -webkit-align-content: flex-end;
        align-content: flex-end;
      };

      --layout-center-aligned: {
        -ms-flex-line-pack: center;  /* IE10 */
        -ms-align-content: center;
        -webkit-align-content: center;
        align-content: center;
      };

      --layout-between-aligned: {
        -ms-flex-line-pack: justify;  /* IE10 */
        -ms-align-content: space-between;
        -webkit-align-content: space-between;
        align-content: space-between;
      };

      --layout-around-aligned: {
        -ms-flex-line-pack: distribute;  /* IE10 */
        -ms-align-content: space-around;
        -webkit-align-content: space-around;
        align-content: space-around;
      };

      /*******************************
                Other Layout
      *******************************/

      --layout-block: {
        display: block;
      };

      --layout-invisible: {
        visibility: hidden !important;
      };

      --layout-relative: {
        position: relative;
      };

      --layout-fit: {
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-scroll: {
        -webkit-overflow-scrolling: touch;
        overflow: auto;
      };

      --layout-fullbleed: {
        margin: 0;
        height: 100vh;
      };

      /* fixed position */

      --layout-fixed-top: {
        position: fixed;
        top: 0;
        left: 0;
        right: 0;
      };

      --layout-fixed-right: {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
      };

      --layout-fixed-bottom: {
        position: fixed;
        right: 0;
        bottom: 0;
        left: 0;
      };

      --layout-fixed-left: {
        position: fixed;
        top: 0;
        bottom: 0;
        left: 0;
      };

    }
  </style>
</custom-style>`;yo.setAttribute("style","display: none;"),document.head.appendChild(yo.content);var vo=document.createElement("style");vo.textContent="[hidden] { display: none !important; }",document.head.appendChild(vo);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
class bo{constructor(t){bo[" "](t),this.type=t&&t.type||"default",this.key=t&&t.key,t&&"value"in t&&(this.value=t.value)}get value(){var t=this.type,e=this.key;if(t&&e)return bo.types[t]&&bo.types[t][e]}set value(t){var e=this.type,n=this.key;e&&n&&(e=bo.types[e]=bo.types[e]||{},null==t?delete e[n]:e[n]=t)}get list(){if(this.type){var t=bo.types[this.type];return t?Object.keys(t).map((function(t){return xo[this.type][t]}),this):[]}}byKey(t){return this.key=t,this.value}}bo[" "]=function(){},bo.types={};var xo=bo.types;Nr({is:"iron-meta",properties:{type:{type:String,value:"default"},key:{type:String},value:{type:String,notify:!0},self:{type:Boolean,observer:"_selfChanged"},__meta:{type:Boolean,computed:"__computeMeta(type, key, value)"}},hostAttributes:{hidden:!0},__computeMeta:function(t,e,n){var i=new bo({type:t,key:e});return void 0!==n&&n!==i.value?i.value=n:this.value!==i.value&&(this.value=i.value),i},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(t){t&&(this.value=this)},byKey:function(t){return new bo({type:this.type,key:t}).value}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center-center;
        position: relative;

        vertical-align: middle;

        fill: var(--iron-icon-fill-color, currentcolor);
        stroke: var(--iron-icon-stroke-color, none);

        width: var(--iron-icon-width, 24px);
        height: var(--iron-icon-height, 24px);
        @apply --iron-icon;
      }

      :host([hidden]) {
        display: none;
      }
    </style>
`,is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:po.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(t){var e=(t||"").split(":");this._iconName=e.pop(),this._iconsetName=e.pop()||this._DEFAULT_ICONSET,this._updateIcon()},_srcChanged:function(t){this._updateIcon()},_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&qi(this.root).removeChild(this._img),""===this._iconName?this._iconset&&this._iconset.removeIcon(this):this._iconsetName&&this._meta&&(this._iconset=this._meta.byKey(this._iconsetName),this._iconset?(this._iconset.applyIcon(this,this._iconName,this.theme),this.unlisten(window,"iron-iconset-added","_updateIcon")):this.listen(window,"iron-iconset-added","_updateIcon"))):(this._iconset&&this._iconset.removeIcon(this),this._img||(this._img=document.createElement("img"),this._img.style.width="100%",this._img.style.height="100%",this._img.draggable=!1),this._img.src=this.src,qi(this.root).appendChild(this._img))}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({is:"iron-iconset-svg",properties:{name:{type:String,observer:"_nameChanged"},size:{type:Number,value:24},rtlMirroring:{type:Boolean,value:!1},useGlobalRtlAttribute:{type:Boolean,value:!1}},created:function(){this._meta=new bo({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){return this._icons=this._createIconMap(),Object.keys(this._icons).map((function(t){return this.name+":"+t}),this)},applyIcon:function(t,e){this.removeIcon(t);var n=this._cloneIcon(e,this.rtlMirroring&&this._targetIsRTL(t));if(n){var i=qi(t.root||t);return i.insertBefore(n,i.childNodes[0]),t._svgIcon=n}return null},removeIcon:function(t){t._svgIcon&&(qi(t.root||t).removeChild(t._svgIcon),t._svgIcon=null)},_targetIsRTL:function(t){if(null==this.__targetIsRTL)if(this.useGlobalRtlAttribute){var e=document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement;this.__targetIsRTL="rtl"===e.getAttribute("dir")}else t&&t.nodeType!==Node.ELEMENT_NODE&&(t=t.host),this.__targetIsRTL=t&&"rtl"===window.getComputedStyle(t).direction;return this.__targetIsRTL},_nameChanged:function(){this._meta.value=null,this._meta.key=this.name,this._meta.value=this,this.async((function(){this.fire("iron-iconset-added",this,{node:window})}))},_createIconMap:function(){var t=Object.create(null);return qi(this).querySelectorAll("[id]").forEach((function(e){t[e.id]=e})),t},_cloneIcon:function(t,e){return this._icons=this._icons||this._createIconMap(),this._prepareSvgClone(this._icons[t],this.size,e)},_prepareSvgClone:function(t,e,n){if(t){var i=t.cloneNode(!0),r=document.createElementNS("http://www.w3.org/2000/svg","svg"),o=i.getAttribute("viewBox")||"0 0 "+e+" "+e,a="pointer-events: none; display: block; width: 100%; height: 100%;";return n&&i.hasAttribute("mirror-in-rtl")&&(a+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;"),r.setAttribute("viewBox",o),r.setAttribute("preserveAspectRatio","xMidYMid meet"),r.setAttribute("focusable","false"),r.style.cssText=a,r.appendChild(i).removeAttribute("id"),r}return null}});
/**
    @license
    Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const wo=_e`<iron-iconset-svg name="image" size="24">
<svg><defs>
<g id="add-a-photo"><path d="M3 4V1h2v3h3v2H5v3H3V6H0V4h3zm3 6V7h3V4h7l1.83 2H21c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2V10h3zm7 9c2.76 0 5-2.24 5-5s-2.24-5-5-5-5 2.24-5 5 2.24 5 5 5zm-3.2-5c0 1.77 1.43 3.2 3.2 3.2s3.2-1.43 3.2-3.2-1.43-3.2-3.2-3.2-3.2 1.43-3.2 3.2z"></path></g>
<g id="add-to-photos"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-1 9h-4v4h-2v-4H9V9h4V5h2v4h4v2z"></path></g>
<g id="adjust"><path d="M12 2C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm3-8c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3z"></path></g>
<g id="assistant"><path d="M19 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h4l3 3 3-3h4c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-5.12 10.88L12 17l-1.88-4.12L6 11l4.12-1.88L12 5l1.88 4.12L18 11l-4.12 1.88z"></path></g>
<g id="assistant-photo"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="audiotrack"><path d="M12 3v9.28c-.47-.17-.97-.28-1.5-.28C8.01 12 6 14.01 6 16.5S8.01 21 10.5 21c2.31 0 4.2-1.75 4.45-4H15V6h4V3h-7z"></path></g>
<g id="blur-circular"><path d="M10 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM7 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-3-3c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm3-6c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-1.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm3 6c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-4c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm2-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-3.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1z"></path></g>
<g id="blur-linear"><path d="M5 17.5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 13c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zM3 21h18v-2H3v2zM5 9.5c.83 0 1.5-.67 1.5-1.5S5.83 6.5 5 6.5 3.5 7.17 3.5 8 4.17 9.5 5 9.5zm0 4c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5.67 1.5 1.5 1.5zM9 17c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8-.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM3 3v2h18V3H3zm14 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm0 4c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM13 9c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1z"></path></g>
<g id="blur-off"><path d="M14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-.2 4.48l.2.02c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5-1.5.67-1.5 1.5l.02.2c.09.67.61 1.19 1.28 1.28zM14 3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-4 0c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm11 7c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm8 8c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-4c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm-4 13.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM2.5 5.27l3.78 3.78L6 9c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l2.81 2.81c-.71.11-1.25.73-1.25 1.47 0 .83.67 1.5 1.5 1.5.74 0 1.36-.54 1.47-1.25l2.81 2.81c-.09-.03-.18-.06-.28-.06-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1c0-.1-.03-.19-.06-.28l3.78 3.78L20 20.23 3.77 4 2.5 5.27zM10 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm11-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zM3 9.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 11c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3-3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5z"></path></g>
<g id="blur-on"><path d="M6 13c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm-3 .5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM6 5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm15 5.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM14 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0-3.5c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zm-11 10c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm7 7c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm0-17c.28 0 .5-.22.5-.5s-.22-.5-.5-.5-.5.22-.5.5.22.5.5.5zM10 7c.55 0 1-.45 1-1s-.45-1-1-1-1 .45-1 1 .45 1 1 1zm0 5.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm8 .5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-8c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0-4c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm3 8.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zM14 17c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm0 3.5c-.28 0-.5.22-.5.5s.22.5.5.5.5-.22.5-.5-.22-.5-.5-.5zm-4-12c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0 8.5c-.55 0-1 .45-1 1s.45 1 1 1 1-.45 1-1-.45-1-1-1zm4-4.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm0-4c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="brightness-1"><circle cx="12" cy="12" r="10"></circle></g>
<g id="brightness-2"><path d="M10 2c-1.82 0-3.53.5-5 1.35C7.99 5.08 10 8.3 10 12s-2.01 6.92-5 8.65C6.47 21.5 8.18 22 10 22c5.52 0 10-4.48 10-10S15.52 2 10 2z"></path></g>
<g id="brightness-3"><path d="M9 2c-1.05 0-2.05.16-3 .46 4.06 1.27 7 5.06 7 9.54 0 4.48-2.94 8.27-7 9.54.95.3 1.95.46 3 .46 5.52 0 10-4.48 10-10S14.52 2 9 2z"></path></g>
<g id="brightness-4"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-5"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6z"></path></g>
<g id="brightness-6"><path d="M20 15.31L23.31 12 20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69zM12 18V6c3.31 0 6 2.69 6 6s-2.69 6-6 6z"></path></g>
<g id="brightness-7"><path d="M20 8.69V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12 20 8.69zM12 18c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zm0-10c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4z"></path></g>
<g id="broken-image"><path d="M21 5v6.59l-3-3.01-4 4.01-4-4-4 4-3-3.01V5c0-1.1.9-2 2-2h14c1.1 0 2 .9 2 2zm-3 6.42l3 3.01V19c0 1.1-.9 2-2 2H5c-1.1 0-2-.9-2-2v-6.58l3 2.99 4-4 4 4 4-3.99z"></path></g>
<g id="brush"><path d="M7 14c-1.66 0-3 1.34-3 3 0 1.31-1.16 2-2 2 .92 1.22 2.49 2 4 2 2.21 0 4-1.79 4-4 0-1.66-1.34-3-3-3zm13.71-9.37l-1.34-1.34c-.39-.39-1.02-.39-1.41 0L9 12.25 11.75 15l8.96-8.96c.39-.39.39-1.02 0-1.41z"></path></g>
<g id="burst-mode"><path d="M1 5h2v14H1zm4 0h2v14H5zm17 0H10c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zM11 17l2.5-3.15L15.29 16l2.5-3.22L21 17H11z"></path></g>
<g id="camera"><path d="M9.4 10.5l4.77-8.26C13.47 2.09 12.75 2 12 2c-2.4 0-4.6.85-6.32 2.25l3.66 6.35.06-.1zM21.54 9c-.92-2.92-3.15-5.26-6-6.34L11.88 9h9.66zm.26 1h-7.49l.29.5 4.76 8.25C21 16.97 22 14.61 22 12c0-.69-.07-1.35-.2-2zM8.54 12l-3.9-6.75C3.01 7.03 2 9.39 2 12c0 .69.07 1.35.2 2h7.49l-1.15-2zm-6.08 3c.92 2.92 3.15 5.26 6 6.34L12.12 15H2.46zm11.27 0l-3.9 6.76c.7.15 1.42.24 2.17.24 2.4 0 4.6-.85 6.32-2.25l-3.66-6.35-.93 1.6z"></path></g>
<g id="camera-alt"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="camera-front"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zM12 8c1.1 0 2-.9 2-2s-.9-2-2-2-1.99.9-1.99 2S10.9 8 12 8zm5-8H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zM7 2h10v10.5c0-1.67-3.33-2.5-5-2.5s-5 .83-5 2.5V2z"></path></g>
<g id="camera-rear"><path d="M10 20H5v2h5v2l3-3-3-3v2zm4 0v2h5v-2h-5zm3-20H7C5.9 0 5 .9 5 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V2c0-1.1-.9-2-2-2zm-5 6c-1.11 0-2-.9-2-2s.89-2 1.99-2 2 .9 2 2C14 5.1 13.1 6 12 6z"></path></g>
<g id="camera-roll"><path d="M14 5c0-1.1-.9-2-2-2h-1V2c0-.55-.45-1-1-1H6c-.55 0-1 .45-1 1v1H4c-1.1 0-2 .9-2 2v15c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2h8V5h-8zm-2 13h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2zm4 9h-2v-2h2v2zm0-9h-2V7h2v2z"></path></g>
<g id="center-focus-strong"><path d="M12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm-7 7H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4z"></path></g>
<g id="center-focus-weak"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="collections"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="collections-bookmark"><path d="M4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm16-4H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 10l-2.5-1.5L15 12V4h5v8z"></path></g>
<g id="color-lens"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="colorize"><path d="M20.71 5.63l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-3.12 3.12-1.93-1.91-1.41 1.41 1.42 1.42L3 16.25V21h4.75l8.92-8.92 1.42 1.42 1.41-1.41-1.92-1.92 3.12-3.12c.4-.4.4-1.03.01-1.42zM6.92 19L5 17.08l8.06-8.06 1.92 1.92L6.92 19z"></path></g>
<g id="compare"><path d="M10 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h5v2h2V1h-2v2zm0 15H5l5-6v6zm9-15h-5v2h5v13l-5-6v9h5c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="control-point"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10 10-4.49 10-10S17.51 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="control-point-duplicate"><path d="M16 8h-2v3h-3v2h3v3h2v-3h3v-2h-3zM2 12c0-2.79 1.64-5.2 4.01-6.32V3.52C2.52 4.76 0 8.09 0 12s2.52 7.24 6.01 8.48v-2.16C3.64 17.2 2 14.79 2 12zm13-9c-4.96 0-9 4.04-9 9s4.04 9 9 9 9-4.04 9-9-4.04-9-9-9zm0 16c-3.86 0-7-3.14-7-7s3.14-7 7-7 7 3.14 7 7-3.14 7-7 7z"></path></g>
<g id="crop"><path d="M17 15h2V7c0-1.1-.9-2-2-2H9v2h8v8zM7 17V1H5v4H1v2h4v10c0 1.1.9 2 2 2h10v4h2v-4h4v-2H7z"></path></g>
<g id="crop-16-9"><path d="M19 6H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H5V8h14v8z"></path></g>
<g id="crop-3-2"><path d="M19 4H5c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H5V6h14v12z"></path></g>
<g id="crop-5-4"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-7-5"><path d="M19 7H5c-1.1 0-2 .9-2 2v6c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zm0 8H5V9h14v6z"></path></g>
<g id="crop-din"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="crop-free"><path d="M3 5v4h2V5h4V3H5c-1.1 0-2 .9-2 2zm2 10H3v4c0 1.1.9 2 2 2h4v-2H5v-4zm14 4h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zm0-16h-4v2h4v4h2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="crop-landscape"><path d="M19 5H5c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 12H5V7h14v10z"></path></g>
<g id="crop-original"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14zm-5.04-6.71l-2.75 3.54-1.96-2.36L6.5 17h11l-3.54-4.71z"></path></g>
<g id="crop-portrait"><path d="M17 3H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H7V5h10v14z"></path></g>
<g id="crop-rotate"><path d="M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z"></path></g>
<g id="crop-square"><path d="M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z"></path></g>
<g id="dehaze"><path d="M2 15.5v2h20v-2H2zm0-5v2h20v-2H2zm0-5v2h20v-2H2z"></path></g>
<g id="details"><path d="M3 4l9 16 9-16H3zm3.38 2h11.25L12 16 6.38 6z"></path></g>
<g id="edit"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="exposure"><path d="M15 17v2h2v-2h2v-2h-2v-2h-2v2h-2v2h2zm5-15H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM5 5h6v2H5V5zm15 15H4L20 4v16z"></path></g>
<g id="exposure-neg-1"><path d="M4 11v2h8v-2H4zm15 7h-2V7.38L14 8.4V6.7L18.7 5h.3v13z"></path></g>
<g id="exposure-neg-2"><path d="M15.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17s.19-.79.19-1.18c0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H21v-1.71h-5.95zM2 11v2h8v-2H2z"></path></g>
<g id="exposure-plus-1"><path d="M10 7H8v4H4v2h4v4h2v-4h4v-2h-4V7zm10 11h-2V7.38L15 8.4V6.7L19.7 5h.3v13z"></path></g>
<g id="exposure-plus-2"><path d="M16.05 16.29l2.86-3.07c.38-.39.72-.79 1.04-1.18.32-.39.59-.78.82-1.17.23-.39.41-.78.54-1.17.13-.39.19-.79.19-1.18 0-.53-.09-1.02-.27-1.46-.18-.44-.44-.81-.78-1.11-.34-.31-.77-.54-1.26-.71-.51-.16-1.08-.24-1.72-.24-.69 0-1.31.11-1.85.32-.54.21-1 .51-1.36.88-.37.37-.65.8-.84 1.3-.18.47-.27.97-.28 1.5h2.14c.01-.31.05-.6.13-.87.09-.29.23-.54.4-.75.18-.21.41-.37.68-.49.27-.12.6-.18.96-.18.31 0 .58.05.81.15.23.1.43.25.59.43.16.18.28.4.37.65.08.25.13.52.13.81 0 .22-.03.43-.08.65-.06.22-.15.45-.29.7-.14.25-.32.53-.56.83-.23.3-.52.65-.88 1.03l-4.17 4.55V18H22v-1.71h-5.95zM8 7H6v4H2v2h4v4h2v-4h4v-2H8V7z"></path></g>
<g id="exposure-zero"><path d="M16.14 12.5c0 1-.1 1.85-.3 2.55-.2.7-.48 1.27-.83 1.7-.36.44-.79.75-1.3.95-.51.2-1.07.3-1.7.3-.62 0-1.18-.1-1.69-.3-.51-.2-.95-.51-1.31-.95-.36-.44-.65-1.01-.85-1.7-.2-.7-.3-1.55-.3-2.55v-2.04c0-1 .1-1.85.3-2.55.2-.7.48-1.26.84-1.69.36-.43.8-.74 1.31-.93C10.81 5.1 11.38 5 12 5c.63 0 1.19.1 1.7.29.51.19.95.5 1.31.93.36.43.64.99.84 1.69.2.7.3 1.54.3 2.55v2.04zm-2.11-2.36c0-.64-.05-1.18-.13-1.62-.09-.44-.22-.79-.4-1.06-.17-.27-.39-.46-.64-.58-.25-.13-.54-.19-.86-.19-.32 0-.61.06-.86.18s-.47.31-.64.58c-.17.27-.31.62-.4 1.06s-.13.98-.13 1.62v2.67c0 .64.05 1.18.14 1.62.09.45.23.81.4 1.09s.39.48.64.61.54.19.87.19c.33 0 .62-.06.87-.19s.46-.33.63-.61c.17-.28.3-.64.39-1.09.09-.45.13-.99.13-1.62v-2.66z"></path></g>
<g id="filter"><path d="M15.96 10.29l-2.75 3.54-1.96-2.36L8.5 15h11l-3.54-4.71zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-1"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 10h2V5h-4v2h2v8zm7-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-2"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-4-4h-4v-2h2c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2h-4v2h4v2h-2c-1.1 0-2 .89-2 2v4h6v-2z"></path></g>
<g id="filter-3"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-4v2h4v2h-2v2h2v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-4"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm12 10h2V5h-2v4h-2V5h-2v6h4v4zm6-14H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-5"><path d="M21 1H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm14 8v-2c0-1.11-.9-2-2-2h-2V7h4V5h-6v6h4v2h-4v2h4c1.1 0 2-.89 2-2z"></path></g>
<g id="filter-6"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-2c0-1.11-.9-2-2-2h-2V7h4V5h-4c-1.1 0-2 .89-2 2v6c0 1.11.9 2 2 2zm0-4h2v2h-2v-2z"></path></g>
<g id="filter-7"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2l4-8V5h-6v2h4l-4 8h2z"></path></g>
<g id="filter-8"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zm-8-2h2c1.1 0 2-.89 2-2v-1.5c0-.83-.67-1.5-1.5-1.5.83 0 1.5-.67 1.5-1.5V7c0-1.11-.9-2-2-2h-2c-1.1 0-2 .89-2 2v1.5c0 .83.67 1.5 1.5 1.5-.83 0-1.5.67-1.5 1.5V13c0 1.11.9 2 2 2zm0-8h2v2h-2V7zm0 4h2v2h-2v-2z"></path></g>
<g id="filter-9"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14zM15 5h-2c-1.1 0-2 .89-2 2v2c0 1.11.9 2 2 2h2v2h-4v2h4c1.1 0 2-.89 2-2V7c0-1.11-.9-2-2-2zm0 4h-2V7h2v2z"></path></g>
<g id="filter-9-plus"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm11 7V8c0-1.11-.9-2-2-2h-1c-1.1 0-2 .89-2 2v1c0 1.11.9 2 2 2h1v1H9v2h3c1.1 0 2-.89 2-2zm-3-3V8h1v1h-1zm10-8H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 8h-2V7h-2v2h-2v2h2v2h2v-2h2v6H7V3h14v6z"></path></g>
<g id="filter-b-and-w"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16l-7-8v8H5l7-8V5h7v14z"></path></g>
<g id="filter-center-focus"><path d="M5 15H3v4c0 1.1.9 2 2 2h4v-2H5v-4zM5 5h4V3H5c-1.1 0-2 .9-2 2v4h2V5zm14-2h-4v2h4v4h2V5c0-1.1-.9-2-2-2zm0 16h-4v2h4c1.1 0 2-.9 2-2v-4h-2v4zM12 9c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="filter-drama"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.61 5.64 5.36 8.04 2.35 8.36 0 10.9 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4h2c0-2.76-1.86-5.08-4.4-5.78C8.61 6.88 10.2 6 12 6c3.03 0 5.5 2.47 5.5 5.5v.5H19c1.65 0 3 1.35 3 3s-1.35 3-3 3z"></path></g>
<g id="filter-frames"><path d="M20 4h-4l-4-4-4 4H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H4V6h4.52l3.52-3.5L15.52 6H20v14zM18 8H6v10h12"></path></g>
<g id="filter-hdr"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="filter-none"><path d="M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z"></path></g>
<g id="filter-tilt-shift"><path d="M11 4.07V2.05c-2.01.2-3.84 1-5.32 2.21L7.1 5.69c1.11-.86 2.44-1.44 3.9-1.62zm7.32.19C16.84 3.05 15.01 2.25 13 2.05v2.02c1.46.18 2.79.76 3.9 1.62l1.42-1.43zM19.93 11h2.02c-.2-2.01-1-3.84-2.21-5.32L18.31 7.1c.86 1.11 1.44 2.44 1.62 3.9zM5.69 7.1L4.26 5.68C3.05 7.16 2.25 8.99 2.05 11h2.02c.18-1.46.76-2.79 1.62-3.9zM4.07 13H2.05c.2 2.01 1 3.84 2.21 5.32l1.43-1.43c-.86-1.1-1.44-2.43-1.62-3.89zM15 12c0-1.66-1.34-3-3-3s-3 1.34-3 3 1.34 3 3 3 3-1.34 3-3zm3.31 4.9l1.43 1.43c1.21-1.48 2.01-3.32 2.21-5.32h-2.02c-.18 1.45-.76 2.78-1.62 3.89zM13 19.93v2.02c2.01-.2 3.84-1 5.32-2.21l-1.43-1.43c-1.1.86-2.43 1.44-3.89 1.62zm-7.32-.19C7.16 20.95 9 21.75 11 21.95v-2.02c-1.46-.18-2.79-.76-3.9-1.62l-1.42 1.43z"></path></g>
<g id="filter-vintage"><path d="M18.7 12.4c-.28-.16-.57-.29-.86-.4.29-.11.58-.24.86-.4 1.92-1.11 2.99-3.12 3-5.19-1.79-1.03-4.07-1.11-6 0-.28.16-.54.35-.78.54.05-.31.08-.63.08-.95 0-2.22-1.21-4.15-3-5.19C10.21 1.85 9 3.78 9 6c0 .32.03.64.08.95-.24-.2-.5-.39-.78-.55-1.92-1.11-4.2-1.03-6 0 0 2.07 1.07 4.08 3 5.19.28.16.57.29.86.4-.29.11-.58.24-.86.4-1.92 1.11-2.99 3.12-3 5.19 1.79 1.03 4.07 1.11 6 0 .28-.16.54-.35.78-.54-.05.32-.08.64-.08.96 0 2.22 1.21 4.15 3 5.19 1.79-1.04 3-2.97 3-5.19 0-.32-.03-.64-.08-.95.24.2.5.38.78.54 1.92 1.11 4.2 1.03 6 0-.01-2.07-1.08-4.08-3-5.19zM12 16c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="flare"><path d="M7 11H1v2h6v-2zm2.17-3.24L7.05 5.64 5.64 7.05l2.12 2.12 1.41-1.41zM13 1h-2v6h2V1zm5.36 6.05l-1.41-1.41-2.12 2.12 1.41 1.41 2.12-2.12zM17 11v2h6v-2h-6zm-5-2c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3zm2.83 7.24l2.12 2.12 1.41-1.41-2.12-2.12-1.41 1.41zm-9.19.71l1.41 1.41 2.12-2.12-1.41-1.41-2.12 2.12zM11 23h2v-6h-2v6z"></path></g>
<g id="flash-auto"><path d="M3 2v12h3v9l7-12H9l4-9H3zm16 0h-2l-3.2 9h1.9l.7-2h3.2l.7 2h1.9L19 2zm-2.15 5.65L18 4l1.15 3.65h-2.3z"></path></g>
<g id="flash-off"><path d="M3.27 3L2 4.27l5 5V13h3v9l3.58-6.14L17.73 20 19 18.73 3.27 3zM17 10h-4l4-8H7v2.18l8.46 8.46L17 10z"></path></g>
<g id="flash-on"><path d="M7 2v11h3v9l7-12h-4l4-8z"></path></g>
<g id="flip"><path d="M15 21h2v-2h-2v2zm4-12h2V7h-2v2zM3 5v14c0 1.1.9 2 2 2h4v-2H5V5h4V3H5c-1.1 0-2 .9-2 2zm16-2v2h2c0-1.1-.9-2-2-2zm-8 20h2V1h-2v22zm8-6h2v-2h-2v2zM15 5h2V3h-2v2zm4 8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2z"></path></g>
<g id="gradient"><path d="M11 9h2v2h-2zm-2 2h2v2H9zm4 0h2v2h-2zm2-2h2v2h-2zM7 9h2v2H7zm12-6H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 18H7v-2h2v2zm4 0h-2v-2h2v2zm4 0h-2v-2h2v2zm2-7h-2v2h2v2h-2v-2h-2v2h-2v-2h-2v2H9v-2H7v2H5v-2h2v-2H5V5h14v6z"></path></g>
<g id="grain"><path d="M10 12c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zM6 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12-8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm-4 8c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-4-4c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="grid-off"><path d="M8 4v1.45l2 2V4h4v4h-3.45l2 2H14v1.45l2 2V10h4v4h-3.45l2 2H20v1.45l2 2V4c0-1.1-.9-2-2-2H4.55l2 2H8zm8 0h4v4h-4V4zM1.27 1.27L0 2.55l2 2V20c0 1.1.9 2 2 2h15.46l2 2 1.27-1.27L1.27 1.27zM10 12.55L11.45 14H10v-1.45zm-6-6L5.45 8H4V6.55zM8 20H4v-4h4v4zm0-6H4v-4h3.45l.55.55V14zm6 6h-4v-4h3.45l.55.54V20zm2 0v-1.46L17.46 20H16z"></path></g>
<g id="grid-on"><path d="M20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 20H4v-4h4v4zm0-6H4v-4h4v4zm0-6H4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4zm6 12h-4v-4h4v4zm0-6h-4v-4h4v4zm0-6h-4V4h4v4z"></path></g>
<g id="hdr-off"><path d="M17.5 15v-2h1.1l.9 2H21l-.9-2.1c.5-.2.9-.8.9-1.4v-1c0-.8-.7-1.5-1.5-1.5H16v4.9l1.1 1.1h.4zm0-4.5h2v1h-2v-1zm-4.5 0v.4l1.5 1.5v-1.9c0-.8-.7-1.5-1.5-1.5h-1.9l1.5 1.5h.4zm-3.5-1l-7-7-1.1 1L6.9 9h-.4v2h-2V9H3v6h1.5v-2.5h2V15H8v-4.9l1.5 1.5V15h3.4l7.6 7.6 1.1-1.1-12.1-12z"></path></g>
<g id="hdr-on"><path d="M21 11.5v-1c0-.8-.7-1.5-1.5-1.5H16v6h1.5v-2h1.1l.9 2H21l-.9-2.1c.5-.3.9-.8.9-1.4zm-1.5 0h-2v-1h2v1zm-13-.5h-2V9H3v6h1.5v-2.5h2V15H8V9H6.5v2zM13 9H9.5v6H13c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5zm0 4.5h-2v-3h2v3z"></path></g>
<g id="hdr-strong"><path d="M17 6c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zM5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="hdr-weak"><path d="M5 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm12-2c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm0 10c-2.21 0-4-1.79-4-4s1.79-4 4-4 4 1.79 4 4-1.79 4-4 4z"></path></g>
<g id="healing"><path d="M17.73 12.02l3.98-3.98c.39-.39.39-1.02 0-1.41l-4.34-4.34c-.39-.39-1.02-.39-1.41 0l-3.98 3.98L8 2.29C7.8 2.1 7.55 2 7.29 2c-.25 0-.51.1-.7.29L2.25 6.63c-.39.39-.39 1.02 0 1.41l3.98 3.98L2.25 16c-.39.39-.39 1.02 0 1.41l4.34 4.34c.39.39 1.02.39 1.41 0l3.98-3.98 3.98 3.98c.2.2.45.29.71.29.26 0 .51-.1.71-.29l4.34-4.34c.39-.39.39-1.02 0-1.41l-3.99-3.98zM12 9c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-4.71 1.96L3.66 7.34l3.63-3.63 3.62 3.62-3.62 3.63zM10 13c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2 2c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2-4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2.66 9.34l-3.63-3.62 3.63-3.63 3.62 3.62-3.62 3.63z"></path></g>
<g id="image"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="image-aspect-ratio"><path d="M16 10h-2v2h2v-2zm0 4h-2v2h2v-2zm-8-4H6v2h2v-2zm4 0h-2v2h2v-2zm8-6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V6h16v12z"></path></g>
<g id="iso"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM5.5 7.5h2v-2H9v2h2V9H9v2H7.5V9h-2V7.5zM19 19H5L19 5v14zm-2-2v-1.5h-5V17h5z"></path></g>
<g id="landscape"><path d="M14 6l-3.75 5 2.85 3.8-1.6 1.2C9.81 13.75 7 10 7 10l-6 8h22L14 6z"></path></g>
<g id="leak-add"><path d="M6 3H3v3c1.66 0 3-1.34 3-3zm8 0h-2c0 4.97-4.03 9-9 9v2c6.08 0 11-4.93 11-11zm-4 0H8c0 2.76-2.24 5-5 5v2c3.87 0 7-3.13 7-7zm0 18h2c0-4.97 4.03-9 9-9v-2c-6.07 0-11 4.93-11 11zm8 0h3v-3c-1.66 0-3 1.34-3 3zm-4 0h2c0-2.76 2.24-5 5-5v-2c-3.87 0-7 3.13-7 7z"></path></g>
<g id="leak-remove"><path d="M10 3H8c0 .37-.04.72-.12 1.06l1.59 1.59C9.81 4.84 10 3.94 10 3zM3 4.27l2.84 2.84C5.03 7.67 4.06 8 3 8v2c1.61 0 3.09-.55 4.27-1.46L8.7 9.97C7.14 11.24 5.16 12 3 12v2c2.71 0 5.19-.99 7.11-2.62l2.5 2.5C10.99 15.81 10 18.29 10 21h2c0-2.16.76-4.14 2.03-5.69l1.43 1.43C14.55 17.91 14 19.39 14 21h2c0-1.06.33-2.03.89-2.84L19.73 21 21 19.73 4.27 3 3 4.27zM14 3h-2c0 1.5-.37 2.91-1.02 4.16l1.46 1.46C13.42 6.98 14 5.06 14 3zm5.94 13.12c.34-.08.69-.12 1.06-.12v-2c-.94 0-1.84.19-2.66.52l1.6 1.6zm-4.56-4.56l1.46 1.46C18.09 12.37 19.5 12 21 12v-2c-2.06 0-3.98.58-5.62 1.56z"></path></g>
<g id="lens"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2z"></path></g>
<g id="linked-camera"><circle cx="12" cy="14" r="3.2"></circle><path d="M16 3.33c2.58 0 4.67 2.09 4.67 4.67H22c0-3.31-2.69-6-6-6v1.33M16 6c1.11 0 2 .89 2 2h1.33c0-1.84-1.49-3.33-3.33-3.33V6"></path><path d="M17 9c0-1.11-.89-2-2-2V4H9L7.17 6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9h-5zm-5 10c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="looks"><path d="M12 10c-3.86 0-7 3.14-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.86-3.14-7-7-7zm0-4C5.93 6 1 10.93 1 17h2c0-4.96 4.04-9 9-9s9 4.04 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="looks-3"><path d="M19.01 3h-14c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 7.5c0 .83-.67 1.5-1.5 1.5.83 0 1.5.67 1.5 1.5V15c0 1.11-.9 2-2 2h-4v-2h4v-2h-2v-2h2V9h-4V7h4c1.1 0 2 .89 2 2v1.5z"></path></g>
<g id="looks-4"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 14h-2v-4H9V7h2v4h2V7h2v10z"></path></g>
<g id="looks-5"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2H9v-2h4v-2H9V7h6v2z"></path></g>
<g id="looks-6"><path d="M11 15h2v-2h-2v2zm8-12H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 6h-4v2h2c1.1 0 2 .89 2 2v2c0 1.11-.9 2-2 2h-2c-1.1 0-2-.89-2-2V9c0-1.11.9-2 2-2h4v2z"></path></g>
<g id="looks-one"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-5 14h-2V9h-2V7h4v10z"></path></g>
<g id="looks-two"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-4 8c0 1.11-.9 2-2 2h-2v2h4v2H9v-4c0-1.11.9-2 2-2h2V9H9V7h4c1.1 0 2 .89 2 2v2z"></path></g>
<g id="loupe"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.49 2 2 6.49 2 12s4.49 10 10 10h8c1.1 0 2-.9 2-2v-8c0-5.51-4.49-10-10-10zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="monochrome-photos"><path d="M20 5h-3.2L15 3H9L7.2 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 14h-8v-1c-2.8 0-5-2.2-5-5s2.2-5 5-5V7h8v12zm-3-6c0-2.8-2.2-5-5-5v1.8c1.8 0 3.2 1.4 3.2 3.2s-1.4 3.2-3.2 3.2V18c2.8 0 5-2.2 5-5zm-8.2 0c0 1.8 1.4 3.2 3.2 3.2V9.8c-1.8 0-3.2 1.4-3.2 3.2z"></path></g>
<g id="movie-creation"><path d="M18 4l2 4h-3l-2-4h-2l2 4h-3l-2-4H8l2 4H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4z"></path></g>
<g id="movie-filter"><path d="M18 4l2 3h-3l-2-3h-2l2 3h-3l-2-3H8l2 3H7L5 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4h-4zm-6.75 11.25L10 18l-1.25-2.75L6 14l2.75-1.25L10 10l1.25 2.75L14 14l-2.75 1.25zm5.69-3.31L16 14l-.94-2.06L13 11l2.06-.94L16 8l.94 2.06L19 11l-2.06.94z"></path></g>
<g id="music-note"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"></path></g>
<g id="nature"><path d="M13 16.12c3.47-.41 6.17-3.36 6.17-6.95 0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H5v2h14v-2h-6v-3.88z"></path></g>
<g id="nature-people"><path d="M22.17 9.17c0-3.87-3.13-7-7-7s-7 3.13-7 7c0 3.47 2.52 6.34 5.83 6.89V20H6v-3h1v-4c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v4h1v5h16v-2h-3v-3.88c3.47-.41 6.17-3.36 6.17-6.95zM4.5 11c.83 0 1.5-.67 1.5-1.5S5.33 8 4.5 8 3 8.67 3 9.5 3.67 11 4.5 11z"></path></g>
<g id="navigate-before"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="navigate-next"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="palette"><path d="M12 3c-4.97 0-9 4.03-9 9s4.03 9 9 9c.83 0 1.5-.67 1.5-1.5 0-.39-.15-.74-.39-1.01-.23-.26-.38-.61-.38-.99 0-.83.67-1.5 1.5-1.5H16c2.76 0 5-2.24 5-5 0-4.42-4.03-8-9-8zm-5.5 9c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9 8 9.67 8 10.5 7.33 12 6.5 12zm3-4C8.67 8 8 7.33 8 6.5S8.67 5 9.5 5s1.5.67 1.5 1.5S10.33 8 9.5 8zm5 0c-.83 0-1.5-.67-1.5-1.5S13.67 5 14.5 5s1.5.67 1.5 1.5S15.33 8 14.5 8zm3 4c-.83 0-1.5-.67-1.5-1.5S16.67 9 17.5 9s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="panorama"><path d="M23 18V6c0-1.1-.9-2-2-2H3c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zM8.5 12.5l2.5 3.01L14.5 11l4.5 6H5l3.5-4.5z"></path></g>
<g id="panorama-fish-eye"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="panorama-horizontal"><path d="M20 6.54v10.91c-2.6-.77-5.28-1.16-8-1.16-2.72 0-5.4.39-8 1.16V6.54c2.6.77 5.28 1.16 8 1.16 2.72.01 5.4-.38 8-1.16M21.43 4c-.1 0-.2.02-.31.06C18.18 5.16 15.09 5.7 12 5.7c-3.09 0-6.18-.55-9.12-1.64-.11-.04-.22-.06-.31-.06-.34 0-.57.23-.57.63v14.75c0 .39.23.62.57.62.1 0 .2-.02.31-.06 2.94-1.1 6.03-1.64 9.12-1.64 3.09 0 6.18.55 9.12 1.64.11.04.21.06.31.06.33 0 .57-.23.57-.63V4.63c0-.4-.24-.63-.57-.63z"></path></g>
<g id="panorama-vertical"><path d="M19.94 21.12c-1.1-2.94-1.64-6.03-1.64-9.12 0-3.09.55-6.18 1.64-9.12.04-.11.06-.22.06-.31 0-.34-.23-.57-.63-.57H4.63c-.4 0-.63.23-.63.57 0 .1.02.2.06.31C5.16 5.82 5.71 8.91 5.71 12c0 3.09-.55 6.18-1.64 9.12-.05.11-.07.22-.07.31 0 .33.23.57.63.57h14.75c.39 0 .63-.24.63-.57-.01-.1-.03-.2-.07-.31zM6.54 20c.77-2.6 1.16-5.28 1.16-8 0-2.72-.39-5.4-1.16-8h10.91c-.77 2.6-1.16 5.28-1.16 8 0 2.72.39 5.4 1.16 8H6.54z"></path></g>
<g id="panorama-wide-angle"><path d="M12 6c2.45 0 4.71.2 7.29.64.47 1.78.71 3.58.71 5.36 0 1.78-.24 3.58-.71 5.36-2.58.44-4.84.64-7.29.64s-4.71-.2-7.29-.64C4.24 15.58 4 13.78 4 12c0-1.78.24-3.58.71-5.36C7.29 6.2 9.55 6 12 6m0-2c-2.73 0-5.22.24-7.95.72l-.93.16-.25.9C2.29 7.85 2 9.93 2 12s.29 4.15.87 6.22l.25.89.93.16c2.73.49 5.22.73 7.95.73s5.22-.24 7.95-.72l.93-.16.25-.89c.58-2.08.87-4.16.87-6.23s-.29-4.15-.87-6.22l-.25-.89-.93-.16C17.22 4.24 14.73 4 12 4z"></path></g>
<g id="photo"><path d="M21 19V5c0-1.1-.9-2-2-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2zM8.5 13.5l2.5 3.01L14.5 12l4.5 6H5l3.5-4.5z"></path></g>
<g id="photo-album"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4zm0 15l3-3.86 2.14 2.58 3-3.86L18 19H6z"></path></g>
<g id="photo-camera"><circle cx="12" cy="12" r="3.2"></circle><path d="M9 2L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"></path></g>
<g id="photo-filter"><path d="M19.02 10v9H5V5h9V3H5.02c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-9h-2zM17 10l.94-2.06L20 7l-2.06-.94L17 4l-.94 2.06L14 7l2.06.94zm-3.75.75L12 8l-1.25 2.75L8 12l2.75 1.25L12 16l1.25-2.75L16 12z"></path></g>
<g id="photo-library"><path d="M22 16V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2zm-11-4l2.03 2.71L16 11l4 5H8l3-4zM2 6v14c0 1.1.9 2 2 2h14v-2H4V6H2z"></path></g>
<g id="photo-size-select-actual"><path d="M21 3H3C2 3 1 4 1 5v14c0 1.1.9 2 2 2h18c1 0 2-1 2-2V5c0-1-1-2-2-2zM5 17l3.5-4.5 2.5 3.01L14.5 11l4.5 6H5z"></path></g>
<g id="photo-size-select-large"><path d="M21 15h2v2h-2v-2zm0-4h2v2h-2v-2zm2 8h-2v2c1 0 2-1 2-2zM13 3h2v2h-2V3zm8 4h2v2h-2V7zm0-4v2h2c0-1-1-2-2-2zM1 7h2v2H1V7zm16-4h2v2h-2V3zm0 16h2v2h-2v-2zM3 3C2 3 1 4 1 5h2V3zm6 0h2v2H9V3zM5 3h2v2H5V3zm-4 8v8c0 1.1.9 2 2 2h12V11H1zm2 8l2.5-3.21 1.79 2.15 2.5-3.22L13 19H3z"></path></g>
<g id="photo-size-select-small"><path d="M23 15h-2v2h2v-2zm0-4h-2v2h2v-2zm0 8h-2v2c1 0 2-1 2-2zM15 3h-2v2h2V3zm8 4h-2v2h2V7zm-2-4v2h2c0-1-1-2-2-2zM3 21h8v-6H1v4c0 1.1.9 2 2 2zM3 7H1v2h2V7zm12 12h-2v2h2v-2zm4-16h-2v2h2V3zm0 16h-2v2h2v-2zM3 3C2 3 1 4 1 5h2V3zm0 8H1v2h2v-2zm8-8H9v2h2V3zM7 3H5v2h2V3z"></path></g>
<g id="picture-as-pdf"><path d="M20 2H8c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-8.5 7.5c0 .83-.67 1.5-1.5 1.5H9v2H7.5V7H10c.83 0 1.5.67 1.5 1.5v1zm5 2c0 .83-.67 1.5-1.5 1.5h-2.5V7H15c.83 0 1.5.67 1.5 1.5v3zm4-3H19v1h1.5V11H19v2h-1.5V7h3v1.5zM9 9.5h1v-1H9v1zM4 6H2v14c0 1.1.9 2 2 2h14v-2H4V6zm10 5.5h1v-3h-1v3z"></path></g>
<g id="portrait"><path d="M12 12.25c1.24 0 2.25-1.01 2.25-2.25S13.24 7.75 12 7.75 9.75 8.76 9.75 10s1.01 2.25 2.25 2.25zm4.5 4c0-1.5-3-2.25-4.5-2.25s-4.5.75-4.5 2.25V17h9v-.75zM19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="remove-red-eye"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="rotate-90-degrees-ccw"><path d="M7.34 6.41L.86 12.9l6.49 6.48 6.49-6.48-6.5-6.49zM3.69 12.9l3.66-3.66L11 12.9l-3.66 3.66-3.65-3.66zm15.67-6.26C17.61 4.88 15.3 4 13 4V.76L8.76 5 13 9.24V6c1.79 0 3.58.68 4.95 2.05 2.73 2.73 2.73 7.17 0 9.9C16.58 19.32 14.79 20 13 20c-.97 0-1.94-.21-2.84-.61l-1.49 1.49C10.02 21.62 11.51 22 13 22c2.3 0 4.61-.88 6.36-2.64 3.52-3.51 3.52-9.21 0-12.72z"></path></g>
<g id="rotate-left"><path d="M7.11 8.53L5.7 7.11C4.8 8.27 4.24 9.61 4.07 11h2.02c.14-.87.49-1.72 1.02-2.47zM6.09 13H4.07c.17 1.39.72 2.73 1.62 3.89l1.41-1.42c-.52-.75-.87-1.59-1.01-2.47zm1.01 5.32c1.16.9 2.51 1.44 3.9 1.61V17.9c-.87-.15-1.71-.49-2.46-1.03L7.1 18.32zM13 4.07V1L8.45 5.55 13 10V6.09c2.84.48 5 2.94 5 5.91s-2.16 5.43-5 5.91v2.02c3.95-.49 7-3.85 7-7.93s-3.05-7.44-7-7.93z"></path></g>
<g id="rotate-right"><path d="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02c-2.84-.48-5-2.94-5-5.91s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-.17-1.39-.72-2.73-1.62-3.89l-1.42 1.42c.54.75.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-.17 2.74-.71 3.9-1.61l-1.44-1.44c-.75.54-1.59.89-2.46 1.03zm3.89-2.42l1.42 1.41c.9-1.16 1.45-2.5 1.62-3.89h-2.02c-.14.87-.48 1.72-1.02 2.48z"></path></g>
<g id="slideshow"><path d="M10 8v8l5-4-5-4zm9-5H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"></path></g>
<g id="straighten"><path d="M21 6H3c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 10H3V8h2v4h2V8h2v4h2V8h2v4h2V8h2v4h2V8h2v8z"></path></g>
<g id="style"><path d="M2.53 19.65l1.34.56v-9.03l-2.43 5.86c-.41 1.02.08 2.19 1.09 2.61zm19.5-3.7L17.07 3.98c-.31-.75-1.04-1.21-1.81-1.23-.26 0-.53.04-.79.15L7.1 5.95c-.75.31-1.21 1.03-1.23 1.8-.01.27.04.54.15.8l4.96 11.97c.31.76 1.05 1.22 1.83 1.23.26 0 .52-.05.77-.15l7.36-3.05c1.02-.42 1.51-1.59 1.09-2.6zM7.88 8.75c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-2 11c0 1.1.9 2 2 2h1.45l-3.45-8.34v6.34z"></path></g>
<g id="switch-camera"><path d="M20 4h-3.17L15 2H9L7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-5 11.5V13H9v2.5L5.5 12 9 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="switch-video"><path d="M18 9.5V6c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h14c.55 0 1-.45 1-1v-3.5l4 4v-13l-4 4zm-5 6V13H7v2.5L3.5 12 7 8.5V11h6V8.5l3.5 3.5-3.5 3.5z"></path></g>
<g id="tag-faces"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"></path></g>
<g id="texture"><path d="M19.51 3.08L3.08 19.51c.09.34.27.65.51.9.25.24.56.42.9.51L20.93 4.49c-.19-.69-.73-1.23-1.42-1.41zM11.88 3L3 11.88v2.83L14.71 3h-2.83zM5 3c-1.1 0-2 .9-2 2v2l4-4H5zm14 18c.55 0 1.05-.22 1.41-.59.37-.36.59-.86.59-1.41v-2l-4 4h2zm-9.71 0h2.83L21 12.12V9.29L9.29 21z"></path></g>
<g id="timelapse"><path d="M16.24 7.76C15.07 6.59 13.54 6 12 6v6l-4.24 4.24c2.34 2.34 6.14 2.34 8.49 0 2.34-2.34 2.34-6.14-.01-8.48zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="timer"><path d="M15 1H9v2h6V1zm-4 13h2V8h-2v6zm8.03-6.61l1.42-1.42c-.43-.51-.9-.99-1.41-1.41l-1.42 1.42C16.07 4.74 14.12 4 12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9 9-4.03 9-9c0-2.12-.74-4.07-1.97-5.61zM12 20c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="timer-10"><path d="M0 7.72V9.4l3-1V18h2V6h-.25L0 7.72zm23.78 6.65c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39 0-.14.03-.28.09-.41.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59C21.49 9.07 21 9 20.46 9c-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.69.23.96c.15.28.36.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02zm-9.96-7.32c-.34-.4-.75-.7-1.23-.88-.47-.18-1.01-.27-1.59-.27-.58 0-1.11.09-1.59.27-.48.18-.89.47-1.23.88-.34.41-.6.93-.79 1.59-.18.65-.28 1.45-.28 2.39v1.92c0 .94.09 1.74.28 2.39.19.66.45 1.19.8 1.6.34.41.75.71 1.23.89.48.18 1.01.28 1.59.28.59 0 1.12-.09 1.59-.28.48-.18.88-.48 1.22-.89.34-.41.6-.94.78-1.6.18-.65.28-1.45.28-2.39v-1.92c0-.94-.09-1.74-.28-2.39-.18-.66-.44-1.19-.78-1.59zm-.92 6.17c0 .6-.04 1.11-.12 1.53-.08.42-.2.76-.36 1.02-.16.26-.36.45-.59.57-.23.12-.51.18-.82.18-.3 0-.58-.06-.82-.18s-.44-.31-.6-.57c-.16-.26-.29-.6-.38-1.02-.09-.42-.13-.93-.13-1.53v-2.5c0-.6.04-1.11.13-1.52.09-.41.21-.74.38-1 .16-.25.36-.43.6-.55.24-.11.51-.17.81-.17.31 0 .58.06.81.17.24.11.44.29.6.55.16.25.29.58.37.99.08.41.13.92.13 1.52v2.51z"></path></g>
<g id="timer-3"><path d="M11.61 12.97c-.16-.24-.36-.46-.62-.65-.25-.19-.56-.35-.93-.48.3-.14.57-.3.8-.5.23-.2.42-.41.57-.64.15-.23.27-.46.34-.71.08-.24.11-.49.11-.73 0-.55-.09-1.04-.28-1.46-.18-.42-.44-.77-.78-1.06-.33-.28-.73-.5-1.2-.64-.45-.13-.97-.2-1.53-.2-.55 0-1.06.08-1.52.24-.47.17-.87.4-1.2.69-.33.29-.6.63-.78 1.03-.2.39-.29.83-.29 1.29h1.98c0-.26.05-.49.14-.69.09-.2.22-.38.38-.52.17-.14.36-.25.58-.33.22-.08.46-.12.73-.12.61 0 1.06.16 1.36.47.3.31.44.75.44 1.32 0 .27-.04.52-.12.74-.08.22-.21.41-.38.57-.17.16-.38.28-.63.37-.25.09-.55.13-.89.13H6.72v1.57H7.9c.34 0 .64.04.91.11.27.08.5.19.69.35.19.16.34.36.44.61.1.24.16.54.16.87 0 .62-.18 1.09-.53 1.42-.35.33-.84.49-1.45.49-.29 0-.56-.04-.8-.13-.24-.08-.44-.2-.61-.36-.17-.16-.3-.34-.39-.56-.09-.22-.14-.46-.14-.72H4.19c0 .55.11 1.03.32 1.45.21.42.5.77.86 1.05s.77.49 1.24.63.96.21 1.48.21c.57 0 1.09-.08 1.58-.23.49-.15.91-.38 1.26-.68.36-.3.64-.66.84-1.1.2-.43.3-.93.3-1.48 0-.29-.04-.58-.11-.86-.08-.25-.19-.51-.35-.76zm9.26 1.4c-.14-.28-.35-.53-.63-.74-.28-.21-.61-.39-1.01-.53s-.85-.27-1.35-.38c-.35-.07-.64-.15-.87-.23-.23-.08-.41-.16-.55-.25-.14-.09-.23-.19-.28-.3-.05-.11-.08-.24-.08-.39s.03-.28.09-.41c.06-.13.15-.25.27-.34.12-.1.27-.18.45-.24s.4-.09.64-.09c.25 0 .47.04.66.11.19.07.35.17.48.29.13.12.22.26.29.42.06.16.1.32.1.49h1.95c0-.39-.08-.75-.24-1.09-.16-.34-.39-.63-.69-.88-.3-.25-.66-.44-1.09-.59-.43-.15-.92-.22-1.46-.22-.51 0-.98.07-1.39.21-.41.14-.77.33-1.06.57-.29.24-.51.52-.67.84-.16.32-.23.65-.23 1.01s.08.68.23.96c.15.28.37.52.64.73.27.21.6.38.98.53.38.14.81.26 1.27.36.39.08.71.17.95.26s.43.19.57.29c.13.1.22.22.27.34.05.12.07.25.07.39 0 .32-.13.57-.4.77-.27.2-.66.29-1.17.29-.22 0-.43-.02-.64-.08-.21-.05-.4-.13-.56-.24-.17-.11-.3-.26-.41-.44-.11-.18-.17-.41-.18-.67h-1.89c0 .36.08.71.24 1.05.16.34.39.65.7.93.31.27.69.49 1.15.66.46.17.98.25 1.58.25.53 0 1.01-.06 1.44-.19.43-.13.8-.31 1.11-.54.31-.23.54-.51.71-.83.17-.32.25-.67.25-1.06-.02-.4-.09-.74-.24-1.02z"></path></g>
<g id="timer-off"><path d="M19.04 4.55l-1.42 1.42C16.07 4.74 14.12 4 12 4c-1.83 0-3.53.55-4.95 1.48l1.46 1.46C9.53 6.35 10.73 6 12 6c3.87 0 7 3.13 7 7 0 1.27-.35 2.47-.94 3.49l1.45 1.45C20.45 16.53 21 14.83 21 13c0-2.12-.74-4.07-1.97-5.61l1.42-1.42-1.41-1.42zM15 1H9v2h6V1zm-4 8.44l2 2V8h-2v1.44zM3.02 4L1.75 5.27 4.5 8.03C3.55 9.45 3 11.16 3 13c0 4.97 4.02 9 9 9 1.84 0 3.55-.55 4.98-1.5l2.5 2.5 1.27-1.27-7.71-7.71L3.02 4zM12 20c-3.87 0-7-3.13-7-7 0-1.28.35-2.48.95-3.52l9.56 9.56c-1.03.61-2.23.96-3.51.96z"></path></g>
<g id="tonality"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-1 17.93c-3.94-.49-7-3.85-7-7.93s3.05-7.44 7-7.93v15.86zm2-15.86c1.03.13 2 .45 2.87.93H13v-.93zM13 7h5.24c.25.31.48.65.68 1H13V7zm0 3h6.74c.08.33.15.66.19 1H13v-1zm0 9.93V19h2.87c-.87.48-1.84.8-2.87.93zM18.24 17H13v-1h5.92c-.2.35-.43.69-.68 1zm1.5-3H13v-1h6.93c-.04.34-.11.67-.19 1z"></path></g>
<g id="transform"><path d="M22 18v-2H8V4h2L7 1 4 4h2v2H2v2h4v8c0 1.1.9 2 2 2h8v2h-2l3 3 3-3h-2v-2h4zM10 8h6v6h2V8c0-1.1-.9-2-2-2h-6v2z"></path></g>
<g id="tune"><path d="M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z"></path></g>
<g id="view-comfy"><path d="M3 9h4V5H3v4zm0 5h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zM8 9h4V5H8v4zm5-4v4h4V5h-4zm5 9h4v-4h-4v4zM3 19h4v-4H3v4zm5 0h4v-4H8v4zm5 0h4v-4h-4v4zm5 0h4v-4h-4v4zm0-14v4h4V5h-4z"></path></g>
<g id="view-compact"><path d="M3 19h6v-7H3v7zm7 0h12v-7H10v7zM3 5v6h19V5H3z"></path></g>
<g id="vignette"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-9 15c-4.42 0-8-2.69-8-6s3.58-6 8-6 8 2.69 8 6-3.58 6-8 6z"></path></g>
<g id="wb-auto"><path d="M6.85 12.65h2.3L8 9l-1.15 3.65zM22 7l-1.2 6.29L19.3 7h-1.6l-1.49 6.29L15 7h-.76C12.77 5.17 10.53 4 8 4c-4.42 0-8 3.58-8 8s3.58 8 8 8c3.13 0 5.84-1.81 7.15-4.43l.1.43H17l1.5-6.1L20 16h1.75l2.05-9H22zm-11.7 9l-.7-2H6.4l-.7 2H3.8L7 7h2l3.2 9h-1.9z"></path></g>
<g id="wb-cloudy"><path d="M19.36 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.64-4.96z"></path></g>
<g id="wb-incandescent"><path d="M3.55 18.54l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8zM11 22.45h2V19.5h-2v2.95zM4 10.5H1v2h3v-2zm11-4.19V1.5H9v4.81C7.21 7.35 6 9.28 6 11.5c0 3.31 2.69 6 6 6s6-2.69 6-6c0-2.22-1.21-4.15-3-5.19zm5 4.19v2h3v-2h-3zm-2.76 7.66l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4z"></path></g>
<g id="wb-iridescent"><path d="M5 14.5h14v-6H5v6zM11 .55V3.5h2V.55h-2zm8.04 2.5l-1.79 1.79 1.41 1.41 1.8-1.79-1.42-1.41zM13 22.45V19.5h-2v2.95h2zm7.45-3.91l-1.8-1.79-1.41 1.41 1.79 1.8 1.42-1.42zM3.55 4.46l1.79 1.79 1.41-1.41-1.79-1.79-1.41 1.41zm1.41 15.49l1.79-1.8-1.41-1.41-1.79 1.79 1.41 1.42z"></path></g>
<g id="wb-sunny"><path d="M6.76 4.84l-1.8-1.79-1.41 1.41 1.79 1.79 1.42-1.41zM4 10.5H1v2h3v-2zm9-9.95h-2V3.5h2V.55zm7.45 3.91l-1.41-1.41-1.79 1.79 1.41 1.41 1.79-1.79zm-3.21 13.7l1.79 1.8 1.41-1.41-1.8-1.79-1.4 1.4zM20 10.5v2h3v-2h-3zm-8-5c-3.31 0-6 2.69-6 6s2.69 6 6 6 6-2.69 6-6-2.69-6-6-6zm-1 16.95h2V19.5h-2v2.95zm-7.45-3.91l1.41 1.41 1.79-1.8-1.41-1.41-1.79 1.8z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(wo.content);
/**
    @license
    Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const So=_e`<iron-iconset-svg name="icons" size="24">
<svg><defs>
<g id="3d-rotation"><path d="M7.52 21.48C4.25 19.94 1.91 16.76 1.55 13H.05C.56 19.16 5.71 24 12 24l.66-.03-3.81-3.81-1.33 1.32zm.89-6.52c-.19 0-.37-.03-.52-.08-.16-.06-.29-.13-.4-.24-.11-.1-.2-.22-.26-.37-.06-.14-.09-.3-.09-.47h-1.3c0 .36.07.68.21.95.14.27.33.5.56.69.24.18.51.32.82.41.3.1.62.15.96.15.37 0 .72-.05 1.03-.15.32-.1.6-.25.83-.44s.42-.43.55-.72c.13-.29.2-.61.2-.97 0-.19-.02-.38-.07-.56-.05-.18-.12-.35-.23-.51-.1-.16-.24-.3-.4-.43-.17-.13-.37-.23-.61-.31.2-.09.37-.2.52-.33.15-.13.27-.27.37-.42.1-.15.17-.3.22-.46.05-.16.07-.32.07-.48 0-.36-.06-.68-.18-.96-.12-.28-.29-.51-.51-.69-.2-.19-.47-.33-.77-.43C9.1 8.05 8.76 8 8.39 8c-.36 0-.69.05-1 .16-.3.11-.57.26-.79.45-.21.19-.38.41-.51.67-.12.26-.18.54-.18.85h1.3c0-.17.03-.32.09-.45s.14-.25.25-.34c.11-.09.23-.17.38-.22.15-.05.3-.08.48-.08.4 0 .7.1.89.31.19.2.29.49.29.86 0 .18-.03.34-.08.49-.05.15-.14.27-.25.37-.11.1-.25.18-.41.24-.16.06-.36.09-.58.09H7.5v1.03h.77c.22 0 .42.02.6.07s.33.13.45.23c.12.11.22.24.29.4.07.16.1.35.1.57 0 .41-.12.72-.35.93-.23.23-.55.33-.95.33zm8.55-5.92c-.32-.33-.7-.59-1.14-.77-.43-.18-.92-.27-1.46-.27H12v8h2.3c.55 0 1.06-.09 1.51-.27.45-.18.84-.43 1.16-.76.32-.33.57-.73.74-1.19.17-.47.26-.99.26-1.57v-.4c0-.58-.09-1.1-.26-1.57-.18-.47-.43-.87-.75-1.2zm-.39 3.16c0 .42-.05.79-.14 1.13-.1.33-.24.62-.43.85-.19.23-.43.41-.71.53-.29.12-.62.18-.99.18h-.91V9.12h.97c.72 0 1.27.23 1.64.69.38.46.57 1.12.57 1.99v.4zM12 0l-.66.03 3.81 3.81 1.33-1.33c3.27 1.55 5.61 4.72 5.96 8.48h1.5C23.44 4.84 18.29 0 12 0z"></path></g>
<g id="accessibility"><path d="M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z"></path></g>
<g id="accessible"><circle cx="12" cy="4" r="2"></circle><path d="M19 13v-2c-1.54.02-3.09-.75-4.07-1.83l-1.29-1.43c-.17-.19-.38-.34-.61-.45-.01 0-.01-.01-.02-.01H13c-.35-.2-.75-.3-1.19-.26C10.76 7.11 10 8.04 10 9.09V15c0 1.1.9 2 2 2h5v5h2v-5.5c0-1.1-.9-2-2-2h-3v-3.45c1.29 1.07 3.25 1.94 5 1.95zm-6.17 5c-.41 1.16-1.52 2-2.83 2-1.66 0-3-1.34-3-3 0-1.31.84-2.41 2-2.83V12.1c-2.28.46-4 2.48-4 4.9 0 2.76 2.24 5 5 5 2.42 0 4.44-1.72 4.9-4h-2.07z"></path></g>
<g id="account-balance"><path d="M4 10v7h3v-7H4zm6 0v7h3v-7h-3zM2 22h19v-3H2v3zm14-12v7h3v-7h-3zm-4.5-9L2 6v2h19V6l-9.5-5z"></path></g>
<g id="account-balance-wallet"><path d="M21 18v1c0 1.1-.9 2-2 2H5c-1.11 0-2-.9-2-2V5c0-1.1.89-2 2-2h14c1.1 0 2 .9 2 2v1h-9c-1.11 0-2 .9-2 2v8c0 1.1.89 2 2 2h9zm-9-2h10V8H12v8zm4-2.5c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="account-box"><path d="M3 5v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2H5c-1.11 0-2 .9-2 2zm12 4c0 1.66-1.34 3-3 3s-3-1.34-3-3 1.34-3 3-3 3 1.34 3 3zm-9 8c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1H6v-1z"></path></g>
<g id="account-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm0 14.2c-2.5 0-4.71-1.28-6-3.22.03-1.99 4-3.08 6-3.08 1.99 0 5.97 1.09 6 3.08-1.29 1.94-3.5 3.22-6 3.22z"></path></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"></path></g>
<g id="add-alert"><path d="M10.01 21.01c0 1.1.89 1.99 1.99 1.99s1.99-.89 1.99-1.99h-3.98zm8.87-4.19V11c0-3.25-2.25-5.97-5.29-6.69v-.72C13.59 2.71 12.88 2 12 2s-1.59.71-1.59 1.59v.72C7.37 5.03 5.12 7.75 5.12 11v5.82L3 18.94V20h18v-1.06l-2.12-2.12zM16 13.01h-3v3h-2v-3H8V11h3V8h2v3h3v2.01z"></path></g>
<g id="add-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11h-4v4h-2v-4H7v-2h4V7h2v4h4v2z"></path></g>
<g id="add-circle-outline"><path d="M13 7h-2v4H7v2h4v4h2v-4h4v-2h-4V7zm-1-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="add-shopping-cart"><path d="M11 9h2V6h3V4h-3V1h-2v3H8v2h3v3zm-4 9c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zm10 0c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2zm-9.83-3.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.86-7.01L19.42 4h-.01l-1.1 2-2.76 5H8.53l-.13-.27L6.16 6l-.95-2-.94-2H1v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.13 0-.25-.11-.25-.25z"></path></g>
<g id="alarm"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12.5 8H11v6l4.75 2.85.75-1.23-4-2.37V8zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7z"></path></g>
<g id="alarm-add"><path d="M7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm1-11h-2v3H8v2h3v3h2v-3h3v-2h-3V9z"></path></g>
<g id="alarm-off"><path d="M12 6c3.87 0 7 3.13 7 7 0 .84-.16 1.65-.43 2.4l1.52 1.52c.58-1.19.91-2.51.91-3.92 0-4.97-4.03-9-9-9-1.41 0-2.73.33-3.92.91L9.6 6.43C10.35 6.16 11.16 6 12 6zm10-.28l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM2.92 2.29L1.65 3.57 2.98 4.9l-1.11.93 1.42 1.42 1.11-.94.8.8C3.83 8.69 3 10.75 3 13c0 4.97 4.02 9 9 9 2.25 0 4.31-.83 5.89-2.2l2.2 2.2 1.27-1.27L3.89 3.27l-.97-.98zm13.55 16.1C15.26 19.39 13.7 20 12 20c-3.87 0-7-3.13-7-7 0-1.7.61-3.26 1.61-4.47l9.86 9.86zM8.02 3.28L6.6 1.86l-.86.71 1.42 1.42.86-.71z"></path></g>
<g id="alarm-on"><path d="M22 5.72l-4.6-3.86-1.29 1.53 4.6 3.86L22 5.72zM7.88 3.39L6.6 1.86 2 5.71l1.29 1.53 4.59-3.85zM12 4c-4.97 0-9 4.03-9 9s4.02 9 9 9c4.97 0 9-4.03 9-9s-4.03-9-9-9zm0 16c-3.87 0-7-3.13-7-7s3.13-7 7-7 7 3.13 7 7-3.13 7-7 7zm-1.46-5.47L8.41 12.4l-1.06 1.06 3.18 3.18 6-6-1.06-1.06-4.93 4.95z"></path></g>
<g id="all-out"><path d="M16.21 4.16l4 4v-4zm4 12l-4 4h4zm-12 4l-4-4v4zm-4-12l4-4h-4zm12.95-.95c-2.73-2.73-7.17-2.73-9.9 0s-2.73 7.17 0 9.9 7.17 2.73 9.9 0 2.73-7.16 0-9.9zm-1.1 8.8c-2.13 2.13-5.57 2.13-7.7 0s-2.13-5.57 0-7.7 5.57-2.13 7.7 0 2.13 5.57 0 7.7z"></path></g>
<g id="android"><path d="M6 18c0 .55.45 1 1 1h1v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h2v3.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5V19h1c.55 0 1-.45 1-1V8H6v10zM3.5 8C2.67 8 2 8.67 2 9.5v7c0 .83.67 1.5 1.5 1.5S5 17.33 5 16.5v-7C5 8.67 4.33 8 3.5 8zm17 0c-.83 0-1.5.67-1.5 1.5v7c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5v-7c0-.83-.67-1.5-1.5-1.5zm-4.97-5.84l1.3-1.3c.2-.2.2-.51 0-.71-.2-.2-.51-.2-.71 0l-1.48 1.48C13.85 1.23 12.95 1 12 1c-.96 0-1.86.23-2.66.63L7.85.15c-.2-.2-.51-.2-.71 0-.2.2-.2.51 0 .71l1.31 1.31C6.97 3.26 6 5.01 6 7h12c0-1.99-.97-3.75-2.47-4.84zM10 5H9V4h1v1zm5 0h-1V4h1v1z"></path></g>
<g id="announcement"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 9h-2V5h2v6zm0 4h-2v-2h2v2z"></path></g>
<g id="apps"><path d="M4 8h4V4H4v4zm6 12h4v-4h-4v4zm-6 0h4v-4H4v4zm0-6h4v-4H4v4zm6 0h4v-4h-4v4zm6-10v4h4V4h-4zm-6 4h4V4h-4v4zm6 6h4v-4h-4v4zm0 6h4v-4h-4v4z"></path></g>
<g id="archive"><path d="M20.54 5.23l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.16.55L3.46 5.23C3.17 5.57 3 6.02 3 6.5V19c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.48-.17-.93-.46-1.27zM12 17.5L6.5 12H10v-2h4v2h3.5L12 17.5zM5.12 5l.81-1h12l.94 1H5.12z"></path></g>
<g id="arrow-back"><path d="M20 11H7.83l5.59-5.59L12 4l-8 8 8 8 1.41-1.41L7.83 13H20v-2z"></path></g>
<g id="arrow-downward"><path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"></path></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>
<g id="arrow-drop-down-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 12l-4-4h8l-4 4z"></path></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z"></path></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"></path></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"></path></g>
<g id="aspect-ratio"><path d="M19 12h-2v3h-3v2h5v-5zM7 9h3V7H5v5h2V9zm14-6H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="assessment"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"></path></g>
<g id="assignment"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm2 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"></path></g>
<g id="assignment-ind"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 4c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1.4c0-2 4-3.1 6-3.1s6 1.1 6 3.1V19z"></path></g>
<g id="assignment-late"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-6 15h-2v-2h2v2zm0-4h-2V8h2v6zm-1-9c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1z"></path></g>
<g id="assignment-return"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm4 12h-4v3l-5-5 5-5v3h4v4z"></path></g>
<g id="assignment-returned"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm0 15l-5-5h3V9h4v4h3l-5 5z"></path></g>
<g id="assignment-turned-in"><path d="M19 3h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm-2 14l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="attachment"><path d="M2 12.5C2 9.46 4.46 7 7.5 7H18c2.21 0 4 1.79 4 4s-1.79 4-4 4H9.5C8.12 15 7 13.88 7 12.5S8.12 10 9.5 10H17v2H9.41c-.55 0-.55 1 0 1H18c1.1 0 2-.9 2-2s-.9-2-2-2H7.5C5.57 9 4 10.57 4 12.5S5.57 16 7.5 16H17v2H7.5C4.46 18 2 15.54 2 12.5z"></path></g>
<g id="autorenew"><path d="M12 6v3l4-4-4-4v3c-4.42 0-8 3.58-8 8 0 1.57.46 3.03 1.24 4.26L6.7 14.8c-.45-.83-.7-1.79-.7-2.8 0-3.31 2.69-6 6-6zm6.76 1.74L17.3 9.2c.44.84.7 1.79.7 2.8 0 3.31-2.69 6-6 6v-3l-4 4 4 4v-3c4.42 0 8-3.58 8-8 0-1.57-.46-3.03-1.24-4.26z"></path></g>
<g id="backspace"><path d="M22 3H7c-.69 0-1.23.35-1.59.88L0 12l5.41 8.11c.36.53.9.89 1.59.89h15c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-3 12.59L17.59 17 14 13.41 10.41 17 9 15.59 12.59 12 9 8.41 10.41 7 14 10.59 17.59 7 19 8.41 15.41 12 19 15.59z"></path></g>
<g id="backup"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="block"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM4 12c0-4.42 3.58-8 8-8 1.85 0 3.55.63 4.9 1.69L5.69 16.9C4.63 15.55 4 13.85 4 12zm8 8c-1.85 0-3.55-.63-4.9-1.69L18.31 7.1C19.37 8.45 20 10.15 20 12c0 4.42-3.58 8-8 8z"></path></g>
<g id="book"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="bookmark"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="bookmark-border"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="bug-report"><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"></path></g>
<g id="build"><path d="M22.7 19l-9.1-9.1c.9-2.3.4-5-1.5-6.9-2-2-5-2.4-7.4-1.3L9 6 6 9 1.6 4.7C.4 7.1.9 10.1 2.9 12.1c1.9 1.9 4.6 2.4 6.9 1.5l9.1 9.1c.4.4 1 .4 1.4 0l2.3-2.3c.5-.4.5-1.1.1-1.4z"></path></g>
<g id="cached"><path d="M19 8l-4 4h3c0 3.31-2.69 6-6 6-1.01 0-1.97-.25-2.8-.7l-1.46 1.46C8.97 19.54 10.43 20 12 20c4.42 0 8-3.58 8-8h3l-4-4zM6 12c0-3.31 2.69-6 6-6 1.01 0 1.97.25 2.8.7l1.46-1.46C15.03 4.46 13.57 4 12 4c-4.42 0-8 3.58-8 8H1l4 4 4-4H6z"></path></g>
<g id="camera-enhance"><path d="M9 3L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2h-3.17L15 3H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-1l1.25-2.75L16 13l-2.75-1.25L12 9l-1.25 2.75L8 13l2.75 1.25z"></path></g>
<g id="cancel"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"></path></g>
<g id="card-giftcard"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="card-membership"><path d="M20 2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h4v5l4-2 4 2v-5h4c1.11 0 2-.89 2-2V4c0-1.11-.89-2-2-2zm0 13H4v-2h16v2zm0-5H4V4h16v6z"></path></g>
<g id="card-travel"><path d="M20 6h-3V4c0-1.11-.89-2-2-2H9c-1.11 0-2 .89-2 2v2H4c-1.11 0-2 .89-2 2v11c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zM9 4h6v2H9V4zm11 15H4v-2h16v2zm0-5H4V8h3v2h2V8h6v2h2V8h3v6z"></path></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z"></path></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g>
<g id="check-box"><path d="M19 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-9 14l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="check-box-outline-blank"><path d="M19 5v14H5V5h14m0-2H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="check-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z"></path></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
<g id="chrome-reader-mode"><path d="M13 12h7v1.5h-7zm0-2.5h7V11h-7zm0 5h7V16h-7zM21 4H3c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 15h-9V6h9v13z"></path></g>
<g id="class"><path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM6 4h5v8l-2.5-1.5L6 12V4z"></path></g>
<g id="clear"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="close"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g>
<g id="cloud"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96z"></path></g>
<g id="cloud-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm4.5 14H8c-1.66 0-3-1.34-3-3s1.34-3 3-3l.14.01C8.58 8.28 10.13 7 12 7c2.21 0 4 1.79 4 4h.5c1.38 0 2.5 1.12 2.5 2.5S17.88 16 16.5 16z"></path></g>
<g id="cloud-done"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM10 17l-3.5-3.5 1.41-1.41L10 14.17 15.18 9l1.41 1.41L10 17z"></path></g>
<g id="cloud-download"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM17 13l-5 5-5-5h3V9h4v4h3z"></path></g>
<g id="cloud-off"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4c-1.48 0-2.85.43-4.01 1.17l1.46 1.46C10.21 6.23 11.08 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3 0 1.13-.64 2.11-1.56 2.62l1.45 1.45C23.16 18.16 24 16.68 24 15c0-2.64-2.05-4.78-4.65-4.96zM3 5.27l2.75 2.74C2.56 8.15 0 10.77 0 14c0 3.31 2.69 6 6 6h11.73l2 2L21 20.73 4.27 4 3 5.27zM7.73 10l8 8H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h1.73z"></path></g>
<g id="cloud-queue"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4s1.79-4 4-4h.71C7.37 7.69 9.48 6 12 6c3.04 0 5.5 2.46 5.5 5.5v.5H19c1.66 0 3 1.34 3 3s-1.34 3-3 3z"></path></g>
<g id="cloud-upload"><path d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM14 13v4h-4v-4H7l5-5 5 5h-3z"></path></g>
<g id="code"><path d="M9.4 16.6L4.8 12l4.6-4.6L8 6l-6 6 6 6 1.4-1.4zm5.2 0l4.6-4.6-4.6-4.6L16 6l6 6-6 6-1.4-1.4z"></path></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z"></path></g>
<g id="content-copy"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"></path></g>
<g id="content-cut"><path d="M9.64 7.64c.23-.5.36-1.05.36-1.64 0-2.21-1.79-4-4-4S2 3.79 2 6s1.79 4 4 4c.59 0 1.14-.13 1.64-.36L10 12l-2.36 2.36C7.14 14.13 6.59 14 6 14c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4c0-.59-.13-1.14-.36-1.64L12 14l7 7h3v-1L9.64 7.64zM6 8c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm0 12c-1.1 0-2-.89-2-2s.9-2 2-2 2 .89 2 2-.9 2-2 2zm6-7.5c-.28 0-.5-.22-.5-.5s.22-.5.5-.5.5.22.5.5-.22.5-.5.5zM19 3l-6 6 2 2 7-7V3z"></path></g>
<g id="content-paste"><path d="M19 2h-4.18C14.4.84 13.3 0 12 0c-1.3 0-2.4.84-2.82 2H5c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 0c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm7 18H5V4h2v3h10V4h2v16z"></path></g>
<g id="copyright"><path d="M10.08 10.86c.05-.33.16-.62.3-.87s.34-.46.59-.62c.24-.15.54-.22.91-.23.23.01.44.05.63.13.2.09.38.21.52.36s.25.33.34.53.13.42.14.64h1.79c-.02-.47-.11-.9-.28-1.29s-.4-.73-.7-1.01-.66-.5-1.08-.66-.88-.23-1.39-.23c-.65 0-1.22.11-1.7.34s-.88.53-1.2.92-.56.84-.71 1.36S8 11.29 8 11.87v.27c0 .58.08 1.12.23 1.64s.39.97.71 1.35.72.69 1.2.91 1.05.34 1.7.34c.47 0 .91-.08 1.32-.23s.77-.36 1.08-.63.56-.58.74-.94.29-.74.3-1.15h-1.79c-.01.21-.06.4-.15.58s-.21.33-.36.46-.32.23-.52.3c-.19.07-.39.09-.6.1-.36-.01-.66-.08-.89-.23-.25-.16-.45-.37-.59-.62s-.25-.55-.3-.88-.08-.67-.08-1v-.27c0-.35.03-.68.08-1.01zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="create"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"></path></g>
<g id="create-new-folder"><path d="M20 6h-8l-2-2H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-1 8h-3v3h-2v-3h-3v-2h3V9h2v3h3v2z"></path></g>
<g id="credit-card"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z"></path></g>
<g id="date-range"><path d="M9 11H7v2h2v-2zm4 0h-2v2h2v-2zm4 0h-2v2h2v-2zm2-7h-1V2h-2v2H8V2H6v2H5c-1.11 0-1.99.9-1.99 2L3 20c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 16H5V9h14v11z"></path></g>
<g id="delete"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-forever"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zm2.46-7.12l1.41-1.41L12 12.59l2.12-2.12 1.41 1.41L13.41 14l2.12 2.12-1.41 1.41L12 15.41l-2.12 2.12-1.41-1.41L10.59 14l-2.13-2.12zM15.5 4l-1-1h-5l-1 1H5v2h14V4z"></path></g>
<g id="delete-sweep"><path d="M15 16h4v2h-4zm0-8h7v2h-7zm0 4h6v2h-6zM3 18c0 1.1.9 2 2 2h6c1.1 0 2-.9 2-2V8H3v10zM14 5h-3l-1-1H6L5 5H2v2h12z"></path></g>
<g id="description"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 16H8v-2h8v2zm0-4H8v-2h8v2zm-3-5V3.5L18.5 9H13z"></path></g>
<g id="dns"><path d="M20 13H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zM7 19c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM20 3H4c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h16c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1zM7 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z"></path></g>
<g id="done-all"><path d="M18 7l-1.41-1.41-6.34 6.34 1.41 1.41L18 7zm4.24-1.41L11.66 16.17 7.48 12l-1.41 1.41L11.66 19l12-12-1.42-1.41zM.41 13.41L6 19l1.41-1.41L1.83 12 .41 13.41z"></path></g>
<g id="donut-large"><path d="M11 5.08V2c-5 .5-9 4.81-9 10s4 9.5 9 10v-3.08c-3-.48-6-3.4-6-6.92s3-6.44 6-6.92zM18.97 11H22c-.47-5-4-8.53-9-9v3.08C16 5.51 18.54 8 18.97 11zM13 18.92V22c5-.47 8.53-4 9-9h-3.03c-.43 3-2.97 5.49-5.97 5.92z"></path></g>
<g id="donut-small"><path d="M11 9.16V2c-5 .5-9 4.79-9 10s4 9.5 9 10v-7.16c-1-.41-2-1.52-2-2.84s1-2.43 2-2.84zM14.86 11H22c-.48-4.75-4-8.53-9-9v7.16c1 .3 1.52.98 1.86 1.84zM13 14.84V22c5-.47 8.52-4.25 9-9h-7.14c-.34.86-.86 1.54-1.86 1.84z"></path></g>
<g id="drafts"><path d="M21.99 8c0-.72-.37-1.35-.94-1.7L12 1 2.95 6.3C2.38 6.65 2 7.28 2 8v10c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2l-.01-10zM12 13L3.74 7.84 12 3l8.26 4.84L12 13z"></path></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z"></path></g>
<g id="error"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"></path></g>
<g id="error-outline"><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="euro-symbol"><path d="M15 18.5c-2.51 0-4.68-1.42-5.76-3.5H15v-2H8.58c-.05-.33-.08-.66-.08-1s.03-.67.08-1H15V9H9.24C10.32 6.92 12.5 5.5 15 5.5c1.61 0 3.09.59 4.23 1.57L21 5.3C19.41 3.87 17.3 3 15 3c-3.92 0-7.24 2.51-8.48 6H3v2h3.06c-.04.33-.06.66-.06 1 0 .34.02.67.06 1H3v2h3.52c1.24 3.49 4.56 6 8.48 6 2.31 0 4.41-.87 6-2.3l-1.78-1.77c-1.13.98-2.6 1.57-4.22 1.57z"></path></g>
<g id="event"><path d="M17 12h-5v5h5v-5zM16 1v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2h-1V1h-2zm3 18H5V8h14v11z"></path></g>
<g id="event-seat"><path d="M4 18v3h3v-3h10v3h3v-6H4zm15-8h3v3h-3zM2 10h3v3H2zm15 3H7V5c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2v8z"></path></g>
<g id="exit-to-app"><path d="M10.09 15.59L11.5 17l5-5-5-5-1.41 1.41L12.67 11H3v2h9.67l-2.58 2.59zM19 3H5c-1.11 0-2 .9-2 2v4h2V5h14v14H5v-4H3v4c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2z"></path></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"></path></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"></path></g>
<g id="explore"><path d="M12 10.9c-.61 0-1.1.49-1.1 1.1s.49 1.1 1.1 1.1c.61 0 1.1-.49 1.1-1.1s-.49-1.1-1.1-1.1zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm2.19 12.19L6 18l3.81-8.19L18 6l-3.81 8.19z"></path></g>
<g id="extension"><path d="M20.5 11H19V7c0-1.1-.9-2-2-2h-4V3.5C13 2.12 11.88 1 10.5 1S8 2.12 8 3.5V5H4c-1.1 0-1.99.9-1.99 2v3.8H3.5c1.49 0 2.7 1.21 2.7 2.7s-1.21 2.7-2.7 2.7H2V20c0 1.1.9 2 2 2h3.8v-1.5c0-1.49 1.21-2.7 2.7-2.7 1.49 0 2.7 1.21 2.7 2.7V22H17c1.1 0 2-.9 2-2v-4h1.5c1.38 0 2.5-1.12 2.5-2.5S21.88 11 20.5 11z"></path></g>
<g id="face"><path d="M9 11.75c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zm6 0c-.69 0-1.25.56-1.25 1.25s.56 1.25 1.25 1.25 1.25-.56 1.25-1.25-.56-1.25-1.25-1.25zM12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8 0-.29.02-.58.05-.86 2.36-1.05 4.23-2.98 5.21-5.37C11.07 8.33 14.05 10 17.42 10c.78 0 1.53-.09 2.25-.26.21.71.33 1.47.33 2.26 0 4.41-3.59 8-8 8z"></path></g>
<g id="favorite"><path d="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"></path></g>
<g id="favorite-border"><path d="M16.5 3c-1.74 0-3.41.81-4.5 2.09C10.91 3.81 9.24 3 7.5 3 4.42 3 2 5.42 2 8.5c0 3.78 3.4 6.86 8.55 11.54L12 21.35l1.45-1.32C18.6 15.36 22 12.28 22 8.5 22 5.42 19.58 3 16.5 3zm-4.4 15.55l-.1.1-.1-.1C7.14 14.24 4 11.39 4 8.5 4 6.5 5.5 5 7.5 5c1.54 0 3.04.99 3.57 2.36h1.87C13.46 5.99 14.96 5 16.5 5c2 0 3.5 1.5 3.5 3.5 0 2.89-3.14 5.74-7.9 10.05z"></path></g>
<g id="feedback"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-7 12h-2v-2h2v2zm0-4h-2V6h2v4z"></path></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z"></path></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z"></path></g>
<g id="find-in-page"><path d="M20 19.59V8l-6-6H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c.45 0 .85-.15 1.19-.4l-4.43-4.43c-.8.52-1.74.83-2.76.83-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5c0 1.02-.31 1.96-.83 2.75L20 19.59zM9 13c0 1.66 1.34 3 3 3s3-1.34 3-3-1.34-3-3-3-3 1.34-3 3z"></path></g>
<g id="find-replace"><path d="M11 6c1.38 0 2.63.56 3.54 1.46L12 10h6V4l-2.05 2.05C14.68 4.78 12.93 4 11 4c-3.53 0-6.43 2.61-6.92 6H6.1c.46-2.28 2.48-4 4.9-4zm5.64 9.14c.66-.9 1.12-1.97 1.28-3.14H15.9c-.46 2.28-2.48 4-4.9 4-1.38 0-2.63-.56-3.54-1.46L10 12H4v6l2.05-2.05C7.32 17.22 9.07 18 11 18c1.55 0 2.98-.51 4.14-1.36L20 21.49 21.49 20l-4.85-4.86z"></path></g>
<g id="fingerprint"><path d="M17.81 4.47c-.08 0-.16-.02-.23-.06C15.66 3.42 14 3 12.01 3c-1.98 0-3.86.47-5.57 1.41-.24.13-.54.04-.68-.2-.13-.24-.04-.55.2-.68C7.82 2.52 9.86 2 12.01 2c2.13 0 3.99.47 6.03 1.52.25.13.34.43.21.67-.09.18-.26.28-.44.28zM3.5 9.72c-.1 0-.2-.03-.29-.09-.23-.16-.28-.47-.12-.7.99-1.4 2.25-2.5 3.75-3.27C9.98 4.04 14 4.03 17.15 5.65c1.5.77 2.76 1.86 3.75 3.25.16.22.11.54-.12.7-.23.16-.54.11-.7-.12-.9-1.26-2.04-2.25-3.39-2.94-2.87-1.47-6.54-1.47-9.4.01-1.36.7-2.5 1.7-3.4 2.96-.08.14-.23.21-.39.21zm6.25 12.07c-.13 0-.26-.05-.35-.15-.87-.87-1.34-1.43-2.01-2.64-.69-1.23-1.05-2.73-1.05-4.34 0-2.97 2.54-5.39 5.66-5.39s5.66 2.42 5.66 5.39c0 .28-.22.5-.5.5s-.5-.22-.5-.5c0-2.42-2.09-4.39-4.66-4.39-2.57 0-4.66 1.97-4.66 4.39 0 1.44.32 2.77.93 3.85.64 1.15 1.08 1.64 1.85 2.42.19.2.19.51 0 .71-.11.1-.24.15-.37.15zm7.17-1.85c-1.19 0-2.24-.3-3.1-.89-1.49-1.01-2.38-2.65-2.38-4.39 0-.28.22-.5.5-.5s.5.22.5.5c0 1.41.72 2.74 1.94 3.56.71.48 1.54.71 2.54.71.24 0 .64-.03 1.04-.1.27-.05.53.13.58.41.05.27-.13.53-.41.58-.57.11-1.07.12-1.21.12zM14.91 22c-.04 0-.09-.01-.13-.02-1.59-.44-2.63-1.03-3.72-2.1-1.4-1.39-2.17-3.24-2.17-5.22 0-1.62 1.38-2.94 3.08-2.94 1.7 0 3.08 1.32 3.08 2.94 0 1.07.93 1.94 2.08 1.94s2.08-.87 2.08-1.94c0-3.77-3.25-6.83-7.25-6.83-2.84 0-5.44 1.58-6.61 4.03-.39.81-.59 1.76-.59 2.8 0 .78.07 2.01.67 3.61.1.26-.03.55-.29.64-.26.1-.55-.04-.64-.29-.49-1.31-.73-2.61-.73-3.96 0-1.2.23-2.29.68-3.24 1.33-2.79 4.28-4.6 7.51-4.6 4.55 0 8.25 3.51 8.25 7.83 0 1.62-1.38 2.94-3.08 2.94s-3.08-1.32-3.08-2.94c0-1.07-.93-1.94-2.08-1.94s-2.08.87-2.08 1.94c0 1.71.66 3.31 1.87 4.51.95.94 1.86 1.46 3.27 1.85.27.07.42.35.35.61-.05.23-.26.38-.47.38z"></path></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"></path></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"></path></g>
<g id="flight-land"><path d="M2.5 19h19v2h-19zm7.18-5.73l4.35 1.16 5.31 1.42c.8.21 1.62-.26 1.84-1.06.21-.8-.26-1.62-1.06-1.84l-5.31-1.42-2.76-9.02L10.12 2v8.28L5.15 8.95l-.93-2.32-1.45-.39v5.17l1.6.43 5.31 1.43z"></path></g>
<g id="flight-takeoff"><path d="M2.5 19h19v2h-19zm19.57-9.36c-.21-.8-1.04-1.28-1.84-1.06L14.92 10l-6.9-6.43-1.93.51 4.14 7.17-4.97 1.33-1.97-1.54-1.45.39 1.82 3.16.77 1.33 1.6-.43 5.31-1.42 4.35-1.16L21 11.49c.81-.23 1.28-1.05 1.07-1.85z"></path></g>
<g id="flip-to-back"><path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8c-1.11 0-2 .9-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2c0-1.1-.9-2-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.89 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zM5 7H3v12c0 1.1.89 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"></path></g>
<g id="flip-to-front"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"></path></g>
<g id="folder"><path d="M10 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"></path></g>
<g id="folder-open"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z"></path></g>
<g id="folder-shared"><path d="M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm-5 3c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm4 8h-8v-1c0-1.33 2.67-2 4-2s4 .67 4 2v1z"></path></g>
<g id="font-download"><path d="M9.93 13.5h4.14L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-4.05 16.5l-1.14-3H9.17l-1.12 3H5.96l5.11-13h1.86l5.11 13h-2.09z"></path></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z"></path></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"></path></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"></path></g>
<g id="g-translate"><path d="M20 5h-9.12L10 2H4c-1.1 0-2 .9-2 2v13c0 1.1.9 2 2 2h7l1 3h8c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zM7.17 14.59c-2.25 0-4.09-1.83-4.09-4.09s1.83-4.09 4.09-4.09c1.04 0 1.99.37 2.74 1.07l.07.06-1.23 1.18-.06-.05c-.29-.27-.78-.59-1.52-.59-1.31 0-2.38 1.09-2.38 2.42s1.07 2.42 2.38 2.42c1.37 0 1.96-.87 2.12-1.46H7.08V9.91h3.95l.01.07c.04.21.05.4.05.61 0 2.35-1.61 4-3.92 4zm6.03-1.71c.33.6.74 1.18 1.19 1.7l-.54.53-.65-2.23zm.77-.76h-.99l-.31-1.04h3.99s-.34 1.31-1.56 2.74c-.52-.62-.89-1.23-1.13-1.7zM21 20c0 .55-.45 1-1 1h-7l2-2-.81-2.77.92-.92L17.79 18l.73-.73-2.71-2.68c.9-1.03 1.6-2.25 1.92-3.51H19v-1.04h-3.64V9h-1.04v1.04h-1.96L11.18 6H20c.55 0 1 .45 1 1v13z"></path></g>
<g id="gavel"><path d="M1 21h12v2H1zM5.245 8.07l2.83-2.827 14.14 14.142-2.828 2.828zM12.317 1l5.657 5.656-2.83 2.83-5.654-5.66zM3.825 9.485l5.657 5.657-2.828 2.828-5.657-5.657z"></path></g>
<g id="gesture"><path d="M4.59 6.89c.7-.71 1.4-1.35 1.71-1.22.5.2 0 1.03-.3 1.52-.25.42-2.86 3.89-2.86 6.31 0 1.28.48 2.34 1.34 2.98.75.56 1.74.73 2.64.46 1.07-.31 1.95-1.4 3.06-2.77 1.21-1.49 2.83-3.44 4.08-3.44 1.63 0 1.65 1.01 1.76 1.79-3.78.64-5.38 3.67-5.38 5.37 0 1.7 1.44 3.09 3.21 3.09 1.63 0 4.29-1.33 4.69-6.1H21v-2.5h-2.47c-.15-1.65-1.09-4.2-4.03-4.2-2.25 0-4.18 1.91-4.94 2.84-.58.73-2.06 2.48-2.29 2.72-.25.3-.68.84-1.11.84-.45 0-.72-.83-.36-1.92.35-1.09 1.4-2.86 1.85-3.52.78-1.14 1.3-1.92 1.3-3.28C8.95 3.69 7.31 3 6.44 3 5.12 3 3.97 4 3.72 4.25c-.36.36-.66.66-.88.93l1.75 1.71zm9.29 11.66c-.31 0-.74-.26-.74-.72 0-.6.73-2.2 2.87-2.76-.3 2.69-1.43 3.48-2.13 3.48z"></path></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g>
<g id="gif"><path d="M11.5 9H13v6h-1.5zM9 9H6c-.6 0-1 .5-1 1v4c0 .5.4 1 1 1h3c.6 0 1-.5 1-1v-2H8.5v1.5h-2v-3H10V10c0-.5-.4-1-1-1zm10 1.5V9h-4.5v6H16v-2h2v-1.5h-2v-1z"></path></g>
<g id="grade"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="group-work"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="help"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 17h-2v-2h2v2zm2.07-7.75l-.9.92C13.45 12.9 13 13.5 13 15h-2v-.5c0-1.1.45-2.1 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41 0-1.1-.9-2-2-2s-2 .9-2 2H8c0-2.21 1.79-4 4-4s4 1.79 4 4c0 .88-.36 1.68-.93 2.25z"></path></g>
<g id="help-outline"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"></path></g>
<g id="highlight-off"><path d="M14.59 8L12 10.59 9.41 8 8 9.41 10.59 12 8 14.59 9.41 16 12 13.41 14.59 16 16 14.59 13.41 12 16 9.41 14.59 8zM12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="history"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"></path></g>
<g id="hourglass-empty"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6zm10 14.5V20H8v-3.5l4-4 4 4zm-4-5l-4-4V4h8v3.5l-4 4z"></path></g>
<g id="hourglass-full"><path d="M6 2v6h.01L6 8.01 10 12l-4 4 .01.01H6V22h12v-5.99h-.01L18 16l-4-4 4-3.99-.01-.01H18V2H6z"></path></g>
<g id="http"><path d="M4.5 11h-2V9H1v6h1.5v-2.5h2V15H6V9H4.5v2zm2.5-.5h1.5V15H10v-4.5h1.5V9H7v1.5zm5.5 0H14V15h1.5v-4.5H17V9h-4.5v1.5zm9-1.5H18v6h1.5v-2h2c.8 0 1.5-.7 1.5-1.5v-1c0-.8-.7-1.5-1.5-1.5zm0 2.5h-2v-1h2v1z"></path></g>
<g id="https"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="important-devices"><path d="M23 11.01L18 11c-.55 0-1 .45-1 1v9c0 .55.45 1 1 1h5c.55 0 1-.45 1-1v-9c0-.55-.45-.99-1-.99zM23 20h-5v-7h5v7zM20 2H2C.89 2 0 2.89 0 4v12c0 1.1.89 2 2 2h7v2H7v2h8v-2h-2v-2h2v-2H2V4h18v5h2V4c0-1.11-.9-2-2-2zm-8.03 7L11 6l-.97 3H7l2.47 1.76-.94 2.91 2.47-1.8 2.47 1.8-.94-2.91L15 9h-3.03z"></path></g>
<g id="inbox"><path d="M19 3H4.99c-1.11 0-1.98.89-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.11-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10z"></path></g>
<g id="indeterminate-check-box"><path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-2 10H7v-2h10v2z"></path></g>
<g id="info"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"></path></g>
<g id="info-outline"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"></path></g>
<g id="input"><path d="M21 3.01H3c-1.1 0-2 .9-2 2V9h2V4.99h18v14.03H3V15H1v4.01c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98v-14c0-1.11-.9-2-2-2zM11 16l4-4-4-4v3H1v2h10v3z"></path></g>
<g id="invert-colors"><path d="M17.66 7.93L12 2.27 6.34 7.93c-3.12 3.12-3.12 8.19 0 11.31C7.9 20.8 9.95 21.58 12 21.58c2.05 0 4.1-.78 5.66-2.34 3.12-3.12 3.12-8.19 0-11.31zM12 19.59c-1.6 0-3.11-.62-4.24-1.76C6.62 16.69 6 15.19 6 13.59s.62-3.11 1.76-4.24L12 5.1v14.49z"></path></g>
<g id="label"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16z"></path></g>
<g id="label-outline"><path d="M17.63 5.84C17.27 5.33 16.67 5 16 5L5 5.01C3.9 5.01 3 5.9 3 7v10c0 1.1.9 1.99 2 1.99L16 19c.67 0 1.27-.33 1.63-.84L22 12l-4.37-6.16zM16 17H5V7h11l3.55 5L16 17z"></path></g>
<g id="language"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm6.93 6h-2.95c-.32-1.25-.78-2.45-1.38-3.56 1.84.63 3.37 1.91 4.33 3.56zM12 4.04c.83 1.2 1.48 2.53 1.91 3.96h-3.82c.43-1.43 1.08-2.76 1.91-3.96zM4.26 14C4.1 13.36 4 12.69 4 12s.1-1.36.26-2h3.38c-.08.66-.14 1.32-.14 2 0 .68.06 1.34.14 2H4.26zm.82 2h2.95c.32 1.25.78 2.45 1.38 3.56-1.84-.63-3.37-1.9-4.33-3.56zm2.95-8H5.08c.96-1.66 2.49-2.93 4.33-3.56C8.81 5.55 8.35 6.75 8.03 8zM12 19.96c-.83-1.2-1.48-2.53-1.91-3.96h3.82c-.43 1.43-1.08 2.76-1.91 3.96zM14.34 14H9.66c-.09-.66-.16-1.32-.16-2 0-.68.07-1.35.16-2h4.68c.09.65.16 1.32.16 2 0 .68-.07 1.34-.16 2zm.25 5.56c.6-1.11 1.06-2.31 1.38-3.56h2.95c-.96 1.65-2.49 2.93-4.33 3.56zM16.36 14c.08-.66.14-1.32.14-2 0-.68-.06-1.34-.14-2h3.38c.16.64.26 1.31.26 2s-.1 1.36-.26 2h-3.38z"></path></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"></path></g>
<g id="launch"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="lightbulb-outline"><path d="M9 21c0 .55.45 1 1 1h4c.55 0 1-.45 1-1v-1H9v1zm3-19C8.14 2 5 5.14 5 9c0 2.38 1.19 4.47 3 5.74V17c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2.26c1.81-1.27 3-3.36 3-5.74 0-3.86-3.14-7-7-7zm2.85 11.1l-.85.6V16h-4v-2.3l-.85-.6C7.8 12.16 7 10.63 7 9c0-2.76 2.24-5 5-5s5 2.24 5 5c0 1.63-.8 3.16-2.15 4.1z"></path></g>
<g id="line-style"><path d="M3 16h5v-2H3v2zm6.5 0h5v-2h-5v2zm6.5 0h5v-2h-5v2zM3 20h2v-2H3v2zm4 0h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM3 12h8v-2H3v2zm10 0h8v-2h-8v2zM3 4v4h18V4H3z"></path></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z"></path></g>
<g id="link"><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"></path></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"></path></g>
<g id="lock"><path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"></path></g>
<g id="lock-open"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6h1.9c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm0 12H6V10h12v10z"></path></g>
<g id="lock-outline"><path d="M12 17c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm6-9h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM8.9 6c0-1.71 1.39-3.1 3.1-3.1s3.1 1.39 3.1 3.1v2H8.9V6zM18 20H6V10h12v10z"></path></g>
<g id="low-priority"><path d="M14 5h8v2h-8zm0 5.5h8v2h-8zm0 5.5h8v2h-8zM2 11.5C2 15.08 4.92 18 8.5 18H9v2l3-3-3-3v2h-.5C6.02 16 4 13.98 4 11.5S6.02 7 8.5 7H12V5H8.5C4.92 5 2 7.92 2 11.5z"></path></g>
<g id="loyalty"><path d="M21.41 11.58l-9-9C12.05 2.22 11.55 2 11 2H4c-1.1 0-2 .9-2 2v7c0 .55.22 1.05.59 1.42l9 9c.36.36.86.58 1.41.58.55 0 1.05-.22 1.41-.59l7-7c.37-.36.59-.86.59-1.41 0-.55-.23-1.06-.59-1.42zM5.5 7C4.67 7 4 6.33 4 5.5S4.67 4 5.5 4 7 4.67 7 5.5 6.33 7 5.5 7zm11.77 8.27L13 19.54l-4.27-4.27C8.28 14.81 8 14.19 8 13.5c0-1.38 1.12-2.5 2.5-2.5.69 0 1.32.28 1.77.74l.73.72.73-.73c.45-.45 1.08-.73 1.77-.73 1.38 0 2.5 1.12 2.5 2.5 0 .69-.28 1.32-.73 1.77z"></path></g>
<g id="mail"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread"><path d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"></path></g>
<g id="markunread-mailbox"><path d="M20 6H10v6H8V4h6V0H6v6H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2z"></path></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"></path></g>
<g id="more-horiz"><path d="M6 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="more-vert"><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="motorcycle"><path d="M19.44 9.03L15.41 5H11v2h3.59l2 2H5c-2.8 0-5 2.2-5 5s2.2 5 5 5c2.46 0 4.45-1.69 4.9-4h1.65l2.77-2.77c-.21.54-.32 1.14-.32 1.77 0 2.8 2.2 5 5 5s5-2.2 5-5c0-2.65-1.97-4.77-4.56-4.97zM7.82 15C7.4 16.15 6.28 17 5 17c-1.63 0-3-1.37-3-3s1.37-3 3-3c1.28 0 2.4.85 2.82 2H5v2h2.82zM19 17c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3z"></path></g>
<g id="move-to-inbox"><path d="M19 3H4.99c-1.11 0-1.98.9-1.98 2L3 19c0 1.1.88 2 1.99 2H19c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12h-4c0 1.66-1.35 3-3 3s-3-1.34-3-3H4.99V5H19v10zm-3-5h-2V7h-4v3H8l4 4 4-4z"></path></g>
<g id="next-week"><path d="M20 7h-4V5c0-.55-.22-1.05-.59-1.41C15.05 3.22 14.55 3 14 3h-4c-1.1 0-2 .9-2 2v2H4c-1.1 0-2 .9-2 2v11c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V9c0-1.1-.9-2-2-2zM10 5h4v2h-4V5zm1 13.5l-1-1 3-3-3-3 1-1 4 4-4 4z"></path></g>
<g id="note-add"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm2 14h-3v3h-2v-3H8v-2h3v-3h2v3h3v2zm-3-7V3.5L18.5 9H13z"></path></g>
<g id="offline-pin"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm5 16H7v-2h10v2zm-6.7-4L7 10.7l1.4-1.4 1.9 1.9 5.3-5.3L17 7.3 10.3 14z"></path></g>
<g id="opacity"><path d="M17.66 8L12 2.35 6.34 8C4.78 9.56 4 11.64 4 13.64s.78 4.11 2.34 5.67 3.61 2.35 5.66 2.35 4.1-.79 5.66-2.35S20 15.64 20 13.64 19.22 9.56 17.66 8zM6 14c.01-2 .62-3.27 1.76-4.4L12 5.27l4.24 4.38C17.38 10.77 17.99 12 18 14H6z"></path></g>
<g id="open-in-browser"><path d="M19 4H5c-1.11 0-2 .9-2 2v12c0 1.1.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-.9 2-2V6c0-1.1-.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"></path></g>
<g id="open-in-new"><path d="M19 19H5V5h7V3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2v-7h-2v7zM14 3v2h3.59l-9.83 9.83 1.41 1.41L19 6.41V10h2V3h-7z"></path></g>
<g id="open-with"><path d="M10 9h4V6h3l-5-5-5 5h3v3zm-1 1H6V7l-5 5 5 5v-3h3v-4zm14 2l-5-5v3h-3v4h3v3l5-5zm-9 3h-4v3H7l5 5 5-5h-3v-3z"></path></g>
<g id="pageview"><path d="M11.5 9C10.12 9 9 10.12 9 11.5s1.12 2.5 2.5 2.5 2.5-1.12 2.5-2.5S12.88 9 11.5 9zM20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm-3.21 14.21l-2.91-2.91c-.69.44-1.51.7-2.39.7C9.01 16 7 13.99 7 11.5S9.01 7 11.5 7 16 9.01 16 11.5c0 .88-.26 1.69-.7 2.39l2.91 2.9-1.42 1.42z"></path></g>
<g id="pan-tool"><path d="M23 5.5V20c0 2.2-1.8 4-4 4h-7.3c-1.08 0-2.1-.43-2.85-1.19L1 14.83s1.26-1.23 1.3-1.25c.22-.19.49-.29.79-.29.22 0 .42.06.6.16.04.01 4.31 2.46 4.31 2.46V4c0-.83.67-1.5 1.5-1.5S11 3.17 11 4v7h1V1.5c0-.83.67-1.5 1.5-1.5S15 .67 15 1.5V11h1V2.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5V11h1V5.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5z"></path></g>
<g id="payment"><path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"></path></g>
<g id="perm-camera-mic"><path d="M20 5h-3.17L15 3H9L7.17 5H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h7v-2.09c-2.83-.48-5-2.94-5-5.91h2c0 2.21 1.79 4 4 4s4-1.79 4-4h2c0 2.97-2.17 5.43-5 5.91V21h7c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm-6 8c0 1.1-.9 2-2 2s-2-.9-2-2V9c0-1.1.9-2 2-2s2 .9 2 2v4z"></path></g>
<g id="perm-contact-calendar"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm-7 3c1.66 0 3 1.34 3 3s-1.34 3-3 3-3-1.34-3-3 1.34-3 3-3zm6 12H6v-1c0-2 4-3.1 6-3.1s6 1.1 6 3.1v1z"></path></g>
<g id="perm-data-setting"><path d="M18.99 11.5c.34 0 .67.03 1 .07L20 0 0 20h11.56c-.04-.33-.07-.66-.07-1 0-4.14 3.36-7.5 7.5-7.5zm3.71 7.99c.02-.16.04-.32.04-.49 0-.17-.01-.33-.04-.49l1.06-.83c.09-.08.12-.21.06-.32l-1-1.73c-.06-.11-.19-.15-.31-.11l-1.24.5c-.26-.2-.54-.37-.85-.49l-.19-1.32c-.01-.12-.12-.21-.24-.21h-2c-.12 0-.23.09-.25.21l-.19 1.32c-.3.13-.59.29-.85.49l-1.24-.5c-.11-.04-.24 0-.31.11l-1 1.73c-.06.11-.04.24.06.32l1.06.83c-.02.16-.03.32-.03.49 0 .17.01.33.03.49l-1.06.83c-.09.08-.12.21-.06.32l1 1.73c.06.11.19.15.31.11l1.24-.5c.26.2.54.37.85.49l.19 1.32c.02.12.12.21.25.21h2c.12 0 .23-.09.25-.21l.19-1.32c.3-.13.59-.29.84-.49l1.25.5c.11.04.24 0 .31-.11l1-1.73c.06-.11.03-.24-.06-.32l-1.07-.83zm-3.71 1.01c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z"></path></g>
<g id="perm-device-information"><path d="M13 7h-2v2h2V7zm0 4h-2v6h2v-6zm4-9.99L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14z"></path></g>
<g id="perm-identity"><path d="M12 5.9c1.16 0 2.1.94 2.1 2.1s-.94 2.1-2.1 2.1S9.9 9.16 9.9 8s.94-2.1 2.1-2.1m0 9c2.97 0 6.1 1.46 6.1 2.1v1.1H5.9V17c0-.64 3.13-2.1 6.1-2.1M12 4C9.79 4 8 5.79 8 8s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 9c-2.67 0-8 1.34-8 4v3h16v-3c0-2.66-5.33-4-8-4z"></path></g>
<g id="perm-media"><path d="M2 6H0v5h.01L0 20c0 1.1.9 2 2 2h18v-2H2V6zm20-2h-8l-2-2H6c-1.1 0-1.99.9-1.99 2L4 16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zM7 15l4.5-6 3.5 4.51 2.5-3.01L21 15H7z"></path></g>
<g id="perm-phone-msg"><path d="M20 15.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM12 3v10l3-3h6V3h-9z"></path></g>
<g id="perm-scan-wifi"><path d="M12 3C6.95 3 3.15 4.85 0 7.23L12 22 24 7.25C20.85 4.87 17.05 3 12 3zm1 13h-2v-6h2v6zm-2-8V6h2v2h-2z"></path></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5"></circle><circle cx="9" cy="5.5" r="2.5"></circle><circle cx="15" cy="5.5" r="2.5"></circle><circle cx="19.5" cy="9.5" r="2.5"></circle><path d="M17.34 14.86c-.87-1.02-1.6-1.89-2.48-2.91-.46-.54-1.05-1.08-1.75-1.32-.11-.04-.22-.07-.33-.09-.25-.04-.52-.04-.78-.04s-.53 0-.79.05c-.11.02-.22.05-.33.09-.7.24-1.28.78-1.75 1.32-.87 1.02-1.6 1.89-2.48 2.91-1.31 1.31-2.92 2.76-2.62 4.79.29 1.02 1.02 2.03 2.33 2.32.73.15 3.06-.44 5.54-.44h.18c2.48 0 4.81.58 5.54.44 1.31-.29 2.04-1.31 2.33-2.32.31-2.04-1.3-3.49-2.61-4.8z"></path></g>
<g id="picture-in-picture"><path d="M19 7h-8v6h8V7zm2-4H3c-1.1 0-2 .9-2 2v14c0 1.1.9 1.98 2 1.98h18c1.1 0 2-.88 2-1.98V5c0-1.1-.9-2-2-2zm0 16.01H3V4.98h18v14.03z"></path></g>
<g id="picture-in-picture-alt"><path d="M19 11h-8v6h8v-6zm4 8V4.98C23 3.88 22.1 3 21 3H3c-1.1 0-2 .88-2 1.98V19c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2zm-2 .02H3V4.97h18v14.05z"></path></g>
<g id="play-for-work"><path d="M11 5v5.59H7.5l4.5 4.5 4.5-4.5H13V5h-2zm-5 9c0 3.31 2.69 6 6 6s6-2.69 6-6h-2c0 2.21-1.79 4-4 4s-4-1.79-4-4H6z"></path></g>
<g id="polymer"><path d="M19 4h-4L7.11 16.63 4.5 12 9 4H5L.5 12 5 20h4l7.89-12.63L19.5 12 15 20h4l4.5-8z"></path></g>
<g id="power-settings-new"><path d="M13 3h-2v10h2V3zm4.83 2.17l-1.42 1.42C17.99 7.86 19 9.81 19 12c0 3.87-3.13 7-7 7s-7-3.13-7-7c0-2.19 1.01-4.14 2.58-5.42L6.17 5.17C4.23 6.82 3 9.26 3 12c0 4.97 4.03 9 9 9s9-4.03 9-9c0-2.74-1.23-5.18-3.17-6.83z"></path></g>
<g id="pregnant-woman"><path d="M9 4c0-1.11.89-2 2-2s2 .89 2 2-.89 2-2 2-2-.89-2-2zm7 9c-.01-1.34-.83-2.51-2-3 0-1.66-1.34-3-3-3s-3 1.34-3 3v7h2v5h3v-5h3v-4z"></path></g>
<g id="print"><path d="M19 8H5c-1.66 0-3 1.34-3 3v6h4v4h12v-4h4v-6c0-1.66-1.34-3-3-3zm-3 11H8v-5h8v5zm3-7c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm-1-9H6v4h12V3z"></path></g>
<g id="query-builder"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="question-answer"><path d="M21 6h-2v9H6v2c0 .55.45 1 1 1h11l4 4V7c0-.55-.45-1-1-1zm-4 6V3c0-.55-.45-1-1-1H3c-.55 0-1 .45-1 1v14l4-4h10c.55 0 1-.45 1-1z"></path></g>
<g id="radio-button-checked"><path d="M12 7c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="radio-button-unchecked"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"></path></g>
<g id="receipt"><path d="M18 17H6v-2h12v2zm0-4H6v-2h12v2zm0-4H6V7h12v2zM3 22l1.5-1.5L6 22l1.5-1.5L9 22l1.5-1.5L12 22l1.5-1.5L15 22l1.5-1.5L18 22l1.5-1.5L21 22V2l-1.5 1.5L18 2l-1.5 1.5L15 2l-1.5 1.5L12 2l-1.5 1.5L9 2 7.5 3.5 6 2 4.5 3.5 3 2v20z"></path></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4"></circle><path d="M9 15c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4zm7.76-9.64l-1.68 1.69c.84 1.18.84 2.71 0 3.89l1.68 1.69c2.02-2.02 2.02-5.07 0-7.27zM20.07 2l-1.63 1.63c2.77 3.02 2.77 7.56 0 10.74L20.07 16c3.9-3.89 3.91-9.95 0-14z"></path></g>
<g id="redeem"><path d="M20 6h-2.18c.11-.31.18-.65.18-1 0-1.66-1.34-3-3-3-1.05 0-1.96.54-2.5 1.35l-.5.67-.5-.68C10.96 2.54 10.05 2 9 2 7.34 2 6 3.34 6 5c0 .35.07.69.18 1H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-5-2c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zM9 4c.55 0 1 .45 1 1s-.45 1-1 1-1-.45-1-1 .45-1 1-1zm11 15H4v-2h16v2zm0-5H4V8h5.08L7 10.83 8.62 12 11 8.76l1-1.36 1 1.36L15.38 12 17 10.83 14.92 8H20v6z"></path></g>
<g id="redo"><path d="M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.65 0-8.58 3.03-9.96 7.22L3.9 16c1.05-3.19 4.05-5.5 7.6-5.5 1.95 0 3.73.72 5.12 1.88L13 16h9V7l-3.6 3.6z"></path></g>
<g id="refresh"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"></path></g>
<g id="remove"><path d="M19 13H5v-2h14v2z"></path></g>
<g id="remove-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm5 11H7v-2h10v2z"></path></g>
<g id="remove-circle-outline"><path d="M7 11v2h10v-2H7zm5-9C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"></path></g>
<g id="remove-shopping-cart"><path d="M22.73 22.73L2.77 2.77 2 2l-.73-.73L0 2.54l4.39 4.39 2.21 4.66-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h7.46l1.38 1.38c-.5.36-.83.95-.83 1.62 0 1.1.89 2 1.99 2 .67 0 1.26-.33 1.62-.84L21.46 24l1.27-1.27zM7.42 15c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h2.36l2 2H7.42zm8.13-2c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H6.54l9.01 9zM7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2z"></path></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z"></path></g>
<g id="reply"><path d="M10 9V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="reply-all"><path d="M7 8V5l-7 7 7 7v-3l-4-4 4-4zm6 1V5l-7 7 7 7v-4.1c5 0 8.5 1.6 11 5.1-1-5-4-10-11-11z"></path></g>
<g id="report"><path d="M15.73 3H8.27L3 8.27v7.46L8.27 21h7.46L21 15.73V8.27L15.73 3zM12 17.3c-.72 0-1.3-.58-1.3-1.3 0-.72.58-1.3 1.3-1.3.72 0 1.3.58 1.3 1.3 0 .72-.58 1.3-1.3 1.3zm1-4.3h-2V7h2v6z"></path></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="restore"><path d="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89.07.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54.72-1.21-3.5-2.08V8H12z"></path></g>
<g id="restore-page"><path d="M14 2H6c-1.1 0-1.99.9-1.99 2L4 20c0 1.1.89 2 1.99 2H18c1.1 0 2-.9 2-2V8l-6-6zm-2 16c-2.05 0-3.81-1.24-4.58-3h1.71c.63.9 1.68 1.5 2.87 1.5 1.93 0 3.5-1.57 3.5-3.5S13.93 9.5 12 9.5c-1.35 0-2.52.78-3.1 1.9l1.6 1.6h-4V9l1.3 1.3C8.69 8.92 10.23 8 12 8c2.76 0 5 2.24 5 5s-2.24 5-5 5z"></path></g>
<g id="room"><path d="M12 2C8.13 2 5 5.13 5 9c0 5.25 7 13 7 13s7-7.75 7-13c0-3.87-3.13-7-7-7zm0 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"></path></g>
<g id="rounded-corner"><path d="M19 19h2v2h-2v-2zm0-2h2v-2h-2v2zM3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm0-4h2V3H3v2zm4 0h2V3H7v2zm8 16h2v-2h-2v2zm-4 0h2v-2h-2v2zm4 0h2v-2h-2v2zm-8 0h2v-2H7v2zm-4 0h2v-2H3v2zM21 8c0-2.76-2.24-5-5-5h-5v2h5c1.65 0 3 1.35 3 3v5h2V8z"></path></g>
<g id="rowing"><path d="M8.5 14.5L4 19l1.5 1.5L9 17h2l-2.5-2.5zM15 1c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm6 20.01L18 24l-2.99-3.01V19.5l-7.1-7.09c-.31.05-.61.07-.91.07v-2.16c1.66.03 3.61-.87 4.67-2.04l1.4-1.55c.19-.21.43-.38.69-.5.29-.14.62-.23.96-.23h.03C15.99 6.01 17 7.02 17 8.26v5.75c0 .84-.35 1.61-.92 2.16l-3.58-3.58v-2.27c-.63.52-1.43 1.02-2.29 1.39L16.5 18H18l3 3.01z"></path></g>
<g id="save"><path d="M17 3H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"></path></g>
<g id="schedule"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm.5-13H11v6l5.25 3.15.75-1.23-4.5-2.67z"></path></g>
<g id="search"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path></g>
<g id="select-all"><path d="M3 5h2V3c-1.1 0-2 .9-2 2zm0 8h2v-2H3v2zm4 8h2v-2H7v2zM3 9h2V7H3v2zm10-6h-2v2h2V3zm6 0v2h2c0-1.1-.9-2-2-2zM5 21v-2H3c0 1.1.9 2 2 2zm-2-4h2v-2H3v2zM9 3H7v2h2V3zm2 18h2v-2h-2v2zm8-8h2v-2h-2v2zm0 8c1.1 0 2-.9 2-2h-2v2zm0-12h2V7h-2v2zm0 8h2v-2h-2v2zm-4 4h2v-2h-2v2zm0-16h2V3h-2v2zM7 17h10V7H7v10zm2-8h6v6H9V9z"></path></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"></path></g>
<g id="settings"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"></path></g>
<g id="settings-applications"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm7-7H5c-1.11 0-2 .9-2 2v14c0 1.1.89 2 2 2h14c1.11 0 2-.9 2-2V5c0-1.1-.89-2-2-2zm-1.75 9c0 .23-.02.46-.05.68l1.48 1.16c.13.11.17.3.08.45l-1.4 2.42c-.09.15-.27.21-.43.15l-1.74-.7c-.36.28-.76.51-1.18.69l-.26 1.85c-.03.17-.18.3-.35.3h-2.8c-.17 0-.32-.13-.35-.29l-.26-1.85c-.43-.18-.82-.41-1.18-.69l-1.74.7c-.16.06-.34 0-.43-.15l-1.4-2.42c-.09-.15-.05-.34.08-.45l1.48-1.16c-.03-.23-.05-.46-.05-.69 0-.23.02-.46.05-.68l-1.48-1.16c-.13-.11-.17-.3-.08-.45l1.4-2.42c.09-.15.27-.21.43-.15l1.74.7c.36-.28.76-.51 1.18-.69l.26-1.85c.03-.17.18-.3.35-.3h2.8c.17 0 .32.13.35.29l.26 1.85c.43.18.82.41 1.18.69l1.74-.7c.16-.06.34 0 .43.15l1.4 2.42c.09.15.05.34-.08.45l-1.48 1.16c.03.23.05.46.05.69z"></path></g>
<g id="settings-backup-restore"><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"></path></g>
<g id="settings-bluetooth"><path d="M11 24h2v-2h-2v2zm-4 0h2v-2H7v2zm8 0h2v-2h-2v2zm2.71-18.29L12 0h-1v7.59L6.41 3 5 4.41 10.59 10 5 15.59 6.41 17 11 12.41V20h1l5.71-5.71-4.3-4.29 4.3-4.29zM13 3.83l1.88 1.88L13 7.59V3.83zm1.88 10.46L13 16.17v-3.76l1.88 1.88z"></path></g>
<g id="settings-brightness"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02zM8 16h2.5l1.5 1.5 1.5-1.5H16v-2.5l1.5-1.5-1.5-1.5V8h-2.5L12 6.5 10.5 8H8v2.5L6.5 12 8 13.5V16zm4-7c1.66 0 3 1.34 3 3s-1.34 3-3 3V9z"></path></g>
<g id="settings-cell"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm4 0h2v-2h-2v2zM16 .01L8 0C6.9 0 6 .9 6 2v16c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V2c0-1.1-.9-1.99-2-1.99zM16 16H8V4h8v12z"></path></g>
<g id="settings-ethernet"><path d="M7.77 6.76L6.23 5.48.82 12l5.41 6.52 1.54-1.28L3.42 12l4.35-5.24zM7 13h2v-2H7v2zm10-2h-2v2h2v-2zm-6 2h2v-2h-2v2zm6.77-7.52l-1.54 1.28L20.58 12l-4.35 5.24 1.54 1.28L23.18 12l-5.41-6.52z"></path></g>
<g id="settings-input-antenna"><path d="M12 5c-3.87 0-7 3.13-7 7h2c0-2.76 2.24-5 5-5s5 2.24 5 5h2c0-3.87-3.13-7-7-7zm1 9.29c.88-.39 1.5-1.26 1.5-2.29 0-1.38-1.12-2.5-2.5-2.5S9.5 10.62 9.5 12c0 1.02.62 1.9 1.5 2.29v3.3L7.59 21 9 22.41l3-3 3 3L16.41 21 13 17.59v-3.3zM12 1C5.93 1 1 5.93 1 12h2c0-4.97 4.03-9 9-9s9 4.03 9 9h2c0-6.07-4.93-11-11-11z"></path></g>
<g id="settings-input-component"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-composite"><path d="M5 2c0-.55-.45-1-1-1s-1 .45-1 1v4H1v6h6V6H5V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2H9v2zm-8 0c0 1.3.84 2.4 2 2.82V23h2v-4.18C6.16 18.4 7 17.3 7 16v-2H1v2zM21 6V2c0-.55-.45-1-1-1s-1 .45-1 1v4h-2v6h6V6h-2zm-8-4c0-.55-.45-1-1-1s-1 .45-1 1v4H9v6h6V6h-2V2zm4 14c0 1.3.84 2.4 2 2.82V23h2v-4.18c1.16-.41 2-1.51 2-2.82v-2h-6v2z"></path></g>
<g id="settings-input-hdmi"><path d="M18 7V4c0-1.1-.9-2-2-2H8c-1.1 0-2 .9-2 2v3H5v6l3 6v3h8v-3l3-6V7h-1zM8 4h8v3h-2V5h-1v2h-2V5h-1v2H8V4z"></path></g>
<g id="settings-input-svideo"><path d="M8 11.5c0-.83-.67-1.5-1.5-1.5S5 10.67 5 11.5 5.67 13 6.5 13 8 12.33 8 11.5zm7-5c0-.83-.67-1.5-1.5-1.5h-3C9.67 5 9 5.67 9 6.5S9.67 8 10.5 8h3c.83 0 1.5-.67 1.5-1.5zM8.5 15c-.83 0-1.5.67-1.5 1.5S7.67 18 8.5 18s1.5-.67 1.5-1.5S9.33 15 8.5 15zM12 1C5.93 1 1 5.93 1 12s4.93 11 11 11 11-4.93 11-11S18.07 1 12 1zm0 20c-4.96 0-9-4.04-9-9s4.04-9 9-9 9 4.04 9 9-4.04 9-9 9zm5.5-11c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5zm-2 5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z"></path></g>
<g id="settings-overscan"><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"></path></g>
<g id="settings-phone"><path d="M13 9h-2v2h2V9zm4 0h-2v2h2V9zm3 6.5c-1.25 0-2.45-.2-3.57-.57-.35-.11-.74-.03-1.02.24l-2.2 2.2c-2.83-1.44-5.15-3.75-6.59-6.58l2.2-2.21c.28-.27.36-.66.25-1.01C8.7 6.45 8.5 5.25 8.5 4c0-.55-.45-1-1-1H4c-.55 0-1 .45-1 1 0 9.39 7.61 17 17 17 .55 0 1-.45 1-1v-3.5c0-.55-.45-1-1-1zM19 9v2h2V9h-2z"></path></g>
<g id="settings-power"><path d="M7 24h2v-2H7v2zm4 0h2v-2h-2v2zm2-22h-2v10h2V2zm3.56 2.44l-1.45 1.45C16.84 6.94 18 8.83 18 11c0 3.31-2.69 6-6 6s-6-2.69-6-6c0-2.17 1.16-4.06 2.88-5.12L7.44 4.44C5.36 5.88 4 8.28 4 11c0 4.42 3.58 8 8 8s8-3.58 8-8c0-2.72-1.36-5.12-3.44-6.56zM15 24h2v-2h-2v2z"></path></g>
<g id="settings-remote"><path d="M15 9H9c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h6c.55 0 1-.45 1-1V10c0-.55-.45-1-1-1zm-3 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zM7.05 6.05l1.41 1.41C9.37 6.56 10.62 6 12 6s2.63.56 3.54 1.46l1.41-1.41C15.68 4.78 13.93 4 12 4s-3.68.78-4.95 2.05zM12 0C8.96 0 6.21 1.23 4.22 3.22l1.41 1.41C7.26 3.01 9.51 2 12 2s4.74 1.01 6.36 2.64l1.41-1.41C17.79 1.23 15.04 0 12 0z"></path></g>
<g id="settings-voice"><path d="M7 24h2v-2H7v2zm5-11c1.66 0 2.99-1.34 2.99-3L15 4c0-1.66-1.34-3-3-3S9 2.34 9 4v6c0 1.66 1.34 3 3 3zm-1 11h2v-2h-2v2zm4 0h2v-2h-2v2zm4-14h-1.7c0 3-2.54 5.1-5.3 5.1S6.7 13 6.7 10H5c0 3.41 2.72 6.23 6 6.72V20h2v-3.28c3.28-.49 6-3.31 6-6.72z"></path></g>
<g id="shop"><path d="M16 6V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H2v13c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6h-6zm-6-2h4v2h-4V4zM9 18V9l7.5 4L9 18z"></path></g>
<g id="shop-two"><path d="M3 9H1v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2H3V9zm15-4V3c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H5v11c0 1.11.89 2 2 2h14c1.11 0 2-.89 2-2V5h-5zm-6-2h4v2h-4V3zm0 12V8l5.5 3-5.5 4z"></path></g>
<g id="shopping-basket"><path d="M17.21 9l-4.38-6.56c-.19-.28-.51-.42-.83-.42-.32 0-.64.14-.83.43L6.79 9H2c-.55 0-1 .45-1 1 0 .09.01.18.04.27l2.54 9.27c.23.84 1 1.46 1.92 1.46h13c.92 0 1.69-.62 1.93-1.46l2.54-9.27L23 10c0-.55-.45-1-1-1h-4.79zM9 9l3-4.4L15 9H9zm3 8c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"></path></g>
<g id="shopping-cart"><path d="M7 18c-1.1 0-1.99.9-1.99 2S5.9 22 7 22s2-.9 2-2-.9-2-2-2zM1 2v2h2l3.6 7.59-1.35 2.45c-.16.28-.25.61-.25.96 0 1.1.9 2 2 2h12v-2H7.42c-.14 0-.25-.11-.25-.25l.03-.12.9-1.63h7.45c.75 0 1.41-.41 1.75-1.03l3.58-6.49c.08-.14.12-.31.12-.48 0-.55-.45-1-1-1H5.21l-.94-2H1zm16 16c-1.1 0-1.99.9-1.99 2s.89 2 1.99 2 2-.9 2-2-.9-2-2-2z"></path></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z"></path></g>
<g id="speaker-notes"><path d="M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z"></path></g>
<g id="speaker-notes-off"><path d="M10.54 11l-.54-.54L7.54 8 6 6.46 2.38 2.84 1.27 1.73 0 3l2.01 2.01L2 22l4-4h9l5.73 5.73L22 22.46 17.54 18l-7-7zM8 14H6v-2h2v2zm-2-3V9l2 2H6zm14-9H4.08L10 7.92V6h8v2h-7.92l1 1H18v2h-4.92l6.99 6.99C21.14 17.95 22 17.08 22 16V4c0-1.1-.9-2-2-2z"></path></g>
<g id="spellcheck"><path d="M12.45 16h2.09L9.43 3H7.57L2.46 16h2.09l1.12-3h5.64l1.14 3zm-6.02-5L8.5 5.48 10.57 11H6.43zm15.16.59l-8.09 8.09L9.83 16l-1.41 1.41 5.09 5.09L23 13l-1.41-1.41z"></path></g>
<g id="star"><path d="M12 17.27L18.18 21l-1.64-7.03L22 9.24l-7.19-.61L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21z"></path></g>
<g id="star-border"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4l-3.76 2.27 1-4.28-3.32-2.88 4.38-.38L12 6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="star-half"><path d="M22 9.24l-7.19-.62L12 2 9.19 8.63 2 9.24l5.46 4.73L5.82 21 12 17.27 18.18 21l-1.63-7.03L22 9.24zM12 15.4V6.1l1.71 4.04 4.38.38-3.32 2.88 1 4.28L12 15.4z"></path></g>
<g id="stars"><path d="M11.99 2C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zm4.24 16L12 15.45 7.77 18l1.12-4.81-3.73-3.23 4.92-.42L12 5l1.92 4.53 4.92.42-3.73 3.23L16.23 18z"></path></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z"></path></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z"></path></g>
<g id="subdirectory-arrow-right"><path d="M19 15l-6 6-1.42-1.42L15.17 16H4V4h2v10h9.17l-3.59-3.58L13 9l6 6z"></path></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z"></path></g>
<g id="supervisor-account"><path d="M16.5 12c1.38 0 2.49-1.12 2.49-2.5S17.88 7 16.5 7C15.12 7 14 8.12 14 9.5s1.12 2.5 2.5 2.5zM9 11c1.66 0 2.99-1.34 2.99-3S10.66 5 9 5C7.34 5 6 6.34 6 8s1.34 3 3 3zm7.5 3c-1.83 0-5.5.92-5.5 2.75V19h11v-2.25c0-1.83-3.67-2.75-5.5-2.75zM9 13c-2.33 0-7 1.17-7 3.5V19h7v-2.25c0-.85.33-2.34 2.37-3.47C10.5 13.1 9.66 13 9 13z"></path></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z"></path></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z"></path></g>
<g id="swap-vertical-circle"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM6.5 9L10 5.5 13.5 9H11v4H9V9H6.5zm11 6L14 18.5 10.5 15H13v-4h2v4h2.5z"></path></g>
<g id="system-update-alt"><path d="M12 16.5l4-4h-3v-9h-2v9H8l4 4zm9-13h-6v1.99h6v14.03H3V5.49h6V3.5H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-14c0-1.1-.9-2-2-2z"></path></g>
<g id="tab"><path d="M21 3H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H3V5h10v4h8v10z"></path></g>
<g id="tab-unselected"><path d="M1 9h2V7H1v2zm0 4h2v-2H1v2zm0-8h2V3c-1.1 0-2 .9-2 2zm8 16h2v-2H9v2zm-8-4h2v-2H1v2zm2 4v-2H1c0 1.1.9 2 2 2zM21 3h-8v6h10V5c0-1.1-.9-2-2-2zm0 14h2v-2h-2v2zM9 5h2V3H9v2zM5 21h2v-2H5v2zM5 5h2V3H5v2zm16 16c1.1 0 2-.9 2-2h-2v2zm0-8h2v-2h-2v2zm-8 8h2v-2h-2v2zm4 0h2v-2h-2v2z"></path></g>
<g id="text-format"><path d="M5 17v2h14v-2H5zm4.5-4.2h5l.9 2.2h2.1L12.75 4h-1.5L6.5 15h2.1l.9-2.2zM12 5.98L13.87 11h-3.74L12 5.98z"></path></g>
<g id="theaters"><path d="M18 3v2h-2V3H8v2H6V3H4v18h2v-2h2v2h8v-2h2v2h2V3h-2zM8 17H6v-2h2v2zm0-4H6v-2h2v2zm0-4H6V7h2v2zm10 8h-2v-2h2v2zm0-4h-2v-2h2v2zm0-4h-2V7h2v2z"></path></g>
<g id="thumb-down"><path d="M15 3H6c-.83 0-1.54.5-1.84 1.22l-3.02 7.05c-.09.23-.14.47-.14.73v1.91l.01.01L1 14c0 1.1.9 2 2 2h6.31l-.95 4.57-.03.32c0 .41.17.79.44 1.06L9.83 23l6.59-6.59c.36-.36.58-.86.58-1.41V5c0-1.1-.9-2-2-2zm4 0v12h4V3h-4z"></path></g>
<g id="thumb-up"><path d="M1 21h4V9H1v12zm22-11c0-1.1-.9-2-2-2h-6.31l.95-4.57.03-.32c0-.41-.17-.79-.44-1.06L14.17 1 7.59 7.59C7.22 7.95 7 8.45 7 9v10c0 1.1.9 2 2 2h9c.83 0 1.54-.5 1.84-1.22l3.02-7.05c.09-.23.14-.47.14-.73v-1.91l-.01-.01L23 10z"></path></g>
<g id="thumbs-up-down"><path d="M12 6c0-.55-.45-1-1-1H5.82l.66-3.18.02-.23c0-.31-.13-.59-.33-.8L5.38 0 .44 4.94C.17 5.21 0 5.59 0 6v6.5c0 .83.67 1.5 1.5 1.5h6.75c.62 0 1.15-.38 1.38-.91l2.26-5.29c.07-.17.11-.36.11-.55V6zm10.5 4h-6.75c-.62 0-1.15.38-1.38.91l-2.26 5.29c-.07.17-.11.36-.11.55V18c0 .55.45 1 1 1h5.18l-.66 3.18-.02.24c0 .31.13.59.33.8l.79.78 4.94-4.94c.27-.27.44-.65.44-1.06v-6.5c0-.83-.67-1.5-1.5-1.5z"></path></g>
<g id="timeline"><path d="M23 8c0 1.1-.9 2-2 2-.18 0-.35-.02-.51-.07l-3.56 3.55c.05.16.07.34.07.52 0 1.1-.9 2-2 2s-2-.9-2-2c0-.18.02-.36.07-.52l-2.55-2.55c-.16.05-.34.07-.52.07s-.36-.02-.52-.07l-4.55 4.56c.05.16.07.33.07.51 0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2c.18 0 .35.02.51.07l4.56-4.55C8.02 9.36 8 9.18 8 9c0-1.1.9-2 2-2s2 .9 2 2c0 .18-.02.36-.07.52l2.55 2.55c.16-.05.34-.07.52-.07s.36.02.52.07l3.55-3.56C19.02 8.35 19 8.18 19 8c0-1.1.9-2 2-2s2 .9 2 2z"></path></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z"></path></g>
<g id="today"><path d="M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z"></path></g>
<g id="toll"><path d="M15 4c-4.42 0-8 3.58-8 8s3.58 8 8 8 8-3.58 8-8-3.58-8-8-8zm0 14c-3.31 0-6-2.69-6-6s2.69-6 6-6 6 2.69 6 6-2.69 6-6 6zM3 12c0-2.61 1.67-4.83 4-5.65V4.26C3.55 5.15 1 8.27 1 12s2.55 6.85 6 7.74v-2.09c-2.33-.82-4-3.04-4-5.65z"></path></g>
<g id="touch-app"><path d="M9 11.24V7.5C9 6.12 10.12 5 11.5 5S14 6.12 14 7.5v3.74c1.21-.81 2-2.18 2-3.74C16 5.01 13.99 3 11.5 3S7 5.01 7 7.5c0 1.56.79 2.93 2 3.74zm9.84 4.63l-4.54-2.26c-.17-.07-.35-.11-.54-.11H13v-6c0-.83-.67-1.5-1.5-1.5S10 6.67 10 7.5v10.74l-3.43-.72c-.08-.01-.15-.03-.24-.03-.31 0-.59.13-.79.33l-.79.8 4.94 4.94c.27.27.65.44 1.06.44h6.79c.75 0 1.33-.55 1.44-1.28l.75-5.27c.01-.07.02-.14.02-.2 0-.62-.38-1.16-.91-1.38z"></path></g>
<g id="track-changes"><path d="M19.07 4.93l-1.41 1.41C19.1 7.79 20 9.79 20 12c0 4.42-3.58 8-8 8s-8-3.58-8-8c0-4.08 3.05-7.44 7-7.93v2.02C8.16 6.57 6 9.03 6 12c0 3.31 2.69 6 6 6s6-2.69 6-6c0-1.66-.67-3.16-1.76-4.24l-1.41 1.41C15.55 9.9 16 10.9 16 12c0 2.21-1.79 4-4 4s-4-1.79-4-4c0-1.86 1.28-3.41 3-3.86v2.14c-.6.35-1 .98-1 1.72 0 1.1.9 2 2 2s2-.9 2-2c0-.74-.4-1.38-1-1.72V2h-1C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10c0-2.76-1.12-5.26-2.93-7.07z"></path></g>
<g id="translate"><path d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"></path></g>
<g id="trending-down"><path d="M16 18l2.29-2.29-4.88-4.88-4 4L2 7.41 3.41 6l6 6 4-4 6.3 6.29L22 12v6z"></path></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z"></path></g>
<g id="trending-up"><path d="M16 6l2.29 2.29-4.88 4.88-4-4L2 16.59 3.41 18l6-6 4 4 6.3-6.29L22 12V6z"></path></g>
<g id="turned-in"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2z"></path></g>
<g id="turned-in-not"><path d="M17 3H7c-1.1 0-1.99.9-1.99 2L5 21l7-3 7 3V5c0-1.1-.9-2-2-2zm0 15l-5-2.18L7 18V5h10v13z"></path></g>
<g id="unarchive"><path d="M20.55 5.22l-1.39-1.68C18.88 3.21 18.47 3 18 3H6c-.47 0-.88.21-1.15.55L3.46 5.22C3.17 5.57 3 6.01 3 6.5V19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V6.5c0-.49-.17-.93-.45-1.28zM12 9.5l5.5 5.5H14v2h-4v-2H6.5L12 9.5zM5.12 5l.82-1h12l.93 1H5.12z"></path></g>
<g id="undo"><path d="M12.5 8c-2.65 0-5.05.99-6.9 2.6L2 7v9h9l-3.62-3.62c1.39-1.16 3.16-1.88 5.12-1.88 3.54 0 6.55 2.31 7.6 5.5l2.37-.78C21.08 11.03 17.15 8 12.5 8z"></path></g>
<g id="unfold-less"><path d="M7.41 18.59L8.83 20 12 16.83 15.17 20l1.41-1.41L12 14l-4.59 4.59zm9.18-13.18L15.17 4 12 7.17 8.83 4 7.41 5.41 12 10l4.59-4.59z"></path></g>
<g id="unfold-more"><path d="M12 5.83L15.17 9l1.41-1.41L12 3 7.41 7.59 8.83 9 12 5.83zm0 12.34L8.83 15l-1.41 1.41L12 21l4.59-4.59L15.17 15 12 18.17z"></path></g>
<g id="update"><path d="M21 10.12h-6.78l2.74-2.82c-2.73-2.7-7.15-2.8-9.88-.1-2.73 2.71-2.73 7.08 0 9.79 2.73 2.71 7.15 2.71 9.88 0C18.32 15.65 19 14.08 19 12.1h2c0 1.98-.88 4.55-2.64 6.29-3.51 3.48-9.21 3.48-12.72 0-3.5-3.47-3.53-9.11-.02-12.58 3.51-3.47 9.14-3.47 12.65 0L21 3v7.12zM12.5 8v4.25l3.5 2.08-.72 1.21L11 13V8h1.5z"></path></g>
<g id="verified-user"><path d="M12 1L3 5v6c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V5l-9-4zm-2 16l-4-4 1.41-1.41L10 14.17l6.59-6.59L18 9l-8 8z"></path></g>
<g id="view-agenda"><path d="M20 13H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1v-6c0-.55-.45-1-1-1zm0-10H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V4c0-.55-.45-1-1-1z"></path></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z"></path></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z"></path></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z"></path></g>
<g id="view-day"><path d="M2 21h19v-3H2v3zM20 8H3c-.55 0-1 .45-1 1v6c0 .55.45 1 1 1h17c.55 0 1-.45 1-1V9c0-.55-.45-1-1-1zM2 3v3h19V3H2z"></path></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z"></path></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z"></path></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z"></path></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z"></path></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z"></path></g>
<g id="view-week"><path d="M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z"></path></g>
<g id="visibility"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zM12 17c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5zm0-8c-1.66 0-3 1.34-3 3s1.34 3 3 3 3-1.34 3-3-1.34-3-3-3z"></path></g>
<g id="visibility-off"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"></path></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"></path></g>
<g id="watch-later"><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zm4.2 14.2L11 13V7h1.5v5.2l4.5 2.7-.8 1.3z"></path></g>
<g id="weekend"><path d="M21 10c-1.1 0-2 .9-2 2v3H5v-3c0-1.1-.9-2-2-2s-2 .9-2 2v5c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2v-5c0-1.1-.9-2-2-2zm-3-5H6c-1.1 0-2 .9-2 2v2.15c1.16.41 2 1.51 2 2.82V14h12v-2.03c0-1.3.84-2.4 2-2.82V7c0-1.1-.9-2-2-2z"></path></g>
<g id="work"><path d="M20 6h-4V4c0-1.11-.89-2-2-2h-4c-1.11 0-2 .89-2 2v2H4c-1.11 0-1.99.89-1.99 2L2 19c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V8c0-1.11-.89-2-2-2zm-6 0h-4V4h4v2z"></path></g>
<g id="youtube-searched-for"><path d="M17.01 14h-.8l-.27-.27c.98-1.14 1.57-2.61 1.57-4.23 0-3.59-2.91-6.5-6.5-6.5s-6.5 3-6.5 6.5H2l3.84 4 4.16-4H6.51C6.51 7 8.53 5 11.01 5s4.5 2.01 4.5 4.5c0 2.48-2.02 4.5-4.5 4.5-.65 0-1.26-.14-1.82-.38L7.71 15.1c.97.57 2.09.9 3.3.9 1.61 0 3.08-.59 4.22-1.57l.27.27v.79l5.01 4.99L22 19l-4.99-5z"></path></g>
<g id="zoom-in"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zm2.5-4h-2v2H9v-2H7V9h2V7h1v2h2v1z"></path></g>
<g id="zoom-out"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(So.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var Mo={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},Eo={8:"backspace",9:"tab",13:"enter",27:"esc",33:"pageup",34:"pagedown",35:"end",36:"home",32:"space",37:"left",38:"up",39:"right",40:"down",46:"del",106:"*"},To={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},Ao=/[a-z0-9*]/,Co=/U\+/,ko=/^arrow/,Lo=/^space(bar)?/,Po=/^escape$/;function Io(t,e){var n="";if(t){var i=t.toLowerCase();" "===i||Lo.test(i)?n="space":Po.test(i)?n="esc":1==i.length?e&&!Ao.test(i)||(n=i):n=ko.test(i)?i.replace("arrow",""):"multiply"==i?"*":i}return n}function No(t,e){return(function n(t,e){return t.key?Io(t.key,e):t.detail&&t.detail.key?Io(t.detail.key,e):(function n(t){var e="";return t&&(t in Mo?e=Mo[t]:Co.test(t)?(t=parseInt(t.replace("U+","0x"),16),e=String.fromCharCode(t).toLowerCase()):e=t.toLowerCase()),e})(t.keyIdentifier)||(function i(t){var e="";return Number(t)&&(e=t>=65&&t<=90?String.fromCharCode(32+t):t>=112&&t<=123?"f"+(t-112+1):t>=48&&t<=57?String(t-48):t>=96&&t<=105?String(t-96):Eo[t]),e})(t.keyCode)||""})(e,t.hasModifiers)===t.key&&(!t.hasModifiers||!!e.shiftKey==!!t.shiftKey&&!!e.ctrlKey==!!t.ctrlKey&&!!e.altKey==!!t.altKey&&!!e.metaKey==!!t.metaKey)}function Oo(t){return t.trim().split(" ").map((function(t){return(function e(t){return 1===t.length?{combo:t,key:t,event:"keydown"}:t.split("+").reduce((function(t,e){var n=e.split(":"),i=n[0],r=n[1];return i in To?(t[To[i]]=!0,t.hasModifiers=!0):(t.key=i,t.event=r||"keydown"),t}),{combo:t.split(":").shift()})})(t)}))}const Ro={properties:{keyEventTarget:{type:Object,value:function(){return this}},stopKeyboardEventPropagation:{type:Boolean,value:!1},_boundKeyHandlers:{type:Array,value:function(){return[]}},_imperativeKeyBindings:{type:Object,value:function(){return{}}}},observers:["_resetKeyEventListeners(keyEventTarget, _boundKeyHandlers)"],keyBindings:{},registered:function(){this._prepKeyBindings()},attached:function(){this._listenKeyEventListeners()},detached:function(){this._unlistenKeyEventListeners()},addOwnKeyBinding:function(t,e){this._imperativeKeyBindings[t]=e,this._prepKeyBindings(),this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={},this._prepKeyBindings(),this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(t,e){for(var n=Oo(e),i=0;i<n.length;++i)if(No(n[i],t))return!0;return!1},_collectKeyBindings:function(){var t=this.behaviors.map((function(t){return t.keyBindings}));return-1===t.indexOf(this.keyBindings)&&t.push(this.keyBindings),t},_prepKeyBindings:function(){for(var t in this._keyBindings={},this._collectKeyBindings().forEach((function(t){for(var e in t)this._addKeyBinding(e,t[e])}),this),this._imperativeKeyBindings)this._addKeyBinding(t,this._imperativeKeyBindings[t]);for(var e in this._keyBindings)this._keyBindings[e].sort((function(t,e){var n=t[0].hasModifiers;return n===e[0].hasModifiers?0:n?-1:1}))},_addKeyBinding:function(t,e){Oo(t).forEach((function(t){this._keyBindings[t.event]=this._keyBindings[t.event]||[],this._keyBindings[t.event].push([t,e])}),this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners(),this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){this.keyEventTarget&&Object.keys(this._keyBindings).forEach((function(t){var e=this._onKeyBindingEvent.bind(this,this._keyBindings[t]);this._boundKeyHandlers.push([this.keyEventTarget,t,e]),this.keyEventTarget.addEventListener(t,e)}),this)},_unlistenKeyEventListeners:function(){for(var t;this._boundKeyHandlers.length;)(t=this._boundKeyHandlers.pop())[0].removeEventListener(t[1],t[2])},_onKeyBindingEvent:function(t,e){if(this.stopKeyboardEventPropagation&&e.stopPropagation(),!e.defaultPrevented)for(var n=0;n<t.length;n++){var i=t[n][0],r=t[n][1];if(No(i,e)&&(this._triggerKeyHandler(i,r,e),e.defaultPrevented))return}},_triggerKeyHandler:function(t,e,n){var i=Object.create(t);i.keyboardEvent=n;var r=new CustomEvent(t.event,{detail:i,cancelable:!0});this[e].call(this,r),r.defaultPrevented&&n.preventDefault()}},zo={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(t,e){if(this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null),e)if("document"===t)this.scrollTarget=this._doc;else if("string"==typeof t){var n=this.domHost;this.scrollTarget=n&&n.$?n.$[t]:qi(this.ownerDocument).querySelector("#"+t)}else this._isValidScrollTarget()&&(this._oldScrollTarget=t,this._toggleScrollListener(this._shouldHaveListener,t))},_scrollHandler:function t(){},get _defaultScrollTarget(){return this._doc},get _doc(){return this.ownerDocument.documentElement},get _scrollTop(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageYOffset:this.scrollTarget.scrollTop:0},get _scrollLeft(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.pageXOffset:this.scrollTarget.scrollLeft:0},set _scrollTop(t){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,t):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=t)},set _scrollLeft(t){this.scrollTarget===this._doc?window.scrollTo(t,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=t)},scroll:function(t,e){var n;"object"==typeof t?(n=t.left,e=t.top):n=t,n=n||0,e=e||0,this.scrollTarget===this._doc?window.scrollTo(n,e):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=n,this.scrollTarget.scrollTop=e)},get _scrollTargetWidth(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerWidth:this.scrollTarget.offsetWidth:0},get _scrollTargetHeight(){return this._isValidScrollTarget()?this.scrollTarget===this._doc?window.innerHeight:this.scrollTarget.offsetHeight:0},_isValidScrollTarget:function(){return this.scrollTarget instanceof HTMLElement},_toggleScrollListener:function(t,e){var n=e===this._doc?window:e;t?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),n.addEventListener("scroll",this._boundScrollHandler)):this._boundScrollHandler&&(n.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(t){this._shouldHaveListener=t,this._toggleScrollListener(t,this.scrollTarget)}};
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var Do=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Bo=Do&&Do[1]>=8,Ho="-10000px",Fo=-100;Nr({_template:_e`
    <style>
      :host {
        display: block;
      }

      @media only screen and (-webkit-max-device-pixel-ratio: 1) {
        :host {
          will-change: transform;
        }
      }

      #items {
        @apply --iron-list-items-container;
        position: relative;
      }

      :host(:not([grid])) #items > ::slotted(*) {
        width: 100%;
      }

      #items > ::slotted(*) {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
        top: 0;
        will-change: transform;
      }
    </style>

    <array-selector id="selector" items="{{items}}" selected="{{selectedItems}}" selected-item="{{selectedItem}}"></array-selector>

    <div id="items">
      <slot></slot>
    </div>
`,is:"iron-list",properties:{items:{type:Array},as:{type:String,value:"item"},indexAs:{type:String,value:"index"},selectedAs:{type:String,value:"selected"},grid:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_gridChanged"},selectionEnabled:{type:Boolean,value:!1},selectedItem:{type:Object,notify:!0},selectedItems:{type:Object,notify:!0},multiSelection:{type:Boolean,value:!1},scrollOffset:{type:Number,value:0}},observers:["_itemsChanged(items.*)","_selectionEnabledChanged(selectionEnabled)","_multiSelectionChanged(multiSelection)","_setOverflow(scrollTarget, scrollOffset)"],behaviors:[Kr,mo,zo,ho],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedItem:null,_focusedVirtualIndex:-1,_focusedPhysicalIndex:-1,_offscreenFocusedItem:null,_focusBackfillItem:null,_itemsPerRow:1,_itemWidth:0,_rowHeight:0,_templateCost:0,_parentModel:!0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return(this.grid?this._physicalRows*this._rowHeight:this._physicalSize)-this._viewportHeight},get _itemsParent(){return qi(qi(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var t=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,t-this._physicalCount)},set _virtualStart(t){t=this._clamp(t,0,this._maxVirtualStart),this.grid&&(t-=t%this._itemsPerRow),this._virtualStartVal=t},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(t){(t%=this._physicalCount)<0&&(t=this._physicalCount+t),this.grid&&(t-=t%this._itemsPerRow),this._physicalStartVal=t},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(t){this._physicalCountVal=t},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return 0===this._viewportHeight?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var t=this._firstVisibleIndexVal;if(null==t){var e=this._physicalTop+this._scrollOffset;t=this._iterateItems((function(t,n){return(e+=this._getPhysicalSizeIncrement(t))>this._scrollPosition?this.grid?n-n%this._itemsPerRow:n:this.grid&&this._virtualCount-1===n?n-n%this._itemsPerRow:void 0}))||0,this._firstVisibleIndexVal=t}return t},get lastVisibleIndex(){var t=this._lastVisibleIndexVal;if(null==t){if(this.grid)t=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var e=this._physicalTop+this._scrollOffset;this._iterateItems((function(n,i){e<this._scrollBottom&&(t=i),e+=this._getPhysicalSizeIncrement(n)}))}this._lastVisibleIndexVal=t}return t},get _defaultScrollTarget(){return this},get _virtualRowCount(){return Math.ceil(this._virtualCount/this._itemsPerRow)},get _estRowsInView(){return Math.ceil(this._viewportHeight/this._rowHeight)},get _physicalRows(){return Math.ceil(this._physicalCount/this._itemsPerRow)},get _scrollOffset(){return this._scrollerPaddingTop+this.scrollOffset},ready:function(){this.addEventListener("focus",this._didFocus.bind(this),!0)},attached:function(){this._debounce("_render",this._render,_t),this.listen(this,"iron-resize","_resizeHandler"),this.listen(this,"keydown","_keydownHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler"),this.unlisten(this,"keydown","_keydownHandler")},_setOverflow:function(t){this.style.webkitOverflowScrolling=t===this?"touch":"",this.style.overflowY=t===this?"auto":"",this._lastVisibleIndexVal=null,this._firstVisibleIndexVal=null,this._debounce("_render",this._render,_t)},updateViewportBoundaries:function(){var t=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(t["padding-top"],10),this._isRTL=Boolean("rtl"===t.direction),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var t=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),e=t-this._scrollPosition,n=e>=0;if(this._scrollPosition=t,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(e)>this._physicalSize&&this._physicalSize>0){e-=this._scrollOffset;var i=Math.round(e/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+i,this._physicalStart=this._physicalStart+i,this._physicalTop=Math.min(Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._scrollPosition),this._update()}else if(this._physicalCount>0){var r=this._getReusables(n);n?(this._physicalTop=r.physicalTop,this._virtualStart=this._virtualStart+r.indexes.length,this._physicalStart=this._physicalStart+r.indexes.length):(this._virtualStart=this._virtualStart-r.indexes.length,this._physicalStart=this._physicalStart-r.indexes.length),this._update(r.indexes,n?null:r.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),vt)}},_getReusables:function(t){var e,n,i,r=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._scrollPosition,h=this._scrollBottom;for(t?(e=this._physicalStart,n=u-c):(e=this._physicalEnd,n=this._physicalBottom+this._scrollOffset-h);n-=i=this._getPhysicalSizeIncrement(e),!(r.length>=l||n<=o);)if(t){if(s+r.length+1>=this._virtualCount)break;if(c+i>=u-this._scrollOffset)break;r.push(e),c+=i,e=(e+1)%l}else{if(a-r.length<=0)break;if(c+this._physicalSize-i<=h)break;r.push(e),c-=i,e=0===e?l-1:e-1}return{indexes:r,physicalTop:c-this._scrollOffset}},_update:function(t,e){if(!(t&&0===t.length||0===this._physicalCount)){if(this._manageFocus(),this._assignModels(t),this._updateMetrics(t),e)for(;e.length;){var n=e.pop();this._physicalTop-=this._getPhysicalSizeIncrement(n)}this._positionItems(),this._updateScrollerSize()}},_createPool:function(t){var e,n;this._ensureTemplatized();var i=new Array(t);for(e=0;e<t;e++)n=this.stamp(null),i[e]=n.root.querySelector("*"),this._itemsParent.appendChild(n.root);return i},_isClientFull:function(){return 0!=this._scrollBottom&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(t){var e=this._clamp(this._physicalCount+t,3,this._virtualCount-this._virtualStart);if(e=this._convertIndexToCompleteRow(e),this.grid){var n=e%this._itemsPerRow;n&&e-n<=this._physicalCount&&(e+=this._itemsPerRow),e-=n}var i=e-this._physicalCount,r=Math.round(.5*this._physicalCount);if(!(i<0)){if(i>0){var o=window.performance.now();[].push.apply(this._physicalItems,this._createPool(i));for(var a=0;a<i;a++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+i,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+i),this._update(),this._templateCost=(window.performance.now()-o)/i,r=Math.round(.5*this._physicalCount)}this._virtualEnd>=this._virtualCount-1||0===r||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,r)),yt):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,r),vt))}},_render:function(){if(this.isAttached&&this._isVisible)if(0!==this._physicalCount){var t=this._getReusables(!0);this._physicalTop=t.physicalTop,this._virtualStart=this._virtualStart+t.indexes.length,this._physicalStart=this._physicalStart+t.indexes.length,this._update(t.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(3))},_ensureTemplatized:function(){if(!this.ctor){this._userTemplate=this.queryEffectiveChildren("template"),this._userTemplate||console.warn("iron-list requires a template to be provided in light-dom");var t={__key__:!0};t[this.as]=!0,t[this.indexAs]=!0,t[this.selectedAs]=!0,t.tabIndex=!0,this._instanceProps=t,this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(t,e){void 0!==e&&(this.notifyResize(),zi(),t&&this._updateGridMetrics())},_itemsChanged:function(t){if("items"===t.path)this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,_t);else if("items.splices"===t.path){if(this._adjustVirtualIndex(t.value.indexSplices),this._virtualCount=this.items?this.items.length:0,t.value.indexSplices.some((function(t){return t.addedCount>0||t.removed.length>0}))){var e=this._getActiveElement();this.contains(e)&&e.blur()}var n=t.value.indexSplices.some((function(t){return t.index+t.addedCount>=this._virtualStart&&t.index<=this._virtualEnd}),this);this._isClientFull()&&!n||this._debounce("_render",this._render,_t)}else"items.length"!==t.path&&this._forwardItemPath(t.path,t.value)},_forwardItemPath:function(t,e){var n,i,r,o=(t=t.slice(6)).indexOf(".");-1===o&&(o=t.length);var a=this.modelForElement(this._offscreenFocusedItem),s=parseInt(t.substring(0,o),10);(n=this._isIndexRendered(s))?(i=this._getPhysicalIndex(s),r=this.modelForElement(this._physicalItems[i])):a&&(r=a),r&&r[this.indexAs]===s&&(t=t.substring(o+1),r._setPendingPropertyOrPath(t=this.as+(t?"."+t:""),e,!1,!0),r._flushProperties&&r._flushProperties(),n&&(this._updateMetrics([i]),this._positionItems(),this._updateScrollerSize()))},_adjustVirtualIndex:function(t){t.forEach((function(t){if(t.removed.forEach(this._removeItem,this),t.index<this._virtualStart){var e=Math.max(t.addedCount-t.removed.length,t.index-this._virtualStart);this._virtualStart=this._virtualStart+e,this._focusedVirtualIndex>=0&&(this._focusedVirtualIndex=this._focusedVirtualIndex+e)}}),this)},_removeItem:function(t){this.$.selector.deselect(t),this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===t&&this._removeFocusedItem()},_iterateItems:function(t,e){var n,i,r,o;if(2===arguments.length&&e){for(o=0;o<e.length;o++)if(i=this._computeVidx(n=e[o]),null!=(r=t.call(this,n,i)))return r}else{for(n=this._physicalStart,i=this._virtualStart;n<this._physicalCount;n++,i++)if(null!=(r=t.call(this,n,i)))return r;for(n=0;n<this._physicalStart;n++,i++)if(null!=(r=t.call(this,n,i)))return r}},_computeVidx:function(t){return t>=this._physicalStart?this._virtualStart+(t-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+t},_assignModels:function(t){this._iterateItems((function(t,e){var n=this._physicalItems[t],i=this.items&&this.items[e];if(null!=i){var r=this.modelForElement(n);r.__key__=null,this._forwardProperty(r,this.as,i),this._forwardProperty(r,this.selectedAs,this.$.selector.isSelected(i)),this._forwardProperty(r,this.indexAs,e),this._forwardProperty(r,"tabIndex",this._focusedVirtualIndex===e?0:-1),this._physicalIndexForKey[r.__key__]=t,r._flushProperties&&r._flushProperties(!0),n.removeAttribute("hidden")}else n.setAttribute("hidden","")}),t)},_updateMetrics:function(t){zi();var e=0,n=0,i=this._physicalAverageCount,r=this._physicalAverage;this._iterateItems((function(t,i){n+=this._physicalSizes[t],this._physicalSizes[t]=this._physicalItems[t].offsetHeight,e+=this._physicalSizes[t],this._physicalAverageCount+=this._physicalSizes[t]?1:0}),t),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(n=1===this._itemsPerRow?n:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+e-n,this._itemsPerRow=1),this._physicalAverageCount!==i&&(this._physicalAverage=Math.round((r*i+e)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=this._physicalCount>0?this._physicalItems[0].getBoundingClientRect().width:200,this._rowHeight=this._physicalCount>0?this._physicalItems[0].offsetHeight:200,this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var t=this._physicalTop;if(this.grid){var e=(this._viewportWidth-this._itemsPerRow*this._itemWidth)/2;this._iterateItems((function(n,i){var r=Math.floor(i%this._itemsPerRow*this._itemWidth+e);this._isRTL&&(r*=-1),this.translate3d(r+"px",t+"px",0,this._physicalItems[n]),this._shouldRenderNextRow(i)&&(t+=this._rowHeight)}))}else{const e=[];this._iterateItems((function(n,i){const r=this._physicalItems[n];this.translate3d(0,t+"px",0,r),t+=this._physicalSizes[n];const o=r.id;o&&e.push(o)})),e.length&&this.setAttribute("aria-owns",e.join(" "))}},_getPhysicalSizeIncrement:function(t){return this.grid?this._computeVidx(t)%this._itemsPerRow!=this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[t]},_shouldRenderNextRow:function(t){return t%this._itemsPerRow==this._itemsPerRow-1},_adjustScrollPosition:function(){var t=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(0!==t){this._physicalTop=this._physicalTop-t;var e=this._scrollPosition;!Bo&&e>0&&this._resetScrollPosition(e-t)}},_resetScrollPosition:function(t){this.scrollTarget&&t>=0&&(this._scrollTop=t,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(t){this._estScrollHeight=this.grid?this._virtualRowCount*this._rowHeight:this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,((t=(t=(t=t||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||this.grid&&this.$.items.style.height<this._estScrollHeight)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToItem:function(t){return this.scrollToIndex(this.items.indexOf(t))},scrollToIndex:function(t){if(!("number"!=typeof t||t<0||t>this.items.length-1)&&(zi(),0!==this._physicalCount)){t=this._clamp(t,0,this._virtualCount-1),(!this._isIndexRendered(t)||t>=this._maxVirtualStart)&&(this._virtualStart=this.grid?t-2*this._itemsPerRow:t-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var e=this._physicalStart,n=this._virtualStart,i=0,r=this._hiddenContentSize;n<t&&i<=r;)i+=this._getPhysicalSizeIncrement(e),e=(e+1)%this._physicalCount,n++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+i),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",(function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._isVisible?(this.updateViewportBoundaries(),this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)}),_t)},selectItem:function(t){return this.selectIndex(this.items.indexOf(t))},selectIndex:function(t){if(!(t<0||t>=this._virtualCount)){if(!this.multiSelection&&this.selectedItem&&this.clearSelection(),this._isIndexRendered(t)){var e=this.modelForElement(this._physicalItems[this._getPhysicalIndex(t)]);e&&(e[this.selectedAs]=!0),this.updateSizeForIndex(t)}this.$.selector.selectIndex(t)}},deselectItem:function(t){return this.deselectIndex(this.items.indexOf(t))},deselectIndex:function(t){t<0||t>=this._virtualCount||(this._isIndexRendered(t)&&(this.modelForElement(this._physicalItems[this._getPhysicalIndex(t)])[this.selectedAs]=!1,this.updateSizeForIndex(t)),this.$.selector.deselectIndex(t))},toggleSelectionForItem:function(t){return this.toggleSelectionForIndex(this.items.indexOf(t))},toggleSelectionForIndex:function(t){(this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(t):this.$.selector.isSelected(this.items[t]))?this.deselectIndex(t):this.selectIndex(t)},clearSelection:function(){this._iterateItems((function(t,e){this.modelForElement(this._physicalItems[t])[this.selectedAs]=!1})),this.$.selector.clearSelection()},_selectionEnabledChanged:function(t){(t?this.listen:this.unlisten).call(this,this,"tap","_selectionHandler")},_selectionHandler:function(t){var e=this.modelForElement(t.target);if(e){var n,i,r=qi(t).path[0],o=this._getActiveElement(),a=this._physicalItems[this._getPhysicalIndex(e[this.indexAs])];"input"!==r.localName&&"button"!==r.localName&&"select"!==r.localName&&(n=e.tabIndex,e.tabIndex=Fo,i=o?o.tabIndex:-1,e.tabIndex=n,o&&a!==o&&a.contains(o)&&i!==Fo||this.toggleSelectionForItem(e[this.as]))}},_multiSelectionChanged:function(t){this.clearSelection(),this.$.selector.multi=t},updateSizeForItem:function(t){return this.updateSizeForIndex(this.items.indexOf(t))},updateSizeForIndex:function(t){return this._isIndexRendered(t)?(this._updateMetrics([this._getPhysicalIndex(t)]),this._positionItems(),null):null},_manageFocus:function(){var t=this._focusedVirtualIndex;t>=0&&t<this._virtualCount?this._isIndexRendered(t)?this._restoreFocusedItem():this._createFocusBackfillItem():this._virtualCount>0&&this._physicalCount>0&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(t){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(t/this._itemsPerRow)*this._itemsPerRow:t},_isIndexRendered:function(t){return t>=this._virtualStart&&t<=this._virtualEnd},_isIndexVisible:function(t){return t>=this.firstVisibleIndex&&t<=this.lastVisibleIndex},_getPhysicalIndex:function(t){return(this._physicalStart+(t-this._virtualStart))%this._physicalCount},focusItem:function(t){this._focusPhysicalItem(t)},_focusPhysicalItem:function(t){if(!(t<0||t>=this._virtualCount)){this._restoreFocusedItem(),this._isIndexRendered(t)||this.scrollToIndex(t);var e,n=this._physicalItems[this._getPhysicalIndex(t)],i=this.modelForElement(n);i.tabIndex=Fo,n.tabIndex===Fo&&(e=n),e||(e=qi(n).querySelector('[tabindex="-100"]')),i.tabIndex=0,this._focusedVirtualIndex=t,e&&e.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem),this._offscreenFocusedItem=null,this._focusBackfillItem=null,this._focusedItem=null,this._focusedVirtualIndex=-1,this._focusedPhysicalIndex=-1},_createFocusBackfillItem:function(){var t=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||this._focusedVirtualIndex<0)){if(!this._focusBackfillItem){var e=this.stamp(null);this._focusBackfillItem=e.root.querySelector("*"),this._itemsParent.appendChild(e.root)}this._offscreenFocusedItem=this._physicalItems[t],this.modelForElement(this._offscreenFocusedItem).tabIndex=0,this._physicalItems[t]=this._focusBackfillItem,this._focusedPhysicalIndex=t,this.translate3d(0,Ho,0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(this._offscreenFocusedItem&&!(this._focusedVirtualIndex<0)){this._assignModels();var t=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),e=this._physicalItems[t];if(e){var n=this.modelForElement(e),i=this.modelForElement(this._offscreenFocusedItem);n[this.as]===i[this.as]?(this._focusBackfillItem=e,n.tabIndex=-1,this._physicalItems[t]=this._offscreenFocusedItem,this.translate3d(0,Ho,0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null),this._offscreenFocusedItem=null}}},_didFocus:function(t){var e=this.modelForElement(t.target),n=this.modelForElement(this._focusedItem),i=null!==this._offscreenFocusedItem,r=this._focusedVirtualIndex;e&&(n===e?this._isIndexVisible(r)||this.scrollToIndex(r):(this._restoreFocusedItem(),n&&(n.tabIndex=-1),e.tabIndex=0,this._focusedVirtualIndex=r=e[this.indexAs],this._focusedPhysicalIndex=this._getPhysicalIndex(r),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],i&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(t){switch(t.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&t.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex+(this.grid?this._itemsPerRow:1));break;case 39:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?-1:1));break;case 38:this._focusedVirtualIndex>0&&t.preventDefault(),this._focusPhysicalItem(this._focusedVirtualIndex-(this.grid?this._itemsPerRow:1));break;case 37:this.grid&&this._focusPhysicalItem(this._focusedVirtualIndex+(this._isRTL?1:-1));break;case 13:this._focusPhysicalItem(this._focusedVirtualIndex),this.selectionEnabled&&this._selectionHandler(t)}},_clamp:function(t,e,n){return Math.min(n,Math.max(e,t))},_debounce:function(t,e,n){this._debouncers=this._debouncers||{},this._debouncers[t]=En.debounce(this._debouncers[t],n,e.bind(this)),An(this._debouncers[t])},_forwardProperty:function(t,e,n){t._setPendingProperty(e,n)},_forwardHostPropV2:function(t,e){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach((function(n){n&&this.modelForElement(n).forwardHostProp(t,e)}),this)},_notifyInstancePropV2:function(t,e,n){if(Q(this.as,e)){var i=t[this.indexAs];e==this.as&&(this.items[i]=n),this.notifyPath(J(this.as,"items."+i,e),n)}},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(t,e,n){0===e.indexOf(this.as+".")&&this.notifyPath("items."+t.__key__+"."+e.slice(this.as.length+1),n)},_forwardParentPath:function(t,e){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach((function(n){n&&this.modelForElement(n).notifyPath(t,e)}),this)},_forwardParentProp:function(t,e){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach((function(n){n&&(this.modelForElement(n)[t]=e)}),this)},_getActiveElement:function(){var t=this._itemsParent.node.domHost;return qi(t?t.root:document).activeElement}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
class Vo{constructor(t){this.selection=[],this.selectCallback=t}get(){return this.multi?this.selection.slice():this.selection[0]}clear(t){this.selection.slice().forEach((function(e){(!t||t.indexOf(e)<0)&&this.setItemSelected(e,!1)}),this)}isSelected(t){return this.selection.indexOf(t)>=0}setItemSelected(t,e){if(null!=t&&e!==this.isSelected(t)){if(e)this.selection.push(t);else{var n=this.selection.indexOf(t);n>=0&&this.selection.splice(n,1)}this.selectCallback&&this.selectCallback(t,e)}}select(t){this.multi?this.toggle(t):this.get()!==t&&(this.setItemSelected(this.get(),!1),this.setItemSelected(t,!0))}toggle(t){this.setItemSelected(t,!this.isSelected(t))}}
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */const jo={properties:{attrForSelected:{type:String,value:null},selected:{type:String,notify:!0},selectedItem:{type:Object,readOnly:!0,notify:!0},activateEvent:{type:String,value:"tap",observer:"_activateEventChanged"},selectable:String,selectedClass:{type:String,value:"iron-selected"},selectedAttribute:{type:String,value:null},fallbackSelection:{type:String,value:null},items:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}},_excludedLocalNames:{type:Object,value:function(){return{template:1,"dom-bind":1,"dom-if":1,"dom-repeat":1}}}},observers:["_updateAttrForSelected(attrForSelected)","_updateSelected(selected)","_checkFallback(fallbackSelection)"],created:function(){this._bindFilterItem=this._filterItem.bind(this),this._selection=new Vo(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this),this._addListener(this.activateEvent)},detached:function(){this._observer&&qi(this).unobserveNodes(this._observer),this._removeListener(this.activateEvent)},indexOf:function(t){return this.items?this.items.indexOf(t):-1},select:function(t){this.selected=t},selectPrevious:function(){var t=this.items.length,e=t-1;void 0!==this.selected&&(e=(Number(this._valueToIndex(this.selected))-1+t)%t),this.selected=this._indexToValue(e)},selectNext:function(){var t=0;void 0!==this.selected&&(t=(Number(this._valueToIndex(this.selected))+1)%this.items.length),this.selected=this._indexToValue(t)},selectIndex:function(t){this.select(this._indexToValue(t))},forceSynchronousItemUpdate:function(){this._observer&&"function"==typeof this._observer.flush?this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return null!=this.selected},_checkFallback:function(){this._updateSelected()},_addListener:function(t){this.listen(this,t,"_activateHandler")},_removeListener:function(t){this.unlisten(this,t,"_activateHandler")},_activateEventChanged:function(t,e){this._removeListener(e),this._addListener(t)},_updateItems:function(){var t=qi(this).queryDistributedElements(this.selectable||"*");t=Array.prototype.filter.call(t,this._bindFilterItem),this._setItems(t)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(t){if(this.items){var e=this._valueToItem(this.selected);e?this._selection.select(e):this._selection.clear(),this.fallbackSelection&&this.items.length&&void 0===this._selection.get()&&(this.selected=this.fallbackSelection)}},_filterItem:function(t){return!this._excludedLocalNames[t.localName]},_valueToItem:function(t){return null==t?null:this.items[this._valueToIndex(t)]},_valueToIndex:function(t){if(!this.attrForSelected)return Number(t);for(var e,n=0;e=this.items[n];n++)if(this._valueForItem(e)==t)return n},_indexToValue:function(t){if(!this.attrForSelected)return t;var e=this.items[t];return e?this._valueForItem(e):void 0},_valueForItem:function(t){if(!t)return null;if(!this.attrForSelected){var e=this.indexOf(t);return-1===e?null:e}var n=t[st(this.attrForSelected)];return null!=n?n:t.getAttribute(this.attrForSelected)},_applySelection:function(t,e){this.selectedClass&&this.toggleClass(this.selectedClass,e,t),this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,e,t),this._selectionChange(),this.fire("iron-"+(e?"select":"deselect"),{item:t})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(t){return qi(t).observeNodes((function(t){this._updateItems(),this._updateSelected(),this.fire("iron-items-changed",t,{bubbles:!1,cancelable:!1})}))},_activateHandler:function(t){for(var e=t.target,n=this.items;e&&e!=this;){var i=n.indexOf(e);if(i>=0){var r=this._indexToValue(i);return void this._itemActivate(r,e)}e=e.parentNode}},_itemActivate:function(t,e){this.fire("iron-activate",{selected:t,item:e},{cancelable:!0}).defaultPrevented||this.select(t)}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({_template:_e`
    <style>
      :host {
        display: block;
      }

      :host > ::slotted(:not(slot):not(.iron-selected)) {
        display: none !important;
      }
    </style>

    <slot></slot>
`,is:"iron-pages",behaviors:[mo,jo],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(t,e){this.async(this.notifyResize)}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Uo=_e`
<custom-style>
  <style is="custom-style">
    html {

      --shadow-transition: {
        transition: box-shadow 0.28s cubic-bezier(0.4, 0, 0.2, 1);
      };

      --shadow-none: {
        box-shadow: none;
      };

      /* from http://codepen.io/shyndman/pen/c5394ddf2e8b2a5c9185904b57421cdb */

      --shadow-elevation-2dp: {
        box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14),
                    0 1px 5px 0 rgba(0, 0, 0, 0.12),
                    0 3px 1px -2px rgba(0, 0, 0, 0.2);
      };

      --shadow-elevation-3dp: {
        box-shadow: 0 3px 4px 0 rgba(0, 0, 0, 0.14),
                    0 1px 8px 0 rgba(0, 0, 0, 0.12),
                    0 3px 3px -2px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-4dp: {
        box-shadow: 0 4px 5px 0 rgba(0, 0, 0, 0.14),
                    0 1px 10px 0 rgba(0, 0, 0, 0.12),
                    0 2px 4px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-6dp: {
        box-shadow: 0 6px 10px 0 rgba(0, 0, 0, 0.14),
                    0 1px 18px 0 rgba(0, 0, 0, 0.12),
                    0 3px 5px -1px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-8dp: {
        box-shadow: 0 8px 10px 1px rgba(0, 0, 0, 0.14),
                    0 3px 14px 2px rgba(0, 0, 0, 0.12),
                    0 5px 5px -3px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-12dp: {
        box-shadow: 0 12px 16px 1px rgba(0, 0, 0, 0.14),
                    0 4px 22px 3px rgba(0, 0, 0, 0.12),
                    0 6px 7px -4px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-16dp: {
        box-shadow: 0 16px 24px 2px rgba(0, 0, 0, 0.14),
                    0  6px 30px 5px rgba(0, 0, 0, 0.12),
                    0  8px 10px -5px rgba(0, 0, 0, 0.4);
      };

      --shadow-elevation-24dp: {
        box-shadow: 0 24px 38px 3px rgba(0, 0, 0, 0.14),
                    0 9px 46px 8px rgba(0, 0, 0, 0.12),
                    0 11px 15px -7px rgba(0, 0, 0, 0.4);
      };
    }
  </style>
</custom-style>`;Uo.setAttribute("style","display: none;"),document.head.appendChild(Uo.content);
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Go=_e`
<dom-module id="paper-material-styles">
  <template>
    <style>
      html {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      .paper-material {
        @apply --paper-material;
      }
      .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }

      /* Duplicate the styles because of https://github.com/webcomponents/shadycss/issues/193 */
      :host {
        --paper-material: {
          display: block;
          position: relative;
        };
        --paper-material-elevation-1: {
          @apply --shadow-elevation-2dp;
        };
        --paper-material-elevation-2: {
          @apply --shadow-elevation-4dp;
        };
        --paper-material-elevation-3: {
          @apply --shadow-elevation-6dp;
        };
        --paper-material-elevation-4: {
          @apply --shadow-elevation-8dp;
        };
        --paper-material-elevation-5: {
          @apply --shadow-elevation-16dp;
        };
      }
      :host(.paper-material) {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]) {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]) {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]) {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]) {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]) {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>`;Go.setAttribute("style","display: none;"),document.head.appendChild(Go.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Wo={properties:{focused:{type:Boolean,value:!1,notify:!0,readOnly:!0,reflectToAttribute:!0},disabled:{type:Boolean,value:!1,notify:!0,observer:"_disabledChanged",reflectToAttribute:!0},_oldTabIndex:{type:String},_boundFocusBlurHandler:{type:Function,value:function(){return this._focusBlurHandler.bind(this)}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",this._boundFocusBlurHandler,!0),this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(t){this._setFocused("focus"===t.type)},_disabledChanged:function(t,e){this.setAttribute("aria-disabled",t?"true":"false"),this.style.pointerEvents=t?"none":"",t?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):void 0!==this._oldTabIndex&&(null===this._oldTabIndex?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}},qo={properties:{pressed:{type:Boolean,readOnly:!0,value:!1,reflectToAttribute:!0,observer:"_pressedChanged"},toggles:{type:Boolean,value:!1,reflectToAttribute:!0},active:{type:Boolean,value:!1,notify:!0,reflectToAttribute:!0},pointerDown:{type:Boolean,readOnly:!0,value:!1},receivedFocusFromKeyboard:{type:Boolean,readOnly:!0},ariaActiveAttribute:{type:String,value:"aria-pressed",observer:"_ariaActiveAttributeChanged"}},listeners:{down:"_downHandler",up:"_upHandler",tap:"_tapHandler"},observers:["_focusChanged(focused)","_activeChanged(active, ariaActiveAttribute)"],keyBindings:{"enter:keydown":"_asyncClick","space:keydown":"_spaceKeyDownHandler","space:keyup":"_spaceKeyUpHandler"},_mouseEventRe:/^mouse/,_tapHandler:function(){this.toggles?this._userActivate(!this.active):this.active=!1},_focusChanged:function(t){this._detectKeyboardFocus(t),t||this._setPressed(!1)},_detectKeyboardFocus:function(t){this._setReceivedFocusFromKeyboard(!this.pointerDown&&t)},_userActivate:function(t){this.active!==t&&(this.active=t,this.fire("change"))},_downHandler:function(t){this._setPointerDown(!0),this._setPressed(!0),this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1),this._setPressed(!1)},_spaceKeyDownHandler:function(t){var e=t.detail.keyboardEvent,n=qi(e).localTarget;this.isLightDescendant(n)||(e.preventDefault(),e.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(t){var e=qi(t.detail.keyboardEvent).localTarget;this.isLightDescendant(e)||(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async((function(){this.click()}),1)},_pressedChanged:function(t){this._changedButtonState()},_ariaActiveAttributeChanged:function(t,e){e&&e!=t&&this.hasAttribute(e)&&this.removeAttribute(e)},_activeChanged:function(t,e){this.toggles?this.setAttribute(this.ariaActiveAttribute,t?"true":"false"):this.removeAttribute(this.ariaActiveAttribute),this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}},Yo=[Ro,qo];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var Xo={distance:function(t,e,n,i){var r=t-n,o=e-i;return Math.sqrt(r*r+o*o)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};function $o(t){this.element=t,this.width=this.boundingRect.width,this.height=this.boundingRect.height,this.size=Math.max(this.width,this.height)}function Ko(t){this.element=t,this.color=window.getComputedStyle(t).color,this.wave=document.createElement("div"),this.waveContainer=document.createElement("div"),this.wave.style.backgroundColor=this.color,this.wave.classList.add("wave"),this.waveContainer.classList.add("wave-container"),qi(this.waveContainer).appendChild(this.wave),this.resetInteractionState()}$o.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(t,e){var n=Xo.distance(t,e,0,0),i=Xo.distance(t,e,this.width,0),r=Xo.distance(t,e,0,this.height),o=Xo.distance(t,e,this.width,this.height);return Math.max(n,i,r,o)}},Ko.MAX_RADIUS=300,Ko.prototype={get recenters(){return this.element.recenters},get center(){return this.element.center},get mouseDownElapsed(){var t;return this.mouseDownStart?(t=Xo.now()-this.mouseDownStart,this.mouseUpStart&&(t-=this.mouseUpElapsed),t):0},get mouseUpElapsed(){return this.mouseUpStart?Xo.now()-this.mouseUpStart:0},get mouseDownElapsedSeconds(){return this.mouseDownElapsed/1e3},get mouseUpElapsedSeconds(){return this.mouseUpElapsed/1e3},get mouseInteractionSeconds(){return this.mouseDownElapsedSeconds+this.mouseUpElapsedSeconds},get initialOpacity(){return this.element.initialOpacity},get opacityDecayVelocity(){return this.element.opacityDecayVelocity},get radius(){var t=1.1*Math.min(Math.sqrt(this.containerMetrics.width*this.containerMetrics.width+this.containerMetrics.height*this.containerMetrics.height),Ko.MAX_RADIUS)+5,e=t*(1-Math.pow(80,-this.mouseInteractionSeconds/(1.1-t/Ko.MAX_RADIUS*.2)));return Math.abs(e)},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){return Math.max(0,Math.min(.3*this.mouseUpElapsedSeconds,this.opacity))},get isOpacityFullyDecayed(){return this.opacity<.01&&this.radius>=Math.min(this.maxRadius,Ko.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,Ko.MAX_RADIUS)},get isAnimationComplete(){return this.mouseUpStart?this.isOpacityFullyDecayed:this.isRestingAtMaxRadius},get translationFraction(){return Math.min(1,this.radius/this.containerMetrics.size*2/Math.sqrt(2))},get xNow(){return this.xEnd?this.xStart+this.translationFraction*(this.xEnd-this.xStart):this.xStart},get yNow(){return this.yEnd?this.yStart+this.translationFraction*(this.yEnd-this.yStart):this.yStart},get isMouseDown(){return this.mouseDownStart&&!this.mouseUpStart},resetInteractionState:function(){this.maxRadius=0,this.mouseDownStart=0,this.mouseUpStart=0,this.xStart=0,this.yStart=0,this.xEnd=0,this.yEnd=0,this.slideDistance=0,this.containerMetrics=new $o(this.element)},draw:function(){var t,e,n;this.wave.style.opacity=this.opacity,t=this.radius/(this.containerMetrics.size/2),this.waveContainer.style.webkitTransform="translate("+(e=this.xNow-this.containerMetrics.width/2)+"px, "+(n=this.yNow-this.containerMetrics.height/2)+"px)",this.waveContainer.style.transform="translate3d("+e+"px, "+n+"px, 0)",this.wave.style.webkitTransform="scale("+t+","+t+")",this.wave.style.transform="scale3d("+t+","+t+",1)"},downAction:function(t){var e=this.containerMetrics.width/2,n=this.containerMetrics.height/2;this.resetInteractionState(),this.mouseDownStart=Xo.now(),this.center?(this.xStart=e,this.yStart=n,this.slideDistance=Xo.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=t?t.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=t?t.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2),this.recenters&&(this.xEnd=e,this.yEnd=n,this.slideDistance=Xo.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)),this.maxRadius=this.containerMetrics.furthestCornerDistanceFrom(this.xStart,this.yStart),this.waveContainer.style.top=(this.containerMetrics.height-this.containerMetrics.size)/2+"px",this.waveContainer.style.left=(this.containerMetrics.width-this.containerMetrics.size)/2+"px",this.waveContainer.style.width=this.containerMetrics.size+"px",this.waveContainer.style.height=this.containerMetrics.size+"px"},upAction:function(t){this.isMouseDown&&(this.mouseUpStart=Xo.now())},remove:function(){qi(qi(this.waveContainer).parentNode).removeChild(this.waveContainer)}},Nr({_template:_e`
    <style>
      :host {
        display: block;
        position: absolute;
        border-radius: inherit;
        overflow: hidden;
        top: 0;
        left: 0;
        right: 0;
        bottom: 0;

        /* See PolymerElements/paper-behaviors/issues/34. On non-Chrome browsers,
         * creating a node (with a position:absolute) in the middle of an event
         * handler "interrupts" that event handler (which happens when the
         * ripple is created on demand) */
        pointer-events: none;
      }

      :host([animating]) {
        /* This resolves a rendering issue in Chrome (as of 40) where the
           ripple is not properly clipped by its parent (which may have
           rounded corners). See: http://jsbin.com/temexa/4

           Note: We only apply this style conditionally. Otherwise, the browser
           will create a new compositing layer for every ripple element on the
           page, and that would be bad. */
        -webkit-transform: translate(0, 0);
        transform: translate3d(0, 0, 0);
      }

      #background,
      #waves,
      .wave-container,
      .wave {
        pointer-events: none;
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
      }

      #background,
      .wave {
        opacity: 0;
      }

      #waves,
      .wave {
        overflow: hidden;
      }

      .wave-container,
      .wave {
        border-radius: 50%;
      }

      :host(.circle) #background,
      :host(.circle) #waves {
        border-radius: 50%;
      }

      :host(.circle) .wave-container {
        overflow: hidden;
      }
    </style>

    <div id="background"></div>
    <div id="waves"></div>
`,is:"paper-ripple",behaviors:[Ro],properties:{initialOpacity:{type:Number,value:.25},opacityDecayVelocity:{type:Number,value:.8},recenters:{type:Boolean,value:!1},center:{type:Boolean,value:!1},ripples:{type:Array,value:function(){return[]}},animating:{type:Boolean,readOnly:!0,reflectToAttribute:!0,value:!1},holdDown:{type:Boolean,value:!1,observer:"_holdDownChanged"},noink:{type:Boolean,value:!1},_animating:{type:Boolean},_boundAnimate:{type:Function,value:function(){return this.animate.bind(this)}}},get target(){return this.keyEventTarget},keyBindings:{"enter:keydown":"_onEnterKeydown","space:keydown":"_onSpaceKeydown","space:keyup":"_onSpaceKeyup"},attached:function(){this.keyEventTarget=11==qi(this).parentNode.nodeType?qi(this).getOwnerRoot().host:qi(this).parentNode;var t=this.keyEventTarget;this.listen(t,"up","uiUpAction"),this.listen(t,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction"),this.unlisten(this.keyEventTarget,"down","uiDownAction"),this.keyEventTarget=null},get shouldKeepAnimating(){for(var t=0;t<this.ripples.length;++t)if(!this.ripples[t].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null),this.async((function(){this.upAction()}),1)},uiDownAction:function(t){this.noink||this.downAction(t)},downAction:function(t){this.holdDown&&this.ripples.length>0||(this.addRipple().downAction(t),this._animating||(this._animating=!0,this.animate()))},uiUpAction:function(t){this.noink||this.upAction(t)},upAction:function(t){this.holdDown||(this.ripples.forEach((function(e){e.upAction(t)})),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1,this.$.background.style.backgroundColor="",this.fire("transitionend")},addRipple:function(){var t=new Ko(this);return qi(this.$.waves).appendChild(t.waveContainer),this.$.background.style.backgroundColor=t.color,this.ripples.push(t),this._setAnimating(!0),t},removeRipple:function(t){var e=this.ripples.indexOf(t);e<0||(this.ripples.splice(e,1),t.remove(),this.ripples.length||this._setAnimating(!1))},animate:function(){if(this._animating){var t,e;for(t=0;t<this.ripples.length;++t)(e=this.ripples[t]).draw(),this.$.background.style.opacity=e.outerOpacity,e.isOpacityFullyDecayed&&!e.isRestingAtMaxRadius&&this.removeRipple(e);this.shouldKeepAnimating||0!==this.ripples.length?window.requestAnimationFrame(this._boundAnimate):this.onAnimationComplete()}},animateRipple:function(){return this.animate()},_onEnterKeydown:function(){this.uiDownAction(),this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(t,e){void 0!==e&&(t?this.downAction():this.upAction())}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Zo={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(t){qo._downHandler.call(this,t),this.pressed&&this.ensureRipple(t)},ensureRipple:function(t){if(!this.hasRipple()){this._ripple=this._createRipple(),this._ripple.noink=this.noink;var e=this._rippleContainer||this.root;if(e&&qi(e).appendChild(this._ripple),t){var n=qi(this._rippleContainer||this),i=qi(t).rootTarget;n.deepContains(i)&&this._ripple.uiDownAction(t)}}},getRipple:function(){return this.ensureRipple(),this._ripple},hasRipple:function(){return Boolean(this._ripple)},_createRipple:function(){return document.createElement("paper-ripple")},_noinkChanged:function(t){this.hasRipple()&&(this._ripple.noink=t)}},Jo={properties:{elevation:{type:Number,reflectToAttribute:!0,readOnly:!0}},observers:["_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)","_computeKeyboardClass(receivedFocusFromKeyboard)"],hostAttributes:{role:"button",tabindex:"0",animated:!0},_calculateElevation:function(){var t=1;this.disabled?t=0:this.active||this.pressed?t=4:this.receivedFocusFromKeyboard&&(t=3),this._setElevation(t)},_computeKeyboardClass:function(t){this.toggleClass("keyboard-focus",t)},_spaceKeyDownHandler:function(t){qo._spaceKeyDownHandler.call(this,t),this.hasRipple()&&this.getRipple().ripples.length<1&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(t){qo._spaceKeyUpHandler.call(this,t),this.hasRipple()&&this._ripple.uiUpAction()}},Qo=[Yo,Wo,Zo,Jo],ta=_e`
  <style include="paper-material-styles">
    /* Need to specify the same specificity as the styles imported from paper-material. */
    :host {
      @apply --layout-inline;
      @apply --layout-center-center;
      position: relative;
      box-sizing: border-box;
      min-width: 5.14em;
      margin: 0 0.29em;
      background: transparent;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      -webkit-tap-highlight-color: transparent;
      font: inherit;
      text-transform: uppercase;
      outline-width: 0;
      border-radius: 3px;
      -moz-user-select: none;
      -ms-user-select: none;
      -webkit-user-select: none;
      user-select: none;
      cursor: pointer;
      z-index: 0;
      padding: 0.7em 0.57em;

      @apply --paper-font-common-base;
      @apply --paper-button;
    }

    :host([elevation="1"]) {
      @apply --paper-material-elevation-1;
    }

    :host([elevation="2"]) {
      @apply --paper-material-elevation-2;
    }

    :host([elevation="3"]) {
      @apply --paper-material-elevation-3;
    }

    :host([elevation="4"]) {
      @apply --paper-material-elevation-4;
    }

    :host([elevation="5"]) {
      @apply --paper-material-elevation-5;
    }

    :host([hidden]) {
      display: none !important;
    }

    :host([raised].keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-raised-keyboard-focus;
    }

    :host(:not([raised]).keyboard-focus) {
      font-weight: bold;
      @apply --paper-button-flat-keyboard-focus;
    }

    :host([disabled]) {
      background: none;
      color: #a8a8a8;
      cursor: auto;
      pointer-events: none;

      @apply --paper-button-disabled;
    }

    :host([disabled][raised]) {
      background: #eaeaea;
    }


    :host([animated]) {
      @apply --shadow-transition;
    }

    paper-ripple {
      color: var(--paper-button-ink-color);
    }
  </style>

  <slot></slot>`;
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */ta.setAttribute("strip-whitespace",""),Nr({_template:ta,is:"paper-button",behaviors:[Qo],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?Jo._calculateElevation.apply(this):this._setElevation(0)}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const ea=_e`
<custom-style>
  <style is="custom-style">
    html {

      /* Material Design color palette for Google products */

      --google-red-100: #f4c7c3;
      --google-red-300: #e67c73;
      --google-red-500: #db4437;
      --google-red-700: #c53929;

      --google-blue-100: #c6dafc;
      --google-blue-300: #7baaf7;
      --google-blue-500: #4285f4;
      --google-blue-700: #3367d6;

      --google-green-100: #b7e1cd;
      --google-green-300: #57bb8a;
      --google-green-500: #0f9d58;
      --google-green-700: #0b8043;

      --google-yellow-100: #fce8b2;
      --google-yellow-300: #f7cb4d;
      --google-yellow-500: #f4b400;
      --google-yellow-700: #f09300;

      --google-grey-100: #f5f5f5;
      --google-grey-300: #e0e0e0;
      --google-grey-500: #9e9e9e;
      --google-grey-700: #616161;

      /* Material Design color palette from online spec document */

      --paper-red-50: #ffebee;
      --paper-red-100: #ffcdd2;
      --paper-red-200: #ef9a9a;
      --paper-red-300: #e57373;
      --paper-red-400: #ef5350;
      --paper-red-500: #f44336;
      --paper-red-600: #e53935;
      --paper-red-700: #d32f2f;
      --paper-red-800: #c62828;
      --paper-red-900: #b71c1c;
      --paper-red-a100: #ff8a80;
      --paper-red-a200: #ff5252;
      --paper-red-a400: #ff1744;
      --paper-red-a700: #d50000;

      --paper-pink-50: #fce4ec;
      --paper-pink-100: #f8bbd0;
      --paper-pink-200: #f48fb1;
      --paper-pink-300: #f06292;
      --paper-pink-400: #ec407a;
      --paper-pink-500: #e91e63;
      --paper-pink-600: #d81b60;
      --paper-pink-700: #c2185b;
      --paper-pink-800: #ad1457;
      --paper-pink-900: #880e4f;
      --paper-pink-a100: #ff80ab;
      --paper-pink-a200: #ff4081;
      --paper-pink-a400: #f50057;
      --paper-pink-a700: #c51162;

      --paper-purple-50: #f3e5f5;
      --paper-purple-100: #e1bee7;
      --paper-purple-200: #ce93d8;
      --paper-purple-300: #ba68c8;
      --paper-purple-400: #ab47bc;
      --paper-purple-500: #9c27b0;
      --paper-purple-600: #8e24aa;
      --paper-purple-700: #7b1fa2;
      --paper-purple-800: #6a1b9a;
      --paper-purple-900: #4a148c;
      --paper-purple-a100: #ea80fc;
      --paper-purple-a200: #e040fb;
      --paper-purple-a400: #d500f9;
      --paper-purple-a700: #aa00ff;

      --paper-deep-purple-50: #ede7f6;
      --paper-deep-purple-100: #d1c4e9;
      --paper-deep-purple-200: #b39ddb;
      --paper-deep-purple-300: #9575cd;
      --paper-deep-purple-400: #7e57c2;
      --paper-deep-purple-500: #673ab7;
      --paper-deep-purple-600: #5e35b1;
      --paper-deep-purple-700: #512da8;
      --paper-deep-purple-800: #4527a0;
      --paper-deep-purple-900: #311b92;
      --paper-deep-purple-a100: #b388ff;
      --paper-deep-purple-a200: #7c4dff;
      --paper-deep-purple-a400: #651fff;
      --paper-deep-purple-a700: #6200ea;

      --paper-indigo-50: #e8eaf6;
      --paper-indigo-100: #c5cae9;
      --paper-indigo-200: #9fa8da;
      --paper-indigo-300: #7986cb;
      --paper-indigo-400: #5c6bc0;
      --paper-indigo-500: #3f51b5;
      --paper-indigo-600: #3949ab;
      --paper-indigo-700: #303f9f;
      --paper-indigo-800: #283593;
      --paper-indigo-900: #1a237e;
      --paper-indigo-a100: #8c9eff;
      --paper-indigo-a200: #536dfe;
      --paper-indigo-a400: #3d5afe;
      --paper-indigo-a700: #304ffe;

      --paper-blue-50: #e3f2fd;
      --paper-blue-100: #bbdefb;
      --paper-blue-200: #90caf9;
      --paper-blue-300: #64b5f6;
      --paper-blue-400: #42a5f5;
      --paper-blue-500: #2196f3;
      --paper-blue-600: #1e88e5;
      --paper-blue-700: #1976d2;
      --paper-blue-800: #1565c0;
      --paper-blue-900: #0d47a1;
      --paper-blue-a100: #82b1ff;
      --paper-blue-a200: #448aff;
      --paper-blue-a400: #2979ff;
      --paper-blue-a700: #2962ff;

      --paper-light-blue-50: #e1f5fe;
      --paper-light-blue-100: #b3e5fc;
      --paper-light-blue-200: #81d4fa;
      --paper-light-blue-300: #4fc3f7;
      --paper-light-blue-400: #29b6f6;
      --paper-light-blue-500: #03a9f4;
      --paper-light-blue-600: #039be5;
      --paper-light-blue-700: #0288d1;
      --paper-light-blue-800: #0277bd;
      --paper-light-blue-900: #01579b;
      --paper-light-blue-a100: #80d8ff;
      --paper-light-blue-a200: #40c4ff;
      --paper-light-blue-a400: #00b0ff;
      --paper-light-blue-a700: #0091ea;

      --paper-cyan-50: #e0f7fa;
      --paper-cyan-100: #b2ebf2;
      --paper-cyan-200: #80deea;
      --paper-cyan-300: #4dd0e1;
      --paper-cyan-400: #26c6da;
      --paper-cyan-500: #00bcd4;
      --paper-cyan-600: #00acc1;
      --paper-cyan-700: #0097a7;
      --paper-cyan-800: #00838f;
      --paper-cyan-900: #006064;
      --paper-cyan-a100: #84ffff;
      --paper-cyan-a200: #18ffff;
      --paper-cyan-a400: #00e5ff;
      --paper-cyan-a700: #00b8d4;

      --paper-teal-50: #e0f2f1;
      --paper-teal-100: #b2dfdb;
      --paper-teal-200: #80cbc4;
      --paper-teal-300: #4db6ac;
      --paper-teal-400: #26a69a;
      --paper-teal-500: #009688;
      --paper-teal-600: #00897b;
      --paper-teal-700: #00796b;
      --paper-teal-800: #00695c;
      --paper-teal-900: #004d40;
      --paper-teal-a100: #a7ffeb;
      --paper-teal-a200: #64ffda;
      --paper-teal-a400: #1de9b6;
      --paper-teal-a700: #00bfa5;

      --paper-green-50: #e8f5e9;
      --paper-green-100: #c8e6c9;
      --paper-green-200: #a5d6a7;
      --paper-green-300: #81c784;
      --paper-green-400: #66bb6a;
      --paper-green-500: #4caf50;
      --paper-green-600: #43a047;
      --paper-green-700: #388e3c;
      --paper-green-800: #2e7d32;
      --paper-green-900: #1b5e20;
      --paper-green-a100: #b9f6ca;
      --paper-green-a200: #69f0ae;
      --paper-green-a400: #00e676;
      --paper-green-a700: #00c853;

      --paper-light-green-50: #f1f8e9;
      --paper-light-green-100: #dcedc8;
      --paper-light-green-200: #c5e1a5;
      --paper-light-green-300: #aed581;
      --paper-light-green-400: #9ccc65;
      --paper-light-green-500: #8bc34a;
      --paper-light-green-600: #7cb342;
      --paper-light-green-700: #689f38;
      --paper-light-green-800: #558b2f;
      --paper-light-green-900: #33691e;
      --paper-light-green-a100: #ccff90;
      --paper-light-green-a200: #b2ff59;
      --paper-light-green-a400: #76ff03;
      --paper-light-green-a700: #64dd17;

      --paper-lime-50: #f9fbe7;
      --paper-lime-100: #f0f4c3;
      --paper-lime-200: #e6ee9c;
      --paper-lime-300: #dce775;
      --paper-lime-400: #d4e157;
      --paper-lime-500: #cddc39;
      --paper-lime-600: #c0ca33;
      --paper-lime-700: #afb42b;
      --paper-lime-800: #9e9d24;
      --paper-lime-900: #827717;
      --paper-lime-a100: #f4ff81;
      --paper-lime-a200: #eeff41;
      --paper-lime-a400: #c6ff00;
      --paper-lime-a700: #aeea00;

      --paper-yellow-50: #fffde7;
      --paper-yellow-100: #fff9c4;
      --paper-yellow-200: #fff59d;
      --paper-yellow-300: #fff176;
      --paper-yellow-400: #ffee58;
      --paper-yellow-500: #ffeb3b;
      --paper-yellow-600: #fdd835;
      --paper-yellow-700: #fbc02d;
      --paper-yellow-800: #f9a825;
      --paper-yellow-900: #f57f17;
      --paper-yellow-a100: #ffff8d;
      --paper-yellow-a200: #ffff00;
      --paper-yellow-a400: #ffea00;
      --paper-yellow-a700: #ffd600;

      --paper-amber-50: #fff8e1;
      --paper-amber-100: #ffecb3;
      --paper-amber-200: #ffe082;
      --paper-amber-300: #ffd54f;
      --paper-amber-400: #ffca28;
      --paper-amber-500: #ffc107;
      --paper-amber-600: #ffb300;
      --paper-amber-700: #ffa000;
      --paper-amber-800: #ff8f00;
      --paper-amber-900: #ff6f00;
      --paper-amber-a100: #ffe57f;
      --paper-amber-a200: #ffd740;
      --paper-amber-a400: #ffc400;
      --paper-amber-a700: #ffab00;

      --paper-orange-50: #fff3e0;
      --paper-orange-100: #ffe0b2;
      --paper-orange-200: #ffcc80;
      --paper-orange-300: #ffb74d;
      --paper-orange-400: #ffa726;
      --paper-orange-500: #ff9800;
      --paper-orange-600: #fb8c00;
      --paper-orange-700: #f57c00;
      --paper-orange-800: #ef6c00;
      --paper-orange-900: #e65100;
      --paper-orange-a100: #ffd180;
      --paper-orange-a200: #ffab40;
      --paper-orange-a400: #ff9100;
      --paper-orange-a700: #ff6500;

      --paper-deep-orange-50: #fbe9e7;
      --paper-deep-orange-100: #ffccbc;
      --paper-deep-orange-200: #ffab91;
      --paper-deep-orange-300: #ff8a65;
      --paper-deep-orange-400: #ff7043;
      --paper-deep-orange-500: #ff5722;
      --paper-deep-orange-600: #f4511e;
      --paper-deep-orange-700: #e64a19;
      --paper-deep-orange-800: #d84315;
      --paper-deep-orange-900: #bf360c;
      --paper-deep-orange-a100: #ff9e80;
      --paper-deep-orange-a200: #ff6e40;
      --paper-deep-orange-a400: #ff3d00;
      --paper-deep-orange-a700: #dd2c00;

      --paper-brown-50: #efebe9;
      --paper-brown-100: #d7ccc8;
      --paper-brown-200: #bcaaa4;
      --paper-brown-300: #a1887f;
      --paper-brown-400: #8d6e63;
      --paper-brown-500: #795548;
      --paper-brown-600: #6d4c41;
      --paper-brown-700: #5d4037;
      --paper-brown-800: #4e342e;
      --paper-brown-900: #3e2723;

      --paper-grey-50: #fafafa;
      --paper-grey-100: #f5f5f5;
      --paper-grey-200: #eeeeee;
      --paper-grey-300: #e0e0e0;
      --paper-grey-400: #bdbdbd;
      --paper-grey-500: #9e9e9e;
      --paper-grey-600: #757575;
      --paper-grey-700: #616161;
      --paper-grey-800: #424242;
      --paper-grey-900: #212121;

      --paper-blue-grey-50: #eceff1;
      --paper-blue-grey-100: #cfd8dc;
      --paper-blue-grey-200: #b0bec5;
      --paper-blue-grey-300: #90a4ae;
      --paper-blue-grey-400: #78909c;
      --paper-blue-grey-500: #607d8b;
      --paper-blue-grey-600: #546e7a;
      --paper-blue-grey-700: #455a64;
      --paper-blue-grey-800: #37474f;
      --paper-blue-grey-900: #263238;

      /* opacity for dark text on a light background */
      --dark-divider-opacity: 0.12;
      --dark-disabled-opacity: 0.38; /* or hint text or icon */
      --dark-secondary-opacity: 0.54;
      --dark-primary-opacity: 0.87;

      /* opacity for light text on a dark background */
      --light-divider-opacity: 0.12;
      --light-disabled-opacity: 0.3; /* or hint text or icon */
      --light-secondary-opacity: 0.7;
      --light-primary-opacity: 1.0;

    }

  </style>
</custom-style>
`;ea.setAttribute("style","display: none;"),document.head.appendChild(ea.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const na=_e`
<custom-style>
  <style is="custom-style">
    html {
      /*
       * You can use these generic variables in your elements for easy theming.
       * For example, if all your elements use \`--primary-text-color\` as its main
       * color, then switching from a light to a dark theme is just a matter of
       * changing the value of \`--primary-text-color\` in your application.
       */
      --primary-text-color: var(--light-theme-text-color);
      --primary-background-color: var(--light-theme-background-color);
      --secondary-text-color: var(--light-theme-secondary-color);
      --disabled-text-color: var(--light-theme-disabled-color);
      --divider-color: var(--light-theme-divider-color);
      --error-color: var(--paper-deep-orange-a700);

      /*
       * Primary and accent colors. Also see color.js for more colors.
       */
      --primary-color: var(--paper-indigo-500);
      --light-primary-color: var(--paper-indigo-100);
      --dark-primary-color: var(--paper-indigo-700);

      --accent-color: var(--paper-pink-a200);
      --light-accent-color: var(--paper-pink-a100);
      --dark-accent-color: var(--paper-pink-a400);


      /*
       * Material Design Light background theme
       */
      --light-theme-background-color: #ffffff;
      --light-theme-base-color: #000000;
      --light-theme-text-color: var(--paper-grey-900);
      --light-theme-secondary-color: #737373;  /* for secondary text and icons */
      --light-theme-disabled-color: #9b9b9b;  /* disabled/hint text */
      --light-theme-divider-color: #dbdbdb;

      /*
       * Material Design Dark background theme
       */
      --dark-theme-background-color: var(--paper-grey-900);
      --dark-theme-base-color: #ffffff;
      --dark-theme-text-color: #ffffff;
      --dark-theme-secondary-color: #bcbcbc;  /* for secondary text and icons */
      --dark-theme-disabled-color: #646464;  /* disabled/hint text */
      --dark-theme-divider-color: #3c3c3c;

      /*
       * Deprecated values because of their confusing names.
       */
      --text-primary-color: var(--dark-theme-text-color);
      --default-primary-color: var(--primary-color);
    }
  </style>
</custom-style>`;na.setAttribute("style","display: none;"),document.head.appendChild(na.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const ia={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1}},attached:function(){},detached:function(){}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */let ra=null;const oa={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){ra=new bo({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return ra&&ra.byKey(this.validator)},hasValidator:function(){return null!=this._validator},validate:function(t){return this.invalid=void 0===t&&void 0!==this.value?!this._getValidity(this.value):!this._getValidity(t),!this.invalid},_getValidity:function(t){return!this.hasValidator()||this._validator.validate(t)}},aa={properties:{checked:{type:Boolean,value:!1,reflectToAttribute:!0,notify:!0,observer:"_checkedChanged"},toggles:{type:Boolean,value:!0,reflectToAttribute:!0},value:{type:String,value:"on",observer:"_valueChanged"}},observers:["_requiredChanged(required)"],created:function(){this._hasIronCheckedElementBehavior=!0},_getValidity:function(t){return this.disabled||!this.required||this.checked},_requiredChanged:function(){this.required?this.setAttribute("aria-required","true"):this.removeAttribute("aria-required")},_checkedChanged:function(){this.active=this.checked,this.fire("iron-change")},_valueChanged:function(){null==this.value&&(this.value="on")}},sa={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(t){t&&this.ensureRipple(),this.hasRipple()&&(this._ripple.holdDown=t)},_createRipple:function(){var t=Zo._createRipple();return t.id="ink",t.setAttribute("center",""),t.classList.add("circle"),t}},la=[Yo,Wo,Zo,sa],ca=[la,[ia,oa,aa],{_checkedChanged:function(){aa._checkedChanged.call(this),this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){Zo._buttonStateChanged.call(this),this.disabled||this.isAttached&&(this.checked=this.active)}}],ua=_e`<style>
  :host {
    display: inline-block;
    white-space: nowrap;
    cursor: pointer;
    --calculated-paper-checkbox-size: var(--paper-checkbox-size, 18px);
    /* -1px is a sentinel for the default and is replaced in \`attached\`. */
    --calculated-paper-checkbox-ink-size: var(--paper-checkbox-ink-size, -1px);
    @apply --paper-font-common-base;
    line-height: 0;
    -webkit-tap-highlight-color: transparent;
  }

  :host([hidden]) {
    display: none !important;
  }

  :host(:focus) {
    outline: none;
  }

  .hidden {
    display: none;
  }

  #checkboxContainer {
    display: inline-block;
    position: relative;
    width: var(--calculated-paper-checkbox-size);
    height: var(--calculated-paper-checkbox-size);
    min-width: var(--calculated-paper-checkbox-size);
    margin: var(--paper-checkbox-margin, initial);
    vertical-align: var(--paper-checkbox-vertical-align, middle);
    background-color: var(--paper-checkbox-unchecked-background-color, transparent);
  }

  #ink {
    position: absolute;

    /* Center the ripple in the checkbox by negative offsetting it by
     * (inkWidth - rippleWidth) / 2 */
    top: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    width: var(--calculated-paper-checkbox-ink-size);
    height: var(--calculated-paper-checkbox-ink-size);
    color: var(--paper-checkbox-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
  }

  #ink:dir(rtl) {
    right: calc(0px - (var(--calculated-paper-checkbox-ink-size) - var(--calculated-paper-checkbox-size)) / 2);
    left: auto;
  }

  #ink[checked] {
    color: var(--paper-checkbox-checked-ink-color, var(--primary-color));
  }

  #checkbox {
    position: relative;
    box-sizing: border-box;
    height: 100%;
    border: solid 2px;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    border-radius: 2px;
    pointer-events: none;
    -webkit-transition: background-color 140ms, border-color 140ms;
    transition: background-color 140ms, border-color 140ms;

    -webkit-transition-duration: var(--paper-checkbox-animation-duration, 140ms);
    transition-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  /* checkbox checked animations */
  #checkbox.checked #checkmark {
    -webkit-animation: checkmark-expand 140ms ease-out forwards;
    animation: checkmark-expand 140ms ease-out forwards;

    -webkit-animation-duration: var(--paper-checkbox-animation-duration, 140ms);
    animation-duration: var(--paper-checkbox-animation-duration, 140ms);
  }

  @-webkit-keyframes checkmark-expand {
    0% {
      -webkit-transform: scale(0, 0) rotate(45deg);
    }
    100% {
      -webkit-transform: scale(1, 1) rotate(45deg);
    }
  }

  @keyframes checkmark-expand {
    0% {
      transform: scale(0, 0) rotate(45deg);
    }
    100% {
      transform: scale(1, 1) rotate(45deg);
    }
  }

  #checkbox.checked {
    background-color: var(--paper-checkbox-checked-color, var(--primary-color));
    border-color: var(--paper-checkbox-checked-color, var(--primary-color));
  }

  #checkmark {
    position: absolute;
    width: 36%;
    height: 70%;
    border-style: solid;
    border-top: none;
    border-left: none;
    border-right-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-bottom-width: calc(2/15 * var(--calculated-paper-checkbox-size));
    border-color: var(--paper-checkbox-checkmark-color, white);
    -webkit-transform-origin: 97% 86%;
    transform-origin: 97% 86%;
    box-sizing: content-box; /* protect against page-level box-sizing */
  }

  #checkmark:dir(rtl) {
    -webkit-transform-origin: 50% 14%;
    transform-origin: 50% 14%;
  }

  /* label */
  #checkboxLabel {
    position: relative;
    display: inline-block;
    vertical-align: middle;
    padding-left: var(--paper-checkbox-label-spacing, 8px);
    white-space: normal;
    line-height: normal;
    color: var(--paper-checkbox-label-color, var(--primary-text-color));
    @apply --paper-checkbox-label;
  }

  :host([checked]) #checkboxLabel {
    color: var(--paper-checkbox-label-checked-color, var(--paper-checkbox-label-color, var(--primary-text-color)));
    @apply --paper-checkbox-label-checked;
  }

  #checkboxLabel:dir(rtl) {
    padding-right: var(--paper-checkbox-label-spacing, 8px);
    padding-left: 0;
  }

  #checkboxLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #checkbox {
    opacity: 0.5;
    border-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
  }

  :host([disabled][checked]) #checkbox {
    background-color: var(--paper-checkbox-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #checkboxLabel  {
    opacity: 0.65;
  }

  /* invalid state */
  #checkbox.invalid:not(.checked) {
    border-color: var(--paper-checkbox-error-color, var(--error-color));
  }
</style>

<div id="checkboxContainer">
  <div id="checkbox" class$="[[_computeCheckboxClass(checked, invalid)]]">
    <div id="checkmark" class$="[[_computeCheckmarkClass(checked)]]"></div>
  </div>
</div>

<div id="checkboxLabel"><slot></slot></div>`;
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
let ha;ua.setAttribute("strip-whitespace",""),Nr({_template:ua,is:"paper-checkbox",behaviors:[ca],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){ki(this,(function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim()){var t=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),e="px",n=t.match(/[A-Za-z]+$/);null!==n&&(e=n[0]);var i=parseFloat(t),r=8/3*i;"px"===e&&(r=Math.floor(r))%2!=i%2&&r++,this.updateStyles({"--paper-checkbox-ink-size":r+e})}}))},_computeCheckboxClass:function(t,e){var n="";return t&&(n+="checked "),e&&(n+="invalid"),n},_computeCheckmarkClass:function(t){return t?"":"hidden"},_createRipple:function(){return this._rippleContainer=this.$.checkboxContainer,sa._createRipple.call(this)}});const da={properties:{sizingTarget:{type:Object,value:function(){return this}},fitInto:{type:Object,value:window},noOverlap:{type:Boolean},positionTarget:{type:Element},horizontalAlign:{type:String},verticalAlign:{type:String},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},autoFitOnAttach:{type:Boolean,value:!1},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_fitInfo:{type:Object}},get _fitWidth(){return this.fitInto===window?this.fitInto.innerWidth:this.fitInto.getBoundingClientRect().width},get _fitHeight(){return this.fitInto===window?this.fitInto.innerHeight:this.fitInto.getBoundingClientRect().height},get _fitLeft(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().left},get _fitTop(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().top},get _defaultPositionTarget(){var t=qi(this).parentNode;return t&&t.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(t=t.host),t},get _localeHorizontalAlign(){if(this._isRTL){if("right"===this.horizontalAlign)return"left";if("left"===this.horizontalAlign)return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},get _isRTL(){return void 0===this._memoizedIsRTL&&(this._memoizedIsRTL="rtl"==window.getComputedStyle(this).direction),this._memoizedIsRTL},attached:function(){this.positionTarget=this.positionTarget||this._defaultPositionTarget,this.autoFitOnAttach&&("none"===window.getComputedStyle(this).display?setTimeout(function(){this.fit()}.bind(this)):(window.ShadyDOM&&ShadyDOM.flush(),this.fit()))},detached:function(){this.__deferredFit&&(clearTimeout(this.__deferredFit),this.__deferredFit=null)},fit:function(){this.position(),this.constrain(),this.center()},_discoverInfo:function(){if(!this._fitInfo){var t=window.getComputedStyle(this),e=window.getComputedStyle(this.sizingTarget);this._fitInfo={inlineStyle:{top:this.style.top||"",left:this.style.left||"",position:this.style.position||""},sizerInlineStyle:{maxWidth:this.sizingTarget.style.maxWidth||"",maxHeight:this.sizingTarget.style.maxHeight||"",boxSizing:this.sizingTarget.style.boxSizing||""},positionedBy:{vertically:"auto"!==t.top?"top":"auto"!==t.bottom?"bottom":null,horizontally:"auto"!==t.left?"left":"auto"!==t.right?"right":null},sizedBy:{height:"none"!==e.maxHeight,width:"none"!==e.maxWidth,minWidth:parseInt(e.minWidth,10)||0,minHeight:parseInt(e.minHeight,10)||0},margin:{top:parseInt(t.marginTop,10)||0,right:parseInt(t.marginRight,10)||0,bottom:parseInt(t.marginBottom,10)||0,left:parseInt(t.marginLeft,10)||0}}}},resetFit:function(){var t=this._fitInfo||{};for(var e in t.sizerInlineStyle)this.sizingTarget.style[e]=t.sizerInlineStyle[e];for(var e in t.inlineStyle)this.style[e]=t.inlineStyle[e];this._fitInfo=null},refit:function(){var t=this.sizingTarget.scrollLeft,e=this.sizingTarget.scrollTop;this.resetFit(),this.fit(),this.sizingTarget.scrollLeft=t,this.sizingTarget.scrollTop=e},position:function(){if(!this.__shouldPosition)return;this._discoverInfo(),window.ShadyDOM&&window.ShadyDOM.flush(),this.style.position="fixed",this.sizingTarget.style.boxSizing="border-box",this.style.left="0px",this.style.top="0px";var t=this.getBoundingClientRect(),e=this.__getNormalizedRect(this.positionTarget),n=this.__getNormalizedRect(this.fitInto);let i,r,o,a;this.expandSizingTargetForScrollbars&&(i=this.sizingTarget.offsetWidth,r=this.sizingTarget.offsetHeight,o=this.sizingTarget.clientWidth,a=this.sizingTarget.clientHeight);var s=this._fitInfo.margin,l=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,{width:t.width+s.left+s.right,height:t.height+s.top+s.bottom},t,e,n),c=l.left+s.left,u=l.top+s.top,h=Math.min(n.right-s.right,c+t.width),d=Math.min(n.bottom-s.bottom,u+t.height);c=Math.max(n.left+s.left,Math.min(c,h-this._fitInfo.sizedBy.minWidth)),u=Math.max(n.top+s.top,Math.min(u,d-this._fitInfo.sizedBy.minHeight));const p=Math.max(h-c,this._fitInfo.sizedBy.minWidth),f=Math.max(d-u,this._fitInfo.sizedBy.minHeight);this.sizingTarget.style.maxWidth=p+"px",this.sizingTarget.style.maxHeight=f+"px";const m=c-t.left,g=u-t.top;if(this.style.left=`${m}px`,this.style.top=`${g}px`,this.expandSizingTargetForScrollbars){const t=this.sizingTarget.offsetHeight,e=t-this.sizingTarget.clientHeight-(r-a);if(e>0){const i=Math.min(n.height-s.top-s.bottom,f+e);this.sizingTarget.style.maxHeight=`${i}px`;const r=this.sizingTarget.offsetHeight,o=r-t;let a;"top"===l.verticalAlign?a=g:"middle"===l.verticalAlign?a=g-o/2:"bottom"===l.verticalAlign&&(a=g-o),a=Math.max(n.top+s.top,Math.min(a,n.bottom-s.bottom-r)),this.style.top=`${a}px`}const c=this.sizingTarget.offsetWidth,u=c-this.sizingTarget.clientWidth-(i-o);if(u>0){const t=(()=>{if(void 0!==ha)return ha;const t=document.createElement("div");Object.assign(t.style,{overflow:"auto",position:"fixed",left:"0px",top:"0px",maxWidth:"100px",maxHeight:"100px"});const e=document.createElement("div");return e.style.width="200px",e.style.height="200px",t.appendChild(e),document.body.appendChild(t),ha=Math.abs(t.offsetWidth-100)>1?t.offsetWidth-t.clientWidth:0,document.body.removeChild(t),ha})(),e=Math.min(n.width-s.left-s.right,p+u-t);this.sizingTarget.style.maxWidth=`${e}px`;const i=this.sizingTarget.offsetWidth+t,r=i-c;let o;"left"===l.horizontalAlign?o=m:"center"===l.horizontalAlign?o=m-r/2:"right"===l.horizontalAlign&&(o=m-r),o=Math.max(n.left+s.left,Math.min(o,n.right-s.right-i)),this.style.left=`${o}px`}}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var t=this._fitInfo;t.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px"),t.positionedBy.horizontally||(this.style.position="fixed",this.style.left="0px"),this.sizingTarget.style.boxSizing="border-box";var e=this.getBoundingClientRect();t.sizedBy.height||this.__sizeDimension(e,t.positionedBy.vertically,"top","bottom","Height"),t.sizedBy.width||this.__sizeDimension(e,t.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(t,e,n,i,r){this.__sizeDimension(t,e,n,i,r)},__sizeDimension:function(t,e,n,i,r){var o=this._fitInfo,a=this.__getNormalizedRect(this.fitInto),s="Width"===r?a.width:a.height,l=e===i,c="offset"+r;this.sizingTarget.style["max"+r]=s-o.margin[l?n:i]-(l?s-t[i]:t[n])-(this[c]-this.sizingTarget[c])+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var t=this._fitInfo.positionedBy;if(!t.vertically||!t.horizontally){this.style.position="fixed",t.vertically||(this.style.top="0px"),t.horizontally||(this.style.left="0px");var e=this.getBoundingClientRect(),n=this.__getNormalizedRect(this.fitInto);t.vertically||(this.style.top=n.top-e.top+(n.height-e.height)/2+"px"),t.horizontally||(this.style.left=n.left-e.left+(n.width-e.width)/2+"px")}}},__getNormalizedRect:function(t){return t===document.documentElement||t===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:t.getBoundingClientRect()},__getOffscreenArea:function(t,e,n){var i=Math.min(0,t.top)+Math.min(0,n.bottom-(t.top+e.height)),r=Math.min(0,t.left)+Math.min(0,n.right-(t.left+e.width));return Math.abs(i)*e.width+Math.abs(r)*e.height},__getPosition:function(t,e,n,i,r,o){var a,s=[{verticalAlign:"top",horizontalAlign:"left",top:r.top+this.verticalOffset,left:r.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:r.top+this.verticalOffset,left:r.right-n.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:r.bottom-n.height-this.verticalOffset,left:r.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:r.bottom-n.height-this.verticalOffset,left:r.right-n.width-this.horizontalOffset}];if(this.noOverlap){for(var l=0,c=s.length;l<c;l++){var u={};for(var h in s[l])u[h]=s[l][h];s.push(u)}s[0].top=s[1].top+=r.height,s[2].top=s[3].top-=r.height,s[4].left=s[6].left+=r.width,s[5].left=s[7].left-=r.width}for(e="auto"===e?null:e,(t="auto"===t?null:t)&&"center"!==t||(s.push({verticalAlign:"top",horizontalAlign:"center",top:r.top+this.verticalOffset+(this.noOverlap?r.height:0),left:r.left-i.width/2+r.width/2+this.horizontalOffset}),s.push({verticalAlign:"bottom",horizontalAlign:"center",top:r.bottom-n.height-this.verticalOffset-(this.noOverlap?r.height:0),left:r.left-i.width/2+r.width/2+this.horizontalOffset})),e&&"middle"!==e||(s.push({verticalAlign:"middle",horizontalAlign:"left",top:r.top-i.height/2+r.height/2+this.verticalOffset,left:r.left+this.horizontalOffset+(this.noOverlap?r.width:0)}),s.push({verticalAlign:"middle",horizontalAlign:"right",top:r.top-i.height/2+r.height/2+this.verticalOffset,left:r.right-n.width-this.horizontalOffset-(this.noOverlap?r.width:0)})),"middle"===e&&"center"===t&&s.push({verticalAlign:"middle",horizontalAlign:"center",top:r.top-i.height/2+r.height/2+this.verticalOffset,left:r.left-i.width/2+r.width/2+this.horizontalOffset}),l=0;l<s.length;l++){var d=s[l],p=d.verticalAlign===e,f=d.horizontalAlign===t;if(!this.dynamicAlign&&!this.noOverlap&&p&&f){a=d;break}var m=(!e||p)&&(!t||f);if(this.dynamicAlign||m){if(d.offscreenArea=this.__getOffscreenArea(d,n,o),0===d.offscreenArea&&m){a=d;break}var g=d.offscreenArea-(a=a||d).offscreenArea;(g<0||0===g&&(p||f))&&(a=d)}}return a}};
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var pa=Element.prototype,fa=pa.matches||pa.matchesSelector||pa.mozMatchesSelector||pa.msMatchesSelector||pa.oMatchesSelector||pa.webkitMatchesSelector;const ma=new class{getTabbableNodes(t){var e=[];return this._collectTabbableNodes(t,e)?this._sortByTabIndex(e):e}isFocusable(t){return fa.call(t,"input, select, textarea, button, object")?fa.call(t,":not([disabled])"):fa.call(t,"a[href], area[href], iframe, [tabindex], [contentEditable]")}isTabbable(t){return this.isFocusable(t)&&fa.call(t,':not([tabindex="-1"])')&&this._isVisible(t)}_normalizedTabIndex(t){if(this.isFocusable(t)){var e=t.getAttribute("tabindex")||0;return Number(e)}return-1}_collectTabbableNodes(t,e){if(t.nodeType!==Node.ELEMENT_NODE)return!1;var n=t;if(!this._isVisible(n))return!1;var i,r=this._normalizedTabIndex(n),o=r>0;r>=0&&e.push(n),i="content"===n.localName||"slot"===n.localName?qi(n).getDistributedNodes():qi(n.root||n).children;for(var a=0;a<i.length;a++)o=this._collectTabbableNodes(i[a],e)||o;return o}_isVisible(t){var e=t.style;return"hidden"!==e.visibility&&"none"!==e.display&&"hidden"!==(e=window.getComputedStyle(t)).visibility&&"none"!==e.display}_sortByTabIndex(t){var e=t.length;if(e<2)return t;var n=Math.ceil(e/2),i=this._sortByTabIndex(t.slice(0,n)),r=this._sortByTabIndex(t.slice(n));return this._mergeSortByTabIndex(i,r)}_mergeSortByTabIndex(t,e){for(var n=[];t.length>0&&e.length>0;)this._hasLowerTabOrder(t[0],e[0])?n.push(e.shift()):n.push(t.shift());return n.concat(t,e)}_hasLowerTabOrder(t,e){var n=Math.max(t.tabIndex,0),i=Math.max(e.tabIndex,0);return 0===n||0===i?i>n:n>i}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({_template:_e`
    <style>
      :host {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: var(--iron-overlay-backdrop-background-color, #000);
        opacity: 0;
        transition: opacity 0.2s;
        pointer-events: none;
        @apply --iron-overlay-backdrop;
      }

      :host(.opened) {
        opacity: var(--iron-overlay-backdrop-opacity, 0.6);
        pointer-events: auto;
        @apply --iron-overlay-backdrop-opened;
      }
    </style>

    <slot></slot>
`,is:"iron-overlay-backdrop",properties:{opened:{reflectToAttribute:!0,type:Boolean,value:!1,observer:"_openedChanged"}},listeners:{transitionend:"_onTransitionend"},created:function(){this.__openedRaf=null},attached:function(){this.opened&&this._openedChanged(this.opened)},prepare:function(){this.opened&&!this.parentNode&&qi(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){this.opened||this.parentNode!==document.body||qi(this.parentNode).removeChild(this)},_onTransitionend:function(t){t&&t.target===this&&this.complete()},_openedChanged:function(t){if(t)this.prepare();else{var e=window.getComputedStyle(this);"0s"!==e.transitionDuration&&0!=e.opacity||this.complete()}this.isAttached&&(this.__openedRaf&&(window.cancelAnimationFrame(this.__openedRaf),this.__openedRaf=null),this.scrollTop=this.scrollTop,this.__openedRaf=window.requestAnimationFrame(function(){this.__openedRaf=null,this.toggleClass("opened",this.opened)}.bind(this)))}});const ga=new
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
class{constructor(){this._overlays=[],this._minimumZ=101,this._backdropElement=null,ni(document.documentElement,"tap",(function(){})),document.addEventListener("tap",this._onCaptureClick.bind(this),!0),document.addEventListener("focus",this._onCaptureFocus.bind(this),!0),document.addEventListener("keydown",this._onCaptureKeyDown.bind(this),!0)}get backdropElement(){return this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop")),this._backdropElement}get deepActiveElement(){var t=document.activeElement;for(t&&t instanceof Element!=0||(t=document.body);t.root&&qi(t.root).activeElement;)t=qi(t.root).activeElement;return t}_bringOverlayAtIndexToFront(t){var e=this._overlays[t];if(e){var n=this._overlays.length-1,i=this._overlays[n];if(i&&this._shouldBeBehindOverlay(e,i)&&n--,!(t>=n)){var r=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(e)<=r&&this._applyOverlayZ(e,r);t<n;)this._overlays[t]=this._overlays[t+1],t++;this._overlays[n]=e}}}addOrRemoveOverlay(t){t.opened?this.addOverlay(t):this.removeOverlay(t)}addOverlay(t){var e=this._overlays.indexOf(t);if(e>=0)return this._bringOverlayAtIndexToFront(e),void this.trackBackdrop();var n=this._overlays.length,i=this._overlays[n-1],r=Math.max(this._getZ(i),this._minimumZ),o=this._getZ(t);i&&this._shouldBeBehindOverlay(t,i)&&(this._applyOverlayZ(i,r),n--,r=Math.max(this._getZ(this._overlays[n-1]),this._minimumZ)),o<=r&&this._applyOverlayZ(t,r),this._overlays.splice(n,0,t),this.trackBackdrop()}removeOverlay(t){var e=this._overlays.indexOf(t);-1!==e&&(this._overlays.splice(e,1),this.trackBackdrop())}currentOverlay(){return this._overlays[this._overlays.length-1]}currentOverlayZ(){return this._getZ(this.currentOverlay())}ensureMinimumZ(t){this._minimumZ=Math.max(this._minimumZ,t)}focusOverlay(){var t=this.currentOverlay();t&&t._applyFocus()}trackBackdrop(){var t=this._overlayWithBackdrop();(t||this._backdropElement)&&(this.backdropElement.style.zIndex=this._getZ(t)-1,this.backdropElement.opened=!!t,this.backdropElement.prepare())}getBackdrops(){for(var t=[],e=0;e<this._overlays.length;e++)this._overlays[e].withBackdrop&&t.push(this._overlays[e]);return t}backdropZ(){return this._getZ(this._overlayWithBackdrop())-1}_overlayWithBackdrop(){for(var t=this._overlays.length-1;t>=0;t--)if(this._overlays[t].withBackdrop)return this._overlays[t]}_getZ(t){var e=this._minimumZ;if(t){var n=Number(t.style.zIndex||window.getComputedStyle(t).zIndex);n==n&&(e=n)}return e}_setZ(t,e){t.style.zIndex=e}_applyOverlayZ(t,e){this._setZ(t,e+2)}_overlayInPath(t){t=t||[];for(var e=0;e<t.length;e++)if(t[e]._manager===this)return t[e]}_onCaptureClick(t){var e=this._overlays.length-1;if(-1!==e)for(var n,i=qi(t).path;(n=this._overlays[e])&&this._overlayInPath(i)!==n&&(n._onCaptureClick(t),n.allowClickThrough);)e--}_onCaptureFocus(t){var e=this.currentOverlay();e&&e._onCaptureFocus(t)}_onCaptureKeyDown(t){var e=this.currentOverlay();e&&(Ro.keyboardEventMatchesKeys(t,"esc")?e._onCaptureEsc(t):Ro.keyboardEventMatchesKeys(t,"tab")&&e._onCaptureTab(t))}_shouldBeBehindOverlay(t,e){return!t.alwaysOnTop&&e.alwaysOnTop}};
/**
    @license
    Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */var _a,ya,va={pageX:0,pageY:0},ba=null,xa=[],wa=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"];function Sa(t){Ma.indexOf(t)>=0||(0===Ma.length&&(function e(){_a=_a||Ea.bind(void 0);for(var t=0,e=wa.length;t<e;t++)document.addEventListener(wa[t],_a,{capture:!0,passive:!1})})(),Ma.push(t),ya=Ma[Ma.length-1])}const Ma=[];function Ea(t){if(t.cancelable&&(function e(t){var e=qi(t).rootTarget;if("touchmove"!==t.type&&ba!==e&&(ba=e,xa=(function n(t){for(var e=[],n=t.indexOf(ya),i=0;i<=n;i++)if(t[i].nodeType===Node.ELEMENT_NODE){var r=t[i],o=r.style;"scroll"!==o.overflow&&"auto"!==o.overflow&&(o=window.getComputedStyle(r)),"scroll"!==o.overflow&&"auto"!==o.overflow||e.push(r)}return e})(qi(t).path)),!xa.length)return!0;if("touchstart"===t.type)return!1;var i=(function r(t){var e={deltaX:t.deltaX,deltaY:t.deltaY};if("deltaX"in t);else if("wheelDeltaX"in t&&"wheelDeltaY"in t)e.deltaX=-t.wheelDeltaX,e.deltaY=-t.wheelDeltaY;else if("wheelDelta"in t)e.deltaX=0,e.deltaY=-t.wheelDelta;else if("axis"in t)e.deltaX=1===t.axis?t.detail:0,e.deltaY=2===t.axis?t.detail:0;else if(t.targetTouches){var n=t.targetTouches[0];e.deltaX=va.pageX-n.pageX,e.deltaY=va.pageY-n.pageY}return e}
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */)(t);return!(function o(t,e,n){if(e||n)for(var i=Math.abs(n)>=Math.abs(e),r=0;r<t.length;r++){var o=t[r];if(i?n<0?o.scrollTop>0:o.scrollTop<o.scrollHeight-o.clientHeight:e<0?o.scrollLeft>0:o.scrollLeft<o.scrollWidth-o.clientWidth)return o}})(xa,i.deltaX,i.deltaY)})(t)&&t.preventDefault(),t.targetTouches){var n=t.targetTouches[0];va.pageX=n.pageX,va.pageY=n.pageY}}const Ta={properties:{opened:{observer:"_openedChanged",type:Boolean,value:!1,notify:!0},canceled:{observer:"_canceledChanged",readOnly:!0,type:Boolean,value:!1},withBackdrop:{observer:"_withBackdropChanged",type:Boolean},noAutoFocus:{type:Boolean,value:!1},noCancelOnEscKey:{type:Boolean,value:!1},noCancelOnOutsideClick:{type:Boolean,value:!1},closingReason:{type:Object},restoreFocusOnClose:{type:Boolean,value:!1},allowClickThrough:{type:Boolean},alwaysOnTop:{type:Boolean},scrollAction:{type:String},_manager:{type:Object,value:ga},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||qi(this).querySelector("[autofocus]")||this},get _focusableNodes(){return ma.getTabbableNodes(this)},ready:function(){this.__isAnimating=!1,this.__shouldRemoveTabIndex=!1,this.__firstFocusableNode=this.__lastFocusableNode=null,this.__rafs={},this.__restoreFocusNode=null,this.__scrollTop=this.__scrollLeft=null,this.__onCaptureScroll=this.__onCaptureScroll.bind(this),this.__rootNodes=null,this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened),this._observer=qi(this).observeNodes(this._onNodesChange)},detached:function(){for(var t in this._observer&&qi(this).unobserveNodes(this._observer),this._observer=null,this.__rafs)null!==this.__rafs[t]&&cancelAnimationFrame(this.__rafs[t]);this.__rafs={},this._manager.removeOverlay(this),this.__isAnimating&&(this.opened?this._finishRenderOpened():(this._applyFocus(),this._finishRenderClosed()))},toggle:function(){this._setCanceled(!1),this.opened=!this.opened},open:function(){this._setCanceled(!1),this.opened=!0},close:function(){this._setCanceled(!1),this.opened=!1},cancel:function(t){this.fire("iron-overlay-canceled",t,{cancelable:!0}).defaultPrevented||(this._setCanceled(!0),this.opened=!1)},invalidateTabbables:function(){this.__firstFocusableNode=this.__lastFocusableNode=null},_ensureSetup:function(){this._overlaySetup||(this._overlaySetup=!0,this.style.outline="none",this.style.display="none")},_openedChanged:function(t){t?this.removeAttribute("aria-hidden"):this.setAttribute("aria-hidden","true"),this.isAttached&&(this.__isAnimating=!0,this.__deraf("__openedChanged",this.__openedChanged))},_canceledChanged:function(){this.closingReason=this.closingReason||{},this.closingReason.canceled=this.canceled},_withBackdropChanged:function(){this.withBackdrop&&!this.hasAttribute("tabindex")?(this.setAttribute("tabindex","-1"),this.__shouldRemoveTabIndex=!0):this.__shouldRemoveTabIndex&&(this.removeAttribute("tabindex"),this.__shouldRemoveTabIndex=!1),this.opened&&this.isAttached&&this._manager.trackBackdrop()},_prepareRenderOpened:function(){this.__restoreFocusNode=this._manager.deepActiveElement,this._preparePositioning(),this.refit(),this._finishPositioning(),this.noAutoFocus&&document.activeElement===this._focusNode&&(this._focusNode.blur(),this.__restoreFocusNode.focus())},_renderOpened:function(){this._finishRenderOpened()},_renderClosed:function(){this._finishRenderClosed()},_finishRenderOpened:function(){this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-opened")},_finishRenderClosed:function(){this.style.display="none",this.style.zIndex="",this.notifyResize(),this.__isAnimating=!1,this.fire("iron-overlay-closed",this.closingReason)},_preparePositioning:function(){this.style.transition=this.style.webkitTransition="none",this.style.transform=this.style.webkitTransform="none",this.style.display=""},_finishPositioning:function(){this.style.display="none",this.scrollTop=this.scrollTop,this.style.transition=this.style.webkitTransition="",this.style.transform=this.style.webkitTransform="",this.style.display="",this.scrollTop=this.scrollTop},_applyFocus:function(){if(this.opened)this.noAutoFocus||this._focusNode.focus();else{if(this.restoreFocusOnClose&&this.__restoreFocusNode){var t=this._manager.deepActiveElement;(t===document.body||Aa(this,t))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null,this._focusNode.blur(),this._focusedChild=null}},_onCaptureClick:function(t){this.noCancelOnOutsideClick||this.cancel(t)},_onCaptureFocus:function(t){if(this.withBackdrop){var e=qi(t).path;-1===e.indexOf(this)?(t.stopPropagation(),this._applyFocus()):this._focusedChild=e[0]}},_onCaptureEsc:function(t){this.noCancelOnEscKey||this.cancel(t)},_onCaptureTab:function(t){if(this.withBackdrop){this.__ensureFirstLastFocusables();var e=t.shiftKey,n=e?this.__firstFocusableNode:this.__lastFocusableNode,i=e?this.__lastFocusableNode:this.__firstFocusableNode,r=!1;if(n===i)r=!0;else{var o=this._manager.deepActiveElement;r=o===n||o===this}r&&(t.preventDefault(),this._focusedChild=i,this._applyFocus())}},_onIronResize:function(){this.opened&&!this.__isAnimating&&this.__deraf("refit",this.refit)},_onNodesChange:function(){this.opened&&!this.__isAnimating&&(this.invalidateTabbables(),this.notifyResize())},__ensureFirstLastFocusables:function(){var t=this._focusableNodes;this.__firstFocusableNode=t[0],this.__lastFocusableNode=t[t.length-1]},__openedChanged:function(){this.opened?(this._prepareRenderOpened(),this._manager.addOverlay(this),this._applyFocus(),this._renderOpened()):(this._manager.removeOverlay(this),this._applyFocus(),this._renderClosed())},__deraf:function(t,e){var n=this.__rafs;null!==n[t]&&cancelAnimationFrame(n[t]),n[t]=requestAnimationFrame(function i(){n[t]=null,e.call(this)}.bind(this))},__updateScrollObservers:function(t,e,n){t&&e&&this.__isValidScrollAction(n)?("lock"===n&&(this.__saveScrollPosition(),Sa(this)),this.__addScrollListeners()):((function i(t){var e=Ma.indexOf(t);-1!==e&&(Ma.splice(e,1),ya=Ma[Ma.length-1],0===Ma.length&&(function n(){for(var t=0,e=wa.length;t<e;t++)document.removeEventListener(wa[t],_a,{capture:!0,passive:!1})})())})(this),this.__removeScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){if(this.__rootNodes=[],m)for(var t=this;t;)t.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&t.host&&this.__rootNodes.push(t),t=t.host||t.assignedSlot||t.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach((function(t){t.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})}),this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach((function(t){t.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})}),this),this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(t){return"lock"===t||"refit"===t||"cancel"===t},__onCaptureScroll:function(t){if(!(this.__isAnimating||qi(t).path.indexOf(this)>=0))switch(this.scrollAction){case"lock":this.__restoreScrollPosition();break;case"refit":this.__deraf("refit",this.refit);break;case"cancel":this.cancel(t)}},__saveScrollPosition:function(){document.scrollingElement?(this.__scrollTop=document.scrollingElement.scrollTop,this.__scrollLeft=document.scrollingElement.scrollLeft):(this.__scrollTop=Math.max(document.documentElement.scrollTop,document.body.scrollTop),this.__scrollLeft=Math.max(document.documentElement.scrollLeft,document.body.scrollLeft))},__restoreScrollPosition:function(){document.scrollingElement?(document.scrollingElement.scrollTop=this.__scrollTop,document.scrollingElement.scrollLeft=this.__scrollLeft):(document.documentElement.scrollTop=document.body.scrollTop=this.__scrollTop,document.documentElement.scrollLeft=document.body.scrollLeft=this.__scrollLeft)}},Aa=(t,e)=>{for(let i=e;i;i=(n=i).assignedSlot||n.parentNode||n.host)if(i===t)return!0;var n;return!1},Ca=[da,mo,Ta],ka={hostAttributes:{role:"dialog",tabindex:"-1"},properties:{modal:{type:Boolean,value:!1},__readied:{type:Boolean,value:!1}},observers:["_modalChanged(modal, __readied)"],listeners:{tap:"_onDialogClick"},ready:function(){this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.__readied=!0},_modalChanged:function(t,e){e&&(t?(this.__prevNoCancelOnOutsideClick=this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.noCancelOnOutsideClick=!0,this.noCancelOnEscKey=!0,this.withBackdrop=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(t){this.closingReason=this.closingReason||{},this.closingReason.confirmed=t},_onDialogClick:function(t){for(var e=qi(t).path,n=0,i=e.indexOf(this);n<i;n++){var r=e[n];if(r.hasAttribute&&(r.hasAttribute("dialog-dismiss")||r.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(r.hasAttribute("dialog-confirm")),this.close(),t.stopPropagation();break}}}},La=[Ca,ka];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
if(
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>

      :host {
        display: block;
        @apply --layout-relative;
      }

      :host(.is-scrolled:not(:first-child))::before {
        content: '';
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      :host(.can-scroll:not(.scrolled-to-bottom):not(:last-child))::after {
        content: '';
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        height: 1px;
        background: var(--divider-color);
      }

      .scrollable {
        padding: 0 24px;

        @apply --layout-scroll;
        @apply --paper-dialog-scrollable;
      }

      .fit {
        @apply --layout-fit;
      }
    </style>

    <div id="scrollable" class="scrollable" on-scroll="updateScrollState">
      <slot></slot>
    </div>
`,is:"paper-dialog-scrollable",properties:{dialogElement:{type:Object}},get scrollTarget(){return this.$.scrollable},ready:function(){this._ensureTarget(),this.classList.add("no-padding")},attached:function(){this._ensureTarget(),requestAnimationFrame(this.updateScrollState.bind(this))},updateScrollState:function(){this.toggleClass("is-scrolled",this.scrollTarget.scrollTop>0),this.toggleClass("can-scroll",this.scrollTarget.offsetHeight<this.scrollTarget.scrollHeight),this.toggleClass("scrolled-to-bottom",this.scrollTarget.scrollTop+this.scrollTarget.offsetHeight>=this.scrollTarget.scrollHeight)},_ensureTarget:function(){this.dialogElement=this.dialogElement||this.parentElement,this.dialogElement&&this.dialogElement.behaviors&&this.dialogElement.behaviors.indexOf(ka)>=0?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}}),!window.polymerSkipLoadingFontRoboto){const t=document.createElement("link");t.rel="stylesheet",t.type="text/css",t.crossOrigin="anonymous",t.href="https://fonts.googleapis.com/css?family=Roboto+Mono:400,700|Roboto:400,300,300italic,400italic,500,500italic,700,700italic",document.head.appendChild(t)}
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */const Pa=_e`<custom-style>
  <style is="custom-style">
    html {

      /* Shared Styles */
      --paper-font-common-base: {
        font-family: 'Roboto', 'Noto', sans-serif;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-code: {
        font-family: 'Roboto Mono', 'Consolas', 'Menlo', monospace;
        -webkit-font-smoothing: antialiased;
      };

      --paper-font-common-expensive-kerning: {
        text-rendering: optimizeLegibility;
      };

      --paper-font-common-nowrap: {
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
      };

      /* Material Font Styles */

      --paper-font-display4: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 112px;
        font-weight: 300;
        letter-spacing: -.044em;
        line-height: 120px;
      };

      --paper-font-display3: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 56px;
        font-weight: 400;
        letter-spacing: -.026em;
        line-height: 60px;
      };

      --paper-font-display2: {
        @apply --paper-font-common-base;

        font-size: 45px;
        font-weight: 400;
        letter-spacing: -.018em;
        line-height: 48px;
      };

      --paper-font-display1: {
        @apply --paper-font-common-base;

        font-size: 34px;
        font-weight: 400;
        letter-spacing: -.01em;
        line-height: 40px;
      };

      --paper-font-headline: {
        @apply --paper-font-common-base;

        font-size: 24px;
        font-weight: 400;
        letter-spacing: -.012em;
        line-height: 32px;
      };

      --paper-font-title: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 20px;
        font-weight: 500;
        line-height: 28px;
      };

      --paper-font-subhead: {
        @apply --paper-font-common-base;

        font-size: 16px;
        font-weight: 400;
        line-height: 24px;
      };

      --paper-font-body2: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-body1: {
        @apply --paper-font-common-base;

        font-size: 14px;
        font-weight: 400;
        line-height: 20px;
      };

      --paper-font-caption: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 12px;
        font-weight: 400;
        letter-spacing: 0.011em;
        line-height: 20px;
      };

      --paper-font-menu: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 13px;
        font-weight: 500;
        line-height: 24px;
      };

      --paper-font-button: {
        @apply --paper-font-common-base;
        @apply --paper-font-common-nowrap;

        font-size: 14px;
        font-weight: 500;
        letter-spacing: 0.018em;
        line-height: 24px;
        text-transform: uppercase;
      };

      --paper-font-code2: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 700;
        line-height: 20px;
      };

      --paper-font-code1: {
        @apply --paper-font-common-code;

        font-size: 14px;
        font-weight: 500;
        line-height: 20px;
      };

    }

  </style>
</custom-style>`;Pa.setAttribute("style","display: none;"),document.head.appendChild(Pa.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ia=document.createElement("template");Ia.setAttribute("style","display: none;"),Ia.innerHTML='<dom-module id="paper-dialog-shared-styles">\n  <template>\n    <style>\n      :host {\n        display: block;\n        margin: 24px 40px;\n\n        background: var(--paper-dialog-background-color, var(--primary-background-color));\n        color: var(--paper-dialog-color, var(--primary-text-color));\n\n        @apply --paper-font-body1;\n        @apply --shadow-elevation-16dp;\n        @apply --paper-dialog;\n      }\n\n      :host > ::slotted(*) {\n        margin-top: 20px;\n        padding: 0 24px;\n      }\n\n      :host > ::slotted(.no-padding) {\n        padding: 0;\n      }\n\n      \n      :host > ::slotted(*:first-child) {\n        margin-top: 24px;\n      }\n\n      :host > ::slotted(*:last-child) {\n        margin-bottom: 24px;\n      }\n\n      /* In 1.x, this selector was `:host > ::content h2`. In 2.x <slot> allows\n      to select direct children only, which increases the weight of this\n      selector, so we have to re-define first-child/last-child margins below. */\n      :host > ::slotted(h2) {\n        position: relative;\n        margin: 0;\n\n        @apply --paper-font-title;\n        @apply --paper-dialog-title;\n      }\n\n      /* Apply mixin again, in case it sets margin-top. */\n      :host > ::slotted(h2:first-child) {\n        margin-top: 24px;\n        @apply --paper-dialog-title;\n      }\n\n      /* Apply mixin again, in case it sets margin-bottom. */\n      :host > ::slotted(h2:last-child) {\n        margin-bottom: 24px;\n        @apply --paper-dialog-title;\n      }\n\n      :host > ::slotted(.paper-dialog-buttons),\n      :host > ::slotted(.buttons) {\n        position: relative;\n        padding: 8px 8px 8px 24px;\n        margin: 0;\n\n        color: var(--paper-dialog-button-color, var(--primary-color));\n\n        @apply --layout-horizontal;\n        @apply --layout-end-justified;\n      }\n    </style>\n  </template>\n</dom-module>',document.head.appendChild(Ia.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Na=[{properties:{animationConfig:{type:Object},entryAnimation:{observer:"_entryAnimationChanged",type:String},exitAnimation:{observer:"_exitAnimationChanged",type:String}},_entryAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.entry=[{name:this.entryAnimation,node:this}]},_exitAnimationChanged:function(){this.animationConfig=this.animationConfig||{},this.animationConfig.exit=[{name:this.exitAnimation,node:this}]},_copyProperties:function(t,e){for(var n in e)t[n]=e[n]},_cloneConfig:function(t){var e={isClone:!0};return this._copyProperties(e,t),e},_getAnimationConfigRecursive:function(t,e,n){var i;if(this.animationConfig)if(this.animationConfig.value&&"function"==typeof this.animationConfig.value)this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));else if(i=t?this.animationConfig[t]:this.animationConfig,Array.isArray(i)||(i=[i]),i)for(var r,o=0;r=i[o];o++)if(r.animatable)r.animatable._getAnimationConfigRecursive(r.type||t,e,n);else if(r.id){var a=e[r.id];a?(a.isClone||(e[r.id]=this._cloneConfig(a),a=e[r.id]),this._copyProperties(a,r)):e[r.id]=r}else n.push(r)},getAnimationConfig:function(t){var e={},n=[];for(var i in this._getAnimationConfigRecursive(t,e,n),e)n.push(e[i]);return n}},{_configureAnimations:function(t){var e=[],n=[];if(t.length>0)for(let e,i=0;e=t[i];i++){let t=document.createElement(e.name);if(t.isNeonAnimation){let i=null;t.configure||(t.configure=function(t){return null}),i=t.configure(e),n.push({result:i,config:e,neonAnimation:t})}else console.warn(this.is+":",e.name,"not found!")}for(var i=0;i<n.length;i++){let t=n[i].result,r=n[i].config,o=n[i].neonAnimation;try{"function"!=typeof t.cancel&&(t=document.timeline.play(t))}catch(e){t=null,console.warn("Couldnt play","(",r.name,").",e)}t&&e.push({neonAnimation:o,config:r,animation:t})}return e},_shouldComplete:function(t){for(var e=!0,n=0;n<t.length;n++)if("finished"!=t[n].animation.playState){e=!1;break}return e},_complete:function(t){for(var e=0;e<t.length;e++)t[e].neonAnimation.complete(t[e].config);for(e=0;e<t.length;e++)t[e].animation.cancel()},playAnimation:function(t,e){var n=this.getAnimationConfig(t);if(n){this._active=this._active||{},this._active[t]&&(this._complete(this._active[t]),delete this._active[t]);var i=this._configureAnimations(n);if(0!=i.length){this._active[t]=i;for(var r=0;r<i.length;r++)i[r].animation.onfinish=function(){this._shouldComplete(i)&&(this._complete(i),delete this._active[t],this.fire("neon-animation-finish",e,{bubbles:!1}))}.bind(this)}else this.fire("neon-animation-finish",e,{bubbles:!1})}},cancelAnimation:function(){for(var t in this._active){var e=this._active[t];for(var n in e)e[n].animation.cancel()}this._active={}}}];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
`,is:"paper-dialog",behaviors:[La,Na],listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},_renderOpened:function(){this.cancelAnimation(),this.playAnimation("entry")},_renderClosed:function(){this.cancelAnimation(),this.playAnimation("exit")},_onNeonAnimationFinish:function(){this.opened?this._finishRenderOpened():this._finishRenderClosed()}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Oa=Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
`,is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},timeout:{type:Number,value:150},_text:{type:String,value:""}},created:function(){Oa.instance||(Oa.instance=this),document.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(t){this._text="",this.async((function(){this._text=t}),this.timeout)},_onIronAnnounce:function(t){t.detail&&t.detail.text&&this.announce(t.detail.text)}});Oa.instance=null,Oa.requestAvailability=function(){Oa.instance||(Oa.instance=document.createElement("iron-a11y-announcer")),document.body?document.body.appendChild(Oa.instance):document.addEventListener("load",(function(){document.body.appendChild(Oa.instance)}))},
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
`,is:"iron-input",behaviors:[oa],properties:{bindValue:{type:String,value:""},value:{type:String,computed:"_computeValue(bindValue)"},allowedPattern:{type:String},autoValidate:{type:Boolean,value:!1},_inputElement:Object},observers:["_bindValueChanged(bindValue, _inputElement)"],listeners:{input:"_onInput",keypress:"_onKeypress"},created:function(){Oa.requestAvailability(),this._previousValidInput="",this._patternAlreadyChecked=!1},attached:function(){this._observer=qi(this).observeNodes(function(t){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(qi(this).unobserveNodes(this._observer),this._observer=null)},get inputElement(){return this._inputElement},_initSlottedInput:function(){this._inputElement=this.getEffectiveChildren()[0],this.inputElement&&this.inputElement.value&&(this.bindValue=this.inputElement.value),this.fire("iron-input-ready")},get _patternRegExp(){var t;if(this.allowedPattern)t=new RegExp(this.allowedPattern);else switch(this.inputElement.type){case"number":t=/[0-9.,e-]/}return t},_bindValueChanged:function(t,e){e&&(void 0===t?e.value=null:t!==e.value&&(this.inputElement.value=t),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:t}))},_onInput:function(){this.allowedPattern&&!this._patternAlreadyChecked&&(this._checkPatternValidity()||(this._announceInvalidCharacter("Invalid string of characters not entered."),this.inputElement.value=this._previousValidInput)),this.bindValue=this._previousValidInput=this.inputElement.value,this._patternAlreadyChecked=!1},_isPrintable:function(t){return!(8==t.keyCode||9==t.keyCode||13==t.keyCode||27==t.keyCode||0==t.charCode&&(19==t.keyCode||20==t.keyCode||45==t.keyCode||46==t.keyCode||144==t.keyCode||145==t.keyCode||t.keyCode>32&&t.keyCode<41||t.keyCode>111&&t.keyCode<124))},_onKeypress:function(t){if(this.allowedPattern||"number"===this.inputElement.type){var e=this._patternRegExp;if(e&&!(t.metaKey||t.ctrlKey||t.altKey)){this._patternAlreadyChecked=!0;var n=String.fromCharCode(t.charCode);this._isPrintable(t)&&!e.test(n)&&(t.preventDefault(),this._announceInvalidCharacter("Invalid character "+n+" not entered."))}}},_checkPatternValidity:function(){var t=this._patternRegExp;if(!t)return!0;for(var e=0;e<this.inputElement.value.length;e++)if(!t.test(this.inputElement.value[e]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var t=this.inputElement.checkValidity();return t&&(this.required&&""===this.bindValue?t=!1:this.hasValidator()&&(t=oa.validate.call(this,this.bindValue))),this.invalid=!t,this.fire("iron-input-validate"),t},_announceInvalidCharacter:function(t){this.fire("iron-announce",{text:t})},_computeValue:function(t){return t}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ra={attached:function(){this.fire("addon-attached")},update:function(t){}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
        float: right;

        @apply --paper-font-caption;
        @apply --paper-input-char-counter;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:dir(rtl)) {
        float: left;
      }
    </style>

    <span>[[_charCounterStr]]</span>
`,is:"paper-input-char-counter",behaviors:[Ra],properties:{_charCounterStr:{type:String,value:"0"}},update:function(t){if(t.inputElement){t.value=t.value||"";var e=t.value.toString().length.toString();t.inputElement.hasAttribute("maxlength")&&(e+="/"+t.inputElement.getAttribute("maxlength")),this._charCounterStr=e}}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const za=_e`
<custom-style>
  <style is="custom-style">
    html {
      --paper-input-container-shared-input-style: {
        position: relative; /* to make a stacking context */
        outline: none;
        box-shadow: none;
        padding: 0;
        margin: 0;
        width: 100%;
        max-width: 100%;
        background: transparent;
        border: none;
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        -webkit-appearance: none;
        text-align: inherit;
        vertical-align: var(--paper-input-container-input-align, bottom);

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>
`;za.setAttribute("style","display: none;"),document.head.appendChild(za.content),Nr({_template:_e`
    <style>
      :host {
        display: block;
        padding: 8px 0;
        @apply --paper-input-container;
      }

      :host([inline]) {
        display: inline-block;
      }

      :host([disabled]) {
        pointer-events: none;
        opacity: 0.33;

        @apply --paper-input-container-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      [hidden] {
        display: none !important;
      }

      .floated-label-placeholder {
        @apply --paper-font-caption;
      }

      .underline {
        height: 2px;
        position: relative;
      }

      .focused-line {
        @apply --layout-fit;
        border-bottom: 2px solid var(--paper-input-container-focus-color, var(--primary-color));

        -webkit-transform-origin: center center;
        transform-origin: center center;
        -webkit-transform: scale3d(0,1,1);
        transform: scale3d(0,1,1);

        @apply --paper-input-container-underline-focus;
      }

      .underline.is-highlighted .focused-line {
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .underline.is-invalid .focused-line {
        border-color: var(--paper-input-container-invalid-color, var(--error-color));
        -webkit-transform: none;
        transform: none;
        -webkit-transition: -webkit-transform 0.25s;
        transition: transform 0.25s;

        @apply --paper-transition-easing;
      }

      .unfocused-line {
        @apply --layout-fit;
        border-bottom: 1px solid var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline;
      }

      :host([disabled]) .unfocused-line {
        border-bottom: 1px dashed;
        border-color: var(--paper-input-container-color, var(--secondary-text-color));
        @apply --paper-input-container-underline-disabled;
      }

      .input-wrapper {
        @apply --layout-horizontal;
        @apply --layout-center;
        position: relative;
      }

      .input-content {
        @apply --layout-flex-auto;
        @apply --layout-relative;
        max-width: 100%;
      }

      .input-content ::slotted(label),
      .input-content ::slotted(.paper-input-label) {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        font: inherit;
        color: var(--paper-input-container-color, var(--secondary-text-color));
        -webkit-transition: -webkit-transform 0.25s, width 0.25s;
        transition: transform 0.25s, width 0.25s;
        -webkit-transform-origin: left top;
        transform-origin: left top;
        /* Fix for safari not focusing 0-height date/time inputs with -webkit-apperance: none; */
        min-height: 1px;

        @apply --paper-font-common-nowrap;
        @apply --paper-font-subhead;
        @apply --paper-input-container-label;
        @apply --paper-transition-easing;
      }


      .input-content ::slotted(label):before,
      .input-content ::slotted(.paper-input-label):before {
        @apply --paper-input-container-label-before;
      }

      .input-content ::slotted(label):after,
      .input-content ::slotted(.paper-input-label):after {
        @apply --paper-input-container-label-after;
      }

      .input-content.label-is-floating ::slotted(label),
      .input-content.label-is-floating ::slotted(.paper-input-label) {
        -webkit-transform: translateY(-75%) scale(0.75);
        transform: translateY(-75%) scale(0.75);

        /* Since we scale to 75/100 of the size, we actually have 100/75 of the
        original space now available */
        width: 133%;

        @apply --paper-input-container-label-floating;
      }

      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(label),
      :host(:dir(rtl)) .input-content.label-is-floating ::slotted(.paper-input-label) {
        right: 0;
        left: auto;
        -webkit-transform-origin: right top;
        transform-origin: right top;
      }

      .input-content.label-is-highlighted ::slotted(label),
      .input-content.label-is-highlighted ::slotted(.paper-input-label) {
        color: var(--paper-input-container-focus-color, var(--primary-color));

        @apply --paper-input-container-label-focus;
      }

      .input-content.is-invalid ::slotted(label),
      .input-content.is-invalid ::slotted(.paper-input-label) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .input-content.label-is-hidden ::slotted(label),
      .input-content.label-is-hidden ::slotted(.paper-input-label) {
        visibility: hidden;
      }

      .input-content ::slotted(input),
      .input-content ::slotted(iron-input),
      .input-content ::slotted(textarea),
      .input-content ::slotted(iron-autogrow-textarea),
      .input-content ::slotted(.paper-input-input) {
        @apply --paper-input-container-shared-input-style;
        /* The apply shim doesn't apply the nested color custom property,
          so we have to re-apply it here. */
        color: var(--paper-input-container-input-color, var(--primary-text-color));
        @apply --paper-input-container-input;
      }

      .input-content ::slotted(input)::-webkit-outer-spin-button,
      .input-content ::slotted(input)::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      .input-content.focused ::slotted(input),
      .input-content.focused ::slotted(iron-input),
      .input-content.focused ::slotted(textarea),
      .input-content.focused ::slotted(iron-autogrow-textarea),
      .input-content.focused ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-focus;
      }

      .input-content.is-invalid ::slotted(input),
      .input-content.is-invalid ::slotted(iron-input),
      .input-content.is-invalid ::slotted(textarea),
      .input-content.is-invalid ::slotted(iron-autogrow-textarea),
      .input-content.is-invalid ::slotted(.paper-input-input) {
        @apply --paper-input-container-input-invalid;
      }

      .prefix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;
        @apply --paper-input-prefix;
      }

      .suffix ::slotted(*) {
        display: inline-block;
        @apply --paper-font-subhead;
        @apply --layout-flex-none;

        @apply --paper-input-suffix;
      }

      /* Firefox sets a min-width on the input, which can cause layout issues */
      .input-content ::slotted(input) {
        min-width: 0;
      }

      .input-content ::slotted(textarea) {
        resize: none;
      }

      .add-on-content {
        position: relative;
      }

      .add-on-content.is-invalid ::slotted(*) {
        color: var(--paper-input-container-invalid-color, var(--error-color));
      }

      .add-on-content.is-highlighted ::slotted(*) {
        color: var(--paper-input-container-focus-color, var(--primary-color));
      }
    </style>

    <div class="floated-label-placeholder" aria-hidden="true" hidden="[[noLabelFloat]]">&nbsp;</div>

    <div class="input-wrapper">
      <span class="prefix"><slot name="prefix"></slot></span>

      <div class$="[[_computeInputContentClass(noLabelFloat,alwaysFloatLabel,focused,invalid,_inputHasContent)]]" id="labelAndInputContainer">
        <slot name="label"></slot>
        <slot name="input"></slot>
      </div>

      <span class="suffix"><slot name="suffix"></slot></span>
    </div>

    <div class$="[[_computeUnderlineClass(focused,invalid)]]">
      <div class="unfocused-line"></div>
      <div class="focused-line"></div>
    </div>

    <div class$="[[_computeAddOnContentClass(focused,invalid)]]">
      <slot name="add-on"></slot>
    </div>
`,is:"paper-input-container",properties:{noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},attrForValue:{type:String,value:"bind-value"},autoValidate:{type:Boolean,value:!1},invalid:{observer:"_invalidChanged",type:Boolean,value:!1},focused:{readOnly:!0,type:Boolean,value:!1,notify:!0},_addons:{type:Array},_inputHasContent:{type:Boolean,value:!1},_inputSelector:{type:String,value:"input,iron-input,textarea,.paper-input-input"},_boundOnFocus:{type:Function,value:function(){return this._onFocus.bind(this)}},_boundOnBlur:{type:Function,value:function(){return this._onBlur.bind(this)}},_boundOnInput:{type:Function,value:function(){return this._onInput.bind(this)}},_boundValueChanged:{type:Function,value:function(){return this._onValueChanged.bind(this)}}},listeners:{"addon-attached":"_onAddonAttached","iron-input-validate":"_onIronInputValidate"},get _valueChangedEvent(){return this.attrForValue+"-changed"},get _propertyForValue(){return st(this.attrForValue)},get _inputElement(){return qi(this).querySelector(this._inputSelector)},get _inputElementValue(){return this._inputElement[this._propertyForValue]||this._inputElement.value},ready:function(){this.__isFirstValueUpdate=!0,this._addons||(this._addons=[]),this.addEventListener("focus",this._boundOnFocus,!0),this.addEventListener("blur",this._boundOnBlur,!0)},attached:function(){this.attrForValue?this._inputElement.addEventListener(this._valueChangedEvent,this._boundValueChanged):this.addEventListener("input",this._onInput),this._inputElementValue&&""!=this._inputElementValue?this._handleValueAndAutoValidate(this._inputElement):this._handleValue(this._inputElement)},_onAddonAttached:function(t){this._addons||(this._addons=[]);var e=t.target;-1===this._addons.indexOf(e)&&(this._addons.push(e),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1),this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(t){this._handleValueAndAutoValidate(t.target)},_onValueChanged:function(t){var e=t.target;this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,void 0===e.value||""===e.value)||this._handleValueAndAutoValidate(t.target)},_handleValue:function(t){var e=this._inputElementValue;this._inputHasContent=!(!e&&0!==e&&("number"!==t.type||t.checkValidity())),this.updateAddons({inputElement:t,value:e,invalid:this.invalid})},_handleValueAndAutoValidate:function(t){var e;this.autoValidate&&t&&(e=t.validate?t.validate(this._inputElementValue):t.checkValidity(),this.invalid=!e),this._handleValue(t)},_onIronInputValidate:function(t){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(t){for(var e,n=0;e=this._addons[n];n++)e.update(t)},_computeInputContentClass:function(t,e,n,i,r){var o="input-content";if(t)r&&(o+=" label-is-hidden"),i&&(o+=" is-invalid");else{var a=this.querySelector("label");e||r?(o+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",i?o+=" is-invalid":n&&(o+=" label-is-highlighted")):(a&&(this.$.labelAndInputContainer.style.position="relative"),i&&(o+=" is-invalid"))}return n&&(o+=" focused"),o},_computeUnderlineClass:function(t,e){var n="underline";return e?n+=" is-invalid":t&&(n+=" is-highlighted"),n},_computeAddOnContentClass:function(t,e){var n="add-on-content";return e?n+=" is-invalid":t&&(n+=" is-highlighted"),n}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
        visibility: hidden;

        color: var(--paper-input-container-invalid-color, var(--error-color));

        @apply --paper-font-caption;
        @apply --paper-input-error;
        position: absolute;
        left:0;
        right:0;
      }

      :host([invalid]) {
        visibility: visible;
      }

      #a11yWrapper {
        visibility: hidden;
      }

      :host([invalid]) #a11yWrapper {
        visibility: visible;
      }
    </style>

    <!--
    If the paper-input-error element is directly referenced by an
    \`aria-describedby\` attribute, such as when used as a paper-input add-on,
    then applying \`visibility: hidden;\` to the paper-input-error element itself
    does not hide the error.

    For more information, see:
    https://www.w3.org/TR/accname-1.1/#mapping_additional_nd_description
    -->
    <div id="a11yWrapper">
      <slot></slot>
    </div>
`,is:"paper-input-error",behaviors:[Ra],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(t){this._setInvalid(t.invalid)}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Da={NextLabelID:1,NextAddonID:1,NextInputID:1},Ba={properties:{label:{type:String},value:{notify:!0,type:String},disabled:{type:Boolean,value:!1},invalid:{type:Boolean,value:!1,notify:!0},allowedPattern:{type:String},type:{type:String},list:{type:String},pattern:{type:String},required:{type:Boolean,value:!1},errorMessage:{type:String},charCounter:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1},alwaysFloatLabel:{type:Boolean,value:!1},autoValidate:{type:Boolean,value:!1},validator:{type:String},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,observer:"_autofocusChanged"},inputmode:{type:String},minlength:{type:Number},maxlength:{type:Number},min:{type:String},max:{type:String},step:{type:String},name:{type:String},placeholder:{type:String,value:""},readonly:{type:Boolean,value:!1},size:{type:Number},autocapitalize:{type:String,value:"none"},autocorrect:{type:String,value:"off"},autosave:{type:String},results:{type:Number},accept:{type:String},multiple:{type:Boolean},_ariaDescribedBy:{type:String,value:""},_ariaLabelledBy:{type:String,value:""},_inputId:{type:String,value:""}},listeners:{"addon-attached":"_onAddonAttached"},keyBindings:{"shift+tab:keydown":"_onShiftTabDown"},hostAttributes:{tabindex:0},get inputElement(){return this.$||(this.$={}),this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId)),this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText=["date","datetime","datetime-local","month","time","week","file"]},attached:function(){this._updateAriaLabelledBy(),!ye&&this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.inputElement.type)&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(t,e){return t?t+" "+e:e},_onAddonAttached:function(t){var e=qi(t).rootTarget;if(e.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,e.id);else{var n="paper-input-add-on-"+Da.NextAddonID++;e.id=n,this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,n)}},validate:function(){return this.inputElement.validate()},_focusBlurHandler:function(t){Wo._focusBlurHandler.call(this,t),this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(t){var e=this.getAttribute("tabindex");this._shiftTabPressed=!0,this.setAttribute("tabindex","-1"),this.async((function(){this.setAttribute("tabindex",e),this._shiftTabPressed=!1}),1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(t){try{var e=this.inputElement.selectionStart;this.value=t,this.inputElement.selectionStart=e,this.inputElement.selectionEnd=e}catch(e){this.value=t}},_computeAlwaysFloatLabel:function(t,e){return e||t},_updateAriaLabelledBy:function(){var t,e=qi(this.root).querySelector("label");e?(e.id?t=e.id:(t="paper-input-label-"+Da.NextLabelID++,e.id=t),this._ariaLabelledBy=t):this._ariaLabelledBy=""},_generateInputId:function(){this._inputId&&""!==this._inputId||(this._inputId="input-"+Da.NextInputID++)},_onChange:function(t){this.shadowRoot&&this.fire(t.type,{sourceEvent:t},{node:this,bubbles:t.bubbles,cancelable:t.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var t=document.activeElement;t instanceof HTMLElement&&t!==document.body&&t!==document.documentElement||this._focusableElement.focus()}}},Ha=[Wo,Ro,Ba];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({is:"paper-input",_template:_e`
    <style>
      :host {
        display: block;
      }

      :host([focused]) {
        outline: none;
      }

      :host([hidden]) {
        display: none !important;
      }

      input {
        /* Firefox sets a min-width on the input, which can cause layout issues */
        min-width: 0;
      }

      /* In 1.x, the <input> is distributed to paper-input-container, which styles it.
      In 2.x the <iron-input> is distributed to paper-input-container, which styles
      it, but in order for this to work correctly, we need to reset some
      of the native input's properties to inherit (from the iron-input) */
      iron-input > input {
        @apply --paper-input-container-shared-input-style;
        font-family: inherit;
        font-weight: inherit;
        font-size: inherit;
        letter-spacing: inherit;
        word-spacing: inherit;
        line-height: inherit;
        text-shadow: inherit;
        color: inherit;
        cursor: inherit;
      }

      input:disabled {
        @apply --paper-input-container-input-disabled;
      }

      input::-webkit-outer-spin-button,
      input::-webkit-inner-spin-button {
        @apply --paper-input-container-input-webkit-spinner;
      }

      input::-webkit-clear-button {
        @apply --paper-input-container-input-webkit-clear;
      }

      input::-webkit-calendar-picker-indicator {
        @apply --paper-input-container-input-webkit-calendar-picker-indicator;
      }

      input::-webkit-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input:-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-moz-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      input::-ms-clear {
        @apply --paper-input-container-ms-clear;
      }

      input::-ms-reveal {
        @apply --paper-input-container-ms-reveal;
      }

      input:-ms-input-placeholder {
        color: var(--paper-input-container-color, var(--secondary-text-color));
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container id="container" no-label-float="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <slot name="prefix" slot="prefix"></slot>

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <!-- Need to bind maxlength so that the paper-input-char-counter works correctly -->
      <iron-input bind-value="{{value}}" slot="input" class="input-element" id$="[[_inputId]]" maxlength$="[[maxlength]]" allowed-pattern="[[allowedPattern]]" invalid="{{invalid}}" validator="[[validator]]">
        <input aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" type$="[[type]]" pattern$="[[pattern]]" required$="[[required]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" min$="[[min]]" max$="[[max]]" step$="[[step]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" list$="[[list]]" size$="[[size]]" autocapitalize$="[[autocapitalize]]" autocorrect$="[[autocorrect]]" on-change="_onChange" tabindex$="[[tabIndex]]" autosave$="[[autosave]]" results$="[[results]]" accept$="[[accept]]" multiple$="[[multiple]]" role$="[[inputRole]]" aria-haspopup$="[[inputAriaHaspopup]]">
      </iron-input>

      <slot name="suffix" slot="suffix"></slot>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
  `,behaviors:[Ha,ia],properties:{value:{type:String},inputRole:{type:String,value:void 0},inputAriaHaspopup:{type:String,value:void 0}},get _focusableElement(){return this.inputElement._inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input")),this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.$.nativeInput.type)&&(this.alwaysFloatLabel=!0),this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        position: fixed;
      }

      #contentWrapper ::slotted(*) {
        overflow: auto;
      }

      #contentWrapper.animating ::slotted(*) {
        overflow: hidden;
        pointer-events: none;
      }
    </style>

    <div id="contentWrapper">
      <slot id="content" name="dropdown-content"></slot>
    </div>
`,is:"iron-dropdown",behaviors:[Wo,Ro,Ca,Na],properties:{horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},openAnimationConfig:{type:Object},closeAnimationConfig:{type:Object},focusTarget:{type:Object},noAnimations:{type:Boolean,value:!1},allowOutsideScroll:{type:Boolean,value:!1,observer:"_allowOutsideScrollChanged"}},listeners:{"neon-animation-finish":"_onNeonAnimationFinish"},observers:["_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)"],get containedElement(){for(var t=qi(this.$.content).getDistributedNodes(),e=0,n=t.length;e<n;e++)if(t[e].nodeType===Node.ELEMENT_NODE)return t[e]},ready:function(){this.scrollAction||(this.scrollAction=this.allowOutsideScroll?"refit":"lock"),this._readied=!0},attached:function(){this.sizingTarget&&this.sizingTarget!==this||(this.sizingTarget=this.containedElement||this)},detached:function(){this.cancelAnimation()},_openedChanged:function(){this.opened&&this.disabled?this.cancel():(this.cancelAnimation(),this._updateAnimationConfig(),Ta._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Ta._renderOpened.apply(this,arguments)},_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Ta._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating"),this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var t=this.containedElement,e=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||[]),n=0;n<e.length;n++)e[n].node=t;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(t){this._readied&&(t?this.scrollAction&&"lock"!==this.scrollAction||(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var t=this.focusTarget||this.containedElement;t&&this.opened&&!this.noAutoFocus?t.focus():Ta._applyFocus.apply(this,arguments)}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Fa={properties:{animationTiming:{type:Object,value:function(){return{duration:500,easing:"cubic-bezier(0.4, 0, 0.2, 1)",fill:"both"}}}},isNeonAnimation:!0,created:function(){document.body.animate||console.warn("No web animations detected. This element will not function without a web animations polyfill.")},timingFromConfig:function(t){if(t.timing)for(var e in t.timing)this.animationTiming[e]=t.timing[e];return this.animationTiming},setPrefixedProperty:function(t,e,n){for(var i,r={transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]}[e],o=0;i=r[o];o++)t.style[i]=n;t.style[e]=n},complete:function(t){}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({is:"fade-in-animation",behaviors:[Fa],configure:function(t){return this._effect=new KeyframeEffect(t.node,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(t)),this._effect}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({is:"fade-out-animation",behaviors:[Fa],configure:function(t){return this._effect=new KeyframeEffect(t.node,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(t)),this._effect}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({is:"paper-menu-grow-height-animation",_template:null,behaviors:[Fa],configure:function(t){var e=t.node,n=e.getBoundingClientRect().height;return this._effect=new KeyframeEffect(e,[{height:n/2+"px"},{height:n+"px"}],this.timingFromConfig(t)),this._effect}}),Nr({is:"paper-menu-grow-width-animation",_template:null,behaviors:[Fa],configure:function(t){var e=t.node,n=e.getBoundingClientRect().width;return this._effect=new KeyframeEffect(e,[{width:n/2+"px"},{width:n+"px"}],this.timingFromConfig(t)),this._effect}}),Nr({is:"paper-menu-shrink-width-animation",_template:null,behaviors:[Fa],configure:function(t){var e=t.node,n=e.getBoundingClientRect().width;return this._effect=new KeyframeEffect(e,[{width:n+"px"},{width:n-n/20+"px"}],this.timingFromConfig(t)),this._effect}}),Nr({is:"paper-menu-shrink-height-animation",_template:null,behaviors:[Fa],configure:function(t){var e=t.node,n=e.getBoundingClientRect().height;return this.setPrefixedProperty(e,"transformOrigin","0 0"),this._effect=new KeyframeEffect(e,[{height:n+"px",transform:"translateY(0)"},{height:n/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(t)),this._effect}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var Va={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400};const ja=Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;

        @apply --paper-menu-button;
      }

      :host([disabled]) {
        cursor: auto;
        color: var(--disabled-text-color);

        @apply --paper-menu-button-disabled;
      }

      iron-dropdown {
        @apply --paper-menu-button-dropdown;
      }

      .dropdown-content {
        @apply --shadow-elevation-2dp;

        position: relative;
        border-radius: 2px;
        background-color: var(--paper-menu-button-dropdown-background, var(--primary-background-color));

        @apply --paper-menu-button-content;
      }

      :host([vertical-align="top"]) .dropdown-content {
        margin-bottom: 20px;
        margin-top: -10px;
        top: 10px;
      }

      :host([vertical-align="bottom"]) .dropdown-content {
        bottom: 10px;
        margin-bottom: -10px;
        margin-top: 20px;
      }

      #trigger {
        cursor: pointer;
      }
    </style>

    <div id="trigger" on-tap="toggle">
      <slot name="dropdown-trigger"></slot>
    </div>

    <iron-dropdown id="dropdown" opened="{{opened}}" horizontal-align="[[horizontalAlign]]" vertical-align="[[verticalAlign]]" dynamic-align="[[dynamicAlign]]" horizontal-offset="[[horizontalOffset]]" vertical-offset="[[verticalOffset]]" no-overlap="[[noOverlap]]" open-animation-config="[[openAnimationConfig]]" close-animation-config="[[closeAnimationConfig]]" no-animations="[[noAnimations]]" focus-target="[[_dropdownContent]]" allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" on-iron-overlay-canceled="__onIronOverlayCanceled" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
`,is:"paper-menu-button",behaviors:[Ro,Wo],properties:{opened:{type:Boolean,value:!1,notify:!0,observer:"_openedChanged"},horizontalAlign:{type:String,value:"left",reflectToAttribute:!0},verticalAlign:{type:String,value:"top",reflectToAttribute:!0},dynamicAlign:{type:Boolean},horizontalOffset:{type:Number,value:0,notify:!0},verticalOffset:{type:Number,value:0,notify:!0},noOverlap:{type:Boolean},noAnimations:{type:Boolean,value:!1},ignoreSelect:{type:Boolean,value:!1},closeOnActivate:{type:Boolean,value:!1},openAnimationConfig:{type:Object,value:function(){return[{name:"fade-in-animation",timing:{delay:100,duration:200}},{name:"paper-menu-grow-width-animation",timing:{delay:100,duration:150,easing:Va.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:Va.ANIMATION_CUBIC_BEZIER}}]}},closeAnimationConfig:{type:Object,value:function(){return[{name:"fade-out-animation",timing:{duration:150}},{name:"paper-menu-shrink-width-animation",timing:{delay:100,duration:50,easing:Va.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-shrink-height-animation",timing:{duration:200,easing:"ease-in"}}]}},allowOutsideScroll:{type:Boolean,value:!1},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var t=qi(this.$.content).getDistributedNodes(),e=0,n=t.length;e<n;e++)if(t[e].nodeType===Node.ELEMENT_NODE)return t[e]},toggle:function(){this.opened?this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(t){this.ignoreSelect||this.close()},_onIronActivate:function(t){this.closeOnActivate&&this.close()},_openedChanged:function(t,e){t?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):null!=e&&this.fire("paper-dropdown-close")},_disabledChanged:function(t){Wo._disabledChanged.apply(this,arguments),t&&this.opened&&this.close()},__onIronOverlayCanceled:function(t){var e=this.$.trigger;qi(t.detail).path.indexOf(e)>-1&&t.preventDefault()}});Object.keys(Va).forEach((function(t){ja[t]=Va[t]}));
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ua=document.createElement("template");Ua.setAttribute("style","display: none;"),Ua.innerHTML='<iron-iconset-svg name="paper-dropdown-menu" size="24">\n<svg><defs>\n<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z"></path></g>\n</defs></svg>\n</iron-iconset-svg>',document.head.appendChild(Ua.content);
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ga=document.createElement("template");Ga.setAttribute("style","display: none;"),Ga.innerHTML='<dom-module id="paper-dropdown-menu-shared-styles">\n  <template>\n    <style>\n      :host {\n        display: inline-block;\n        position: relative;\n        text-align: left;\n\n        /* NOTE(cdata): Both values are needed, since some phones require the\n         * value to be `transparent`.\n         */\n        -webkit-tap-highlight-color: rgba(0,0,0,0);\n        -webkit-tap-highlight-color: transparent;\n\n        --paper-input-container-input: {\n          overflow: hidden;\n          white-space: nowrap;\n          text-overflow: ellipsis;\n          max-width: 100%;\n          box-sizing: border-box;\n          cursor: pointer;\n        };\n\n        @apply --paper-dropdown-menu;\n      }\n\n      /* paper-dropdown-menu and paper-dropdown-menu-light both delegate focus\n       * to other internal elements which manage focus styling. */\n      :host(:focus) {\n        outline: none;\n      }\n\n      :host(:dir(rtl)) {\n        text-align: right;\n\n        @apply(--paper-dropdown-menu);\n      }\n\n      :host([disabled]) {\n        @apply --paper-dropdown-menu-disabled;\n      }\n\n      :host([noink]) paper-ripple {\n        display: none;\n      }\n\n      :host([no-label-float]) paper-ripple {\n        top: 8px;\n      }\n\n      paper-ripple {\n        top: 12px;\n        left: 0px;\n        bottom: 8px;\n        right: 0px;\n\n        @apply --paper-dropdown-menu-ripple;\n      }\n\n      paper-menu-button {\n        display: block;\n        padding: 0;\n\n        @apply --paper-dropdown-menu-button;\n      }\n\n      paper-input {\n        @apply --paper-dropdown-menu-input;\n      }\n\n      iron-icon {\n        color: var(--disabled-text-color);\n\n        @apply --paper-dropdown-menu-icon;\n      }\n    </style>\n  </template>\n</dom-module>',document.head.appendChild(Ga.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Wa=tr(HTMLElement);Nr({_template:_e`
    <style include="paper-dropdown-menu-shared-styles"></style>

    <paper-menu-button id="menuButton" vertical-align="[[verticalAlign]]" horizontal-align="[[horizontalAlign]]" dynamic-align="[[dynamicAlign]]" vertical-offset="[[_computeMenuVerticalOffset(noLabelFloat, verticalOffset)]]" disabled="[[disabled]]" no-animations="[[noAnimations]]" on-iron-select="_onIronSelect" on-iron-deselect="_onIronDeselect" opened="{{opened}}" close-on-activate allow-outside-scroll="[[allowOutsideScroll]]" restore-focus-on-close="[[restoreFocusOnClose]]" expand-sizing-target-for-scrollbars="[[expandSizingTargetForScrollbars]]">
      <!-- support hybrid mode: user might be using paper-menu-button 1.x which distributes via <content> -->
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        <!-- paper-input has type="text" for a11y, do not remove -->
        <paper-input id="input" type="text" invalid="[[invalid]]" readonly disabled="[[disabled]]" value="[[value]]" placeholder="[[placeholder]]" error-message="[[errorMessage]]" always-float-label="[[alwaysFloatLabel]]" no-label-float="[[noLabelFloat]]" label="[[label]]" input-role="button" input-aria-haspopup="listbox" autocomplete="off">
          <!-- support hybrid mode: user might be using paper-input 1.x which distributes via <content> -->
          <iron-icon icon="paper-dropdown-menu:arrow-drop-down" suffix slot="suffix"></iron-icon>
        </paper-input>
      </div>
      <slot id="content" name="dropdown-content" slot="dropdown-content"></slot>
    </paper-menu-button>
`,is:"paper-dropdown-menu",behaviors:[Yo,Wo,ia,oa],properties:{selectedItemLabel:{type:String,notify:!0,readOnly:!0},selectedItem:{type:Object,notify:!0,readOnly:!0},value:{type:String,notify:!0},label:{type:String},placeholder:{type:String},errorMessage:{type:String},opened:{type:Boolean,notify:!0,value:!1,observer:"_openedChanged"},allowOutsideScroll:{type:Boolean,value:!1},noLabelFloat:{type:Boolean,value:!1,reflectToAttribute:!0},alwaysFloatLabel:{type:Boolean,value:!1},noAnimations:{type:Boolean,value:!1},horizontalAlign:{type:String,value:"right"},verticalAlign:{type:String,value:"top"},verticalOffset:Number,dynamicAlign:{type:Boolean},restoreFocusOnClose:{type:Boolean,value:!0},expandSizingTargetForScrollbars:{type:Boolean,value:!1}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},observers:["_selectedItemChanged(selectedItem)"],_attachDom(t){const e=Y(this);return e.attachShadow({mode:"open",delegatesFocus:!0,shadyUpgradeFragment:t}),e.shadowRoot.appendChild(t),Wa.prototype._attachDom.call(this,t)},focus(){this.$.input._focusableElement.focus()},attached:function(){var t=this.contentElement;t&&t.selectedItem&&this._setSelectedItem(t.selectedItem)},get contentElement(){for(var t=qi(this.$.content).getDistributedNodes(),e=0,n=t.length;e<n;e++)if(t[e].nodeType===Node.ELEMENT_NODE)return t[e]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(t){this._setSelectedItem(t.detail.item)},_onIronDeselect:function(t){this._setSelectedItem(null)},_onTap:function(t){hi(t)===this&&this.open()},_selectedItemChanged:function(t){var e;e=t?t.label||t.getAttribute("label")||t.textContent.trim():"",this.value=e,this._setSelectedItemLabel(e)},_computeMenuVerticalOffset:function(t,e){return e||(t?-4:8)},_getValidity:function(t){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var t=this.contentElement;t&&t.setAttribute("aria-expanded",this.opened?"true":"false")}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var qa={outerScroll:{scroll:!0},shadowMode:{standard:2,waterfall:1,"waterfall-tall":1},tallMode:{"waterfall-tall":!0}};Nr({_template:_e`
    <style>
      :host {
        @apply --layout-vertical;
        position: relative;
        height: 100%;
        @apply --paper-header-panel;
      }

      #mainContainer {
        @apply --layout-flex;
        position: relative;
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      #mainPanel {
        @apply --layout-vertical;
        @apply --layout-flex;
        position: relative;
        min-height: 0;
        @apply --paper-header-panel-body;
      }

      #mainContainer {
        @apply --paper-header-panel-container;
      }

      /*
       * mode: scroll
       */
      :host([mode=scroll]) #mainContainer {
        @apply --paper-header-panel-scroll-container;
        overflow: visible;
      }

      :host([mode=scroll]) {
        overflow-y: auto;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
      }

      /*
       * mode: cover
       */
      :host([mode=cover]) #mainContainer {
        @apply --paper-header-panel-cover-container;
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
      }

      :host([mode=cover]) #mainPanel {
        position: static;
      }

      /*
       * mode: standard
       */
      :host([mode=standard]) #mainContainer {
        @apply --paper-header-panel-standard-container;
      }

      /*
       * mode: seamed
       */
      :host([mode=seamed]) #mainContainer {
        @apply --paper-header-panel-seamed-container;
      }


      /*
       * mode: waterfall
       */
      :host([mode=waterfall]) #mainContainer {
        @apply --paper-header-panel-waterfall-container;
      }

      /*
       * mode: waterfall-tall
       */
      :host([mode=waterfall-tall]) #mainContainer {
        @apply --paper-header-panel-waterfall-tall-container;
      }

      #dropShadow {
        transition: opacity 0.5s;
        height: 6px;
        box-shadow: inset 0px 5px 6px -3px rgba(0, 0, 0, 0.4);
        @apply --paper-header-panel-shadow;
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        opacity: 0;
        pointer-events: none;
      }

      #dropShadow.has-shadow {
        opacity: 1;
      }

      #mainContainer > ::slotted(.fit) {
        @apply --layout-fit;
      }

    </style>

    <slot id="headerSlot" name="header"></slot>

    <div id="mainPanel">
      <div id="mainContainer" class\$="[[_computeMainContainerClass(mode)]]">
        <slot></slot>
      </div>
      <div id="dropShadow"></div>
    </div>
`,is:"paper-header-panel",properties:{mode:{type:String,value:"standard",observer:"_modeChanged",reflectToAttribute:!0},shadow:{type:Boolean,value:!1},tallClass:{type:String,value:"tall"},atTop:{type:Boolean,value:!0,notify:!0,readOnly:!0,reflectToAttribute:!0}},observers:["_computeDropShadowHidden(atTop, mode, shadow)"],attached:function(){this._addListener(),this._keepScrollingState()},detached:function(){this._removeListener()},ready:function(){this.scrollHandler=this._scroll.bind(this),console.warn(this.is,"is deprecated. Please use app-layout instead!")},get header(){return qi(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(t,e,n){var i=qa.shadowMode[e];this.toggleClass("has-shadow",!!this.shadow||2===i||1===i&&!t,this.$.dropShadow)},_computeMainContainerClass:function(t){var e={};return e.flex="cover"!==t,Object.keys(e).filter((function(t){return e[t]})).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(t,e){var n=qa,i=this.header;i&&(n.tallMode[e]&&!n.tallMode[t]?(i.classList.remove(this.tallClass),this.async((function(){i.classList.remove("animate")}),200)):this.toggleClass("animate",n.tallMode[t],i)),this._keepScrollingState()},_keepScrollingState:function(){var t=this.scroller,e=this.header;this._setAtTop(0===t.scrollTop),e&&this.tallClass&&qa.tallMode[this.mode]&&this.toggleClass(this.tallClass,this.atTop||e.classList.contains(this.tallClass)&&t.scrollHeight<this.offsetHeight,e)},_scroll:function(){this._keepScrollingState(),this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(t){return qa.outerScroll[t]?this:this.$.mainContainer}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({is:"paper-icon-button",_template:_e`
    <style>
      :host {
        display: inline-block;
        position: relative;
        padding: 8px;
        outline: none;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: pointer;
        z-index: 0;
        line-height: 1;

        width: 40px;
        height: 40px;

        /*
          NOTE: Both values are needed, since some phones require the value to
          be \`transparent\`.
        */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        /* Because of polymer/2558, this style has lower specificity than * */
        box-sizing: border-box !important;

        @apply --paper-icon-button;
      }

      :host #ink {
        color: var(--paper-icon-button-ink-color, var(--primary-text-color));
        opacity: 0.6;
      }

      :host([disabled]) {
        color: var(--paper-icon-button-disabled-text, var(--disabled-text-color));
        pointer-events: none;
        cursor: auto;

        @apply --paper-icon-button-disabled;
      }

      :host([hidden]) {
        display: none !important;
      }

      :host(:hover) {
        @apply --paper-icon-button-hover;
      }

      iron-icon {
        --iron-icon-width: 100%;
        --iron-icon-height: 100%;
      }
    </style>

    <iron-icon id="icon" src="[[src]]" icon="[[icon]]"
               alt$="[[alt]]"></iron-icon>
  `,hostAttributes:{role:"button",tabindex:"0"},behaviors:[la],registered:function(){this._template.setAttribute("strip-whitespace","")},properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(t,e){var n=this.getAttribute("aria-label");n&&e!=n||this.setAttribute("aria-label",t)}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
        position: relative;
        width: 400px;
        border: 1px solid;
        padding: 2px;
        -moz-appearance: textarea;
        -webkit-appearance: textarea;
        overflow: hidden;
      }

      .mirror-text {
        visibility: hidden;
        word-wrap: break-word;
        @apply --iron-autogrow-textarea;
      }

      .fit {
        @apply --layout-fit;
      }

      textarea {
        position: relative;
        outline: none;
        border: none;
        resize: none;
        background: inherit;
        color: inherit;
        /* see comments in template */
        width: 100%;
        height: 100%;
        font-size: inherit;
        font-family: inherit;
        line-height: inherit;
        text-align: inherit;
        @apply --iron-autogrow-textarea;
      }

      textarea::-webkit-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea::-moz-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }

      textarea:-ms-input-placeholder {
        @apply --iron-autogrow-textarea-placeholder;
      }
    </style>

    <!-- the mirror sizes the input/textarea so it grows with typing -->
    <!-- use &#160; instead &nbsp; of to allow this element to be used in XHTML -->
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    <!-- size the input/textarea with a div, because the textarea has intrinsic size in ff -->
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" autocapitalize$="[[autocapitalize]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
`,is:"iron-autogrow-textarea",behaviors:[oa,Wo],properties:{value:{observer:"_valueChanged",type:String,notify:!0},bindValue:{observer:"_bindValueChanged",type:String,notify:!0},rows:{type:Number,value:1,observer:"_updateCached"},maxRows:{type:Number,value:0,observer:"_updateCached"},autocomplete:{type:String,value:"off"},autofocus:{type:Boolean,value:!1},autocapitalize:{type:String,value:"none"},inputmode:{type:String},placeholder:{type:String},readonly:{type:String},required:{type:Boolean},minlength:{type:Number},maxlength:{type:Number},label:{type:String}},listeners:{input:"_onInput"},get textarea(){return this.$.textarea},get selectionStart(){return this.$.textarea.selectionStart},get selectionEnd(){return this.$.textarea.selectionEnd},set selectionStart(t){this.$.textarea.selectionStart=t},set selectionEnd(t){this.$.textarea.selectionEnd=t},attached:function(){navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&!navigator.userAgent.match(/OS 1[3456789]/)&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var t=this.$.textarea.validity.valid;return t&&(this.required&&""===this.value?t=!1:this.hasValidator()&&(t=oa.validate.call(this,this.value))),this.invalid=!t,this.fire("iron-input-validate"),t},_bindValueChanged:function(t){this.value=t},_valueChanged:function(t){var e=this.textarea;e&&(e.value!==t&&(e.value=t||0===t?t:""),this.bindValue=t,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(t){var e=qi(t).path;this.value=e?e[0].value:t.target.value},_constrain:function(t){var e;for(t=t||[""],e=this.maxRows>0&&t.length>this.maxRows?t.slice(0,this.maxRows):t.slice(0);this.rows>0&&e.length<this.rows;)e.push("");return e.join("<br/>")+"&#160;"},_valueForMirror:function(){var t=this.textarea;if(t)return this.tokens=t&&t.value?t.value.replace(/&/gm,"&amp;").replace(/"/gm,"&quot;").replace(/'/gm,"&#39;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;").split("\n"):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=this._constrain(this.tokens)}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        pointer-events: none;
      }
    </style>

    <paper-input-container no-label-float$="[[noLabelFloat]]" always-float-label="[[_computeAlwaysFloatLabel(alwaysFloatLabel,placeholder)]]" auto-validate$="[[autoValidate]]" disabled$="[[disabled]]" invalid="[[invalid]]">

      <label hidden$="[[!label]]" aria-hidden="true" for$="[[_inputId]]" slot="label">[[label]]</label>

      <iron-autogrow-textarea class="paper-input-input" slot="input" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" bind-value="{{value}}" invalid="{{invalid}}" validator$="[[validator]]" disabled$="[[disabled]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" name$="[[name]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]" autocapitalize$="[[autocapitalize]]" rows$="[[rows]]" max-rows$="[[maxRows]]" on-change="_onChange"></iron-autogrow-textarea>

      <template is="dom-if" if="[[errorMessage]]">
        <paper-input-error aria-live="assertive" slot="add-on">[[errorMessage]]</paper-input-error>
      </template>

      <template is="dom-if" if="[[charCounter]]">
        <paper-input-char-counter slot="add-on"></paper-input-char-counter>
      </template>

    </paper-input-container>
`,is:"paper-textarea",behaviors:[Ha,ia],properties:{_ariaLabelledBy:{observer:"_ariaLabelledByChanged",type:String},_ariaDescribedBy:{observer:"_ariaDescribedByChanged",type:String},value:{type:String},rows:{type:Number,value:1},maxRows:{type:Number,value:0}},get selectionStart(){return this.$.input.textarea.selectionStart},set selectionStart(t){this.$.input.textarea.selectionStart=t},get selectionEnd(){return this.$.input.textarea.selectionEnd},set selectionEnd(t){this.$.input.textarea.selectionEnd=t},_ariaLabelledByChanged:function(t){this._focusableElement.setAttribute("aria-labelledby",t)},_ariaDescribedByChanged:function(t){this._focusableElement.setAttribute("aria-describedby",t)},get _focusableElement(){return this.inputElement.textarea}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ya=document.createElement("template");Ya.setAttribute("style","display: none;"),Ya.innerHTML="<dom-module id=\"paper-item-shared-styles\">\n  <template>\n    <style>\n      :host, .paper-item {\n        display: block;\n        position: relative;\n        min-height: var(--paper-item-min-height, 48px);\n        padding: 0px 16px;\n      }\n\n      .paper-item {\n        @apply --paper-font-subhead;\n        border:none;\n        outline: none;\n        background: white;\n        width: 100%;\n        text-align: left;\n      }\n\n      :host([hidden]), .paper-item[hidden] {\n        display: none !important;\n      }\n\n      :host(.iron-selected), .paper-item.iron-selected {\n        font-weight: var(--paper-item-selected-weight, bold);\n\n        @apply --paper-item-selected;\n      }\n\n      :host([disabled]), .paper-item[disabled] {\n        color: var(--paper-item-disabled-color, var(--disabled-text-color));\n\n        @apply --paper-item-disabled;\n      }\n\n      :host(:focus), .paper-item:focus {\n        position: relative;\n        outline: 0;\n\n        @apply --paper-item-focused;\n      }\n\n      :host(:focus):before, .paper-item:focus:before {\n        @apply --layout-fit;\n\n        background: currentColor;\n        content: '';\n        opacity: var(--dark-divider-opacity);\n        pointer-events: none;\n\n        @apply --paper-item-focused-before;\n      }\n    </style>\n  </template>\n</dom-module>",document.head.appendChild(Ya.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Xa=[Yo,Wo,{hostAttributes:{role:"option",tabindex:"0"}}];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
`,is:"paper-item",behaviors:[Xa]}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        overflow: hidden; /* needed for text-overflow: ellipsis to work on ff */
        @apply --layout-vertical;
        @apply --layout-center-justified;
        @apply --layout-flex;
      }

      :host([two-line]) {
        min-height: var(--paper-item-body-two-line-min-height, 72px);
      }

      :host([three-line]) {
        min-height: var(--paper-item-body-three-line-min-height, 88px);
      }

      :host > ::slotted(*) {
        overflow: hidden;
        text-overflow: ellipsis;
        white-space: nowrap;
      }

      :host > ::slotted([secondary]) {
        @apply --paper-font-body1;

        color: var(--paper-item-body-secondary-color, var(--secondary-text-color));

        @apply --paper-item-body-secondary;
      }
    </style>

    <slot></slot>
`,is:"paper-item-body"}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style include="paper-item-shared-styles"></style>
    <style>
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
        @apply --paper-icon-item;
      }

      .content-icon {
        @apply --layout-horizontal;
        @apply --layout-center;

        width: var(--paper-item-icon-width, 56px);
        @apply --paper-item-icon;
      }
    </style>

    <div id="contentIcon" class="content-icon">
      <slot name="item-icon"></slot>
    </div>
    <slot></slot>
`,is:"paper-icon-item",behaviors:[Xa]});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const $a={properties:{multi:{type:Boolean,value:!1,observer:"multiChanged"},selectedValues:{type:Array,notify:!0,value:function(){return[]}},selectedItems:{type:Array,readOnly:!0,notify:!0,value:function(){return[]}}},observers:["_updateSelected(selectedValues.splices)"],select:function(t){this.multi?this._toggleSelected(t):this.selected=t},multiChanged:function(t){this._selection.multi=t,this._updateSelected()},get _shouldUpdateSelection(){return null!=this.selected||null!=this.selectedValues&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&this.selectedItems.length>0&&(this.selectedValues=this.selectedItems.map((function(t){return this._indexToValue(this.indexOf(t))}),this).filter((function(t){return null!=t}),this)):jo._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(t){var e=(this._valuesToItems(t=t||[])||[]).filter((function(t){return null!=t}));this._selection.clear(e);for(var n=0;n<e.length;n++)this._selection.setItemSelected(e[n],!0);this.fallbackSelection&&!this._selection.get().length&&this._valueToItem(this.fallbackSelection)&&this.select(this.fallbackSelection)},_selectionChange:function(){var t=this._selection.get();this.multi?(this._setSelectedItems(t),this._setSelectedItem(t.length?t[0]:null)):null!=t?(this._setSelectedItems([t]),this._setSelectedItem(t)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(t){var e=this.selectedValues.indexOf(t);e<0?this.push("selectedValues",t):this.splice("selectedValues",e,1)},_valuesToItems:function(t){return null==t?null:t.map((function(t){return this._valueToItem(t)}),this)}},Ka={properties:{focusedItem:{observer:"_focusedItemChanged",readOnly:!0,type:Object},attrForItemTitle:{type:String},disabled:{type:Boolean,value:!1,observer:"_disabledChanged"}},_MODIFIER_KEYS:["Alt","AltGraph","CapsLock","Control","Fn","FnLock","Hyper","Meta","NumLock","OS","ScrollLock","Shift","Super","Symbol","SymbolLock"],_SEARCH_RESET_TIMEOUT_MS:1e3,_previousTabIndex:0,hostAttributes:{role:"menu"},observers:["_updateMultiselectable(multi)"],listeners:{focus:"_onFocus",keydown:"_onKeydown","iron-items-changed":"_onIronItemsChanged"},keyBindings:{up:"_onUpKey",down:"_onDownKey",esc:"_onEscKey","shift+tab:keydown":"_onShiftTabDown"},attached:function(){this._resetTabindices()},select:function(t){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var e=this._valueToItem(t);e&&e.hasAttribute("disabled")||(this._setFocusedItem(e),$a.select.apply(this,arguments))},_resetTabindices:function(){var t=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach((function(e){e.setAttribute("tabindex",e===t?"0":"-1"),e.setAttribute("aria-selected",this._selection.isSelected(e))}),this)},_updateMultiselectable:function(t){t?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(t){if(-1===this._MODIFIER_KEYS.indexOf(t.key)){this.cancelDebouncer("_clearSearchText");for(var e,n=this._searchText||"",i=(n+=(t.key&&1==t.key.length?t.key:String.fromCharCode(t.keyCode)).toLocaleLowerCase()).length,r=0;e=this.items[r];r++)if(!e.hasAttribute("disabled")){var o=this.attrForItemTitle||"textContent",a=(e[o]||e.getAttribute(o)||"").trim();if(!(a.length<i)&&a.slice(0,i).toLocaleLowerCase()==n){this._setFocusedItem(e);break}}this._searchText=n,this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var t=this.items.length,e=Number(this.indexOf(this.focusedItem)),n=1;n<t+1;n++){var i=this.items[(e-n+t)%t];if(!i.hasAttribute("disabled")){var r=qi(i).getOwnerRoot()||document;if(this._setFocusedItem(i),qi(r).activeElement==i)return}}},_focusNext:function(){for(var t=this.items.length,e=Number(this.indexOf(this.focusedItem)),n=1;n<t+1;n++){var i=this.items[(e+n)%t];if(!i.hasAttribute("disabled")){var r=qi(i).getOwnerRoot()||document;if(this._setFocusedItem(i),qi(r).activeElement==i)return}}},_applySelection:function(t,e){t.setAttribute("aria-selected",e?"true":"false"),jo._applySelection.apply(this,arguments)},_focusedItemChanged:function(t,e){e&&e.setAttribute("tabindex","-1"),!t||t.hasAttribute("disabled")||this.disabled||(t.setAttribute("tabindex","0"),t.focus())},_onIronItemsChanged:function(t){t.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(t){var e=this.getAttribute("tabindex");Ka._shiftTabPressed=!0,this._setFocusedItem(null),this.setAttribute("tabindex","-1"),this.async((function(){this.setAttribute("tabindex",e),Ka._shiftTabPressed=!1}),1)},_onFocus:function(t){if(!Ka._shiftTabPressed){var e=qi(t).rootTarget;(e===this||void 0===e.tabIndex||this.isLightDescendant(e))&&(this._defaultFocusAsync=this.async((function(){var t=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null),t?this._setFocusedItem(t):this.items[0]&&this._focusNext()})))}},_onUpKey:function(t){this._focusPrevious(),t.detail.keyboardEvent.preventDefault()},_onDownKey:function(t){this._focusNext(),t.detail.keyboardEvent.preventDefault()},_onEscKey:function(t){var e=this.focusedItem;e&&e.blur()},_onKeydown:function(t){this.keyboardEventMatchesKeys(t,"up down esc")||this._focusWithKeyboardEvent(t),t.stopPropagation()},_activateHandler:function(t){jo._activateHandler.call(this,t),t.stopPropagation()},_disabledChanged:function(t){t?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)},_shiftTabPressed:!1},Za=[[jo,$a],Ro,Ka];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: block;
        padding: 8px 0;

        background: var(--paper-listbox-background-color, var(--primary-background-color));
        color: var(--paper-listbox-color, var(--primary-text-color));

        @apply --paper-listbox;
      }
    </style>

    <slot></slot>
`,is:"paper-listbox",behaviors:[Za],hostAttributes:{role:"listbox"}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Ja=_e`
<dom-module id="paper-material-shared-styles">
  <template>
    <style>
      :host {
        display: block;
        position: relative;
      }

      :host([elevation="1"]) {
        @apply --shadow-elevation-2dp;
      }

      :host([elevation="2"]) {
        @apply --shadow-elevation-4dp;
      }

      :host([elevation="3"]) {
        @apply --shadow-elevation-6dp;
      }

      :host([elevation="4"]) {
        @apply --shadow-elevation-8dp;
      }

      :host([elevation="5"]) {
        @apply --shadow-elevation-16dp;
      }
    </style>
  </template>
</dom-module>
`;Ja.setAttribute("style","display: none;"),document.body.appendChild(Ja.content),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
`,is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const Qa={properties:{value:{type:Number,value:0,notify:!0,reflectToAttribute:!0},min:{type:Number,value:0,notify:!0},max:{type:Number,value:100,notify:!0},step:{type:Number,value:1,notify:!0},ratio:{type:Number,value:0,readOnly:!0,notify:!0}},observers:["_update(value, min, max, step)"],_calcRatio:function(t){return(this._clampValue(t)-this.min)/(this.max-this.min)},_clampValue:function(t){return Math.min(this.max,Math.max(this.min,this._calcStep(t)))},_calcStep:function(t){if(t=parseFloat(t),!this.step)return t;var e=Math.round((t-this.min)/this.step);return this.step<1?e/(1/this.step)+this.min:e*this.step+this.min},_validateValue:function(){var t=this._clampValue(this.value);return this.value=this.oldValue=isNaN(t)?this.oldValue:t,this.value!==t},_update:function(){this._validateValue(),this._setRatio(100*this._calcRatio(this.value))}};
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */Nr({_template:_e`
    <style>
      :host {
        display: block;
        width: 200px;
        position: relative;
        overflow: hidden;
      }

      :host([hidden]), [hidden] {
        display: none !important;
      }

      #progressContainer {
        @apply --paper-progress-container;
        position: relative;
      }

      #progressContainer,
      /* the stripe for the indeterminate animation*/
      .indeterminate::after {
        height: var(--paper-progress-height, 4px);
      }

      #primaryProgress,
      #secondaryProgress,
      .indeterminate::after {
        @apply --layout-fit;
      }

      #progressContainer,
      .indeterminate::after {
        background: var(--paper-progress-container-color, var(--google-grey-300));
      }

      :host(.transiting) #primaryProgress,
      :host(.transiting) #secondaryProgress {
        -webkit-transition-property: -webkit-transform;
        transition-property: transform;

        /* Duration */
        -webkit-transition-duration: var(--paper-progress-transition-duration, 0.08s);
        transition-duration: var(--paper-progress-transition-duration, 0.08s);

        /* Timing function */
        -webkit-transition-timing-function: var(--paper-progress-transition-timing-function, ease);
        transition-timing-function: var(--paper-progress-transition-timing-function, ease);

        /* Delay */
        -webkit-transition-delay: var(--paper-progress-transition-delay, 0s);
        transition-delay: var(--paper-progress-transition-delay, 0s);
      }

      #primaryProgress,
      #secondaryProgress {
        @apply --layout-fit;
        -webkit-transform-origin: left center;
        transform-origin: left center;
        -webkit-transform: scaleX(0);
        transform: scaleX(0);
        will-change: transform;
      }

      #primaryProgress {
        background: var(--paper-progress-active-color, var(--google-green-500));
      }

      #secondaryProgress {
        background: var(--paper-progress-secondary-color, var(--google-green-100));
      }

      :host([disabled]) #primaryProgress {
        background: var(--paper-progress-disabled-active-color, var(--google-grey-500));
      }

      :host([disabled]) #secondaryProgress {
        background: var(--paper-progress-disabled-secondary-color, var(--google-grey-300));
      }

      :host(:not([disabled])) #primaryProgress.indeterminate {
        -webkit-transform-origin: right center;
        transform-origin: right center;
        -webkit-animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-bar var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      :host(:not([disabled])) #primaryProgress.indeterminate::after {
        content: "";
        -webkit-transform-origin: center center;
        transform-origin: center center;

        -webkit-animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
        animation: indeterminate-splitter var(--paper-progress-indeterminate-cycle-duration, 2s) linear infinite;
      }

      @-webkit-keyframes indeterminate-bar {
        0% {
          -webkit-transform: scaleX(1) translateX(-100%);
        }
        50% {
          -webkit-transform: scaleX(1) translateX(0%);
        }
        75% {
          -webkit-transform: scaleX(1) translateX(0%);
          -webkit-animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          -webkit-transform: scaleX(0) translateX(0%);
        }
      }

      @-webkit-keyframes indeterminate-splitter {
        0% {
          -webkit-transform: scaleX(.75) translateX(-125%);
        }
        30% {
          -webkit-transform: scaleX(.75) translateX(-125%);
          -webkit-animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
        100% {
          -webkit-transform: scaleX(.75) translateX(125%);
        }
      }

      @keyframes indeterminate-bar {
        0% {
          transform: scaleX(1) translateX(-100%);
        }
        50% {
          transform: scaleX(1) translateX(0%);
        }
        75% {
          transform: scaleX(1) translateX(0%);
          animation-timing-function: cubic-bezier(.28,.62,.37,.91);
        }
        100% {
          transform: scaleX(0) translateX(0%);
        }
      }

      @keyframes indeterminate-splitter {
        0% {
          transform: scaleX(.75) translateX(-125%);
        }
        30% {
          transform: scaleX(.75) translateX(-125%);
          animation-timing-function: cubic-bezier(.42,0,.6,.8);
        }
        90% {
          transform: scaleX(.75) translateX(125%);
        }
        100% {
          transform: scaleX(.75) translateX(125%);
        }
      }
    </style>

    <div id="progressContainer">
      <div id="secondaryProgress" hidden\$="[[_hideSecondaryProgress(secondaryRatio)]]"></div>
      <div id="primaryProgress"></div>
    </div>
`,is:"paper-progress",behaviors:[Qa],properties:{secondaryProgress:{type:Number,value:0},secondaryRatio:{type:Number,value:0,readOnly:!0},indeterminate:{type:Boolean,value:!1,observer:"_toggleIndeterminate"},disabled:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_disabledChanged"}},observers:["_progressChanged(secondaryProgress, value, min, max, indeterminate)"],hostAttributes:{role:"progressbar"},_toggleIndeterminate:function(t){this.toggleClass("indeterminate",t,this.$.primaryProgress)},_transformProgress:function(t,e){t.style.transform=t.style.webkitTransform="scaleX("+e/100+")"},_mainRatioChanged:function(t){this._transformProgress(this.$.primaryProgress,t)},_progressChanged:function(t,e,n,i,r){t=this._clampValue(t),e=this._clampValue(e);var o=100*this._calcRatio(t),a=100*this._calcRatio(e);this._setSecondaryRatio(o),this._transformProgress(this.$.secondaryProgress,o),this._transformProgress(this.$.primaryProgress,a),this.secondaryProgress=t,r?this.removeAttribute("aria-valuenow"):this.setAttribute("aria-valuenow",e),this.setAttribute("aria-valuemin",n),this.setAttribute("aria-valuemax",i)},_disabledChanged:function(t){this.setAttribute("aria-disabled",t?"true":"false")},_hideSecondaryProgress:function(t){return 0===t}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const ts=_e`
<style>
  :host {
    display: inline-block;
    line-height: 0;
    white-space: nowrap;
    cursor: pointer;
    @apply --paper-font-common-base;
    --calculated-paper-radio-button-size: var(--paper-radio-button-size, 16px);
    /* -1px is a sentinel for the default and is replace in \`attached\`. */
    --calculated-paper-radio-button-ink-size: var(--paper-radio-button-ink-size, -1px);
  }

  :host(:focus) {
    outline: none;
  }

  #radioContainer {
    @apply --layout-inline;
    @apply --layout-center-center;
    position: relative;
    width: var(--calculated-paper-radio-button-size);
    height: var(--calculated-paper-radio-button-size);
    vertical-align: middle;

    @apply --paper-radio-button-radio-container;
  }

  #ink {
    position: absolute;
    top: 50%;
    left: 50%;
    right: auto;
    width: var(--calculated-paper-radio-button-ink-size);
    height: var(--calculated-paper-radio-button-ink-size);
    color: var(--paper-radio-button-unchecked-ink-color, var(--primary-text-color));
    opacity: 0.6;
    pointer-events: none;
    -webkit-transform: translate(-50%, -50%);
    transform: translate(-50%, -50%);
  }

  #ink[checked] {
    color: var(--paper-radio-button-checked-ink-color, var(--primary-color));
  }

  #offRadio, #onRadio {
    position: absolute;
    box-sizing: border-box;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    border-radius: 50%;
  }

  #offRadio {
    border: 2px solid var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    background-color: var(--paper-radio-button-unchecked-background-color, transparent);
    transition: border-color 0.28s;
  }

  #onRadio {
    background-color: var(--paper-radio-button-checked-color, var(--primary-color));
    -webkit-transform: scale(0);
    transform: scale(0);
    transition: -webkit-transform ease 0.28s;
    transition: transform ease 0.28s;
    will-change: transform;
  }

  :host([checked]) #offRadio {
    border-color: var(--paper-radio-button-checked-color, var(--primary-color));
  }

  :host([checked]) #onRadio {
    -webkit-transform: scale(0.5);
    transform: scale(0.5);
  }

  #radioLabel {
    line-height: normal;
    position: relative;
    display: inline-block;
    vertical-align: middle;
    margin-left: var(--paper-radio-button-label-spacing, 10px);
    white-space: normal;
    color: var(--paper-radio-button-label-color, var(--primary-text-color));

    @apply --paper-radio-button-label;
  }

  :host([checked]) #radioLabel {
    @apply --paper-radio-button-label-checked;
  }

  #radioLabel:dir(rtl) {
    margin-left: 0;
    margin-right: var(--paper-radio-button-label-spacing, 10px);
  }

  #radioLabel[hidden] {
    display: none;
  }

  /* disabled state */

  :host([disabled]) #offRadio {
    border-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled][checked]) #onRadio {
    background-color: var(--paper-radio-button-unchecked-color, var(--primary-text-color));
    opacity: 0.5;
  }

  :host([disabled]) #radioLabel {
    /* slightly darker than the button, so that it's readable */
    opacity: 0.65;
  }
</style>

<div id="radioContainer">
  <div id="offRadio"></div>
  <div id="onRadio"></div>
</div>

<div id="radioLabel"><slot></slot></div>`;ts.setAttribute("strip-whitespace",""),Nr({_template:ts,is:"paper-radio-button",behaviors:[ca],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){ki(this,(function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim()){var t=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),e=Math.floor(3*t);e%2!=t%2&&e++,this.updateStyles({"--paper-radio-button-ink-size":e+"px"})}}))}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const es={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(t){this.focusedItem.click(),t.detail.keyboardEvent.preventDefault()},_onDownKey:function(t){this.focusedItem.click(),t.detail.keyboardEvent.preventDefault()},get _isRTL(){return"rtl"===window.getComputedStyle(this).direction},_onLeftKey:function(t){this._isRTL?this._focusNext():this._focusPrevious(),t.detail.keyboardEvent.preventDefault()},_onRightKey:function(t){this._isRTL?this._focusPrevious():this._focusNext(),t.detail.keyboardEvent.preventDefault()},_onKeydown:function(t){this.keyboardEventMatchesKeys(t,"up down left right esc")||this._focusWithKeyboardEvent(t)}},ns=[Za,es];
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: inline-block;
      }

      :host ::slotted(*) {
        padding: var(--paper-radio-group-item-padding, 12px);
      }
    </style>

    <slot></slot>
`,is:"paper-radio-group",behaviors:[ns],hostAttributes:{role:"radiogroup"},properties:{attrForSelected:{type:String,value:"name"},selectedAttribute:{type:String,value:"checked"},selectable:{type:String,value:"paper-radio-button"},allowEmptySelection:{type:Boolean,value:!1}},select:function(t){var e=this._valueToItem(t);if(!e||!e.hasAttribute("disabled")){if(this.selected){var n=this._valueToItem(this.selected);if(this.selected==t){if(!this.allowEmptySelection)return void(n&&(n.checked=!0));t=""}n&&(n.checked=!1)}jo.select.apply(this,[t]),this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(t){this._focusPrevious(),t.preventDefault(),this._activateFocusedItem()},_onDownKey:function(t){this._focusNext(),t.preventDefault(),this._activateFocusedItem()},_onLeftKey:function(t){es._onLeftKey.apply(this,arguments),this._activateFocusedItem()},_onRightKey:function(t){es._onRightKey.apply(this,arguments),this._activateFocusedItem()}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const is=_e`
  <style>
    :host {
      @apply --layout;
      @apply --layout-justified;
      @apply --layout-center;
      width: 200px;
      cursor: default;
      -webkit-user-select: none;
      -moz-user-select: none;
      -ms-user-select: none;
      user-select: none;
      -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
      --paper-progress-active-color: var(--paper-slider-active-color, var(--google-blue-700));
      --paper-progress-secondary-color: var(--paper-slider-secondary-color, var(--google-blue-300));
      --paper-progress-disabled-active-color: var(--paper-slider-disabled-active-color, var(--paper-grey-400));
      --paper-progress-disabled-secondary-color: var(--paper-slider-disabled-secondary-color, var(--paper-grey-400));
      --calculated-paper-slider-height: var(--paper-slider-height, 2px);
    }

    /* focus shows the ripple */
    :host(:focus) {
      outline: none;
    }

    /**
      * NOTE(keanulee): Though :host-context is not universally supported, some pages
      * still rely on paper-slider being flipped when dir="rtl" is set on body. For full
      * compatibility, dir="rtl" must be explicitly set on paper-slider.
      */
    :dir(rtl) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): This is separate from the rule above because :host-context may
      * not be recognized.
      */
    :host([dir="rtl"]) #sliderContainer {
      -webkit-transform: scaleX(-1);
      transform: scaleX(-1);
    }

    /**
      * NOTE(keanulee): Needed to override the :host-context rule (where supported)
      * to support LTR sliders in RTL pages.
      */
    :host([dir="ltr"]) #sliderContainer {
      -webkit-transform: scaleX(1);
      transform: scaleX(1);
    }

    #sliderContainer {
      position: relative;
      width: 100%;
      height: calc(30px + var(--calculated-paper-slider-height));
      margin-left: calc(15px + var(--calculated-paper-slider-height)/2);
      margin-right: calc(15px + var(--calculated-paper-slider-height)/2);
    }

    #sliderContainer:focus {
      outline: 0;
    }

    #sliderContainer.editable {
      margin-top: 12px;
      margin-bottom: 12px;
    }

    .bar-container {
      position: absolute;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      overflow: hidden;
    }

    .ring > .bar-container {
      left: calc(5px + var(--calculated-paper-slider-height)/2);
      transition: left 0.18s ease;
    }

    .ring.expand.dragging > .bar-container {
      transition: none;
    }

    .ring.expand:not(.pin) > .bar-container {
      left: calc(8px + var(--calculated-paper-slider-height)/2);
    }

    #sliderBar {
      padding: 15px 0;
      width: 100%;
      background-color: var(--paper-slider-bar-color, transparent);
      --paper-progress-container-color: var(--paper-slider-container-color, var(--paper-grey-400));
      --paper-progress-height: var(--calculated-paper-slider-height);
    }

    .slider-markers {
      position: absolute;
      /* slider-knob is 30px + the slider-height so that the markers should start at a offset of 15px*/
      top: 15px;
      height: var(--calculated-paper-slider-height);
      left: 0;
      right: -1px;
      box-sizing: border-box;
      pointer-events: none;
      @apply --layout-horizontal;
    }

    .slider-marker {
      @apply --layout-flex;
    }
    .slider-markers::after,
    .slider-marker::after {
      content: "";
      display: block;
      margin-left: -1px;
      width: 2px;
      height: var(--calculated-paper-slider-height);
      border-radius: 50%;
      background-color: var(--paper-slider-markers-color, #000);
    }

    .slider-knob {
      position: absolute;
      left: 0;
      top: 0;
      margin-left: calc(-15px - var(--calculated-paper-slider-height)/2);
      width: calc(30px + var(--calculated-paper-slider-height));
      height: calc(30px + var(--calculated-paper-slider-height));
    }

    .transiting > .slider-knob {
      transition: left 0.08s ease;
    }

    .slider-knob:focus {
      outline: none;
    }

    .slider-knob.dragging {
      transition: none;
    }

    .snaps > .slider-knob.dragging {
      transition: -webkit-transform 0.08s ease;
      transition: transform 0.08s ease;
    }

    .slider-knob-inner {
      margin: 10px;
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: var(--paper-slider-knob-color, var(--google-blue-700));
      border: 2px solid var(--paper-slider-knob-color, var(--google-blue-700));
      border-radius: 50%;

      -moz-box-sizing: border-box;
      box-sizing: border-box;

      transition-property: -webkit-transform, background-color, border;
      transition-property: transform, background-color, border;
      transition-duration: 0.18s;
      transition-timing-function: ease;
    }

    .expand:not(.pin) > .slider-knob > .slider-knob-inner {
      -webkit-transform: scale(1.5);
      transform: scale(1.5);
    }

    .ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-color, var(--google-blue-700));
    }

    .pin > .slider-knob > .slider-knob-inner::before {
      content: "";
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -13px;
      width: 26px;
      height: 26px;
      border-radius: 50% 50% 50% 0;

      -webkit-transform: rotate(-45deg) scale(0) translate(0);
      transform: rotate(-45deg) scale(0) translate(0);
    }

    .slider-knob-inner::before,
    .slider-knob-inner::after {
      transition: -webkit-transform .18s ease, background-color .18s ease;
      transition: transform .18s ease, background-color .18s ease;
    }

    .pin.ring > .slider-knob > .slider-knob-inner::before {
      background-color: var(--paper-slider-pin-start-color, var(--paper-grey-400));
    }

    .pin.expand > .slider-knob > .slider-knob-inner::before {
      -webkit-transform: rotate(-45deg) scale(1) translate(17px, -17px);
      transform: rotate(-45deg) scale(1) translate(17px, -17px);
    }

    .pin > .slider-knob > .slider-knob-inner::after {
      content: attr(value);
      position: absolute;
      top: 0;
      left: 50%;
      margin-left: -16px;
      width: 32px;
      height: 26px;
      text-align: center;
      color: var(--paper-slider-font-color, #fff);
      font-size: 10px;

      -webkit-transform: scale(0) translate(0);
      transform: scale(0) translate(0);
    }

    .pin.expand > .slider-knob > .slider-knob-inner::after {
      -webkit-transform: scale(1) translate(0, -17px);
      transform: scale(1) translate(0, -17px);
    }

    /* paper-input */
    .slider-input {
      width: 50px;
      overflow: hidden;
      --paper-input-container-input: {
        text-align: center;
        @apply --paper-slider-input-container-input;
      };
      @apply --paper-slider-input;
    }

    /* disabled state */
    #sliderContainer.disabled {
      pointer-events: none;
    }

    .disabled > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      border: 2px solid var(--paper-slider-disabled-knob-color, var(--paper-grey-400));
      -webkit-transform: scale3d(0.75, 0.75, 1);
      transform: scale3d(0.75, 0.75, 1);
    }

    .disabled.ring > .slider-knob > .slider-knob-inner {
      background-color: var(--paper-slider-knob-start-color, transparent);
      border: 2px solid var(--paper-slider-knob-start-border-color, var(--paper-grey-400));
    }

    paper-ripple {
      color: var(--paper-slider-knob-color, var(--google-blue-700));
    }
  </style>

  <div id="sliderContainer" class\$="[[_getClassNames(disabled, pin, snaps, immediateValue, min, expand, dragging, transiting, editable)]]">
    <div class="bar-container">
      <paper-progress disabled\$="[[disabled]]" id="sliderBar" aria-hidden="true" min="[[min]]" max="[[max]]" step="[[step]]" value="[[immediateValue]]" secondary-progress="[[secondaryProgress]]" on-down="_bardown" on-up="_resetKnob" on-track="_bartrack" on-tap="_barclick">
      </paper-progress>
    </div>

    <template is="dom-if" if="[[snaps]]">
      <div class="slider-markers">
        <template is="dom-repeat" items="[[markers]]">
          <div class="slider-marker"></div>
        </template>
      </div>
    </template>

    <div id="sliderKnob" class="slider-knob" on-down="_knobdown" on-up="_resetKnob" on-track="_onTrack" on-transitionend="_knobTransitionEnd">
        <div class="slider-knob-inner" value\$="[[immediateValue]]"></div>
    </div>
  </div>

  <template is="dom-if" if="[[editable]]">
    <paper-input id="input" type="number" step="[[step]]" min="[[min]]" max="[[max]]" class="slider-input" disabled\$="[[disabled]]" value="[[immediateValue]]" on-change="_changeValue" on-keydown="_inputKeyDown" no-label-float>
    </paper-input>
  </template>
`;is.setAttribute("strip-whitespace",""),Nr({_template:is,is:"paper-slider",behaviors:[Ro,ia,la,Qa],properties:{value:{type:Number,value:0},snaps:{type:Boolean,value:!1,notify:!0},pin:{type:Boolean,value:!1,notify:!0},secondaryProgress:{type:Number,value:0,notify:!0,observer:"_secondaryProgressChanged"},editable:{type:Boolean,value:!1},immediateValue:{type:Number,value:0,readOnly:!0,notify:!0},maxMarkers:{type:Number,value:0,notify:!0},expand:{type:Boolean,value:!1,readOnly:!0},ignoreBarTouch:{type:Boolean,value:!1},dragging:{type:Boolean,value:!1,readOnly:!0,notify:!0},transiting:{type:Boolean,value:!1,readOnly:!0},markers:{type:Array,readOnly:!0,value:function(){return[]}}},observers:["_updateKnob(value, min, max, snaps, step)","_valueChanged(value)","_immediateValueChanged(immediateValue)","_updateMarkers(maxMarkers, min, max, snaps)"],hostAttributes:{role:"slider",tabindex:0},keyBindings:{left:"_leftKey",right:"_rightKey","down pagedown home":"_decrementKey","up pageup end":"_incrementKey"},ready:function(){this.ignoreBarTouch&&ri(this.$.sliderBar,"auto")},increment:function(){this.value=this._clampValue(this.value+this.step)},decrement:function(){this.value=this._clampValue(this.value-this.step)},_updateKnob:function(t,e,n,i,r){this.setAttribute("aria-valuemin",e),this.setAttribute("aria-valuemax",n),this.setAttribute("aria-valuenow",t),this._positionKnob(100*this._calcRatio(t))},_valueChanged:function(){this.fire("value-change",{composed:!0})},_immediateValueChanged:function(){this.dragging?this.fire("immediate-value-change",{composed:!0}):this.value=this.immediateValue},_secondaryProgressChanged:function(){this.secondaryProgress=this._clampValue(this.secondaryProgress)},_expandKnob:function(){this._setExpand(!0)},_resetKnob:function(){this.cancelDebouncer("expandKnob"),this._setExpand(!1)},_positionKnob:function(t){this._setImmediateValue(this._calcStep(this._calcKnobPosition(t))),this._setRatio(100*this._calcRatio(this.immediateValue)),this.$.sliderKnob.style.left=this.ratio+"%",this.dragging&&(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(t){return(this.max-this.min)*t/100+this.min},_onTrack:function(t){switch(t.stopPropagation(),t.detail.state){case"start":this._trackStart(t);break;case"track":this._trackX(t);break;case"end":this._trackEnd()}},_trackStart:function(t){this._setTransiting(!1),this._w=this.$.sliderBar.offsetWidth,this._x=this.ratio*this._w/100,this._startx=this._x,this._knobstartx=this._startx,this._minx=-this._startx,this._maxx=this._w-this._startx,this.$.sliderKnob.classList.add("dragging"),this._setDragging(!0)},_trackX:function(t){this.dragging||this._trackStart(t);var e=Math.min(this._maxx,Math.max(this._minx,t.detail.dx*(this._isRTL?-1:1)));this._x=this._startx+e;var n=this._calcStep(this._calcKnobPosition(this._x/this._w*100));this._setImmediateValue(n);var i=this._calcRatio(this.immediateValue)*this._w-this._knobstartx;this.translate3d(i+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var t=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging"),this._setDragging(!1),this._resetKnob(),this.value=this.immediateValue,t.transform=t.webkitTransform="",this.fire("change",{composed:!0})},_knobdown:function(t){this._expandKnob(),t.preventDefault(),this.focus()},_bartrack:function(t){this._allowBarEvent(t)&&this._onTrack(t)},_barclick:function(t){this._w=this.$.sliderBar.offsetWidth;var e=this.$.sliderBar.getBoundingClientRect(),n=(t.detail.x-e.left)/this._w*100;this._isRTL&&(n=100-n);var i=this.ratio;this._setTransiting(!0),this._positionKnob(n),i===this.ratio&&this._setTransiting(!1),this.async((function(){this.fire("change",{composed:!0})})),t.preventDefault(),this.focus()},_bardown:function(t){this._allowBarEvent(t)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(t))},_knobTransitionEnd:function(t){t.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(t,e,n,i){i||this._setMarkers([]);var r=Math.round((n-e)/this.step);r>t&&(r=t),(r<0||!isFinite(r))&&(r=0),this._setMarkers(new Array(r))},_mergeClasses:function(t){return Object.keys(t).filter((function(e){return t[e]})).join(" ")},_getClassNames:function(){return this._mergeClasses({disabled:this.disabled,pin:this.pin,snaps:this.snaps,ring:this.immediateValue<=this.min,expand:this.expand,dragging:this.dragging,transiting:this.transiting,editable:this.editable})},_allowBarEvent:function(t){return!this.ignoreBarTouch||t.detail.sourceEvent instanceof MouseEvent},get _isRTL(){return void 0===this.__isRTL&&(this.__isRTL="rtl"===window.getComputedStyle(this).direction),this.__isRTL},_leftKey:function(t){this._isRTL?this._incrementKey(t):this._decrementKey(t)},_rightKey:function(t){this._isRTL?this._decrementKey(t):this._incrementKey(t)},_incrementKey:function(t){this.disabled||("end"===t.detail.key?this.value=this.max:this.increment(),this.fire("change"),t.preventDefault())},_decrementKey:function(t){this.disabled||("home"===t.detail.key?this.value=this.min:this.decrement(),this.fire("change"),t.preventDefault())},_changeValue:function(t){this.value=t.target.value,this.fire("change",{composed:!0})},_inputKeyDown:function(t){t.stopPropagation()},_createRipple:function(){return this._rippleContainer=this.$.sliderKnob,sa._createRipple.call(this)},_focusedChanged:function(t){t&&this.ensureRipple(),this.hasRipple()&&(this._ripple.style.display=t?"":"none",this._ripple.holdDown=t)}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const rs=document.createElement("template");rs.setAttribute("style","display: none;"),rs.innerHTML="<dom-module id=\"paper-spinner-styles\">\n  <template>\n    <style>\n      /*\n      /**************************/\n      /* STYLES FOR THE SPINNER */\n      /**************************/\n\n      /*\n       * Constants:\n       *      ARCSIZE     = 270 degrees (amount of circle the arc takes up)\n       *      ARCTIME     = 1333ms (time it takes to expand and contract arc)\n       *      ARCSTARTROT = 216 degrees (how much the start location of the arc\n       *                                should rotate each time, 216 gives us a\n       *                                5 pointed star shape (it's 360/5 * 3).\n       *                                For a 7 pointed star, we might do\n       *                                360/7 * 3 = 154.286)\n       *      SHRINK_TIME = 400ms\n       */\n\n      :host {\n        display: inline-block;\n        position: relative;\n        width: 28px;\n        height: 28px;\n\n        /* 360 * ARCTIME / (ARCSTARTROT + (360-ARCSIZE)) */\n        --paper-spinner-container-rotation-duration: 1568ms;\n\n        /* ARCTIME */\n        --paper-spinner-expand-contract-duration: 1333ms;\n\n        /* 4 * ARCTIME */\n        --paper-spinner-full-cycle-duration: 5332ms;\n\n        /* SHRINK_TIME */\n        --paper-spinner-cooldown-duration: 400ms;\n      }\n\n      #spinnerContainer {\n        width: 100%;\n        height: 100%;\n\n        /* The spinner does not have any contents that would have to be\n         * flipped if the direction changes. Always use ltr so that the\n         * style works out correctly in both cases. */\n        direction: ltr;\n      }\n\n      #spinnerContainer.active {\n        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;\n        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite;\n      }\n\n      @-webkit-keyframes container-rotate {\n        to { -webkit-transform: rotate(360deg) }\n      }\n\n      @keyframes container-rotate {\n        to { transform: rotate(360deg) }\n      }\n\n      .spinner-layer {\n        position: absolute;\n        width: 100%;\n        height: 100%;\n        opacity: 0;\n        white-space: nowrap;\n        color: var(--paper-spinner-color, var(--google-blue-500));\n      }\n\n      .layer-1 {\n        color: var(--paper-spinner-layer-1-color, var(--google-blue-500));\n      }\n\n      .layer-2 {\n        color: var(--paper-spinner-layer-2-color, var(--google-red-500));\n      }\n\n      .layer-3 {\n        color: var(--paper-spinner-layer-3-color, var(--google-yellow-500));\n      }\n\n      .layer-4 {\n        color: var(--paper-spinner-layer-4-color, var(--google-green-500));\n      }\n\n      /**\n       * IMPORTANT NOTE ABOUT CSS ANIMATION PROPERTIES (keanulee):\n       *\n       * iOS Safari (tested on iOS 8.1) does not handle animation-delay very well - it doesn't\n       * guarantee that the animation will start _exactly_ after that value. So we avoid using\n       * animation-delay and instead set custom keyframes for each color (as layer-2undant as it\n       * seems).\n       */\n      .active .spinner-layer {\n        -webkit-animation-name: fill-unfill-rotate;\n        -webkit-animation-duration: var(--paper-spinner-full-cycle-duration);\n        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);\n        -webkit-animation-iteration-count: infinite;\n        animation-name: fill-unfill-rotate;\n        animation-duration: var(--paper-spinner-full-cycle-duration);\n        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);\n        animation-iteration-count: infinite;\n        opacity: 1;\n      }\n\n      .active .spinner-layer.layer-1 {\n        -webkit-animation-name: fill-unfill-rotate, layer-1-fade-in-out;\n        animation-name: fill-unfill-rotate, layer-1-fade-in-out;\n      }\n\n      .active .spinner-layer.layer-2 {\n        -webkit-animation-name: fill-unfill-rotate, layer-2-fade-in-out;\n        animation-name: fill-unfill-rotate, layer-2-fade-in-out;\n      }\n\n      .active .spinner-layer.layer-3 {\n        -webkit-animation-name: fill-unfill-rotate, layer-3-fade-in-out;\n        animation-name: fill-unfill-rotate, layer-3-fade-in-out;\n      }\n\n      .active .spinner-layer.layer-4 {\n        -webkit-animation-name: fill-unfill-rotate, layer-4-fade-in-out;\n        animation-name: fill-unfill-rotate, layer-4-fade-in-out;\n      }\n\n      @-webkit-keyframes fill-unfill-rotate {\n        12.5% { -webkit-transform: rotate(135deg) } /* 0.5 * ARCSIZE */\n        25%   { -webkit-transform: rotate(270deg) } /* 1   * ARCSIZE */\n        37.5% { -webkit-transform: rotate(405deg) } /* 1.5 * ARCSIZE */\n        50%   { -webkit-transform: rotate(540deg) } /* 2   * ARCSIZE */\n        62.5% { -webkit-transform: rotate(675deg) } /* 2.5 * ARCSIZE */\n        75%   { -webkit-transform: rotate(810deg) } /* 3   * ARCSIZE */\n        87.5% { -webkit-transform: rotate(945deg) } /* 3.5 * ARCSIZE */\n        to    { -webkit-transform: rotate(1080deg) } /* 4   * ARCSIZE */\n      }\n\n      @keyframes fill-unfill-rotate {\n        12.5% { transform: rotate(135deg) } /* 0.5 * ARCSIZE */\n        25%   { transform: rotate(270deg) } /* 1   * ARCSIZE */\n        37.5% { transform: rotate(405deg) } /* 1.5 * ARCSIZE */\n        50%   { transform: rotate(540deg) } /* 2   * ARCSIZE */\n        62.5% { transform: rotate(675deg) } /* 2.5 * ARCSIZE */\n        75%   { transform: rotate(810deg) } /* 3   * ARCSIZE */\n        87.5% { transform: rotate(945deg) } /* 3.5 * ARCSIZE */\n        to    { transform: rotate(1080deg) } /* 4   * ARCSIZE */\n      }\n\n      @-webkit-keyframes layer-1-fade-in-out {\n        0% { opacity: 1 }\n        25% { opacity: 1 }\n        26% { opacity: 0 }\n        89% { opacity: 0 }\n        90% { opacity: 1 }\n        to { opacity: 1 }\n      }\n\n      @keyframes layer-1-fade-in-out {\n        0% { opacity: 1 }\n        25% { opacity: 1 }\n        26% { opacity: 0 }\n        89% { opacity: 0 }\n        90% { opacity: 1 }\n        to { opacity: 1 }\n      }\n\n      @-webkit-keyframes layer-2-fade-in-out {\n        0% { opacity: 0 }\n        15% { opacity: 0 }\n        25% { opacity: 1 }\n        50% { opacity: 1 }\n        51% { opacity: 0 }\n        to { opacity: 0 }\n      }\n\n      @keyframes layer-2-fade-in-out {\n        0% { opacity: 0 }\n        15% { opacity: 0 }\n        25% { opacity: 1 }\n        50% { opacity: 1 }\n        51% { opacity: 0 }\n        to { opacity: 0 }\n      }\n\n      @-webkit-keyframes layer-3-fade-in-out {\n        0% { opacity: 0 }\n        40% { opacity: 0 }\n        50% { opacity: 1 }\n        75% { opacity: 1 }\n        76% { opacity: 0 }\n        to { opacity: 0 }\n      }\n\n      @keyframes layer-3-fade-in-out {\n        0% { opacity: 0 }\n        40% { opacity: 0 }\n        50% { opacity: 1 }\n        75% { opacity: 1 }\n        76% { opacity: 0 }\n        to { opacity: 0 }\n      }\n\n      @-webkit-keyframes layer-4-fade-in-out {\n        0% { opacity: 0 }\n        65% { opacity: 0 }\n        75% { opacity: 1 }\n        90% { opacity: 1 }\n        to { opacity: 0 }\n      }\n\n      @keyframes layer-4-fade-in-out {\n        0% { opacity: 0 }\n        65% { opacity: 0 }\n        75% { opacity: 1 }\n        90% { opacity: 1 }\n        to { opacity: 0 }\n      }\n\n      .circle-clipper {\n        display: inline-block;\n        position: relative;\n        width: 50%;\n        height: 100%;\n        overflow: hidden;\n      }\n\n      /**\n       * Patch the gap that appear between the two adjacent div.circle-clipper while the\n       * spinner is rotating (appears on Chrome 50, Safari 9.1.1, and Edge).\n       */\n      .spinner-layer::after {\n        content: '';\n        left: 45%;\n        width: 10%;\n        border-top-style: solid;\n      }\n\n      .spinner-layer::after,\n      .circle-clipper .circle {\n        box-sizing: border-box;\n        position: absolute;\n        top: 0;\n        border-width: var(--paper-spinner-stroke-width, 3px);\n        border-radius: 50%;\n      }\n\n      .circle-clipper .circle {\n        bottom: 0;\n        width: 200%;\n        border-style: solid;\n        border-bottom-color: transparent !important;\n      }\n\n      .circle-clipper.left .circle {\n        left: 0;\n        border-right-color: transparent !important;\n        -webkit-transform: rotate(129deg);\n        transform: rotate(129deg);\n      }\n\n      .circle-clipper.right .circle {\n        left: -100%;\n        border-left-color: transparent !important;\n        -webkit-transform: rotate(-129deg);\n        transform: rotate(-129deg);\n      }\n\n      .active .gap-patch::after,\n      .active .circle-clipper .circle {\n        -webkit-animation-duration: var(--paper-spinner-expand-contract-duration);\n        -webkit-animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);\n        -webkit-animation-iteration-count: infinite;\n        animation-duration: var(--paper-spinner-expand-contract-duration);\n        animation-timing-function: cubic-bezier(0.4, 0.0, 0.2, 1);\n        animation-iteration-count: infinite;\n      }\n\n      .active .circle-clipper.left .circle {\n        -webkit-animation-name: left-spin;\n        animation-name: left-spin;\n      }\n\n      .active .circle-clipper.right .circle {\n        -webkit-animation-name: right-spin;\n        animation-name: right-spin;\n      }\n\n      @-webkit-keyframes left-spin {\n        0% { -webkit-transform: rotate(130deg) }\n        50% { -webkit-transform: rotate(-5deg) }\n        to { -webkit-transform: rotate(130deg) }\n      }\n\n      @keyframes left-spin {\n        0% { transform: rotate(130deg) }\n        50% { transform: rotate(-5deg) }\n        to { transform: rotate(130deg) }\n      }\n\n      @-webkit-keyframes right-spin {\n        0% { -webkit-transform: rotate(-130deg) }\n        50% { -webkit-transform: rotate(5deg) }\n        to { -webkit-transform: rotate(-130deg) }\n      }\n\n      @keyframes right-spin {\n        0% { transform: rotate(-130deg) }\n        50% { transform: rotate(5deg) }\n        to { transform: rotate(-130deg) }\n      }\n\n      #spinnerContainer.cooldown {\n        -webkit-animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);\n        animation: container-rotate var(--paper-spinner-container-rotation-duration) linear infinite, fade-out var(--paper-spinner-cooldown-duration) cubic-bezier(0.4, 0.0, 0.2, 1);\n      }\n\n      @-webkit-keyframes fade-out {\n        0% { opacity: 1 }\n        to { opacity: 0 }\n      }\n\n      @keyframes fade-out {\n        0% { opacity: 1 }\n        to { opacity: 0 }\n      }\n    </style>\n  </template>\n</dom-module>",document.head.appendChild(rs.content);
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const os={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(t,e){return[t||e?"active":"",e?"cooldown":""].join(" ")},__activeChanged:function(t,e){this.__setAriaHidden(!t),this.__coolingDown=!t&&e},__altChanged:function(t){"loading"===t?this.alt=this.getAttribute("aria-label")||t:(this.__setAriaHidden(""===t),this.setAttribute("aria-label",t))},__setAriaHidden:function(t){var e="aria-hidden";t?this.setAttribute(e,"true"):this.removeAttribute(e)},__reset:function(){this.active=!1,this.__coolingDown=!1}},as=_e`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */as.setAttribute("strip-whitespace",""),Nr({_template:as,is:"paper-spinner-lite",behaviors:[os]});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
const ss=_e`
  <style include="paper-spinner-styles"></style>

  <div id="spinnerContainer" class-name="[[__computeContainerClasses(active, __coolingDown)]]" on-animationend="__reset" on-webkit-animation-end="__reset">
    <div class="spinner-layer layer-1">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-2">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-3">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>

    <div class="spinner-layer layer-4">
      <div class="circle-clipper left">
        <div class="circle"></div>
      </div>
      <div class="circle-clipper right">
        <div class="circle"></div>
      </div>
    </div>
  </div>
`;ss.setAttribute("strip-whitespace",""),Nr({_template:ss,is:"paper-spinner",behaviors:[os]});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const ls=_e`<iron-iconset-svg name="paper-tabs" size="24">
<svg><defs>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g>
</defs></svg>
</iron-iconset-svg>`;document.head.appendChild(ls.content),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        @apply --layout-inline;
        @apply --layout-center;
        @apply --layout-center-justified;
        @apply --layout-flex-auto;

        position: relative;
        padding: 0 12px;
        overflow: hidden;
        cursor: pointer;
        vertical-align: middle;

        @apply --paper-font-common-base;
        @apply --paper-tab;
      }

      :host(:focus) {
        outline: none;
      }

      :host([link]) {
        padding: 0;
      }

      .tab-content {
        height: 100%;
        transform: translateZ(0);
          -webkit-transform: translateZ(0);
        transition: opacity 0.1s cubic-bezier(0.4, 0.0, 1, 1);
        @apply --layout-horizontal;
        @apply --layout-center-center;
        @apply --layout-flex-auto;
        @apply --paper-tab-content;
      }

      :host(:not(.iron-selected)) > .tab-content {
        opacity: 0.8;

        @apply --paper-tab-content-unselected;
      }

      :host(:focus) .tab-content {
        opacity: 1;
        font-weight: 700;

        @apply --paper-tab-content-focused;
      }

      paper-ripple {
        color: var(--paper-tab-ink, var(--paper-yellow-a100));
      }

      .tab-content > ::slotted(a) {
        @apply --layout-flex-auto;

        height: 100%;
      }
    </style>

    <div class="tab-content">
      <slot></slot>
    </div>
`,is:"paper-tab",behaviors:[Wo,Yo,Zo],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var t=qi(this).parentNode;return!!t&&!!t.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(t){if(this.link){var e=this.queryEffectiveChildren("a");if(!e)return;if(t.target===e)return;e.click()}}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        @apply --layout;
        @apply --layout-center;

        height: 48px;
        font-size: 14px;
        font-weight: 500;
        overflow: hidden;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;

        /* NOTE: Both values are needed, since some phones require the value to be \`transparent\`. */
        -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
        -webkit-tap-highlight-color: transparent;

        @apply --paper-tabs;
      }

      :host(:dir(rtl)) {
        @apply --layout-horizontal-reverse;
      }

      #tabsContainer {
        position: relative;
        height: 100%;
        white-space: nowrap;
        overflow: hidden;
        @apply --layout-flex-auto;
        @apply --paper-tabs-container;
      }

      #tabsContent {
        height: 100%;
        -moz-flex-basis: auto;
        -ms-flex-basis: auto;
        flex-basis: auto;
        @apply --paper-tabs-content;
      }

      #tabsContent.scrollable {
        position: absolute;
        white-space: nowrap;
      }

      #tabsContent:not(.scrollable),
      #tabsContent.scrollable.fit-container {
        @apply --layout-horizontal;
      }

      #tabsContent.scrollable.fit-container {
        min-width: 100%;
      }

      #tabsContent.scrollable.fit-container > ::slotted(*) {
        /* IE - prevent tabs from compressing when they should scroll. */
        -ms-flex: 1 0 auto;
        -webkit-flex: 1 0 auto;
        flex: 1 0 auto;
      }

      .hidden {
        display: none;
      }

      .not-visible {
        opacity: 0;
        cursor: default;
      }

      paper-icon-button {
        width: 48px;
        height: 48px;
        padding: 12px;
        margin: 0 4px;
      }

      #selectionBar {
        position: absolute;
        height: 0;
        bottom: 0;
        left: 0;
        right: 0;
        border-bottom: 2px solid var(--paper-tabs-selection-bar-color, var(--paper-yellow-a100));
          -webkit-transform: scale(0);
        transform: scale(0);
          -webkit-transform-origin: left center;
        transform-origin: left center;
          transition: -webkit-transform;
        transition: transform;

        @apply --paper-tabs-selection-bar;
      }

      #selectionBar.align-bottom {
        top: 0;
        bottom: auto;
      }

      #selectionBar.expand {
        transition-duration: 0.15s;
        transition-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
      }

      #selectionBar.contract {
        transition-duration: 0.18s;
        transition-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
      }

      #tabsContent > ::slotted(:not(#selectionBar)) {
        height: 100%;
      }
    </style>

    <paper-icon-button icon="paper-tabs:chevron-left" class$="[[_computeScrollButtonClass(_leftHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onLeftScrollButtonDown" tabindex="-1"></paper-icon-button>

    <div id="tabsContainer" on-track="_scroll" on-down="_down">
      <div id="tabsContent" class$="[[_computeTabsContentClass(scrollable, fitContainer)]]">
        <div id="selectionBar" class$="[[_computeSelectionBarClass(noBar, alignBottom)]]" on-transitionend="_onBarTransitionEnd"></div>
        <slot></slot>
      </div>
    </div>

    <paper-icon-button icon="paper-tabs:chevron-right" class$="[[_computeScrollButtonClass(_rightHidden, scrollable, hideScrollButtons)]]" on-up="_onScrollButtonUp" on-down="_onRightScrollButtonDown" tabindex="-1"></paper-icon-button>
`,is:"paper-tabs",behaviors:[mo,ns],properties:{noink:{type:Boolean,value:!1,observer:"_noinkChanged"},noBar:{type:Boolean,value:!1},noSlide:{type:Boolean,value:!1},scrollable:{type:Boolean,value:!1},fitContainer:{type:Boolean,value:!1},disableDrag:{type:Boolean,value:!1},hideScrollButtons:{type:Boolean,value:!1},alignBottom:{type:Boolean,value:!1},selectable:{type:String,value:"paper-tab"},autoselect:{type:Boolean,value:!1},autoselectDelay:{type:Number,value:0},_step:{type:Number,value:10},_holdDelay:{type:Number,value:1},_leftHidden:{type:Boolean,value:!1},_rightHidden:{type:Boolean,value:!1},_previousTab:{type:Object}},hostAttributes:{role:"tablist"},listeners:{"iron-resize":"_onTabSizingChanged","iron-items-changed":"_onTabSizingChanged","iron-select":"_onIronSelect","iron-deselect":"_onIronDeselect"},keyBindings:{"left:keyup right:keyup":"_onArrowKeyup"},created:function(){this._holdJob=null,this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,this._bindDelayedActivationHandler=this._delayedActivationHandler.bind(this),this.addEventListener("blur",this._onBlurCapture.bind(this),!0)},ready:function(){this.setScrollDirection("y",this.$.tabsContainer)},detached:function(){this._cancelPendingActivation()},_noinkChanged:function(t){qi(this).querySelectorAll("paper-tab").forEach(t?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(t){t.setAttribute("noink","")},_removeNoinkAttribute:function(t){t.removeAttribute("noink")},_computeScrollButtonClass:function(t,e,n){return!e||n?"hidden":t?"not-visible":""},_computeTabsContentClass:function(t,e){return t?"scrollable"+(e?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(t,e){return t?"hidden":e?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",(function(){this._scroll(),this._tabChanged(this.selectedItem)}),10)},_onIronSelect:function(t){this._tabChanged(t.detail.item,this._previousTab),this._previousTab=t.detail.item,this.cancelDebouncer("tab-changed")},_onIronDeselect:function(t){this.debounce("tab-changed",(function(){this._tabChanged(null,this._previousTab),this._previousTab=null}),1)},_activateHandler:function(){this._cancelPendingActivation(),Ka._activateHandler.apply(this,arguments)},_scheduleActivation:function(t,e){this._pendingActivationItem=t,this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,e)},_delayedActivationHandler:function(){var t=this._pendingActivationItem;this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0,t.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){void 0!==this._pendingActivationTimeout&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationItem=void 0,this._pendingActivationTimeout=void 0)},_onArrowKeyup:function(t){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(t){t.target===this._pendingActivationItem&&this._cancelPendingActivation()},get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(t,e){this.scrollable&&this._affectScroll(e&&-e.ddx||0)},_down:function(t){this.async((function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)}),1)},_affectScroll:function(t){this.$.tabsContainer.scrollLeft+=t;var e=this.$.tabsContainer.scrollLeft;this._leftHidden=0===e,this._rightHidden=e===this._tabContainerScrollSize},_onLeftScrollButtonDown:function(){this._scrollToLeft(),this._holdJob=setInterval(this._scrollToLeft.bind(this),this._holdDelay)},_onRightScrollButtonDown:function(){this._scrollToRight(),this._holdJob=setInterval(this._scrollToRight.bind(this),this._holdDelay)},_onScrollButtonUp:function(){clearInterval(this._holdJob),this._holdJob=null},_scrollToLeft:function(){this._affectScroll(-this._step)},_scrollToRight:function(){this._affectScroll(this._step)},_tabChanged:function(t,e){if(!t)return this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),void this._positionBar(0,0);var n=this.$.tabsContent.getBoundingClientRect(),i=n.width,r=t.getBoundingClientRect(),o=r.left-n.left;if(this._pos={width:this._calcPercent(r.width,i),left:this._calcPercent(o,i)},this.noSlide||null==e)return this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),void this._positionBar(this._pos.width,this._pos.left);var a=e.getBoundingClientRect(),s=this.items.indexOf(e),l=this.items.indexOf(t);this.$.selectionBar.classList.add("expand");var c=s<l;this._isRTL&&(c=!c),c?this._positionBar(this._calcPercent(r.left+r.width-a.left,i)-5,this._left):this._positionBar(this._calcPercent(a.left+a.width-r.left,i)-5,this._calcPercent(o,i)+5),this.scrollable&&this._scrollToSelectedIfNeeded(r.width,o)},_scrollToSelectedIfNeeded:function(t,e){var n=e-this.$.tabsContainer.scrollLeft;(n<0||(n+=t-this.$.tabsContainer.offsetWidth)>0)&&(this.$.tabsContainer.scrollLeft+=n)},_calcPercent:function(t,e){return 100*t/e},_positionBar:function(t,e){e=e||0,this._width=t=t||0,this._left=e,this.transform("translateX("+e+"%) scaleX("+t/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(t){var e=this.$.selectionBar.classList;e.contains("expand")?(e.remove("expand"),e.add("contract"),this._positionBar(this._pos.width,this._pos.left)):e.contains("contract")&&e.remove("contract")}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
var cs=null;Nr({_template:_e`
    <style>
      :host {
        display: block;
        position: fixed;
        background-color: var(--paper-toast-background-color, #323232);
        color: var(--paper-toast-color, #f1f1f1);
        min-height: 48px;
        min-width: 288px;
        padding: 16px 24px;
        box-sizing: border-box;
        box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.26);
        border-radius: 2px;
        margin: 12px;
        font-size: 14px;
        cursor: default;
        -webkit-transition: -webkit-transform 0.3s, opacity 0.3s;
        transition: transform 0.3s, opacity 0.3s;
        opacity: 0;
        -webkit-transform: translateY(100px);
        transform: translateY(100px);
        @apply --paper-font-common-base;
      }

      :host(.capsule) {
        border-radius: 24px;
      }

      :host(.fit-bottom) {
        width: 100%;
        min-width: 0;
        border-radius: 0;
        margin: 0;
      }

      :host(.paper-toast-open) {
        opacity: 1;
        -webkit-transform: translateY(0px);
        transform: translateY(0px);
      }
    </style>

    <span id="label">{{text}}</span>
    <slot></slot>
`,is:"paper-toast",behaviors:[Ca],properties:{fitInto:{type:Object,value:window,observer:"_onFitIntoChanged"},horizontalAlign:{type:String,value:"left"},verticalAlign:{type:String,value:"bottom"},duration:{type:Number,value:3e3},text:{type:String,value:""},noCancelOnOutsideClick:{type:Boolean,value:!0},noAutoFocus:{type:Boolean,value:!0}},listeners:{transitionend:"__onTransitionEnd"},get visible(){return po._warn("`visible` is deprecated, use `opened` instead"),this.opened},get _canAutoClose(){return this.duration>0&&this.duration!==1/0},created:function(){this._autoClose=null,Oa.requestAvailability()},show:function(t){for(var e in"string"==typeof t&&(t={text:t}),t)0===e.indexOf("_")?po._warn('The property "'+e+'" is private and was not set.'):e in this?this[e]=t[e]:po._warn('The property "'+e+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(t){t&&t.target===this&&"opacity"===t.propertyName&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){null!==this._autoClose&&(this.cancelAsync(this._autoClose),this._autoClose=null),this.opened?(cs&&cs!==this&&cs.close(),cs=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):cs===this&&(cs=null),Ta._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(t){this.positionTarget=t}});
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
const us=_e`

    <style>
      :host {
        display: inline-block;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-common-base;
      }

      :host([disabled]) {
        pointer-events: none;
      }

      :host(:focus) {
        outline:none;
      }

      .toggle-bar {
        position: absolute;
        height: 100%;
        width: 100%;
        border-radius: 8px;
        pointer-events: none;
        opacity: 0.4;
        transition: background-color linear .08s;
        background-color: var(--paper-toggle-button-unchecked-bar-color, #000000);

        @apply --paper-toggle-button-unchecked-bar;
      }

      .toggle-button {
        position: absolute;
        top: -3px;
        left: 0;
        height: 20px;
        width: 20px;
        border-radius: 50%;
        box-shadow: 0 1px 5px 0 rgba(0, 0, 0, 0.6);
        transition: -webkit-transform linear .08s, background-color linear .08s;
        transition: transform linear .08s, background-color linear .08s;
        will-change: transform;
        background-color: var(--paper-toggle-button-unchecked-button-color, var(--paper-grey-50));

        @apply --paper-toggle-button-unchecked-button;
      }

      .toggle-button.dragging {
        -webkit-transition: none;
        transition: none;
      }

      :host([checked]:not([disabled])) .toggle-bar {
        opacity: 0.5;
        background-color: var(--paper-toggle-button-checked-bar-color, var(--primary-color));

        @apply --paper-toggle-button-checked-bar;
      }

      :host([disabled]) .toggle-bar {
        background-color: #000;
        opacity: 0.12;
      }

      :host([checked]) .toggle-button {
        -webkit-transform: translate(16px, 0);
        transform: translate(16px, 0);
      }

      :host([checked]:not([disabled])) .toggle-button {
        background-color: var(--paper-toggle-button-checked-button-color, var(--primary-color));

        @apply --paper-toggle-button-checked-button;
      }

      :host([disabled]) .toggle-button {
        background-color: #bdbdbd;
        opacity: 1;
      }

      .toggle-ink {
        position: absolute;
        top: -14px;
        left: -14px;
        right: auto;
        bottom: auto;
        width: 48px;
        height: 48px;
        opacity: 0.5;
        pointer-events: none;
        color: var(--paper-toggle-button-unchecked-ink-color, var(--primary-text-color));

        @apply --paper-toggle-button-unchecked-ink;
      }

      :host([checked]) .toggle-ink {
        color: var(--paper-toggle-button-checked-ink-color, var(--primary-color));

        @apply --paper-toggle-button-checked-ink;
      }

      .toggle-container {
        display: inline-block;
        position: relative;
        width: 36px;
        height: 14px;
        /* The toggle button has an absolute position of -3px; The extra 1px
        /* accounts for the toggle button shadow box. */
        margin: 4px 1px;
      }

      .toggle-label {
        position: relative;
        display: inline-block;
        vertical-align: middle;
        padding-left: var(--paper-toggle-button-label-spacing, 8px);
        pointer-events: none;
        color: var(--paper-toggle-button-label-color, var(--primary-text-color));
      }

      /* invalid state */
      :host([invalid]) .toggle-bar {
        background-color: var(--paper-toggle-button-invalid-bar-color, var(--error-color));
      }

      :host([invalid]) .toggle-button {
        background-color: var(--paper-toggle-button-invalid-button-color, var(--error-color));
      }

      :host([invalid]) .toggle-ink {
        color: var(--paper-toggle-button-invalid-ink-color, var(--error-color));
      }
    </style>

    <div class="toggle-container">
      <div id="toggleBar" class="toggle-bar"></div>
      <div id="toggleButton" class="toggle-button"></div>
    </div>

    <div class="toggle-label"><slot></slot></div>

  `;us.setAttribute("strip-whitespace",""),Nr({_template:us,is:"paper-toggle-button",behaviors:[ca],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){ki(this,(function(){ri(this,"pan-y")}))},_ontrack:function(t){var e=t.detail;"start"===e.state?this._trackStart(e):"track"===e.state?this._trackMove(e):"end"===e.state&&this._trackEnd(e)},_trackStart:function(t){this._width=this.$.toggleBar.offsetWidth/2,this._trackChecked=this.checked,this.$.toggleButton.classList.add("dragging")},_trackMove:function(t){var e=t.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+e:e)),this.translate3d(this._x+"px",0,0,this.$.toggleButton),this._userActivate(this._x>this._width/2)},_trackEnd:function(t){this.$.toggleButton.classList.remove("dragging"),this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var t=Zo._createRipple();return t.id="ink",t.setAttribute("recenters",""),t.classList.add("circle","toggle-ink"),t}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        --calculated-paper-toolbar-height: var(--paper-toolbar-height, 64px);
        --calculated-paper-toolbar-sm-height: var(--paper-toolbar-sm-height, 56px);
        display: block;
        position: relative;
        box-sizing: border-box;
        -moz-box-sizing: border-box;
        height: var(--calculated-paper-toolbar-height);
        background: var(--paper-toolbar-background, var(--primary-color));
        color: var(--paper-toolbar-color, var(--dark-theme-text-color));
        @apply --paper-toolbar;
      }

      :host(.animate) {
        transition: var(--paper-toolbar-transition, height 0.18s ease-in);
      }

      :host(.medium-tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 2);
        @apply --paper-toolbar-medium;
      }

      :host(.tall) {
        height: calc(var(--calculated-paper-toolbar-height) * 3);
        @apply --paper-toolbar-tall;
      }

      .toolbar-tools {
        position: relative;
        height: var(--calculated-paper-toolbar-height);
        padding: 0 16px;
        pointer-events: none;
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-toolbar-content;
      }

      /*
       * TODO: Where should media query breakpoints live so they can be shared between elements?
       */

      @media (max-width: 600px) {
        :host {
          height: var(--calculated-paper-toolbar-sm-height);
        }

        :host(.medium-tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 2);
        }

        :host(.tall) {
          height: calc(var(--calculated-paper-toolbar-sm-height) * 3);
        }

        .toolbar-tools {
          height: var(--calculated-paper-toolbar-sm-height);
        }
      }

      #topBar {
        position: relative;
      }

      /* middle bar */
      #middleBar {
        position: absolute;
        top: 0;
        right: 0;
        left: 0;
      }

      :host(.tall) #middleBar,
      :host(.medium-tall) #middleBar {
        -webkit-transform: translateY(100%);
        transform: translateY(100%);
      }

      /* bottom bar */
      #bottomBar {
        position: absolute;
        right: 0;
        bottom: 0;
        left: 0;
      }

      /*
       * make elements (e.g. buttons) respond to mouse/touch events
       *
       * \`.toolbar-tools\` disables touch events so multiple toolbars can stack and not
       * absorb events. All children must have pointer events re-enabled to work as
       * expected.
       */
      .toolbar-tools > ::slotted(*:not([disabled])) {
        pointer-events: auto;
      }

      .toolbar-tools > ::slotted(.title) {
        @apply --paper-font-common-base;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
        font-size: 20px;
        font-weight: 400;
        line-height: 1;
        pointer-events: none;
        @apply --layout-flex;
      }

      .toolbar-tools > ::slotted(.title) {
        margin-left: 56px;
      }

      .toolbar-tools > ::slotted(paper-icon-button + .title) {
        margin-left: 0;
      }

      /**
       * The --paper-toolbar-title mixin is applied here instead of above to
       * fix the issue with margin-left being ignored due to css ordering.
       */
      .toolbar-tools > ::slotted(.title) {
        @apply --paper-toolbar-title;
      }

      .toolbar-tools > ::slotted(paper-icon-button[icon=menu]) {
        margin-right: 24px;
      }

      .toolbar-tools > ::slotted(.fit) {
        position: absolute;
        top: auto;
        right: 0;
        bottom: 0;
        left: 0;
        width: auto;
        margin: 0;
      }

      /* TODO(noms): Until we have a better solution for classes that don't use
       * /deep/ create our own.
       */
      .start-justified {
        @apply --layout-start-justified;
      }

      .center-justified {
        @apply --layout-center-justified;
      }

      .end-justified {
        @apply --layout-end-justified;
      }

      .around-justified {
        @apply --layout-around-justified;
      }

      .justified {
        @apply --layout-justified;
      }
    </style>

    <div id="topBar" class\$="toolbar-tools [[_computeBarExtraClasses(justify)]]">
      <slot name="top"></slot>
    </div>

    <div id="middleBar" class\$="toolbar-tools [[_computeBarExtraClasses(middleJustify)]]">
      <slot name="middle"></slot>
    </div>

    <div id="bottomBar" class\$="toolbar-tools [[_computeBarExtraClasses(bottomJustify)]]">
      <slot name="bottom"></slot>
    </div>
`,is:"paper-toolbar",hostAttributes:{role:"toolbar"},properties:{bottomJustify:{type:String,value:""},justify:{type:String,value:""},middleJustify:{type:String,value:""}},ready:function(){console.warn(this.is,"is deprecated. Please use app-layout instead!")},attached:function(){this._observer=this._observe(this),this._updateAriaLabelledBy()},detached:function(){this._observer&&this._observer.disconnect()},_observe:function(t){var e=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));return e.observe(t,{childList:!0,subtree:!0}),e},_updateAriaLabelledBy:function(){zi();for(var t,e=[],n=Array.prototype.slice.call(qi(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(qi(this.root).querySelectorAll("content"))),i=0;t=n[i];i++)for(var r,o=qi(t).getDistributedNodes(),a=0;r=o[a];a++)if(r.classList&&r.classList.contains("title"))if(r.id)e.push(r.id);else{var s="paper-toolbar-label-"+Math.floor(1e4*Math.random());r.id=s,e.push(s)}e.length>0&&this.setAttribute("aria-labelledby",e.join(" "))},_computeBarExtraClasses:function(t){return t?t+("justified"===t?"":"-justified"):""}}),
/**
    @license
    Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at
    http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
    http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
    found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
    part of the polymer project is also subject to an additional IP rights grant
    found at http://polymer.github.io/PATENTS.txt
    */
Nr({_template:_e`
    <style>
      :host {
        display: block;
        position: absolute;
        outline: none;
        z-index: 1002;
        -moz-user-select: none;
        -ms-user-select: none;
        -webkit-user-select: none;
        user-select: none;
        cursor: default;
      }

      #tooltip {
        display: block;
        outline: none;
        @apply --paper-font-common-base;
        font-size: 10px;
        line-height: 1;
        background-color: var(--paper-tooltip-background, #616161);
        color: var(--paper-tooltip-text-color, white);
        padding: 8px;
        border-radius: 2px;
        @apply --paper-tooltip;
      }

      @keyframes keyFrameScaleUp {
        0% {
          transform: scale(0.0);
        }
        100% {
          transform: scale(1.0);
        }
      }

      @keyframes keyFrameScaleDown {
        0% {
          transform: scale(1.0);
        }
        100% {
          transform: scale(0.0);
        }
      }

      @keyframes keyFrameFadeInOpacity {
        0% {
          opacity: 0;
        }
        100% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameFadeOutOpacity {
        0% {
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        100% {
          opacity: 0;
        }
      }

      @keyframes keyFrameSlideDownIn {
        0% {
          transform: translateY(-2000px);
          opacity: 0;
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
      }

      @keyframes keyFrameSlideDownOut {
        0% {
          transform: translateY(0);
          opacity: var(--paper-tooltip-opacity, 0.9);
        }
        10% {
          opacity: 0.2;
        }
        100% {
          transform: translateY(-2000px);
          opacity: 0;
        }
      }

      .fade-in-animation {
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameFadeInOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .fade-out-animation {
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 0ms);
        animation-name: keyFrameFadeOutOpacity;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-up-animation {
        transform: scale(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-in, 500ms);
        animation-name: keyFrameScaleUp;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-in, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .scale-down-animation {
        transform: scale(1);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameScaleDown;
        animation-iteration-count: 1;
        animation-timing-function: ease-in;
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation {
        transform: translateY(-2000px);
        opacity: 0;
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownIn;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.0, 0.0, 0.2, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .slide-down-animation-out {
        transform: translateY(0);
        opacity: var(--paper-tooltip-opacity, 0.9);
        animation-delay: var(--paper-tooltip-delay-out, 500ms);
        animation-name: keyFrameSlideDownOut;
        animation-iteration-count: 1;
        animation-timing-function: cubic-bezier(0.4, 0.0, 1, 1);
        animation-duration: var(--paper-tooltip-duration-out, 500ms);
        animation-fill-mode: forwards;
        @apply --paper-tooltip-animation;
      }

      .cancel-animation {
        animation-delay: -30s !important;
      }

      /* Thanks IE 10. */

      .hidden {
        display: none !important;
      }
    </style>

    <div id="tooltip" class="hidden">
      <slot></slot>
    </div>
`,is:"paper-tooltip",hostAttributes:{role:"tooltip",tabindex:-1},properties:{for:{type:String,observer:"_findTarget"},manualMode:{type:Boolean,value:!1,observer:"_manualModeChanged"},position:{type:String,value:"bottom"},fitToVisibleBounds:{type:Boolean,value:!1},offset:{type:Number,value:14},marginTop:{type:Number,value:14},animationDelay:{type:Number,value:500,observer:"_delayChange"},animationEntry:{type:String,value:""},animationExit:{type:String,value:""},animationConfig:{type:Object,value:function(){return{entry:[{name:"fade-in-animation",node:this,timing:{delay:0}}],exit:[{name:"fade-out-animation",node:this}]}}},_showing:{type:Boolean,value:!1}},listeners:{webkitAnimationEnd:"_onAnimationEnd"},get target(){var t=qi(this).parentNode,e=qi(this).getOwnerRoot();return this.for?qi(e).querySelector("#"+this.for):t.nodeType==Node.DOCUMENT_FRAGMENT_NODE?e.host:t},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},playAnimation:function(t){"entry"===t?this.show():"exit"===t&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(""===qi(this).textContent.trim()){for(var t=!0,e=qi(this).getEffectiveChildNodes(),n=0;n<e.length;n++)if(""!==e[n].textContent.trim()){t=!1;break}if(t)return}this._showing=!0,this.$.tooltip.classList.remove("hidden"),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.updatePosition(),this._animationPlaying=!0,this.$.tooltip.classList.add(this._getAnimationType("entry"))}},hide:function(){if(this._showing){if(this._animationPlaying)return this._showing=!1,void this._cancelAnimation();this._onAnimationFinish(),this._showing=!1,this._animationPlaying=!0}},updatePosition:function(){if(this._target&&this.offsetParent){var t=this.offset;14!=this.marginTop&&14==this.offset&&(t=this.marginTop);var e,n,i=this.offsetParent.getBoundingClientRect(),r=this._target.getBoundingClientRect(),o=this.getBoundingClientRect(),a=(r.width-o.width)/2,s=(r.height-o.height)/2,l=r.left-i.left,c=r.top-i.top;switch(this.position){case"top":e=l+a,n=c-o.height-t;break;case"bottom":e=l+a,n=c+r.height+t;break;case"left":e=l-o.width-t,n=c+s;break;case"right":e=l+r.width+t,n=c+s}this.fitToVisibleBounds?(i.left+e+o.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,e)+"px",this.style.right="auto"),i.top+n+o.height>window.innerHeight?(this.style.bottom=i.height-c+t+"px",this.style.top="auto"):(this.style.top=Math.max(-i.top,n)+"px",this.style.bottom="auto")):(this.style.left=e+"px",this.style.top=n+"px")}},_addListeners:function(){this._target&&(this.listen(this._target,"mouseenter","show"),this.listen(this._target,"focus","show"),this.listen(this._target,"mouseleave","hide"),this.listen(this._target,"blur","hide"),this.listen(this._target,"tap","hide")),this.listen(this.$.tooltip,"animationend","_onAnimationEnd"),this.listen(this,"mouseenter","hide")},_findTarget:function(){this.manualMode||this._removeListeners(),this._target=this.target,this.manualMode||this._addListeners()},_delayChange:function(t){500!==t&&this.updateStyles({"--paper-tooltip-delay-in":t+"ms"})},_manualModeChanged:function(){this.manualMode?this._removeListeners():this._addListeners()},_cancelAnimation:function(){this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add("hidden")},_onAnimationFinish:function(){this._showing&&(this.$.tooltip.classList.remove(this._getAnimationType("entry")),this.$.tooltip.classList.remove("cancel-animation"),this.$.tooltip.classList.add(this._getAnimationType("exit")))},_onAnimationEnd:function(){this._animationPlaying=!1,this._showing||(this.$.tooltip.classList.remove(this._getAnimationType("exit")),this.$.tooltip.classList.add("hidden"))},_getAnimationType:function(t){if("entry"===t&&""!==this.animationEntry)return this.animationEntry;if("exit"===t&&""!==this.animationExit)return this.animationExit;if(this.animationConfig[t]&&"string"==typeof this.animationConfig[t][0].name){if(this.animationConfig[t][0].timing&&this.animationConfig[t][0].timing.delay&&0!==this.animationConfig[t][0].timing.delay){var e=this.animationConfig[t][0].timing.delay;"entry"===t?this.updateStyles({"--paper-tooltip-delay-in":e+"ms"}):"exit"===t&&this.updateStyles({"--paper-tooltip-delay-out":e+"ms"})}return this.animationConfig[t][0].name}},_removeListeners:function(){this._target&&(this.unlisten(this._target,"mouseenter","show"),this.unlisten(this._target,"focus","show"),this.unlisten(this._target,"mouseleave","hide"),this.unlisten(this._target,"blur","hide"),this.unlisten(this._target,"tap","hide")),this.unlisten(this.$.tooltip,"animationend","_onAnimationEnd"),this.unlisten(this,"mouseenter","hide")}});class hs{constructor(t){this.listener=t}}const ds=new Set,ps=new Set;function fs(t){const e=new hs(t);return ds.add(e),e}function ms(t){const e=new hs(t);return ps.add(e),e}function gs(){ps.forEach((t=>t.listener()))}function _s(t){ds.delete(t)}function ys(t){ps.delete(t)}window.addEventListener("hashchange",(()=>{ds.forEach((t=>t.listener()))})),window.addEventListener("storage",(()=>{ps.forEach((t=>t.listener()))}));let vs=!1;function bs(){return vs}let xs="";function ws(t){xs=t}function Ss(){return xs}var Ms=Object.freeze({__proto__:null,setUseHash:function Es(t){vs=t},useHash:bs,setFakeHash:ws,getFakeHash:Ss});const Ts="__tab__";let As={};function Cs(){return As}fs((()=>{As=tl(Zs())}));const{get:ks,set:Ls,getInitializer:Ps,getObserver:Is,disposeBinding:Ns}=$s((t=>t),(t=>t)),{get:Os,set:Rs,getInitializer:zs,getObserver:Ds,disposeBinding:Bs}=$s((t=>"true"===t||"false"!==t&&void 0),(t=>t.toString())),{get:Hs,set:Fs,getInitializer:Vs,getObserver:js,disposeBinding:Us}=$s((t=>+t),(t=>t.toString())),{get:Gs,set:Ws,getInitializer:qs,getObserver:Ys,disposeBinding:Xs}=$s((t=>JSON.parse(atob(t))),(t=>btoa(JSON.stringify(t))));function $s(t,e){const n=[],i=[];function r(e,n={}){const{defaultValue:i,useLocalStorage:r=!1}=n,o=r?window.localStorage.getItem(e):tl(Zs())[e];return null==o?we.cloneDeep(i):t(o)}function o(t,n,i={}){const{defaultValue:o,useLocalStorage:a=!1,useLocationReplace:s=!1}=i,l=e(n);if(a)window.localStorage.setItem(t,l),gs();else if(!we.isEqual(n,r(t,{useLocalStorage:a})))if(we.isEqual(n,o))!(function c(t){const e=tl(Zs());delete e[t],Js(Qs(e))})(t);else{const e=tl(Zs());e[t]=l,Js(Qs(e),s)}}return{get:r,set:o,getInitializer:function a(t,e){const o=Object.assign({defaultValue:e.defaultValue,polymerProperty:t,useLocalStorage:!1},e);return function(){const e=Ks(this,t),a=()=>{const t=r(e,o);we.isEqual(t,this[o.polymerProperty])||(this[o.polymerProperty]=t)},s=(o.useLocalStorage?ms:fs)((()=>a()));return o.useLocalStorage?i.push(s):n.push(s),a(),this[o.polymerProperty]}},getObserver:function s(t,e){const n=Object.assign({defaultValue:e.defaultValue,polymerProperty:t,useLocalStorage:!1},e);return function(){o(Ks(this,t),this[n.polymerProperty],n)}},disposeBinding:function l(){n.forEach((t=>_s(t))),i.forEach((t=>ys(t)))}}}function Ks(t,e){const n=t.disambiguator;return(null==n?[e]:[n,e]).join(".")}function Zs(){return bs()?window.location.hash.slice(1):Ss()}function Js(t,e=!1){if(bs())if(e){const e=new URL(window.location.href);e.hash=t,window.history.replaceState(null,"",e.toString())}else window.location.hash=t;else ws(t)}function Qs(t){let e="";void 0!==t[Ts]&&(e+=t[Ts]);const n=Object.keys(t).map((e=>[e,t[e]])).filter((t=>t[0]!==Ts)).map((t=>encodeURIComponent(t[0])+"="+encodeURIComponent(t[1]))).join("&");return n.length>0?e+"&"+n:e}function tl(t){const e={};return t.split("&").forEach((t=>{const n=t.split("=");1===n.length?e[Ts]=n[0]:2===n.length&&(e[decodeURIComponent(n[0])]=decodeURIComponent(n[1]))})),e}let el=class extends ye{constructor(){super(...arguments),this._tagFilter=Ps("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}).call(this),this._tagFilterObserver=Is("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"})}_computeTagFilter(){return this._tagFilter}};function nl(t){const{moduleName:e,styleContent:n}=t,i=document.createElement("dom-module"),r=document.createElement("template"),o=[];t.styleDependencies&&t.styleDependencies.forEach((t=>{const e=document.createElement("style");e.setAttribute("include",t),o.push(e)}));const a=document.createElement("style");Object.assign(a,{textContent:n}),o.forEach((t=>{r.content.appendChild(t)})),r.content.appendChild(a),i.appendChild(r),i.register(e)}el.template=_e`
    <paper-input
      no-label-float=""
      label="Filter tags (regular expressions supported)"
      value="{{_tagFilter}}"
      class="search-input"
    >
      <iron-icon prefix="" icon="search" slot="prefix"></iron-icon>
    </paper-input>
    <style>
      :host {
        display: block;
        margin: 10px 5px 10px 10px;
      }
    </style>
  `,t([o({type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"}),e("design:type",String)],el.prototype,"tagFilter",void 0),t([o({type:String,observer:"_tagFilterObserver"}),e("design:type",String)],el.prototype,"_tagFilter",void 0),el=t([i("tf-tag-filterer")],el),nl({moduleName:"dashboard-style",styleDependencies:["iron-flex"],styleContent:"\n      :host {\n        --sidebar-vertical-padding: 15px;\n        --sidebar-left-padding: 30px;\n      }\n\n      [slot='sidebar'] {\n        box-sizing: border-box;\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n        margin-right: 10px;\n        overflow-x: hidden;\n        padding: 5px 0;\n        text-overflow: ellipsis;\n      }\n\n      .settings {\n        min-height: 50px;\n        overflow-x: hidden;\n        overflow-y: auto;\n        will-change: transform;\n      }\n\n      .runs-selector {\n        display: flex;\n        flex-grow: 1;\n        min-height: 200px;\n      }\n\n      tf-runs-selector {\n        flex-grow: 1;\n        flex-shrink: 1;\n        left: var(--sidebar-left-padding);\n        max-height: calc(100% - var(--sidebar-vertical-padding) * 2);\n        overflow: hidden;\n        position: absolute;\n        right: 0;\n      }\n\n      .search-input {\n        margin: 10px 5px 0 10px;\n      }\n\n      .sidebar-section {\n        border-top: solid 1px rgba(0, 0, 0, 0.12);\n        margin-right: 10px;\n        padding: var(--sidebar-vertical-padding) 0\n          var(--sidebar-vertical-padding) var(--sidebar-left-padding);\n        position: relative;\n        overflow: hidden;\n      }\n\n      .sidebar-section:first-of-type {\n        border: none;\n      }\n\n      .sidebar-section paper-button {\n        margin: 5px;\n      }\n\n      .sidebar-section paper-button:first-of-type {\n        margin-left: 0 !important;\n      }\n\n      .sidebar-section paper-button:last-of-type {\n        margin-right: 0 !important;\n      }\n\n      .sidebar-section > :first-child {\n        margin-top: 0;\n        padding-top: 0;\n      }\n\n      .sidebar-section > :last-child {\n        margin-bottom: 0;\n        padding-bottom: 0;\n      }\n\n      .sidebar-section h3 {\n        color: var(--paper-grey-800);\n        display: block;\n        font-size: 14px;\n        font-weight: normal;\n        margin: 10px 0 5px;\n        pointer-events: none;\n      }\n\n      paper-checkbox {\n        --paper-checkbox-checked-color: var(--tb-ui-dark-accent);\n        --paper-checkbox-unchecked-color: var(--tb-ui-dark-accent);\n        font-size: 15px;\n        margin-top: 5px;\n      }\n  "});const il=document.createElement("style");il.setAttribute("is","custom-style"),il.textContent="\n  :root {\n    --tb-orange-weak: #ffa726;\n    --tb-orange-strong: #f57c00;\n    --tb-orange-dark: #dc7320;\n    --tb-grey-darker: #e2e2e2;\n    --tb-grey-lighter: #f3f3f3;\n    --tb-ui-dark-accent: #757575;\n    --tb-ui-light-accent: #e0e0e0;\n    --tb-graph-faded: #e0d4b3;\n  }\n",document.head.appendChild(il),nl({moduleName:"scrollbar-style",styleContent:"\n    .scrollbar::-webkit-scrollbar-track {\n      visibility: hidden;\n    }\n\n    .scrollbar::-webkit-scrollbar {\n      width: 10px;\n    }\n\n    .scrollbar::-webkit-scrollbar-thumb {\n      border-radius: 10px;\n      -webkit-box-shadow: inset 0 0 2px rgba(0, 0, 0, 0.3);\n      background-color: var(--paper-grey-500);\n      color: var(--paper-grey-900);\n    }\n    .scrollbar {\n      box-sizing: border-box;\n    }\n  "});let rl=class extends ye{};rl.template=_e`
    <div id="sidebar">
      <slot name="sidebar"></slot>
    </div>

    <div id="center">
      <slot name="center" class="scollbar"></slot>
    </div>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      #sidebar {
        flex: 0 0 var(--tf-dashboard-layout-sidebar-basis, 25%);
        height: 100%;
        max-width: var(--tf-dashboard-layout-sidebar-max-width, 350px);
        min-width: var(--tf-dashboard-layout-sidebar-min-width, 270px);
        overflow-y: auto;
        text-overflow: ellipsis;
      }

      #center {
        flex-grow: 1;
        flex-shrink: 1;
        height: 100%;
        overflow: hidden;
      }

      ::slotted([slot='center']) {
        contain: strict;
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  `,rl=t([i("tf-dashboard-layout")],rl);const ol="TF.TensorBoard.PaginatedView.limit";let al=null;const sl=new Set;function ll(t){sl.add(t)}function cl(t){sl.delete(t)}function ul(){return null==al&&(al=Hs(ol,{useLocalStorage:!0}),(null==al||!isFinite(al)||al<=0)&&(al=12)),al}class hl extends ye{updateArrayProp(t,e,n){let i=this.get(t);const r=e;if(!Array.isArray(r))throw RangeError(`Expected new value to '${t}' to be an array.`);Array.isArray(i)||(i=[],this.set(t,i));const o=new Set(r.map(((t,e)=>n(t,e))));let a=0,s=0;for(;a<i.length&&s<r.length;)o.has(n(i[a],a))?(n(i[a],a)==n(r[s],s)?this.set(`${t}.${a}`,r[s]):this.splice(t,a,0,r[s]),s++,a++):this.splice(t,a,1);a<i.length&&this.splice(t,a),s<r.length&&this.push(t,...r.slice(s))}}class dl extends hl{constructor(){super(...arguments),this.as="item",this._contentActive=!0,this._domBootstrapped=!1,this._ctor=null,this._renderedItems=[],this._renderedTemplateInst=new Map,this._lruCachedItems=new Map,this._cacheSize=10,this._getItemKey=t=>JSON.stringify(t),this._isConnected=!1}connectedCallback(){super.connectedCallback(),this._isConnected=!0}setCacheSize(t){this._cacheSize=t}setGetItemKey(t){this._getItemKey=t}updateDom(t){this.updateArrayProp("_renderedItems",t,this._getItemKey)}_ensureTemplatized(){if(!this.isConnected)return!1;if(!this._ctor){const t=this.querySelector("template");this._ctor=Xr(t,this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(t,e){this._renderedTemplateInst.forEach((n=>{n.forwardHostProp(t,e)}))}})}return!0}_bootstrapDom(){this._ensureTemplatized()&&!this._domBootstrapped&&(new MutationObserver((t=>{for(const e of t)if("childList"===e.type)for(const t of Array.from(e.addedNodes))t instanceof Element&&t.setAttribute("slot","items")})).observe(this,{childList:!0}),Array.from(this.children).forEach((t=>{this.removeChild(t)})),this._lruCachedItems.clear(),this._renderedItems.forEach(((t,e)=>this._insertItem(t,e))),this._domBootstrapped=!0)}_updateActive(){this._domBootstrapped&&Array.from(this._renderedTemplateInst.values()).forEach((t=>{t.notifyPath("active",this._contentActive)}))}_updateDom(t){if(this._domBootstrapped&&"_renderedItems"!=t.path&&"_renderedItems.length"!=t.path)if("_renderedItems.splices"===t.path)t.value.indexSplices.forEach((t=>{const{index:e,addedCount:n,object:i,removed:r}=t;r.forEach((t=>{this._removeItem(t,this.children[e])})),i.slice(e,e+n).forEach(((t,n)=>this._insertItem(t,e+n))),this._trimCache()}));else{const e=this._getItemKey(t.value);this._renderedTemplateInst.has(e)?this._renderedTemplateInst.get(e).notifyPath(this.as,t.value):console.warn(`Expected '${e}' to exist in the DOM but could not find one.`)}}_insertItem(t,e){if(!this._ensureTemplatized())throw new Error("Expected templatized before inserting an item");let n;const i=this._getItemKey(t);if(this._lruCachedItems.has(i))n=this._lruCachedItems.get(i),this._lruCachedItems.delete(i),this._renderedTemplateInst.get(i).notifyPath("active",this._contentActive);else{const e=new this._ctor({[this.as]:t,active:this._contentActive});n=e.root,this._renderedTemplateInst.set(i,e)}this.children[e]?this.insertBefore(n,this.children[e]):((n.nodeType==Node.DOCUMENT_FRAGMENT_NODE?Array.from(n.children):[n]).forEach((t=>t.setAttribute("slot","items"))),this.appendChild(n))}_removeItem(t,e){e.parentNode&&e.parentNode.removeChild(e);const n=this._getItemKey(t);this._lruCachedItems.set(n,e),this._renderedTemplateInst.get(n).notifyPath("active",!1)}_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){const[t]=this._lruCachedItems.keys();this._lruCachedItems.delete(t),this._renderedTemplateInst.delete(t)}}}t([o({type:String}),e("design:type",Object)],dl.prototype,"as",void 0),t([o({type:Array}),e("design:type",Array)],dl.prototype,"items",void 0),t([o({type:Boolean}),e("design:type",Boolean)],dl.prototype,"_contentActive",void 0),t([o({type:Boolean}),e("design:type",Object)],dl.prototype,"_domBootstrapped",void 0),t([o({type:Object}),e("design:type",Object)],dl.prototype,"_ctor",void 0),t([o({type:Array}),e("design:type",Array)],dl.prototype,"_renderedItems",void 0),t([o({type:Object}),e("design:type",Object)],dl.prototype,"_renderedTemplateInst",void 0),t([o({type:Object}),e("design:type",Object)],dl.prototype,"_lruCachedItems",void 0),t([o({type:Number}),e("design:type",Object)],dl.prototype,"_cacheSize",void 0),t([o({type:Object}),e("design:type",Object)],dl.prototype,"_getItemKey",void 0),t([o({type:Boolean}),e("design:type",Object)],dl.prototype,"_isConnected",void 0),t([a("_isConnected"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],dl.prototype,"_bootstrapDom",null),t([a("_contentActive"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],dl.prototype,"_updateActive",null),t([a("_renderedItems.*","_domBootstrapped"),e("design:type",Function),e("design:paramtypes",[Object]),e("design:returntype",void 0)],dl.prototype,"_updateDom",null),t([a("_cacheSize"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],dl.prototype,"_trimCache",null);let pl=class extends dl{constructor(){super(...arguments),this.disablePagination=!1,this.getCategoryItemKey=t=>JSON.stringify(t),this._limit=12,this._activeIndex=0,this._pageInputRawValue="",this._pageInputFocused=!1}_computeCount(){return this.category.items.length}get _hasMultiple(){return this._count>1}_togglePane(){this.opened=!this.opened}_changeContentActive(t){this._contentActive=t}_onPaneRenderedChanged(t,e){t&&t!==e&&this.$.ifRendered.render()}_computePaneRendered(t){return!(t.metadata.type===vr.SEARCH_RESULTS&&""===t.name)}get _itemsRendered(){return this._paneRendered&&this.opened}_computeIsSearchResults(t){return t===vr.SEARCH_RESULTS}_computeIsInvalidSearchResults(t){return t.type===vr.SEARCH_RESULTS&&!t.validRegex}_computeIsUniversalSearchQuery(t){return t.type===vr.SEARCH_RESULTS&&t.universalRegex}_isCompositeSearch(){const{type:t,compositeSearch:e}=this.category.metadata;return e&&t===vr.SEARCH_RESULTS}ready(){super.ready(),this.opened=null==this.initialOpened||this.initialOpened,this._limitListener=()=>{this.set("_limit",ul())},ll(this._limitListener),this._limitListener()}detached(){cl(this._limitListener)}_updateRenderedItems(){var t=this._limit,e=this.disablePagination;if(!this._itemsRendered)return;const n=Math.floor(this._activeIndex/t),i=this.category.items||[],r=e?i:i.slice(n*t,(n+1)*t);this.updateDom(r)}_limitChanged(t){this.setCacheSize(2*t)}_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)}get _currentPage(){return Math.floor(this._activeIndex/this._limit)+1}_computePageCount(t,e){return this.category?Math.ceil(this.category.items.length/e):0}get _multiplePagesExist(){return!this.disablePagination&&this._pageCount>1}get _hasPreviousPage(){return this._currentPage>1}get _hasNextPage(){return this._currentPage<this._pageCount}_computeInputWidth(t){return`calc(${t.toString().length}em + 20px)`}_setActiveIndex(t){const e=(this.category.items||[]).length-1;t>e&&(t=e),t<0&&(t=0),this.set("_activeIndex",t)}_clampActiveIndex(){this._setActiveIndex(this._activeIndex)}_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)}_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)}_computePageInputValue(t,e,n){return t?e:n.toString()}_handlePageInputEvent(t){this.set("_pageInputRawValue",t.target.value);const e=Number(t.target.value||NaN);if(isNaN(e))return;const n=Math.max(1,Math.min(e,this._pageCount))-1;this._setActiveIndex(this._limit*n)}_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())}_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue),this.set("_pageInputFocused",!0)}_handlePageBlurEvent(){this.set("_pageInputFocused",!1)}_updatePageInputValue(t){const e=this.shadowRoot.querySelector("#page-input input");e&&(e.value=t)}_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}};pl.template=_e`
    <template is="dom-if" if="[[_paneRendered]]" id="ifRendered">
      <button class="heading" on-tap="_togglePane" open-button$="[[opened]]">
        <span class="name">
          <template is="dom-if" if="[[_isSearchResults]]">
            <template is="dom-if" if="[[_isCompositeSearch(category)]]">
              <span>Tags matching multiple experiments</span>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span
                  >&nbsp;<strong>(malformed regular expression)</strong></span
                >
              </template>
            </template>
            <template is="dom-if" if="[[!_isCompositeSearch(category)]]">
              <span class="light">Tags matching /</span>
              <span class="category-name" title$="[[category.name]]"
                >[[category.name]]</span
              >
              <span class="light">/</span>
              <template is="dom-if" if="[[_isUniversalSearchQuery]]">
                <span> (all tags)</span>
              </template>
              <template is="dom-if" if="[[_isInvalidSearchResults]]">
                <span> <strong>(malformed regular expression)</strong></span>
              </template>
            </template>
          </template>
          <template is="dom-if" if="[[!_isSearchResults]]">
            <span class="category-name" title$="[[category.name]]"
              >[[category.name]]</span
            >
          </template>
        </span>
        <span class="count">
          <template is="dom-if" if="[[_hasMultiple]]">
            <span>[[_count]]</span>
          </template>
          <iron-icon icon="expand-more" class="expand-arrow"></iron-icon>
        </span>
      </button>
      <!-- TODO(stephanwlee): investigate further. For some reason,
        transitionend that the iron-collapse relies on sometimes does not
        trigger when rendering a chart with a spinner. A toy example cannot
        reproduce this bug. -->
      <iron-collapse opened="[[opened]]" no-animation="">
        <div class="content">
          <span id="top-of-container"></span>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div class="big-page-buttons" style="margin-bottom: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>

          <div id="items">
            <slot name="items"></slot>
          </div>
          <template is="dom-if" if="[[_multiplePagesExist]]">
            <div id="controls-container">
              <div style="display: inline-block; padding: 0 5px">
                Page
                <paper-input
                  id="page-input"
                  type="number"
                  no-label-float=""
                  min="1"
                  max="[[_pageCount]]"
                  value="[[_pageInputValue]]"
                  on-input="_handlePageInputEvent"
                  on-change="_handlePageChangeEvent"
                  on-focus="_handlePageFocusEvent"
                  on-blur="_handlePageBlurEvent"
                ></paper-input>
                of [[_pageCount]]
              </div>
            </div>

            <div class="big-page-buttons" style="margin-top: 10px;">
              <paper-button
                on-tap="_performPreviousPage"
                disabled$="[[!_hasPreviousPage]]"
                >Previous page</paper-button
              >
              <paper-button
                on-tap="_performNextPage"
                disabled$="[[!_hasNextPage]]"
                >Next page</paper-button
              >
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>
    <style>
      :host {
        display: block;
        margin: 0 5px 1px 10px;
      }

      :host(:first-of-type) {
        margin-top: 10px;
      }

      :host(:last-of-type) {
        margin-bottom: 20px;
      }

      .heading {
        background-color: white;
        border: none;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
        padding: 10px 15px;
        display: flex;
        align-items: center;
        justify-content: space-between;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      [open-button] {
        border-bottom-left-radius: 0 !important;
        border-bottom-right-radius: 0 !important;
      }

      [open-button] .expand-arrow {
        transform: rotateZ(180deg);
      }

      .name {
        display: inline-flex;
        overflow: hidden;
      }

      .light {
        color: var(--paper-grey-500);
      }

      .category-name {
        white-space: pre;
        overflow: hidden;
        text-overflow: ellipsis;
        padding: 2px 0;
      }

      .count {
        margin: 0 5px;
        font-size: 12px;
        color: var(--paper-grey-500);
        display: flex;
        align-items: center;
        flex: none;
      }

      .heading::-moz-focus-inner {
        padding: 10px 15px;
      }

      .content {
        display: flex;
        flex-direction: column;
        background: white;
        border-bottom-left-radius: 2px;
        border-bottom-right-radius: 2px;
        border-top: none;
        border: 1px solid #dedede;
        padding: 15px;
      }

      .light {
        color: var(--paper-grey-500);
      }

      #controls-container {
        justify-content: center;
        display: flex;
        flex-direction: row;
        flex-grow: 0;
        flex-shrink: 0;
        width: 100%;
      }

      #controls-container paper-button {
        display: inline-block;
      }

      .big-page-buttons {
        display: flex;
      }

      .big-page-buttons paper-button {
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
        display: inline-block;
        flex-basis: 0;
        flex-grow: 1;
        flex-shrink: 1;
        font-size: 13px;
      }

      .big-page-buttons paper-button[disabled] {
        background: none;
      }

      slot {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }

      ::slotted([slot='items']) {
        /* Tooltip for descriptions and others break with more strict ones. */
        contain: style;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],pl.prototype,"category",void 0),t([o({type:Boolean}),e("design:type",Boolean)],pl.prototype,"initialOpened",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],pl.prototype,"opened",void 0),t([o({type:Boolean}),e("design:type",Boolean)],pl.prototype,"disablePagination",void 0),t([o({type:Number,computed:"_computeCount(category.items.*)"}),e("design:type",Number)],pl.prototype,"_count",void 0),t([o({type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"}),e("design:type",Boolean)],pl.prototype,"_paneRendered",void 0),t([o({type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"}),e("design:type",Boolean)],pl.prototype,"_isSearchResults",void 0),t([o({type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"}),e("design:type",Boolean)],pl.prototype,"_isInvalidSearchResults",void 0),t([o({type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"}),e("design:type",Boolean)],pl.prototype,"_isUniversalSearchQuery",void 0),t([o({type:Object,observer:"_getCategoryItemKeyChanged"}),e("design:type",Object)],pl.prototype,"getCategoryItemKey",void 0),t([o({type:Number,observer:"_limitChanged"}),e("design:type",Number)],pl.prototype,"_limit",void 0),t([o({type:Number}),e("design:type",Number)],pl.prototype,"_activeIndex",void 0),t([o({type:Number,computed:"_computePageCount(category.items.*, _limit)"}),e("design:type",Number)],pl.prototype,"_pageCount",void 0),t([o({type:String,computed:"_computeInputWidth(_pageCount)",observer:"_updateInputWidth"}),e("design:type",String)],pl.prototype,"_inputWidth",void 0),t([o({type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"}),e("design:type",String)],pl.prototype,"_pageInputValue",void 0),t([o({type:String}),e("design:type",String)],pl.prototype,"_pageInputRawValue",void 0),t([o({type:Boolean}),e("design:type",Boolean)],pl.prototype,"_pageInputFocused",void 0),t([s("_count"),e("design:type",Boolean),e("design:paramtypes",[])],pl.prototype,"_hasMultiple",null),t([a("opened"),e("design:type",Function),e("design:paramtypes",[Boolean]),e("design:returntype",void 0)],pl.prototype,"_changeContentActive",null),t([s("opened","_paneRendered"),e("design:type",Boolean),e("design:paramtypes",[])],pl.prototype,"_itemsRendered",null),t([a("_itemsRendered","category.items.*","_limit","_activeIndex","_pageCount","disablePagination"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],pl.prototype,"_updateRenderedItems",null),t([s("_limit","_activeIndex"),e("design:type",Number),e("design:paramtypes",[])],pl.prototype,"_currentPage",null),t([s("_pageCount","disablePagination"),e("design:type",Boolean),e("design:paramtypes",[])],pl.prototype,"_multiplePagesExist",null),t([s("_currentPage"),e("design:type",Boolean),e("design:paramtypes",[])],pl.prototype,"_hasPreviousPage",null),t([s("_currentPage","_pageCount"),e("design:type",Boolean),e("design:paramtypes",[])],pl.prototype,"_hasNextPage",null),t([a("category.items.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],pl.prototype,"_clampActiveIndex",null),pl=t([i("tf-category-paginated-view")],pl);class fl{constructor(t){this.listener=t}}class ml{constructor(){this.requestManager=new hr(1),this._listeners=new Set,this.initialized=!1}refresh(){return this.load().then((()=>{this.initialized=!0}))}addListener(t){const e=new fl(t);return this._listeners.add(e),e}removeListenerByKey(t){this._listeners.delete(t)}emitChange(){this._listeners.forEach((t=>{try{t.listener()}catch(t){}}))}}class gl extends ml{load(){const t=gr().environment();return this.requestManager.request(t).then((t=>{const e={dataLocation:t.data_location,windowTitle:t.window_title};void 0!==t.experiment_name&&(e.experimentName=t.experiment_name),void 0!==t.experiment_description&&(e.experimentDescription=t.experiment_description),void 0!==t.creation_time&&(e.creationTime=t.creation_time),we.isEqual(this.environment,e)||(this.environment=e,this.emitChange())}))}getDataLocation(){return this.environment?this.environment.dataLocation:""}getWindowTitle(){return this.environment?this.environment.windowTitle:""}getExperimentName(){return this.environment?this.environment.experimentName:""}getExperimentDescription(){return this.environment?this.environment.experimentDescription:""}getCreationTime(){return this.environment?this.environment.creationTime:null}}const _l=new gl;class yl extends ml{constructor(){super(...arguments),this._runs=[]}load(){const t=gr().runs();return this.requestManager.request(t).then((t=>{we.isEqual(this._runs,t)||(this._runs=t,this.emitChange())}))}getRuns(){return this._runs.slice()}}const vl=new yl;function bl(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function xl(t){return 1===t.length&&(t=(function e(t){return function(e,n){return bl(t(e),n)}})(t)),{left:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)<0?i=o+1:r=o}return i},right:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)>0?r=o:i=o+1}return i}}}var wl=xl(bl),Sl=wl.right,Ml=wl.left;function El(t,e){return[t,e]}function Tl(t,e,n){var i,r,o,a,s=t.length,l=e.length,c=new Array(s*l);for(null==n&&(n=El),i=o=0;i<s;++i)for(a=t[i],r=0;r<l;++r,++o)c[o]=n(a,e[r]);return c}function Al(t){return null===t?NaN:+t}function Cl(t,e){var n,i,r=t.length,o=0,a=-1,s=0,l=0;if(null==e)for(;++a<r;)isNaN(n=Al(t[a]))||(l+=(i=n-s)*(n-(s+=i/++o)));else for(;++a<r;)isNaN(n=Al(e(t[a],a,t)))||(l+=(i=n-s)*(n-(s+=i/++o)));if(o>1)return l/(o-1)}function kl(t,e){var n=Cl(t,e);return n?Math.sqrt(n):n}function Ll(t,e){var n,i,r,o=t.length,a=-1;if(null==e){for(;++a<o;)if(null!=(n=t[a])&&n>=n)for(i=r=n;++a<o;)null!=(n=t[a])&&(i>n&&(i=n),r<n&&(r=n))}else for(;++a<o;)if(null!=(n=e(t[a],a,t))&&n>=n)for(i=r=n;++a<o;)null!=(n=e(t[a],a,t))&&(i>n&&(i=n),r<n&&(r=n));return[i,r]}var Pl=Array.prototype,Il=Pl.slice,Nl=Pl.map;function Ol(t){return function(){return t}}function Rl(t){return t}function zl(t,e,n){t=+t,e=+e,n=(r=arguments.length)<2?(e=t,t=0,1):r<3?1:+n;for(var i=-1,r=0|Math.max(0,Math.ceil((e-t)/n)),o=new Array(r);++i<r;)o[i]=t+i*n;return o}var Dl=Math.sqrt(50),Bl=Math.sqrt(10),Hl=Math.sqrt(2);function Fl(t,e,n){var i,r,o,a,s=-1;if(n=+n,(t=+t)==(e=+e)&&n>0)return[t];if((i=e<t)&&(r=t,t=e,e=r),0===(a=Vl(t,e,n))||!isFinite(a))return[];if(a>0)for(t=Math.ceil(t/a),e=Math.floor(e/a),o=new Array(r=Math.ceil(e-t+1));++s<r;)o[s]=(t+s)*a;else for(t=Math.floor(t*a),e=Math.ceil(e*a),o=new Array(r=Math.ceil(t-e+1));++s<r;)o[s]=(t-s)/a;return i&&o.reverse(),o}function Vl(t,e,n){var i=(e-t)/Math.max(0,n),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=Dl?10:o>=Bl?5:o>=Hl?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=Dl?10:o>=Bl?5:o>=Hl?2:1)}function jl(t,e,n){var i=Math.abs(e-t)/Math.max(0,n),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=Dl?r*=10:o>=Bl?r*=5:o>=Hl&&(r*=2),e<t?-r:r}function Ul(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function Gl(t,e,n){if(null==n&&(n=Al),i=t.length){if((e=+e)<=0||i<2)return+n(t[0],0,t);if(e>=1)return+n(t[i-1],i-1,t);var i,r=(i-1)*e,o=Math.floor(r),a=+n(t[o],o,t);return a+(+n(t[o+1],o+1,t)-a)*(r-o)}}function Wl(t,e){var n,i,r=t.length,o=-1;if(null==e){for(;++o<r;)if(null!=(n=t[o])&&n>=n)for(i=n;++o<r;)null!=(n=t[o])&&n>i&&(i=n)}else for(;++o<r;)if(null!=(n=e(t[o],o,t))&&n>=n)for(i=n;++o<r;)null!=(n=e(t[o],o,t))&&n>i&&(i=n);return i}function ql(t){for(var e,n,i,r=t.length,o=-1,a=0;++o<r;)a+=t[o].length;for(n=new Array(a);--r>=0;)for(e=(i=t[r]).length;--e>=0;)n[--a]=i[e];return n}function Yl(t,e){var n,i,r=t.length,o=-1;if(null==e){for(;++o<r;)if(null!=(n=t[o])&&n>=n)for(i=n;++o<r;)null!=(n=t[o])&&i>n&&(i=n)}else for(;++o<r;)if(null!=(n=e(t[o],o,t))&&n>=n)for(i=n;++o<r;)null!=(n=e(t[o],o,t))&&i>n&&(i=n);return i}function Xl(t){if(!(r=t.length))return[];for(var e=-1,n=Yl(t,$l),i=new Array(n);++e<n;)for(var r,o=-1,a=i[e]=new Array(r);++o<r;)a[o]=t[o][e];return i}function $l(t){return t.length}var Kl=Array.prototype.slice;function Zl(t){return t}var Jl=1e-6;function Ql(t){return"translate("+(t+.5)+",0)"}function tc(t){return"translate(0,"+(t+.5)+")"}function ec(t){return function(e){return+t(e)}}function nc(t){var e=Math.max(0,t.bandwidth()-1)/2;return t.round()&&(e=Math.round(e)),function(n){return+t(n)+e}}function ic(){return!this.__axis}function rc(t,e){var n=[],i=null,r=null,o=6,a=6,s=3,l=1===t||4===t?-1:1,c=4===t||2===t?"x":"y",u=1===t||3===t?Ql:tc;function h(h){var d=null==i?e.ticks?e.ticks.apply(e,n):e.domain():i,p=null==r?e.tickFormat?e.tickFormat.apply(e,n):Zl:r,f=Math.max(o,0)+s,m=e.range(),g=+m[0]+.5,_=+m[m.length-1]+.5,y=(e.bandwidth?nc:ec)(e.copy()),v=h.selection?h.selection():h,b=v.selectAll(".domain").data([null]),x=v.selectAll(".tick").data(d,e).order(),w=x.exit(),S=x.enter().append("g").attr("class","tick"),M=x.select("line"),E=x.select("text");b=b.merge(b.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),x=x.merge(S),M=M.merge(S.append("line").attr("stroke","currentColor").attr(c+"2",l*o)),E=E.merge(S.append("text").attr("fill","currentColor").attr(c,l*f).attr("dy",1===t?"0em":3===t?"0.71em":"0.32em")),h!==v&&(b=b.transition(h),x=x.transition(h),M=M.transition(h),E=E.transition(h),w=w.transition(h).attr("opacity",Jl).attr("transform",(function(t){return isFinite(t=y(t))?u(t):this.getAttribute("transform")})),S.attr("opacity",Jl).attr("transform",(function(t){var e=this.parentNode.__axis;return u(e&&isFinite(e=e(t))?e:y(t))}))),w.remove(),b.attr("d",4===t||2==t?a?"M"+l*a+","+g+"H0.5V"+_+"H"+l*a:"M0.5,"+g+"V"+_:a?"M"+g+","+l*a+"V0.5H"+_+"V"+l*a:"M"+g+",0.5H"+_),x.attr("opacity",1).attr("transform",(function(t){return u(y(t))})),M.attr(c+"2",l*o),E.attr(c,l*f).text(p),v.filter(ic).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",2===t?"start":4===t?"end":"middle"),v.each((function(){this.__axis=y}))}return h.scale=function(t){return arguments.length?(e=t,h):e},h.ticks=function(){return n=Kl.call(arguments),h},h.tickArguments=function(t){return arguments.length?(n=null==t?[]:Kl.call(t),h):n.slice()},h.tickValues=function(t){return arguments.length?(i=null==t?null:Kl.call(t),h):i&&i.slice()},h.tickFormat=function(t){return arguments.length?(r=t,h):r},h.tickSize=function(t){return arguments.length?(o=a=+t,h):o},h.tickSizeInner=function(t){return arguments.length?(o=+t,h):o},h.tickSizeOuter=function(t){return arguments.length?(a=+t,h):a},h.tickPadding=function(t){return arguments.length?(s=+t,h):s},h}function oc(t){return rc(3,t)}function ac(t){return rc(4,t)}var sc={value:function(){}};function lc(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new cc(i)}function cc(t){this._=t}function uc(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function hc(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function dc(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=sc,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}cc.prototype=lc.prototype={constructor:cc,on:function(t,e){var n,i=this._,r=uc(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=dc(i[n],t.name,e);else if(null==e)for(n in i)i[n]=dc(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=hc(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new cc(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var pc="http://www.w3.org/1999/xhtml",fc={svg:"http://www.w3.org/2000/svg",xhtml:pc,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function mc(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),fc.hasOwnProperty(e)?{space:fc[e],local:t}:t}function gc(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===pc&&e.documentElement.namespaceURI===pc?e.createElement(t):e.createElementNS(n,t)}}function _c(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function yc(t){var e=mc(t);return(e.local?_c:gc)(e)}function vc(){}function bc(t){return null==t?vc:function(){return this.querySelector(t)}}function xc(){return[]}function wc(t){return null==t?xc:function(){return this.querySelectorAll(t)}}function Sc(t){return function(){return this.matches(t)}}function Mc(t){return new Array(t.length)}function Ec(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function Tc(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new Ec(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function Ac(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new Ec(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function Cc(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function kc(t){return function(){this.removeAttribute(t)}}function Lc(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Pc(t,e){return function(){this.setAttribute(t,e)}}function Ic(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function Nc(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function Oc(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function Rc(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function zc(t){return function(){this.style.removeProperty(t)}}function Dc(t,e,n){return function(){this.style.setProperty(t,e,n)}}function Bc(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function Hc(t,e){return t.style.getPropertyValue(e)||Rc(t).getComputedStyle(t,null).getPropertyValue(e)}function Fc(t){return function(){delete this[t]}}function Vc(t,e){return function(){this[t]=e}}function jc(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function Uc(t){return t.trim().split(/^|\s+/)}function Gc(t){return t.classList||new Wc(t)}function Wc(t){this._node=t,this._names=Uc(t.getAttribute("class")||"")}function qc(t,e){for(var n=Gc(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function Yc(t,e){for(var n=Gc(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function Xc(t){return function(){qc(this,t)}}function $c(t){return function(){Yc(this,t)}}function Kc(t,e){return function(){(e.apply(this,arguments)?qc:Yc)(this,t)}}function Zc(){this.textContent=""}function Jc(t){return function(){this.textContent=t}}function Qc(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function tu(){this.innerHTML=""}function eu(t){return function(){this.innerHTML=t}}function nu(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function iu(){this.nextSibling&&this.parentNode.appendChild(this)}function ru(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function ou(){return null}function au(){var t=this.parentNode;t&&t.removeChild(this)}function su(){var t=this.cloneNode(!1),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}function lu(){var t=this.cloneNode(!0),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}Ec.prototype={constructor:Ec,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},Wc.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var cu={},uu=null;function hu(t,e,n){return t=du(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function du(t,e,n){return function(i){var r=uu;uu=i;try{t.call(this,this.__data__,e,n)}finally{uu=r}}}function pu(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function fu(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function mu(t,e,n){var i=cu.hasOwnProperty(t.type)?hu:du;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function gu(t,e,n,i){var r=uu;t.sourceEvent=uu,uu=t;try{return e.apply(n,i)}finally{uu=r}}function _u(t,e,n){var i=Rc(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function yu(t,e){return function(){return _u(this,t,e)}}function vu(t,e){return function(){return _u(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(cu={mouseenter:"mouseover",mouseleave:"mouseout"}));var bu=[null];function xu(t,e){this._groups=t,this._parents=e}function wu(){return new xu([[document.documentElement]],bu)}function Su(t){return"string"==typeof t?new xu([[document.querySelector(t)]],[document.documentElement]):new xu([[t]],bu)}xu.prototype=wu.prototype={constructor:xu,select:function Mu(t){"function"!=typeof t&&(t=bc(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new xu(i,this._parents)},selectAll:function Eu(t){"function"!=typeof t&&(t=wc(t));for(var e=this._groups,n=e.length,i=[],r=[],o=0;o<n;++o)for(var a,s=e[o],l=s.length,c=0;c<l;++c)(a=s[c])&&(i.push(t.call(a,a.__data__,c,s)),r.push(a));return new xu(i,r)},filter:function Tu(t){"function"!=typeof t&&(t=Sc(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new xu(i,this._parents)},data:function Au(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?Ac:Tc,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new xu(s,i))._enter=l,s._exit=c,s},enter:function Cu(){return new xu(this._enter||this._groups.map(Mc),this._parents)},exit:function ku(){return new xu(this._exit||this._groups.map(Mc),this._parents)},join:function Lu(t,e,n){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof t?t(i):i.append(t+""),null!=e&&(r=e(r)),null==n?o.remove():n(o),i&&r?i.merge(r).order():r},merge:function Pu(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new xu(o,this._parents)},order:function Iu(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&4^i.compareDocumentPosition(a)&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function Nu(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=Cc);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new xu(r,this._parents).order()},call:function Ou(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function Ru(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function zu(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function Du(){var t=0;return this.each((function(){++t})),t},empty:function Bu(){return!this.node()},each:function Hu(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function Fu(t,e){var n=mc(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?Lc:kc:"function"==typeof e?n.local?Oc:Nc:n.local?Ic:Pc)(n,e))},style:function Vu(t,e,n){return arguments.length>1?this.each((null==e?zc:"function"==typeof e?Bc:Dc)(t,e,null==n?"":n)):Hc(this.node(),t)},property:function ju(t,e){return arguments.length>1?this.each((null==e?Fc:"function"==typeof e?jc:Vc)(t,e)):this.node()[t]},classed:function Uu(t,e){var n=Uc(t+"");if(arguments.length<2){for(var i=Gc(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?Kc:e?Xc:$c)(n,e))},text:function Gu(t){return arguments.length?this.each(null==t?Zc:("function"==typeof t?Qc:Jc)(t)):this.node().textContent},html:function Wu(t){return arguments.length?this.each(null==t?tu:("function"==typeof t?nu:eu)(t)):this.node().innerHTML},raise:function qu(){return this.each(iu)},lower:function Yu(){return this.each(ru)},append:function Xu(t){var e="function"==typeof t?t:yc(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function $u(t,e){var n="function"==typeof t?t:yc(t),i=null==e?ou:"function"==typeof e?e:bc(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function Ku(){return this.each(au)},clone:function Zu(t){return this.select(t?lu:su)},datum:function Ju(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function Qu(t,e,n){var i,r,o=pu(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?mu:fu,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function th(t,e){return this.each(("function"==typeof e?vu:yu)(t,e))}};var eh=0;function nh(){return new ih}function ih(){this._="@"+(++eh).toString(36)}function rh(){for(var t,e=uu;t=e.sourceEvent;)e=t;return e}function oh(t,e){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var i=n.createSVGPoint();return i.x=e.clientX,i.y=e.clientY,[(i=i.matrixTransform(t.getScreenCTM().inverse())).x,i.y]}var r=t.getBoundingClientRect();return[e.clientX-r.left-t.clientLeft,e.clientY-r.top-t.clientTop]}function ah(t){var e=rh();return e.changedTouches&&(e=e.changedTouches[0]),oh(t,e)}function sh(t){return"string"==typeof t?new xu([document.querySelectorAll(t)],[document.documentElement]):new xu([null==t?[]:t],bu)}function lh(t,e,n){arguments.length<3&&(n=e,e=rh().changedTouches);for(var i,r=0,o=e?e.length:0;r<o;++r)if((i=e[r]).identifier===n)return oh(t,i);return null}function ch(){uu.stopImmediatePropagation()}function uh(){uu.preventDefault(),uu.stopImmediatePropagation()}function hh(t){var e=t.document.documentElement,n=Su(t).on("dragstart.drag",uh,!0);"onselectstart"in e?n.on("selectstart.drag",uh,!0):(e.__noselect=e.style.MozUserSelect,e.style.MozUserSelect="none")}function dh(t,e){var n=t.document.documentElement,i=Su(t).on("dragstart.drag",null);e&&(i.on("click.drag",uh,!0),setTimeout((function(){i.on("click.drag",null)}),0)),"onselectstart"in n?i.on("selectstart.drag",null):(n.style.MozUserSelect=n.__noselect,delete n.__noselect)}function ph(t){return function(){return t}}function fh(t,e,n,i,r,o,a,s,l,c){this.target=t,this.type=e,this.subject=n,this.identifier=i,this.active=r,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}function mh(){return!uu.ctrlKey&&!uu.button}function gh(){return this.parentNode}function _h(t){return null==t?{x:uu.x,y:uu.y}:t}function yh(){return navigator.maxTouchPoints||"ontouchstart"in this}function vh(){var t,e,n,i,r=mh,o=gh,a=_h,s=yh,l={},c=lc("start","drag","end"),u=0,h=0;function d(t){t.on("mousedown.drag",p).filter(s).on("touchstart.drag",g).on("touchmove.drag",_).on("touchend.drag touchcancel.drag",y).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!i&&r.apply(this,arguments)){var a=v("mouse",o.apply(this,arguments),ah,this,arguments);a&&(Su(uu.view).on("mousemove.drag",f,!0).on("mouseup.drag",m,!0),hh(uu.view),ch(),n=!1,t=uu.clientX,e=uu.clientY,a("start"))}}function f(){if(uh(),!n){var i=uu.clientX-t,r=uu.clientY-e;n=i*i+r*r>h}l.mouse("drag")}function m(){Su(uu.view).on("mousemove.drag mouseup.drag",null),dh(uu.view,n),uh(),l.mouse("end")}function g(){if(r.apply(this,arguments)){var t,e,n=uu.changedTouches,i=o.apply(this,arguments),a=n.length;for(t=0;t<a;++t)(e=v(n[t].identifier,i,lh,this,arguments))&&(ch(),e("start"))}}function _(){var t,e,n=uu.changedTouches,i=n.length;for(t=0;t<i;++t)(e=l[n[t].identifier])&&(uh(),e("drag"))}function y(){var t,e,n=uu.changedTouches,r=n.length;for(i&&clearTimeout(i),i=setTimeout((function(){i=null}),500),t=0;t<r;++t)(e=l[n[t].identifier])&&(ch(),e("end"))}function v(t,e,n,i,r){var o,s,h,p=n(e,t),f=c.copy();if(gu(new fh(d,"beforestart",o,t,u,p[0],p[1],0,0,f),(function(){return null!=(uu.subject=o=a.apply(i,r))&&(s=o.x-p[0]||0,h=o.y-p[1]||0,!0)})))return function a(c){var m,g=p;switch(c){case"start":l[t]=a,m=u++;break;case"end":delete l[t],--u;case"drag":p=n(e,t),m=u}gu(new fh(d,c,o,t,m,p[0]+s,p[1]+h,p[0]-g[0],p[1]-g[1],f),f.apply,f,[c,i,r])}}return d.filter=function(t){return arguments.length?(r="function"==typeof t?t:ph(!!t),d):r},d.container=function(t){return arguments.length?(o="function"==typeof t?t:ph(t),d):o},d.subject=function(t){return arguments.length?(a="function"==typeof t?t:ph(t),d):a},d.touchable=function(t){return arguments.length?(s="function"==typeof t?t:ph(!!t),d):s},d.on=function(){var t=c.on.apply(c,arguments);return t===c?d:t},d.clickDistance=function(t){return arguments.length?(h=(t=+t)*t,d):Math.sqrt(h)},d}function bh(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function xh(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function wh(){}ih.prototype=nh.prototype={constructor:ih,get:function(t){for(var e=this._;!(e in t);)if(!(t=t.parentNode))return;return t[e]},set:function(t,e){return t[this._]=e},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}},fh.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var Sh=.7,Mh=1/Sh,Eh="\\s*([+-]?\\d+)\\s*",Th="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Ah="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Ch=/^#([0-9a-f]{3,8})$/,kh=new RegExp("^rgb\\("+[Eh,Eh,Eh]+"\\)$"),Lh=new RegExp("^rgb\\("+[Ah,Ah,Ah]+"\\)$"),Ph=new RegExp("^rgba\\("+[Eh,Eh,Eh,Th]+"\\)$"),Ih=new RegExp("^rgba\\("+[Ah,Ah,Ah,Th]+"\\)$"),Nh=new RegExp("^hsl\\("+[Th,Ah,Ah]+"\\)$"),Oh=new RegExp("^hsla\\("+[Th,Ah,Ah,Th]+"\\)$"),Rh={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function zh(){return this.rgb().formatHex()}function Dh(){return this.rgb().formatRgb()}function Bh(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=Ch.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?Hh(e):3===n?new Uh(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?Fh(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?Fh(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=kh.exec(t))?new Uh(e[1],e[2],e[3],1):(e=Lh.exec(t))?new Uh(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=Ph.exec(t))?Fh(e[1],e[2],e[3],e[4]):(e=Ih.exec(t))?Fh(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=Nh.exec(t))?Yh(e[1],e[2]/100,e[3]/100,1):(e=Oh.exec(t))?Yh(e[1],e[2]/100,e[3]/100,e[4]):Rh.hasOwnProperty(t)?Hh(Rh[t]):"transparent"===t?new Uh(NaN,NaN,NaN,0):null}function Hh(t){return new Uh(t>>16&255,t>>8&255,255&t,1)}function Fh(t,e,n,i){return i<=0&&(t=e=n=NaN),new Uh(t,e,n,i)}function Vh(t){return t instanceof wh||(t=Bh(t)),t?new Uh((t=t.rgb()).r,t.g,t.b,t.opacity):new Uh}function jh(t,e,n,i){return 1===arguments.length?Vh(t):new Uh(t,e,n,null==i?1:i)}function Uh(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function Gh(){return"#"+qh(this.r)+qh(this.g)+qh(this.b)}function Wh(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function qh(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function Yh(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new Kh(t,e,n,i)}function Xh(t){if(t instanceof Kh)return new Kh(t.h,t.s,t.l,t.opacity);if(t instanceof wh||(t=Bh(t)),!t)return new Kh;if(t instanceof Kh)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new Kh(a,s,l,t.opacity)}function $h(t,e,n,i){return 1===arguments.length?Xh(t):new Kh(t,e,n,null==i?1:i)}function Kh(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function Zh(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}bh(wh,Bh,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:zh,formatHex:zh,formatHsl:function Jh(){return Xh(this).formatHsl()},formatRgb:Dh,toString:Dh}),bh(Uh,jh,xh(wh,{brighter:function(t){return t=null==t?Mh:Math.pow(Mh,t),new Uh(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?Sh:Math.pow(Sh,t),new Uh(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Gh,formatHex:Gh,formatRgb:Wh,toString:Wh})),bh(Kh,$h,xh(wh,{brighter:function(t){return t=null==t?Mh:Math.pow(Mh,t),new Kh(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Sh:Math.pow(Sh,t),new Kh(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new Uh(Zh(t>=240?t-240:t+120,r,i),Zh(t,r,i),Zh(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var Qh=Math.PI/180,td=180/Math.PI,ed=.96422,nd=.82521,id=4/29,rd=6/29,od=3*rd*rd;function ad(t){if(t instanceof ld)return new ld(t.l,t.a,t.b,t.opacity);if(t instanceof md)return gd(t);t instanceof Uh||(t=Vh(t));var e,n,i=dd(t.r),r=dd(t.g),o=dd(t.b),a=cd((.2225045*i+.7168786*r+.0606169*o)/1);return i===r&&r===o?e=n=a:(e=cd((.4360747*i+.3850649*r+.1430804*o)/ed),n=cd((.0139322*i+.0971045*r+.7141733*o)/nd)),new ld(116*a-16,500*(e-a),200*(a-n),t.opacity)}function sd(t,e,n,i){return 1===arguments.length?ad(t):new ld(t,e,n,null==i?1:i)}function ld(t,e,n,i){this.l=+t,this.a=+e,this.b=+n,this.opacity=+i}function cd(t){return t>.008856451679035631?Math.pow(t,1/3):t/od+id}function ud(t){return t>rd?t*t*t:od*(t-id)}function hd(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function dd(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function pd(t){if(t instanceof md)return new md(t.h,t.c,t.l,t.opacity);if(t instanceof ld||(t=ad(t)),0===t.a&&0===t.b)return new md(NaN,0<t.l&&t.l<100?0:NaN,t.l,t.opacity);var e=Math.atan2(t.b,t.a)*td;return new md(e<0?e+360:e,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function fd(t,e,n,i){return 1===arguments.length?pd(t):new md(t,e,n,null==i?1:i)}function md(t,e,n,i){this.h=+t,this.c=+e,this.l=+n,this.opacity=+i}function gd(t){if(isNaN(t.h))return new ld(t.l,0,0,t.opacity);var e=t.h*Qh;return new ld(t.l,Math.cos(e)*t.c,Math.sin(e)*t.c,t.opacity)}bh(ld,sd,xh(wh,{brighter:function(t){return new ld(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new ld(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,n=isNaN(this.b)?t:t-this.b/200;return new Uh(hd(3.1338561*(e=ed*ud(e))-1.6168667*(t=1*ud(t))-.4906146*(n=nd*ud(n))),hd(-.9787684*e+1.9161415*t+.033454*n),hd(.0719453*e-.2289914*t+1.4052427*n),this.opacity)}})),bh(md,fd,xh(wh,{brighter:function(t){return new md(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new md(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return gd(this).rgb()}}));var _d=-.29227,yd=-.90649,vd=1.97294;function bd(t){if(t instanceof wd)return new wd(t.h,t.s,t.l,t.opacity);t instanceof Uh||(t=Vh(t));var e=t.g/255,n=t.b/255,i=(-.6557636667999999*n+t.r/255*-1.7884503806-3.5172982438*e)/-5.9615122912,r=n-i,o=(vd*(e-i)-_d*r)/yd,a=Math.sqrt(o*o+r*r)/(vd*i*(1-i)),s=a?Math.atan2(o,r)*td-120:NaN;return new wd(s<0?s+360:s,a,i,t.opacity)}function xd(t,e,n,i){return 1===arguments.length?bd(t):new wd(t,e,n,null==i?1:i)}function wd(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function Sd(t,e,n,i,r){var o=t*t,a=o*t;return((1-3*t+3*o-a)*e+(4-6*o+3*a)*n+(1+3*t+3*o-3*a)*i+a*r)/6}function Md(t){var e=t.length-1;return function(n){var i=n<=0?n=0:n>=1?(n=1,e-1):Math.floor(n*e),r=t[i],o=t[i+1];return Sd((n-i/e)*e,i>0?t[i-1]:2*r-o,r,o,i<e-1?t[i+2]:2*o-r)}}function Ed(t){var e=t.length;return function(n){var i=Math.floor(((n%=1)<0?++n:n)*e);return Sd((n-i/e)*e,t[(i+e-1)%e],t[i%e],t[(i+1)%e],t[(i+2)%e])}}function Td(t){return function(){return t}}function Ad(t,e){return function(n){return t+n*e}}function Cd(t,e){var n=e-t;return n?Ad(t,n>180||n<-180?n-360*Math.round(n/360):n):Td(isNaN(t)?e:t)}function kd(t,e){var n=e-t;return n?Ad(t,n):Td(isNaN(t)?e:t)}bh(wd,xd,xh(wh,{brighter:function(t){return t=null==t?Mh:Math.pow(Mh,t),new wd(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Sh:Math.pow(Sh,t),new wd(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*Qh,e=+this.l,n=isNaN(this.s)?0:this.s*e*(1-e),i=Math.cos(t),r=Math.sin(t);return new Uh(255*(e+n*(-.14861*i+1.78277*r)),255*(e+n*(_d*i+yd*r)),255*(e+n*(vd*i)),this.opacity)}}));var Ld=(function t(e){var n=(function i(t){return 1==(t=+t)?kd:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):Td(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=jh(t)).r,(e=jh(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=kd(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function Pd(t){return function(e){var n,i,r=e.length,o=new Array(r),a=new Array(r),s=new Array(r);for(n=0;n<r;++n)i=jh(e[n]),o[n]=i.r||0,a[n]=i.g||0,s[n]=i.b||0;return o=t(o),a=t(a),s=t(s),i.opacity=1,function(t){return i.r=o(t),i.g=a(t),i.b=s(t),i+""}}}var Id=Pd(Md),Nd=Pd(Ed);function Od(t,e){e||(e=[]);var n,i=t?Math.min(e.length,t.length):0,r=e.slice();return function(o){for(n=0;n<i;++n)r[n]=t[n]*(1-o)+e[n]*o;return r}}function Rd(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)}function zd(t,e){var n,i=e?e.length:0,r=t?Math.min(i,t.length):0,o=new Array(r),a=new Array(i);for(n=0;n<r;++n)o[n]=Ud(t[n],e[n]);for(;n<i;++n)a[n]=e[n];return function(t){for(n=0;n<r;++n)a[n]=o[n](t);return a}}function Dd(t,e){var n=new Date;return t=+t,e=+e,function(i){return n.setTime(t*(1-i)+e*i),n}}function Bd(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}function Hd(t,e){var n,i={},r={};for(n in null!==t&&"object"==typeof t||(t={}),null!==e&&"object"==typeof e||(e={}),e)n in t?i[n]=Ud(t[n],e[n]):r[n]=e[n];return function(t){for(n in i)r[n]=i[n](t);return r}}var Fd=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Vd=new RegExp(Fd.source,"g");function jd(t,e){var n,i,r,o=Fd.lastIndex=Vd.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=Fd.exec(t))&&(i=Vd.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Bd(n,i)})),o=Vd.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}function Ud(t,e){var n,i=typeof e;return null==e||"boolean"===i?Td(e):("number"===i?Bd:"string"===i?(n=Bh(e))?(e=n,Ld):jd:e instanceof Bh?Ld:e instanceof Date?Dd:Rd(e)?Od:Array.isArray(e)?zd:"function"!=typeof e.valueOf&&"function"!=typeof e.toString||isNaN(e)?Hd:Bd)(t,e)}function Gd(t,e){return t=+t,e=+e,function(n){return Math.round(t*(1-n)+e*n)}}var Wd,qd,Yd,Xd,$d=180/Math.PI,Kd={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Zd(t,e,n,i,r,o){var a,s,l;return(a=Math.sqrt(t*t+e*e))&&(t/=a,e/=a),(l=t*n+e*i)&&(n-=t*l,i-=e*l),(s=Math.sqrt(n*n+i*i))&&(n/=s,i/=s,l/=s),t*i<e*n&&(t=-t,e=-e,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(e,t)*$d,skewX:Math.atan(l)*$d,scaleX:a,scaleY:s}}function Jd(t,e,n,i){function r(t){return t.length?t.pop()+" ":""}return function(o,a){var s=[],l=[];return o=t(o),a=t(a),(function c(t,i,r,o,a,s){if(t!==r||i!==o){var l=a.push("translate(",null,e,null,n);s.push({i:l-4,x:Bd(t,r)},{i:l-2,x:Bd(i,o)})}else(r||o)&&a.push("translate("+r+e+o+n)})(o.translateX,o.translateY,a.translateX,a.translateY,s,l),(function u(t,e,n,o){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),o.push({i:n.push(r(n)+"rotate(",null,i)-2,x:Bd(t,e)})):e&&n.push(r(n)+"rotate("+e+i)})(o.rotate,a.rotate,s,l),(function h(t,e,n,o){t!==e?o.push({i:n.push(r(n)+"skewX(",null,i)-2,x:Bd(t,e)}):e&&n.push(r(n)+"skewX("+e+i)})(o.skewX,a.skewX,s,l),(function d(t,e,n,i,o,a){if(t!==n||e!==i){var s=o.push(r(o)+"scale(",null,",",null,")");a.push({i:s-4,x:Bd(t,n)},{i:s-2,x:Bd(e,i)})}else 1===n&&1===i||o.push(r(o)+"scale("+n+","+i+")")})(o.scaleX,o.scaleY,a.scaleX,a.scaleY,s,l),o=a=null,function(t){for(var e,n=-1,i=l.length;++n<i;)s[(e=l[n]).i]=e.x(t);return s.join("")}}}var Qd=Jd((function tp(t){return"none"===t?Kd:(Wd||(Wd=document.createElement("DIV"),qd=document.documentElement,Yd=document.defaultView),Wd.style.transform=t,t=Yd.getComputedStyle(qd.appendChild(Wd),null).getPropertyValue("transform"),qd.removeChild(Wd),Zd(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),ep=Jd((function np(t){return null==t?Kd:(Xd||(Xd=document.createElementNS("http://www.w3.org/2000/svg","g")),Xd.setAttribute("transform",t),(t=Xd.transform.baseVal.consolidate())?Zd((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):Kd)}),", ",")",")"),ip=Math.SQRT2;function rp(t){return((t=Math.exp(t))+1/t)/2}function op(t,e){var n,i,r=t[0],o=t[1],a=t[2],s=e[2],l=e[0]-r,c=e[1]-o,u=l*l+c*c;if(u<1e-12)i=Math.log(s/a)/ip,n=function(t){return[r+t*l,o+t*c,a*Math.exp(ip*t*i)]};else{var h=Math.sqrt(u),d=(s*s-a*a+4*u)/(2*a*2*h),p=(s*s-a*a-4*u)/(2*s*2*h),f=Math.log(Math.sqrt(d*d+1)-d),m=Math.log(Math.sqrt(p*p+1)-p);i=(m-f)/ip,n=function(t){var e=t*i,n=rp(f),s=a/(2*h)*(n*(function u(t){return((t=Math.exp(2*t))-1)/(t+1)})(ip*e+f)-(function d(t){return((t=Math.exp(t))-1/t)/2})(f));return[r+s*l,o+s*c,a*n/rp(ip*e+f)]}}return n.duration=1e3*i,n}function ap(t){return function(e,n){var i=t((e=$h(e)).h,(n=$h(n)).h),r=kd(e.s,n.s),o=kd(e.l,n.l),a=kd(e.opacity,n.opacity);return function(t){return e.h=i(t),e.s=r(t),e.l=o(t),e.opacity=a(t),e+""}}}var sp=ap(Cd),lp=ap(kd);function cp(t,e){var n=kd((t=sd(t)).l,(e=sd(e)).l),i=kd(t.a,e.a),r=kd(t.b,e.b),o=kd(t.opacity,e.opacity);return function(e){return t.l=n(e),t.a=i(e),t.b=r(e),t.opacity=o(e),t+""}}function up(t){return function(e,n){var i=t((e=fd(e)).h,(n=fd(n)).h),r=kd(e.c,n.c),o=kd(e.l,n.l),a=kd(e.opacity,n.opacity);return function(t){return e.h=i(t),e.c=r(t),e.l=o(t),e.opacity=a(t),e+""}}}var hp=up(Cd),dp=up(kd);function pp(t){return(function e(n){function i(e,i){var r=t((e=xd(e)).h,(i=xd(i)).h),o=kd(e.s,i.s),a=kd(e.l,i.l),s=kd(e.opacity,i.opacity);return function(t){return e.h=r(t),e.s=o(t),e.l=a(Math.pow(t,n)),e.opacity=s(t),e+""}}return n=+n,i.gamma=e,i})(1)}var fp,mp,gp=pp(Cd),_p=pp(kd),yp=0,vp=0,bp=0,xp=0,wp=0,Sp=0,Mp="object"==typeof performance&&performance.now?performance:Date,Ep="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function Tp(){return wp||(Ep(Ap),wp=Mp.now()+Sp)}function Ap(){wp=0}function Cp(){this._call=this._time=this._next=null}function kp(t,e,n){var i=new Cp;return i.restart(t,e,n),i}function Lp(){Tp(),++yp;for(var t,e=fp;e;)(t=wp-e._time)>=0&&e._call.call(null,t),e=e._next;--yp}function Pp(){wp=(xp=Mp.now())+Sp,yp=vp=0;try{Lp()}finally{yp=0,(function t(){for(var t,e,n=fp,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:fp=e);mp=t,Np(i)})(),wp=0}}function Ip(){var t=Mp.now(),e=t-xp;e>1e3&&(Sp-=e,xp=t)}function Np(t){yp||(vp&&(vp=clearTimeout(vp)),t-wp>24?(t<1/0&&(vp=setTimeout(Pp,t-Mp.now()-Sp)),bp&&(bp=clearInterval(bp))):(bp||(xp=Mp.now(),bp=setInterval(Ip,1e3)),yp=1,Ep(Pp)))}function Op(t,e,n){var i=new Cp;return i.restart((function(n){i.stop(),t(n+e)}),e=null==e?0:+e,n),i}Cp.prototype=kp.prototype={constructor:Cp,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?Tp():+n)+(null==e?0:+e),this._next||mp===this||(mp?mp._next=this:fp=this,mp=this),this._call=t,this._time=n,Np()},stop:function(){this._call&&(this._call=null,this._time=1/0,Np())}};var Rp=lc("start","end","cancel","interrupt"),zp=[];function Dp(t,e,n,i,r,o){var a=t.__transition;if(a){if(n in a)return}else t.__transition={};!(function s(t,e,n){var i,r=t.__transition;function o(l){var c,u,h,d;if(1!==n.state)return s();for(c in r)if((d=r[c]).name===n.name){if(3===d.state)return Op(o);4===d.state?(d.state=6,d.timer.stop(),d.on.call("interrupt",t,t.__data__,d.index,d.group),delete r[c]):+c<e&&(d.state=6,d.timer.stop(),d.on.call("cancel",t,t.__data__,d.index,d.group),delete r[c])}if(Op((function(){3===n.state&&(n.state=4,n.timer.restart(a,n.delay,n.time),a(l))})),n.state=2,n.on.call("start",t,t.__data__,n.index,n.group),2===n.state){for(n.state=3,i=new Array(h=n.tween.length),c=0,u=-1;c<h;++c)(d=n.tween[c].value.call(t,t.__data__,n.index,n.group))&&(i[++u]=d);i.length=u+1}}function a(e){for(var r=e<n.duration?n.ease.call(null,e/n.duration):(n.timer.restart(s),n.state=5,1),o=-1,a=i.length;++o<a;)i[o].call(t,r);5===n.state&&(n.on.call("end",t,t.__data__,n.index,n.group),s())}function s(){for(var i in n.state=6,n.timer.stop(),delete r[e],r)return;delete t.__transition}r[e]=n,n.timer=kp((function l(t){n.state=1,n.timer.restart(o,n.delay,n.time),n.delay<=t&&o(t-n.delay)}),0,n.time)})(t,n,{name:e,index:i,group:r,on:Rp,tween:zp,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:0})}function Bp(t,e){var n=Fp(t,e);if(n.state>0)throw new Error("too late; already scheduled");return n}function Hp(t,e){var n=Fp(t,e);if(n.state>3)throw new Error("too late; already running");return n}function Fp(t,e){var n=t.__transition;if(!n||!(n=n[e]))throw new Error("transition not found");return n}function Vp(t,e){var n,i,r,o=t.__transition,a=!0;if(o){for(r in e=null==e?null:e+"",o)(n=o[r]).name===e?(i=n.state>2&&n.state<5,n.state=6,n.timer.stop(),n.on.call(i?"interrupt":"cancel",t,t.__data__,n.index,n.group),delete o[r]):a=!1;a&&delete t.__transition}}function jp(t,e){var n,i;return function(){var r=Hp(this,t),o=r.tween;if(o!==n)for(var a=0,s=(i=n=o).length;a<s;++a)if(i[a].name===e){(i=i.slice()).splice(a,1);break}r.tween=i}}function Up(t,e,n){var i,r;if("function"!=typeof n)throw new Error;return function(){var o=Hp(this,t),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:e,value:n},l=0,c=r.length;l<c;++l)if(r[l].name===e){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function Gp(t,e,n){var i=t._id;return t.each((function(){var t=Hp(this,i);(t.value||(t.value={}))[e]=n.apply(this,arguments)})),function(t){return Fp(t,i).value[e]}}function Wp(t,e){var n;return("number"==typeof e?Bd:e instanceof Bh?Ld:(n=Bh(e))?(e=n,Ld):jd)(t,e)}function qp(t){return function(){this.removeAttribute(t)}}function Yp(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Xp(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttribute(t);return a===o?null:a===i?r:r=e(i=a,n)}}function $p(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttributeNS(t.space,t.local);return a===o?null:a===i?r:r=e(i=a,n)}}function Kp(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttribute(t))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttribute(t)}}function Zp(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttributeNS(t.space,t.local))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttributeNS(t.space,t.local)}}function Jp(t,e){return function(n){this.setAttribute(t,e.call(this,n))}}function Qp(t,e){return function(n){this.setAttributeNS(t.space,t.local,e.call(this,n))}}function tf(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&Qp(t,r)),n}return r._value=e,r}function ef(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&Jp(t,r)),n}return r._value=e,r}function nf(t,e){return function(){Bp(this,t).delay=+e.apply(this,arguments)}}function rf(t,e){return e=+e,function(){Bp(this,t).delay=e}}function of(t,e){return function(){Hp(this,t).duration=+e.apply(this,arguments)}}function af(t,e){return e=+e,function(){Hp(this,t).duration=e}}function sf(t,e){if("function"!=typeof e)throw new Error;return function(){Hp(this,t).ease=e}}function lf(t,e,n){var i,r,o=(function a(t){return(t+"").trim().split(/^|\s+/).every((function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t}))})(e)?Bp:Hp;return function(){var a=o(this,t),s=a.on;s!==i&&(r=(i=s).copy()).on(e,n),a.on=r}}var cf=wu.prototype.constructor;function uf(t){return function(){this.style.removeProperty(t)}}function hf(t,e,n){return function(i){this.style.setProperty(t,e.call(this,i),n)}}function df(t,e,n){var i,r;function o(){var o=e.apply(this,arguments);return o!==r&&(i=(r=o)&&hf(t,o,n)),i}return o._value=e,o}function pf(t){return function(e){this.textContent=t.call(this,e)}}function ff(t){var e,n;function i(){var i=t.apply(this,arguments);return i!==n&&(e=(n=i)&&pf(i)),e}return i._value=t,i}var mf=0;function gf(t,e,n,i){this._groups=t,this._parents=e,this._name=n,this._id=i}function _f(t){return wu().transition(t)}function yf(){return++mf}var vf=wu.prototype;function bf(t){return+t}function xf(t){return t*t}function wf(t){return t*(2-t)}function Sf(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function Mf(t){return t*t*t}function Ef(t){return--t*t*t+1}function Tf(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}gf.prototype=_f.prototype={constructor:gf,select:function Af(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=bc(t));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var s,l,c=i[a],u=c.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=c[d])&&(l=t.call(s,s.__data__,d,c))&&("__data__"in s&&(l.__data__=s.__data__),h[d]=l,Dp(h[d],e,n,d,h,Fp(s,n)));return new gf(o,this._parents,e,n)},selectAll:function Cf(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=wc(t));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var l,c=i[s],u=c.length,h=0;h<u;++h)if(l=c[h]){for(var d,p=t.call(l,l.__data__,h,c),f=Fp(l,n),m=0,g=p.length;m<g;++m)(d=p[m])&&Dp(d,e,n,m,p,f);o.push(p),a.push(l)}return new gf(o,a,e,n)},filter:function kf(t){"function"!=typeof t&&(t=Sc(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new gf(i,this._parents,this._name,this._id)},merge:function Lf(t){if(t._id!==this._id)throw new Error;for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new gf(o,this._parents,this._name,this._id)},selection:function Pf(){return new cf(this._groups,this._parents)},transition:function If(){for(var t=this._name,e=this._id,n=yf(),i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)if(a=s[c]){var u=Fp(a,e);Dp(a,t,n,c,s,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new gf(i,this._parents,t,n)},call:vf.call,nodes:vf.nodes,node:vf.node,size:vf.size,empty:vf.empty,each:vf.each,on:function Nf(t,e){var n=this._id;return arguments.length<2?Fp(this.node(),n).on.on(t):this.each(lf(n,t,e))},attr:function Of(t,e){var n=mc(t),i="transform"===n?ep:Wp;return this.attrTween(t,"function"==typeof e?(n.local?Zp:Kp)(n,i,Gp(this,"attr."+t,e)):null==e?(n.local?Yp:qp)(n):(n.local?$p:Xp)(n,i,e))},attrTween:function Rf(t,e){var n="attr."+t;if(arguments.length<2)return(n=this.tween(n))&&n._value;if(null==e)return this.tween(n,null);if("function"!=typeof e)throw new Error;var i=mc(t);return this.tween(n,(i.local?tf:ef)(i,e))},style:function zf(t,e,n){var i="transform"==(t+="")?Qd:Wp;return null==e?this.styleTween(t,(function r(t,e){var n,i,r;return function(){var o=Hc(this,t),a=(this.style.removeProperty(t),Hc(this,t));return o===a?null:o===n&&a===i?r:r=e(n=o,i=a)}})(t,i)).on("end.style."+t,uf(t)):"function"==typeof e?this.styleTween(t,(function a(t,e,n){var i,r,o;return function(){var a=Hc(this,t),s=n(this),l=s+"";return null==s&&(this.style.removeProperty(t),l=s=Hc(this,t)),a===l?null:a===i&&l===r?o:(r=l,o=e(i=a,s))}})(t,i,Gp(this,"style."+t,e))).each((function o(t,e){var n,i,r,o,a="style."+e,s="end."+a;return function(){var l=Hp(this,t),c=l.on,u=null==l.value[a]?o||(o=uf(e)):void 0;c===n&&r===u||(i=(n=c).copy()).on(s,r=u),l.on=i}})(this._id,t)):this.styleTween(t,(function s(t,e,n){var i,r,o=n+"";return function(){var a=Hc(this,t);return a===o?null:a===i?r:r=e(i=a,n)}})(t,i,e),n).on("end.style."+t,null)},styleTween:function Df(t,e,n){var i="style."+(t+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==e)return this.tween(i,null);if("function"!=typeof e)throw new Error;return this.tween(i,df(t,e,null==n?"":n))},text:function Bf(t){return this.tween("text","function"==typeof t?(function e(t){return function(){var e=t(this);this.textContent=null==e?"":e}})(Gp(this,"text",t)):(function n(t){return function(){this.textContent=t}})(null==t?"":t+""))},textTween:function Hf(t){var e="text";if(arguments.length<1)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;return this.tween(e,ff(t))},remove:function Ff(){return this.on("end.remove",(function t(e){return function(){var t=this.parentNode;for(var n in this.__transition)if(+n!==e)return;t&&t.removeChild(this)}})(this._id))},tween:function Vf(t,e){var n=this._id;if(t+="",arguments.length<2){for(var i,r=Fp(this.node(),n).tween,o=0,a=r.length;o<a;++o)if((i=r[o]).name===t)return i.value;return null}return this.each((null==e?jp:Up)(n,t,e))},delay:function jf(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?nf:rf)(e,t)):Fp(this.node(),e).delay},duration:function Uf(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?of:af)(e,t)):Fp(this.node(),e).duration},ease:function Gf(t){var e=this._id;return arguments.length?this.each(sf(e,t)):Fp(this.node(),e).ease},end:function Wf(){var t,e,n=this,i=n._id,r=n.size();return new Promise((function(o,a){var s={value:a},l={value:function(){0==--r&&o()}};n.each((function(){var n=Hp(this,i),r=n.on;r!==t&&((e=(t=r).copy())._.cancel.push(s),e._.interrupt.push(s),e._.end.push(l)),n.on=e}))}))}};var qf=(function t(e){function n(t){return Math.pow(t,e)}return e=+e,n.exponent=t,n})(3),Yf=(function t(e){function n(t){return 1-Math.pow(1-t,e)}return e=+e,n.exponent=t,n})(3),Xf=(function t(e){function n(t){return((t*=2)<=1?Math.pow(t,e):2-Math.pow(2-t,e))/2}return e=+e,n.exponent=t,n})(3),$f=Math.PI,Kf=$f/2;function Zf(t){return 1-Math.cos(t*Kf)}function Jf(t){return Math.sin(t*Kf)}function Qf(t){return(1-Math.cos($f*t))/2}function tm(t){return Math.pow(2,10*t-10)}function em(t){return 1-Math.pow(2,-10*t)}function nm(t){return((t*=2)<=1?Math.pow(2,10*t-10):2-Math.pow(2,10-10*t))/2}function im(t){return 1-Math.sqrt(1-t*t)}function rm(t){return Math.sqrt(1- --t*t)}function om(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}var am=7.5625;function sm(t){return 1-lm(1-t)}function lm(t){return(t=+t)<.36363636363636365?am*t*t:t<.7272727272727273?am*(t-=.5454545454545454)*t+.75:t<.9090909090909091?am*(t-=.8181818181818182)*t+.9375:am*(t-=.9545454545454546)*t+.984375}function cm(t){return((t*=2)<=1?1-lm(1-t):lm(t-1)+1)/2}var um=1.70158,hm=(function t(e){function n(t){return t*t*((e+1)*t-e)}return e=+e,n.overshoot=t,n})(um),dm=(function t(e){function n(t){return--t*t*((e+1)*t+e)+1}return e=+e,n.overshoot=t,n})(um),pm=(function t(e){function n(t){return((t*=2)<1?t*t*((e+1)*t-e):(t-=2)*t*((e+1)*t+e)+2)/2}return e=+e,n.overshoot=t,n})(um),fm=2*Math.PI,mm=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=fm);function r(t){return e*Math.pow(2,10*--t)*Math.sin((i-t)/n)}return r.amplitude=function(e){return t(e,n*fm)},r.period=function(n){return t(e,n)},r})(1,.3),gm=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=fm);function r(t){return 1-e*Math.pow(2,-10*(t=+t))*Math.sin((t+i)/n)}return r.amplitude=function(e){return t(e,n*fm)},r.period=function(n){return t(e,n)},r})(1,.3),_m=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=fm);function r(t){return((t=2*t-1)<0?e*Math.pow(2,10*t)*Math.sin((i-t)/n):2-e*Math.pow(2,-10*t)*Math.sin((i+t)/n))/2}return r.amplitude=function(e){return t(e,n*fm)},r.period=function(n){return t(e,n)},r})(1,.3),ym=Object.freeze({__proto__:null,easeLinear:bf,easeQuad:Sf,easeQuadIn:xf,easeQuadOut:wf,easeQuadInOut:Sf,easeCubic:Tf,easeCubicIn:Mf,easeCubicOut:Ef,easeCubicInOut:Tf,easePoly:Xf,easePolyIn:qf,easePolyOut:Yf,easePolyInOut:Xf,easeSin:Qf,easeSinIn:Zf,easeSinOut:Jf,easeSinInOut:Qf,easeExp:nm,easeExpIn:tm,easeExpOut:em,easeExpInOut:nm,easeCircle:om,easeCircleIn:im,easeCircleOut:rm,easeCircleInOut:om,easeBounce:lm,easeBounceIn:sm,easeBounceOut:lm,easeBounceInOut:cm,easeBack:pm,easeBackIn:hm,easeBackOut:dm,easeBackInOut:pm,easeElastic:gm,easeElasticIn:mm,easeElasticOut:gm,easeElasticInOut:_m}),vm={time:null,delay:0,duration:250,ease:Tf};function bm(t,e){for(var n;!(n=t.__transition)||!(n=n[e]);)if(!(t=t.parentNode))return vm.time=Tp(),vm;return n}wu.prototype.interrupt=function xm(t){return this.each((function(){Vp(this,t)}))},wu.prototype.transition=function wm(t){var e,n;t instanceof gf?(e=t._id,t=t._name):(e=yf(),(n=vm).time=Tp(),t=null==t?null:t+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)(a=s[c])&&Dp(a,t,e,c,s,n||bm(a,e));return new gf(i,this._parents,t,e)};var Sm=[null];function Mm(t){return function(){return t}}function Em(t,e,n){this.target=t,this.type=e,this.selection=n}function Tm(){uu.stopImmediatePropagation()}function Am(){uu.preventDefault(),uu.stopImmediatePropagation()}var Cm={name:"drag"},km={name:"space"},Lm={name:"handle"},Pm={name:"center"};function Im(t){return[+t[0],+t[1]]}function Nm(t){return[Im(t[0]),Im(t[1])]}function Om(t){return function(e){return lh(e,uu.touches,t)}}var Rm={name:"x",handles:["w","e"].map(Um),input:function(t,e){return null==t?null:[[+t[0],e[0][1]],[+t[1],e[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},zm={name:"y",handles:["n","s"].map(Um),input:function(t,e){return null==t?null:[[e[0][0],+t[0]],[e[1][0],+t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},Dm={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(Um),input:function(t){return null==t?null:Nm(t)},output:function(t){return t}},Bm={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},Hm={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Fm={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},Vm={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},jm={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function Um(t){return{type:t}}function Gm(){return!uu.ctrlKey&&!uu.button}function Wm(){var t=this.ownerSVGElement||this;return t.hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function qm(){return navigator.maxTouchPoints||"ontouchstart"in this}function Ym(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function Xm(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function $m(t){var e=t.__brush;return e?e.dim.output(e.selection):null}function Km(){return Jm(zm)}function Zm(){return Jm(Dm)}function Jm(t){var e,n=Wm,i=Gm,r=qm,o=!0,a=lc("start","brush","end"),s=6;function l(e){var n=e.property("__brush",m).selectAll(".overlay").data([Um("overlay")]);n.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Bm.overlay).merge(n).each((function(){var t=Ym(this).extent;Su(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),e.selectAll(".selection").data([Um("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Bm.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var i=e.selectAll(".handle").data(t.handles,(function(t){return t.type}));i.exit().remove(),i.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return Bm[t.type]})),e.each(c).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",d).filter(r).on("touchstart.brush",d).on("touchmove.brush",p).on("touchend.brush touchcancel.brush",f).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function c(){var t=Su(this),e=Ym(this).selection;e?(t.selectAll(".selection").style("display",null).attr("x",e[0][0]).attr("y",e[0][1]).attr("width",e[1][0]-e[0][0]).attr("height",e[1][1]-e[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?e[1][0]-s/2:e[0][0]-s/2})).attr("y",(function(t){return"s"===t.type[0]?e[1][1]-s/2:e[0][1]-s/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?e[1][0]-e[0][0]+s:s})).attr("height",(function(t){return"e"===t.type||"w"===t.type?e[1][1]-e[0][1]+s:s}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function u(t,e,n){return!n&&t.__brush.emitter||new h(t,e)}function h(t,e){this.that=t,this.args=e,this.state=t.__brush,this.active=0}function d(){if((!e||uu.touches)&&i.apply(this,arguments)){var n,r,a,s,l,h,d,p,f,m,g,_=this,y=uu.target.__data__.type,v="selection"===(o&&uu.metaKey?y="overlay":y)?Cm:o&&uu.altKey?Pm:Lm,b=t===zm?null:Vm[y],x=t===Rm?null:jm[y],w=Ym(_),S=w.extent,M=w.selection,E=S[0][0],T=S[0][1],A=S[1][0],C=S[1][1],k=0,L=0,P=b&&x&&o&&uu.shiftKey,I=uu.touches?Om(uu.changedTouches[0].identifier):ah,N=I(_),O=N,R=u(_,arguments,!0).beforestart();"overlay"===y?(M&&(f=!0),w.selection=M=[[n=t===zm?E:N[0],a=t===Rm?T:N[1]],[l=t===zm?A:n,d=t===Rm?C:a]]):(n=M[0][0],a=M[0][1],l=M[1][0],d=M[1][1]),r=n,s=a,h=l,p=d;var z=Su(_).attr("pointer-events","none"),D=z.selectAll(".overlay").attr("cursor",Bm[y]);if(uu.touches)R.moved=H,R.ended=V;else{var B=Su(uu.view).on("mousemove.brush",H,!0).on("mouseup.brush",V,!0);o&&B.on("keydown.brush",j,!0).on("keyup.brush",U,!0),hh(uu.view)}Tm(),Vp(_),c.call(_),R.start()}function H(){var t=I(_);!P||m||g||(Math.abs(t[0]-O[0])>Math.abs(t[1]-O[1])?g=!0:m=!0),O=t,f=!0,Am(),F()}function F(){var t;switch(k=O[0]-N[0],L=O[1]-N[1],v){case km:case Cm:b&&(k=Math.max(E-n,Math.min(A-l,k)),r=n+k,h=l+k),x&&(L=Math.max(T-a,Math.min(C-d,L)),s=a+L,p=d+L);break;case Lm:b<0?(k=Math.max(E-n,Math.min(A-n,k)),r=n+k,h=l):b>0&&(k=Math.max(E-l,Math.min(A-l,k)),r=n,h=l+k),x<0?(L=Math.max(T-a,Math.min(C-a,L)),s=a+L,p=d):x>0&&(L=Math.max(T-d,Math.min(C-d,L)),s=a,p=d+L);break;case Pm:b&&(r=Math.max(E,Math.min(A,n-k*b)),h=Math.max(E,Math.min(A,l+k*b))),x&&(s=Math.max(T,Math.min(C,a-L*x)),p=Math.max(T,Math.min(C,d+L*x)))}h<r&&(b*=-1,t=n,n=l,l=t,t=r,r=h,h=t,y in Hm&&D.attr("cursor",Bm[y=Hm[y]])),p<s&&(x*=-1,t=a,a=d,d=t,t=s,s=p,p=t,y in Fm&&D.attr("cursor",Bm[y=Fm[y]])),w.selection&&(M=w.selection),m&&(r=M[0][0],h=M[1][0]),g&&(s=M[0][1],p=M[1][1]),M[0][0]===r&&M[0][1]===s&&M[1][0]===h&&M[1][1]===p||(w.selection=[[r,s],[h,p]],c.call(_),R.brush())}function V(){if(Tm(),uu.touches){if(uu.touches.length)return;e&&clearTimeout(e),e=setTimeout((function(){e=null}),500)}else dh(uu.view,f),B.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);z.attr("pointer-events","all"),D.attr("cursor",Bm.overlay),w.selection&&(M=w.selection),Xm(M)&&(w.selection=null,c.call(_)),R.end()}function j(){switch(uu.keyCode){case 16:P=b&&x;break;case 18:v===Lm&&(b&&(l=h-k*b,n=r+k*b),x&&(d=p-L*x,a=s+L*x),v=Pm,F());break;case 32:v!==Lm&&v!==Pm||(b<0?l=h-k:b>0&&(n=r-k),x<0?d=p-L:x>0&&(a=s-L),v=km,D.attr("cursor",Bm.selection),F());break;default:return}Am()}function U(){switch(uu.keyCode){case 16:P&&(m=g=P=!1,F());break;case 18:v===Pm&&(b<0?l=h:b>0&&(n=r),x<0?d=p:x>0&&(a=s),v=Lm,F());break;case 32:v===km&&(uu.altKey?(b&&(l=h-k*b,n=r+k*b),x&&(d=p-L*x,a=s+L*x),v=Pm):(b<0?l=h:b>0&&(n=r),x<0?d=p:x>0&&(a=s),v=Lm),D.attr("cursor",Bm[y]),F());break;default:return}Am()}}function p(){u(this,arguments).moved()}function f(){u(this,arguments).ended()}function m(){var e=this.__brush||{selection:null};return e.extent=Nm(n.apply(this,arguments)),e.dim=t,e}return l.move=function(e,n){e.selection?e.on("start.brush",(function(){u(this,arguments).beforestart().start()})).on("interrupt.brush end.brush",(function(){u(this,arguments).end()})).tween("brush",(function(){var e=this,i=e.__brush,r=u(e,arguments),o=i.selection,a=t.input("function"==typeof n?n.apply(this,arguments):n,i.extent),s=Ud(o,a);function l(t){i.selection=1===t&&null===a?null:s(t),c.call(e),r.brush()}return null!==o&&null!==a?l:l(1)})):e.each((function(){var e=this,i=arguments,r=e.__brush,o=t.input("function"==typeof n?n.apply(e,i):n,r.extent),a=u(e,i).beforestart();Vp(e),r.selection=null===o?null:o,c.call(e),a.start().brush().end()}))},l.clear=function(t){l.move(t,null)},h.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(e){gu(new Em(l,e,t.output(this.state.selection)),a.apply,a,[e,this.that,this.args])}},l.extent=function(t){return arguments.length?(n="function"==typeof t?t:Mm(Nm(t)),l):n},l.filter=function(t){return arguments.length?(i="function"==typeof t?t:Mm(!!t),l):i},l.touchable=function(t){return arguments.length?(r="function"==typeof t?t:Mm(!!t),l):r},l.handleSize=function(t){return arguments.length?(s=+t,l):s},l.keyModifiers=function(t){return arguments.length?(o=!!t,l):o},l.on=function(){var t=a.on.apply(a,arguments);return t===a?l:t},l}var Qm=Math.cos,tg=Math.sin,eg=Math.PI,ng=eg/2,ig=2*eg,rg=Math.max;function og(t){return function(e,n){return t(e.source.value+e.target.value,n.source.value+n.target.value)}}var ag=Array.prototype.slice;function sg(t){return function(){return t}}var lg=Math.PI,cg=2*lg,ug=1e-6,hg=cg-ug;function dg(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function pg(){return new dg}function fg(t){return t.source}function mg(t){return t.target}function gg(t){return t.radius}function _g(t){return t.startAngle}function yg(t){return t.endAngle}dg.prototype=pg.prototype={constructor:dg,moveTo:function(t,e){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,e){this._+="L"+(this._x1=+t)+","+(this._y1=+e)},quadraticCurveTo:function(t,e,n,i){this._+="Q"+ +t+","+ +e+","+(this._x1=+n)+","+(this._y1=+i)},bezierCurveTo:function(t,e,n,i,r,o){this._+="C"+ +t+","+ +e+","+ +n+","+ +i+","+(this._x1=+r)+","+(this._y1=+o)},arcTo:function(t,e,n,i,r){var o=this._x1,a=this._y1,s=(n=+n)-(t=+t),l=(i=+i)-(e=+e),c=o-t,u=a-e,h=c*c+u*u;if((r=+r)<0)throw new Error("negative radius: "+r);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=e);else if(h>ug)if(Math.abs(u*s-l*c)>ug&&r){var d=n-o,p=i-a,f=s*s+l*l,m=d*d+p*p,g=Math.sqrt(f),_=Math.sqrt(h),y=r*Math.tan((lg-Math.acos((f+h-m)/(2*g*_)))/2),v=y/_,b=y/g;Math.abs(v-1)>ug&&(this._+="L"+(t+v*c)+","+(e+v*u)),this._+="A"+r+","+r+",0,0,"+ +(u*d>c*p)+","+(this._x1=t+b*s)+","+(this._y1=e+b*l)}else this._+="L"+(this._x1=t)+","+(this._y1=e)},arc:function(t,e,n,i,r,o){t=+t,e=+e,o=!!o;var a=(n=+n)*Math.cos(i),s=n*Math.sin(i),l=t+a,c=e+s,u=1^o,h=o?i-r:r-i;if(n<0)throw new Error("negative radius: "+n);null===this._x1?this._+="M"+l+","+c:(Math.abs(this._x1-l)>ug||Math.abs(this._y1-c)>ug)&&(this._+="L"+l+","+c),n&&(h<0&&(h=h%cg+cg),h>hg?this._+="A"+n+","+n+",0,1,"+u+","+(t-a)+","+(e-s)+"A"+n+","+n+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>ug&&(this._+="A"+n+","+n+",0,"+ +(h>=lg)+","+u+","+(this._x1=t+n*Math.cos(r))+","+(this._y1=e+n*Math.sin(r))))},rect:function(t,e,n,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)+"h"+ +n+"v"+ +i+"h"+-n+"Z"},toString:function(){return this._}};var vg="$";function bg(){}function xg(t,e){var n=new bg;if(t instanceof bg)t.each((function(t,e){n.set(e,t)}));else if(Array.isArray(t)){var i,r=-1,o=t.length;if(null==e)for(;++r<o;)n.set(r,t[r]);else for(;++r<o;)n.set(e(i=t[r],r,t),i)}else if(t)for(var a in t)n.set(a,t[a]);return n}function wg(){return{}}function Sg(t,e,n){t[e]=n}function Mg(){return xg()}function Eg(t,e,n){t.set(e,n)}function Tg(){}bg.prototype=xg.prototype={constructor:bg,has:function(t){return vg+t in this},get:function(t){return this[vg+t]},set:function(t,e){return this[vg+t]=e,this},remove:function(t){var e=vg+t;return e in this&&delete this[e]},clear:function(){for(var t in this)t[0]===vg&&delete this[t]},keys:function(){var t=[];for(var e in this)e[0]===vg&&t.push(e.slice(1));return t},values:function(){var t=[];for(var e in this)e[0]===vg&&t.push(this[e]);return t},entries:function(){var t=[];for(var e in this)e[0]===vg&&t.push({key:e.slice(1),value:this[e]});return t},size:function(){var t=0;for(var e in this)e[0]===vg&&++t;return t},empty:function(){for(var t in this)if(t[0]===vg)return!1;return!0},each:function(t){for(var e in this)e[0]===vg&&t(this[e],e.slice(1),this)}};var Ag=xg.prototype;function Cg(t,e){var n=new Tg;if(t instanceof Tg)t.each((function(t){n.add(t)}));else if(t){var i=-1,r=t.length;if(null==e)for(;++i<r;)n.add(t[i]);else for(;++i<r;)n.add(e(t[i],i,t))}return n}function kg(t){var e=[];for(var n in t)e.push(n);return e}Tg.prototype=Cg.prototype={constructor:Tg,has:Ag.has,add:function(t){return this[vg+(t+="")]=t,this},remove:Ag.remove,clear:Ag.clear,values:Ag.keys,size:Ag.size,empty:Ag.empty,each:Ag.each};var Lg=Array.prototype.slice;function Pg(t,e){return t-e}function Ig(t){return function(){return t}}function Ng(t,e){for(var n,i=-1,r=e.length;++i<r;)if(n=Og(t,e[i]))return n;return 0}function Og(t,e){for(var n=e[0],i=e[1],r=-1,o=0,a=t.length,s=a-1;o<a;s=o++){var l=t[o],c=l[0],u=l[1],h=t[s],d=h[0],p=h[1];if(Rg(l,h,e))return 0;u>i!=p>i&&n<(d-c)*(i-u)/(p-u)+c&&(r=-r)}return r}function Rg(t,e,n){var i;return(function r(t,e,n){return(e[0]-t[0])*(n[1]-t[1])==(n[0]-t[0])*(e[1]-t[1])})(t,e,n)&&(function o(t,e,n){return t<=e&&e<=n||n<=e&&e<=t})(t[i=+(t[0]===e[0])],n[i],e[i])}function zg(){}var Dg=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function Bg(){var t=1,e=1,n=Ul,i=s;function r(t){var e=n(t);if(Array.isArray(e))e=e.slice().sort(Pg);else{var i=Ll(t),r=i[0],a=i[1];e=jl(r,a,e),e=zl(Math.floor(r/e)*e,Math.floor(a/e)*e,e)}return e.map((function(e){return o(t,e)}))}function o(n,r){var o=[],s=[];return(function l(n,i,r){var o,s,l,c,u,h=new Array,d=new Array;for(o=s=-1,Dg[(l=n[0]>=i)<<1].forEach(p);++o<t-1;)Dg[l|(l=n[o+1]>=i)<<1].forEach(p);for(Dg[l<<0].forEach(p);++s<e-1;){for(o=-1,Dg[(l=n[s*t+t]>=i)<<1|(c=n[s*t]>=i)<<2].forEach(p);++o<t-1;)u=c,Dg[l|(l=n[s*t+t+o+1]>=i)<<1|(c=n[s*t+o+1]>=i)<<2|u<<3].forEach(p);Dg[l|c<<3].forEach(p)}for(o=-1,Dg[(c=n[s*t]>=i)<<2].forEach(p);++o<t-1;)u=c,Dg[(c=n[s*t+o+1]>=i)<<2|u<<3].forEach(p);function p(t){var e,n,i=[t[0][0]+o,t[0][1]+s],l=[t[1][0]+o,t[1][1]+s],c=a(i),u=a(l);(e=d[c])?(n=h[u])?(delete d[e.end],delete h[n.start],e===n?(e.ring.push(l),r(e.ring)):h[e.start]=d[n.end]={start:e.start,end:n.end,ring:e.ring.concat(n.ring)}):(delete d[e.end],e.ring.push(l),d[e.end=u]=e):(e=h[u])?(n=d[c])?(delete h[e.start],delete d[n.end],e===n?(e.ring.push(l),r(e.ring)):h[n.start]=d[e.end]={start:n.start,end:e.end,ring:n.ring.concat(e.ring)}):(delete h[e.start],e.ring.unshift(i),h[e.start=c]=e):h[c]=d[u]={start:c,end:u,ring:[i,l]}}Dg[c<<3].forEach(p)})(n,r,(function(t){i(t,n,r),(function e(t){for(var e=0,n=t.length,i=t[n-1][1]*t[0][0]-t[n-1][0]*t[0][1];++e<n;)i+=t[e-1][1]*t[e][0]-t[e-1][0]*t[e][1];return i})(t)>0?o.push([t]):s.push(t)})),s.forEach((function(t){for(var e,n=0,i=o.length;n<i;++n)if(-1!==Ng((e=o[n])[0],t))return void e.push(t)})),{type:"MultiPolygon",value:r,coordinates:o}}function a(e){return 2*e[0]+e[1]*(t+1)*4}function s(n,i,r){n.forEach((function(n){var o,a=n[0],s=n[1],l=0|a,c=0|s,u=i[c*t+l];a>0&&a<t&&l===a&&(n[0]=a+(r-(o=i[c*t+l-1]))/(u-o)-.5),s>0&&s<e&&c===s&&(n[1]=s+(r-(o=i[(c-1)*t+l]))/(u-o)-.5)}))}return r.contour=o,r.size=function(n){if(!arguments.length)return[t,e];var i=Math.ceil(n[0]),o=Math.ceil(n[1]);if(!(i>0&&o>0))throw new Error("invalid size");return t=i,e=o,r},r.thresholds=function(t){return arguments.length?(n="function"==typeof t?t:Array.isArray(t)?Ig(Lg.call(t)):Ig(t),r):n},r.smooth=function(t){return arguments.length?(i=t?s:zg,r):i===s},r}function Hg(t,e,n){for(var i=t.width,r=t.height,o=1+(n<<1),a=0;a<r;++a)for(var s=0,l=0;s<i+n;++s)s<i&&(l+=t.data[s+a*i]),s>=n&&(s>=o&&(l-=t.data[s-o+a*i]),e.data[s-n+a*i]=l/Math.min(s+1,i-1+o-s,o))}function Fg(t,e,n){for(var i=t.width,r=t.height,o=1+(n<<1),a=0;a<i;++a)for(var s=0,l=0;s<r+n;++s)s<r&&(l+=t.data[a+s*i]),s>=n&&(s>=o&&(l-=t.data[a+(s-o)*i]),e.data[a+(s-n)*i]=l/Math.min(s+1,r-1+o-s,o))}function Vg(t){return t[0]}function jg(t){return t[1]}function Ug(){return 1}var Gg={},Wg={};function qg(t){return new Function("d","return {"+t.map((function(t,e){return JSON.stringify(t)+": d["+e+'] || ""'})).join(",")+"}")}function Yg(t){var e=Object.create(null),n=[];return t.forEach((function(t){for(var i in t)i in e||n.push(e[i]=i)})),n}function Xg(t,e){var n=t+"",i=n.length;return i<e?new Array(e-i+1).join(0)+n:n}function $g(t){var e=new RegExp('["'+t+"\n\r]"),n=t.charCodeAt(0);function i(t,e){var i,r=[],o=t.length,a=0,s=0,l=o<=0,c=!1;function u(){if(l)return Wg;if(c)return c=!1,Gg;var e,i,r=a;if(34===t.charCodeAt(r)){for(;a++<o&&34!==t.charCodeAt(a)||34===t.charCodeAt(++a););return(e=a)>=o?l=!0:10===(i=t.charCodeAt(a++))?c=!0:13===i&&(c=!0,10===t.charCodeAt(a)&&++a),t.slice(r+1,e-1).replace(/""/g,'"')}for(;a<o;){if(10===(i=t.charCodeAt(e=a++)))c=!0;else if(13===i)c=!0,10===t.charCodeAt(a)&&++a;else if(i!==n)continue;return t.slice(r,e)}return l=!0,t.slice(r,o)}for(10===t.charCodeAt(o-1)&&--o,13===t.charCodeAt(o-1)&&--o;(i=u())!==Wg;){for(var h=[];i!==Gg&&i!==Wg;)h.push(i),i=u();e&&null==(h=e(h,s++))||r.push(h)}return r}function r(e,n){return e.map((function(e){return n.map((function(t){return a(e[t])})).join(t)}))}function o(e){return e.map(a).join(t)}function a(t){return null==t?"":t instanceof Date?(function n(t){var e=t.getUTCHours(),n=t.getUTCMinutes(),i=t.getUTCSeconds(),r=t.getUTCMilliseconds();return isNaN(t)?"Invalid Date":(function o(t){return t<0?"-"+Xg(-t,6):t>9999?"+"+Xg(t,6):Xg(t,4)})(t.getUTCFullYear())+"-"+Xg(t.getUTCMonth()+1,2)+"-"+Xg(t.getUTCDate(),2)+(r?"T"+Xg(e,2)+":"+Xg(n,2)+":"+Xg(i,2)+"."+Xg(r,3)+"Z":i?"T"+Xg(e,2)+":"+Xg(n,2)+":"+Xg(i,2)+"Z":n||e?"T"+Xg(e,2)+":"+Xg(n,2)+"Z":"")})(t):e.test(t+="")?'"'+t.replace(/"/g,'""')+'"':t}return{parse:function s(t,e){var n,r,o=i(t,(function(t,i){if(n)return n(t,i-1);r=t,n=e?(function o(t,e){var n=qg(t);return function(i,r){return e(n(i),r,t)}})(t,e):qg(t)}));return o.columns=r||[],o},parseRows:i,format:function l(e,n){return null==n&&(n=Yg(e)),[n.map(a).join(t)].concat(r(e,n)).join("\n")},formatBody:function c(t,e){return null==e&&(e=Yg(t)),r(t,e).join("\n")},formatRows:function u(t){return t.map(o).join("\n")},formatRow:o,formatValue:a}}var Kg=$g(","),Zg=Kg.parse,Jg=Kg.parseRows,Qg=Kg.format,t_=Kg.formatBody,e_=Kg.formatRows,n_=Kg.formatRow,i_=Kg.formatValue,r_=$g("\t"),o_=r_.parse,a_=r_.parseRows,s_=r_.format,l_=r_.formatBody,c_=r_.formatRows,u_=r_.formatRow,h_=r_.formatValue,d_=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours();function p_(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.blob()}function f_(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.arrayBuffer()}function m_(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.text()}function g_(t,e){return fetch(t,e).then(m_)}function __(t){return function(e,n,i){return 2===arguments.length&&"function"==typeof n&&(i=n,n=void 0),g_(e,n).then((function(e){return t(e,i)}))}}var y_=__(Zg),v_=__(o_);function b_(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);if(204!==t.status&&205!==t.status)return t.json()}function x_(t){return function(e,n){return g_(e,n).then((function(e){return(new DOMParser).parseFromString(e,t)}))}}var w_=x_("application/xml"),S_=x_("text/html"),M_=x_("image/svg+xml");function E_(t){return function(){return t}}function T_(){return 1e-6*(Math.random()-.5)}function A_(t,e,n,i){if(isNaN(e)||isNaN(n))return t;var r,o,a,s,l,c,u,h,d,p=t._root,f={data:i},m=t._x0,g=t._y0,_=t._x1,y=t._y1;if(!p)return t._root=f,t;for(;p.length;)if((c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a,r=p,!(p=p[h=u<<1|c]))return r[h]=f,t;if(s=+t._x.call(null,p.data),l=+t._y.call(null,p.data),e===s&&n===l)return f.next=p,r?r[h]=f:t._root=f,t;do{r=r?r[h]=new Array(4):t._root=new Array(4),(c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a}while((h=u<<1|c)==(d=(l>=a)<<1|s>=o));return r[d]=p,r[h]=f,t}function C_(t,e,n,i,r){this.node=t,this.x0=e,this.y0=n,this.x1=i,this.y1=r}function k_(t){return t[0]}function L_(t){return t[1]}function P_(t,e,n){var i=new I_(null==e?k_:e,null==n?L_:n,NaN,NaN,NaN,NaN);return null==t?i:i.addAll(t)}function I_(t,e,n,i,r,o){this._x=t,this._y=e,this._x0=n,this._y0=i,this._x1=r,this._y1=o,this._root=void 0}function N_(t){for(var e={data:t.data},n=e;t=t.next;)n=n.next={data:t.data};return e}var O_=P_.prototype=I_.prototype;function R_(t){return t.x+t.vx}function z_(t){return t.y+t.vy}function D_(t){return t.index}function B_(t,e){var n=t.get(e);if(!n)throw new Error("missing: "+e);return n}function H_(t){return t.x}function F_(t){return t.y}O_.copy=function(){var t,e,n=new I_(this._x,this._y,this._x0,this._y0,this._x1,this._y1),i=this._root;if(!i)return n;if(!i.length)return n._root=N_(i),n;for(t=[{source:i,target:n._root=new Array(4)}];i=t.pop();)for(var r=0;r<4;++r)(e=i.source[r])&&(e.length?t.push({source:e,target:i.target[r]=new Array(4)}):i.target[r]=N_(e));return n},O_.add=function V_(t){var e=+this._x.call(null,t),n=+this._y.call(null,t);return A_(this.cover(e,n),e,n,t)},O_.addAll=function j_(t){var e,n,i,r,o=t.length,a=new Array(o),s=new Array(o),l=1/0,c=1/0,u=-1/0,h=-1/0;for(n=0;n<o;++n)isNaN(i=+this._x.call(null,e=t[n]))||isNaN(r=+this._y.call(null,e))||(a[n]=i,s[n]=r,i<l&&(l=i),i>u&&(u=i),r<c&&(c=r),r>h&&(h=r));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),n=0;n<o;++n)A_(this,a[n],s[n],t[n]);return this},O_.cover=function U_(t,e){if(isNaN(t=+t)||isNaN(e=+e))return this;var n=this._x0,i=this._y0,r=this._x1,o=this._y1;if(isNaN(n))r=(n=Math.floor(t))+1,o=(i=Math.floor(e))+1;else{for(var a,s,l=r-n,c=this._root;n>t||t>=r||i>e||e>=o;)switch(s=(e<i)<<1|t<n,(a=new Array(4))[s]=c,c=a,l*=2,s){case 0:r=n+l,o=i+l;break;case 1:n=r-l,o=i+l;break;case 2:r=n+l,i=o-l;break;case 3:n=r-l,i=o-l}this._root&&this._root.length&&(this._root=c)}return this._x0=n,this._y0=i,this._x1=r,this._y1=o,this},O_.data=function G_(){var t=[];return this.visit((function(e){if(!e.length)do{t.push(e.data)}while(e=e.next)})),t},O_.extent=function W_(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},O_.find=function q_(t,e,n){var i,r,o,a,s,l,c,u=this._x0,h=this._y0,d=this._x1,p=this._y1,f=[],m=this._root;for(m&&f.push(new C_(m,u,h,d,p)),null==n?n=1/0:(u=t-n,h=e-n,d=t+n,p=e+n,n*=n);l=f.pop();)if(!(!(m=l.node)||(r=l.x0)>d||(o=l.y0)>p||(a=l.x1)<u||(s=l.y1)<h))if(m.length){var g=(r+a)/2,_=(o+s)/2;f.push(new C_(m[3],g,_,a,s),new C_(m[2],r,_,g,s),new C_(m[1],g,o,a,_),new C_(m[0],r,o,g,_)),(c=(e>=_)<<1|t>=g)&&(l=f[f.length-1],f[f.length-1]=f[f.length-1-c],f[f.length-1-c]=l)}else{var y=t-+this._x.call(null,m.data),v=e-+this._y.call(null,m.data),b=y*y+v*v;if(b<n){var x=Math.sqrt(n=b);u=t-x,h=e-x,d=t+x,p=e+x,i=m.data}}return i},O_.remove=function Y_(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var e,n,i,r,o,a,s,l,c,u,h,d,p=this._root,f=this._x0,m=this._y0,g=this._x1,_=this._y1;if(!p)return this;if(p.length)for(;;){if((c=o>=(s=(f+g)/2))?f=s:g=s,(u=a>=(l=(m+_)/2))?m=l:_=l,e=p,!(p=p[h=u<<1|c]))return this;if(!p.length)break;(e[h+1&3]||e[h+2&3]||e[h+3&3])&&(n=e,d=h)}for(;p.data!==t;)if(i=p,!(p=p.next))return this;return(r=p.next)&&delete p.next,i?(r?i.next=r:delete i.next,this):e?(r?e[h]=r:delete e[h],(p=e[0]||e[1]||e[2]||e[3])&&p===(e[3]||e[2]||e[1]||e[0])&&!p.length&&(n?n[d]=p:this._root=p),this):(this._root=r,this)},O_.removeAll=function X_(t){for(var e=0,n=t.length;e<n;++e)this.remove(t[e]);return this},O_.root=function $_(){return this._root},O_.size=function K_(){var t=0;return this.visit((function(e){if(!e.length)do{++t}while(e=e.next)})),t},O_.visit=function Z_(t){var e,n,i,r,o,a,s=[],l=this._root;for(l&&s.push(new C_(l,this._x0,this._y0,this._x1,this._y1));e=s.pop();)if(!t(l=e.node,i=e.x0,r=e.y0,o=e.x1,a=e.y1)&&l.length){var c=(i+o)/2,u=(r+a)/2;(n=l[3])&&s.push(new C_(n,c,u,o,a)),(n=l[2])&&s.push(new C_(n,i,u,c,a)),(n=l[1])&&s.push(new C_(n,c,r,o,u)),(n=l[0])&&s.push(new C_(n,i,r,c,u))}return this},O_.visitAfter=function J_(t){var e,n=[],i=[];for(this._root&&n.push(new C_(this._root,this._x0,this._y0,this._x1,this._y1));e=n.pop();){var r=e.node;if(r.length){var o,a=e.x0,s=e.y0,l=e.x1,c=e.y1,u=(a+l)/2,h=(s+c)/2;(o=r[0])&&n.push(new C_(o,a,s,u,h)),(o=r[1])&&n.push(new C_(o,u,s,l,h)),(o=r[2])&&n.push(new C_(o,a,h,u,c)),(o=r[3])&&n.push(new C_(o,u,h,l,c))}i.push(e)}for(;e=i.pop();)t(e.node,e.x0,e.y0,e.x1,e.y1);return this},O_.x=function Q_(t){return arguments.length?(this._x=t,this):this._x},O_.y=function ty(t){return arguments.length?(this._y=t,this):this._y};var ey=Math.PI*(3-Math.sqrt(5));function ny(t,e){if((n=(t=e?t.toExponential(e-1):t.toExponential()).indexOf("e"))<0)return null;var n,i=t.slice(0,n);return[i.length>1?i[0]+i.slice(2):i,+t.slice(n+1)]}function iy(t){return(t=ny(Math.abs(t)))?t[1]:NaN}var ry,oy=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ay(t){if(!(e=oy.exec(t)))throw new Error("invalid format: "+t);var e;return new sy({fill:e[1],align:e[2],sign:e[3],symbol:e[4],zero:e[5],width:e[6],comma:e[7],precision:e[8]&&e[8].slice(1),trim:e[9],type:e[10]})}function sy(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function ly(t,e){var n=ny(t,e);if(!n)return t+"";var i=n[0],r=n[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}ay.prototype=sy.prototype,sy.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var cy={"%":function(t,e){return(100*t).toFixed(e)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,e){return t.toExponential(e)},f:function(t,e){return t.toFixed(e)},g:function(t,e){return t.toPrecision(e)},o:function(t){return Math.round(t).toString(8)},p:function(t,e){return ly(100*t,e)},r:ly,s:function uy(t,e){var n=ny(t,e);if(!n)return t+"";var i=n[0],r=n[1],o=r-(ry=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,a=i.length;return o===a?i:o>a?i+new Array(o-a+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+ny(t,Math.max(0,e+o-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}};function hy(t){return t}var dy,py,fy,my=Array.prototype.map,gy=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function _y(t){var e=void 0===t.grouping||void 0===t.thousands?hy:(function n(t,e){return function(n,i){for(var r=n.length,o=[],a=0,s=t[0],l=0;r>0&&s>0&&(l+s+1>i&&(s=Math.max(1,i-l)),o.push(n.substring(r-=s,r+s)),!((l+=s+1)>i));)s=t[a=(a+1)%t.length];return o.reverse().join(e)}})(my.call(t.grouping,Number),t.thousands+""),i=void 0===t.currency?"":t.currency[0]+"",r=void 0===t.currency?"":t.currency[1]+"",o=void 0===t.decimal?".":t.decimal+"",a=void 0===t.numerals?hy:(function s(t){return function(e){return e.replace(/[0-9]/g,(function(e){return t[+e]}))}})(my.call(t.numerals,String)),l=void 0===t.percent?"%":t.percent+"",c=void 0===t.minus?"-":t.minus+"",u=void 0===t.nan?"NaN":t.nan+"";function h(t){var n=(t=ay(t)).fill,s=t.align,h=t.sign,d=t.symbol,p=t.zero,f=t.width,m=t.comma,g=t.precision,_=t.trim,y=t.type;"n"===y?(m=!0,y="g"):cy[y]||(void 0===g&&(g=12),_=!0,y="g"),(p||"0"===n&&"="===s)&&(p=!0,n="0",s="=");var v="$"===d?i:"#"===d&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b="$"===d?r:/[%p]/.test(y)?l:"",x=cy[y],w=/[defgprs%]/.test(y);function S(t){var i,r,l,d=v,S=b;if("c"===y)S=x(t)+S,t="";else{var M=(t=+t)<0||1/t<0;if(t=isNaN(t)?u:x(Math.abs(t),g),_&&(t=(function E(t){t:for(var e,n=t.length,i=1,r=-1;i<n;++i)switch(t[i]){case".":r=e=i;break;case"0":0===r&&(r=i),e=i;break;default:if(!+t[i])break t;r>0&&(r=0)}return r>0?t.slice(0,r)+t.slice(e+1):t})(t)),M&&0==+t&&"+"!==h&&(M=!1),d=(M?"("===h?h:c:"-"===h||"("===h?"":h)+d,S=("s"===y?gy[8+ry/3]:"")+S+(M&&"("===h?")":""),w)for(i=-1,r=t.length;++i<r;)if(48>(l=t.charCodeAt(i))||l>57){S=(46===l?o+t.slice(i+1):t.slice(i))+S,t=t.slice(0,i);break}}m&&!p&&(t=e(t,1/0));var T=d.length+t.length+S.length,A=T<f?new Array(f-T+1).join(n):"";switch(m&&p&&(t=e(A+t,A.length?f-S.length:1/0),A=""),s){case"<":t=d+t+S+A;break;case"=":t=d+A+t+S;break;case"^":t=A.slice(0,T=A.length>>1)+d+t+S+A.slice(T);break;default:t=A+d+t+S}return a(t)}return g=void 0===g?6:/[gprs]/.test(y)?Math.max(1,Math.min(21,g)):Math.max(0,Math.min(20,g)),S.toString=function(){return t+""},S}return{format:h,formatPrefix:function d(t,e){var n=h(((t=ay(t)).type="f",t)),i=3*Math.max(-8,Math.min(8,Math.floor(iy(e)/3))),r=Math.pow(10,-i),o=gy[8+i/3];return function(t){return n(r*t)+o}}}}function yy(t){return dy=_y(t),py=dy.format,fy=dy.formatPrefix,dy}function vy(t){return Math.max(0,-iy(Math.abs(t)))}function by(t,e){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(iy(e)/3)))-iy(Math.abs(t)))}function xy(t,e){return t=Math.abs(t),e=Math.abs(e)-t,Math.max(0,iy(e)-iy(t))+1}function wy(){return new Sy}function Sy(){this.reset()}yy({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"}),Sy.prototype={constructor:Sy,reset:function(){this.s=this.t=0},add:function(t){Ey(My,t,this.t),Ey(this,My.s,this.s),this.s?this.t+=My.t:this.s=My.t},valueOf:function(){return this.s}};var My=new Sy;function Ey(t,e,n){var i=t.s=e+n,r=i-e;t.t=e-(i-r)+(n-r)}var Ty=1e-6,Ay=1e-12,Cy=Math.PI,ky=Cy/2,Ly=Cy/4,Py=2*Cy,Iy=180/Cy,Ny=Cy/180,Oy=Math.abs,Ry=Math.atan,zy=Math.atan2,Dy=Math.cos,By=Math.ceil,Hy=Math.exp,Fy=Math.log,Vy=Math.pow,jy=Math.sin,Uy=Math.sign||function(t){return t>0?1:t<0?-1:0},Gy=Math.sqrt,Wy=Math.tan;function qy(t){return t>1?0:t<-1?Cy:Math.acos(t)}function Yy(t){return t>1?ky:t<-1?-ky:Math.asin(t)}function Xy(t){return(t=jy(t/2))*t}function $y(){}function Ky(t,e){t&&Jy.hasOwnProperty(t.type)&&Jy[t.type](t,e)}var Zy={Feature:function(t,e){Ky(t.geometry,e)},FeatureCollection:function(t,e){for(var n=t.features,i=-1,r=n.length;++i<r;)Ky(n[i].geometry,e)}},Jy={Sphere:function(t,e){e.sphere()},Point:function(t,e){e.point((t=t.coordinates)[0],t[1],t[2])},MultiPoint:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)e.point((t=n[i])[0],t[1],t[2])},LineString:function(t,e){Qy(t.coordinates,e,0)},MultiLineString:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)Qy(n[i],e,0)},Polygon:function(t,e){tv(t.coordinates,e)},MultiPolygon:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)tv(n[i],e)},GeometryCollection:function(t,e){for(var n=t.geometries,i=-1,r=n.length;++i<r;)Ky(n[i],e)}};function Qy(t,e,n){var i,r=-1,o=t.length-n;for(e.lineStart();++r<o;)e.point((i=t[r])[0],i[1],i[2]);e.lineEnd()}function tv(t,e){var n=-1,i=t.length;for(e.polygonStart();++n<i;)Qy(t[n],e,1);e.polygonEnd()}function ev(t,e){t&&Zy.hasOwnProperty(t.type)?Zy[t.type](t,e):Ky(t,e)}var nv,iv,rv,ov,av,sv=wy(),lv=wy(),cv={point:$y,lineStart:$y,lineEnd:$y,polygonStart:function(){sv.reset(),cv.lineStart=uv,cv.lineEnd=hv},polygonEnd:function(){var t=+sv;lv.add(t<0?Py+t:t),this.lineStart=this.lineEnd=this.point=$y},sphere:function(){lv.add(Py)}};function uv(){cv.point=dv}function hv(){pv(nv,iv)}function dv(t,e){cv.point=pv,nv=t,iv=e,rv=t*=Ny,ov=Dy(e=(e*=Ny)/2+Ly),av=jy(e)}function pv(t,e){var n=(t*=Ny)-rv,i=n>=0?1:-1,r=i*n,o=Dy(e=(e*=Ny)/2+Ly),a=jy(e),s=av*a,l=ov*o+s*Dy(r),c=s*i*jy(r);sv.add(zy(c,l)),rv=t,ov=o,av=a}function fv(t){return[zy(t[1],t[0]),Yy(t[2])]}function mv(t){var e=t[0],n=t[1],i=Dy(n);return[i*Dy(e),i*jy(e),jy(n)]}function gv(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function _v(t,e){return[t[1]*e[2]-t[2]*e[1],t[2]*e[0]-t[0]*e[2],t[0]*e[1]-t[1]*e[0]]}function yv(t,e){t[0]+=e[0],t[1]+=e[1],t[2]+=e[2]}function vv(t,e){return[t[0]*e,t[1]*e,t[2]*e]}function bv(t){var e=Gy(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=e,t[1]/=e,t[2]/=e}var xv,wv,Sv,Mv,Ev,Tv,Av,Cv,kv,Lv,Pv,Iv,Nv,Ov,Rv,zv,Dv,Bv,Hv,Fv,Vv,jv,Uv,Gv,Wv,qv,Yv=wy(),Xv={point:$v,lineStart:Zv,lineEnd:Jv,polygonStart:function(){Xv.point=Qv,Xv.lineStart=tb,Xv.lineEnd=eb,Yv.reset(),cv.polygonStart()},polygonEnd:function(){cv.polygonEnd(),Xv.point=$v,Xv.lineStart=Zv,Xv.lineEnd=Jv,sv<0?(xv=-(Sv=180),wv=-(Mv=90)):Yv>Ty?Mv=90:Yv<-1e-6&&(wv=-90),Lv[0]=xv,Lv[1]=Sv},sphere:function(){xv=-(Sv=180),wv=-(Mv=90)}};function $v(t,e){kv.push(Lv=[xv=t,Sv=t]),e<wv&&(wv=e),e>Mv&&(Mv=e)}function Kv(t,e){var n=mv([t*Ny,e*Ny]);if(Cv){var i=_v(Cv,n),r=_v([i[1],-i[0],0],i);bv(r),r=fv(r);var o,a=t-Ev,s=a>0?1:-1,l=r[0]*Iy*s,c=Oy(a)>180;c^(s*Ev<l&&l<s*t)?(o=r[1]*Iy)>Mv&&(Mv=o):c^(s*Ev<(l=(l+360)%360-180)&&l<s*t)?(o=-r[1]*Iy)<wv&&(wv=o):(e<wv&&(wv=e),e>Mv&&(Mv=e)),c?t<Ev?nb(xv,t)>nb(xv,Sv)&&(Sv=t):nb(t,Sv)>nb(xv,Sv)&&(xv=t):Sv>=xv?(t<xv&&(xv=t),t>Sv&&(Sv=t)):t>Ev?nb(xv,t)>nb(xv,Sv)&&(Sv=t):nb(t,Sv)>nb(xv,Sv)&&(xv=t)}else kv.push(Lv=[xv=t,Sv=t]);e<wv&&(wv=e),e>Mv&&(Mv=e),Cv=n,Ev=t}function Zv(){Xv.point=Kv}function Jv(){Lv[0]=xv,Lv[1]=Sv,Xv.point=$v,Cv=null}function Qv(t,e){if(Cv){var n=t-Ev;Yv.add(Oy(n)>180?n+(n>0?360:-360):n)}else Tv=t,Av=e;cv.point(t,e),Kv(t,e)}function tb(){cv.lineStart()}function eb(){Qv(Tv,Av),cv.lineEnd(),Oy(Yv)>Ty&&(xv=-(Sv=180)),Lv[0]=xv,Lv[1]=Sv,Cv=null}function nb(t,e){return(e-=t)<0?e+360:e}function ib(t,e){return t[0]-e[0]}function rb(t,e){return t[0]<=t[1]?t[0]<=e&&e<=t[1]:e<t[0]||t[1]<e}var ob={sphere:$y,point:ab,lineStart:lb,lineEnd:hb,polygonStart:function(){ob.lineStart=db,ob.lineEnd=pb},polygonEnd:function(){ob.lineStart=lb,ob.lineEnd=hb}};function ab(t,e){t*=Ny;var n=Dy(e*=Ny);sb(n*Dy(t),n*jy(t),jy(e))}function sb(t,e,n){++Pv,Nv+=(t-Nv)/Pv,Ov+=(e-Ov)/Pv,Rv+=(n-Rv)/Pv}function lb(){ob.point=cb}function cb(t,e){t*=Ny;var n=Dy(e*=Ny);Gv=n*Dy(t),Wv=n*jy(t),qv=jy(e),ob.point=ub,sb(Gv,Wv,qv)}function ub(t,e){t*=Ny;var n=Dy(e*=Ny),i=n*Dy(t),r=n*jy(t),o=jy(e),a=zy(Gy((a=Wv*o-qv*r)*a+(a=qv*i-Gv*o)*a+(a=Gv*r-Wv*i)*a),Gv*i+Wv*r+qv*o);Iv+=a,zv+=a*(Gv+(Gv=i)),Dv+=a*(Wv+(Wv=r)),Bv+=a*(qv+(qv=o)),sb(Gv,Wv,qv)}function hb(){ob.point=ab}function db(){ob.point=fb}function pb(){mb(jv,Uv),ob.point=ab}function fb(t,e){jv=t,Uv=e,t*=Ny,e*=Ny,ob.point=mb;var n=Dy(e);Gv=n*Dy(t),Wv=n*jy(t),qv=jy(e),sb(Gv,Wv,qv)}function mb(t,e){t*=Ny;var n=Dy(e*=Ny),i=n*Dy(t),r=n*jy(t),o=jy(e),a=Wv*o-qv*r,s=qv*i-Gv*o,l=Gv*r-Wv*i,c=Gy(a*a+s*s+l*l),u=Yy(c),h=c&&-u/c;Hv+=h*a,Fv+=h*s,Vv+=h*l,Iv+=u,zv+=u*(Gv+(Gv=i)),Dv+=u*(Wv+(Wv=r)),Bv+=u*(qv+(qv=o)),sb(Gv,Wv,qv)}function gb(t){return function(){return t}}function _b(t,e){function n(n,i){return n=t(n,i),e(n[0],n[1])}return t.invert&&e.invert&&(n.invert=function(n,i){return(n=e.invert(n,i))&&t.invert(n[0],n[1])}),n}function yb(t,e){return[Oy(t)>Cy?t+Math.round(-t/Py)*Py:t,e]}function vb(t,e,n){return(t%=Py)?e||n?_b(xb(t),wb(e,n)):xb(t):e||n?wb(e,n):yb}function bb(t){return function(e,n){return[(e+=t)>Cy?e-Py:e<-Cy?e+Py:e,n]}}function xb(t){var e=bb(t);return e.invert=bb(-t),e}function wb(t,e){var n=Dy(t),i=jy(t),r=Dy(e),o=jy(e);function a(t,e){var a=Dy(e),s=Dy(t)*a,l=jy(t)*a,c=jy(e),u=c*n+s*i;return[zy(l*r-u*o,s*n-c*i),Yy(u*r+l*o)]}return a.invert=function(t,e){var a=Dy(e),s=Dy(t)*a,l=jy(t)*a,c=jy(e),u=c*r-l*o;return[zy(l*r+c*o,s*n+u*i),Yy(u*n-s*i)]},a}function Sb(t){function e(e){return(e=t(e[0]*Ny,e[1]*Ny))[0]*=Iy,e[1]*=Iy,e}return t=vb(t[0]*Ny,t[1]*Ny,t.length>2?t[2]*Ny:0),e.invert=function(e){return(e=t.invert(e[0]*Ny,e[1]*Ny))[0]*=Iy,e[1]*=Iy,e},e}function Mb(t,e,n,i,r,o){if(n){var a=Dy(e),s=jy(e),l=i*n;null==r?(r=e+i*Py,o=e-l/2):(r=Eb(a,r),o=Eb(a,o),(i>0?r<o:r>o)&&(r+=i*Py));for(var c,u=r;i>0?u>o:u<o;u-=l)c=fv([a,-s*Dy(u),-s*jy(u)]),t.point(c[0],c[1])}}function Eb(t,e){(e=mv(e))[0]-=t,bv(e);var n=qy(-e[1]);return((-e[2]<0?-n:n)+Py-Ty)%Py}function Tb(){var t,e=[];return{point:function(e,n,i){t.push([e,n,i])},lineStart:function(){e.push(t=[])},lineEnd:$y,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var n=e;return e=[],t=null,n}}}function Ab(t,e){return Oy(t[0]-e[0])<Ty&&Oy(t[1]-e[1])<Ty}function Cb(t,e,n,i){this.x=t,this.z=e,this.o=n,this.e=i,this.v=!1,this.n=this.p=null}function kb(t,e,n,i,r){var o,a,s=[],l=[];if(t.forEach((function(t){if(!((e=t.length-1)<=0)){var e,n,i=t[0],a=t[e];if(Ab(i,a)){if(!i[2]&&!a[2]){for(r.lineStart(),o=0;o<e;++o)r.point((i=t[o])[0],i[1]);return void r.lineEnd()}a[0]+=2e-6}s.push(n=new Cb(i,t,null,!0)),l.push(n.o=new Cb(i,null,n,!1)),s.push(n=new Cb(a,t,null,!1)),l.push(n.o=new Cb(a,null,n,!0))}})),s.length){for(l.sort(e),Lb(s),Lb(l),o=0,a=l.length;o<a;++o)l[o].e=n=!n;for(var c,u,h=s[0];;){for(var d=h,p=!0;d.v;)if((d=d.n)===h)return;c=d.z,r.lineStart();do{if(d.v=d.o.v=!0,d.e){if(p)for(o=0,a=c.length;o<a;++o)r.point((u=c[o])[0],u[1]);else i(d.x,d.n.x,1,r);d=d.n}else{if(p)for(o=(c=d.p.z).length-1;o>=0;--o)r.point((u=c[o])[0],u[1]);else i(d.x,d.p.x,-1,r);d=d.p}c=(d=d.o).z,p=!p}while(!d.v);r.lineEnd()}}}function Lb(t){if(e=t.length){for(var e,n,i=0,r=t[0];++i<e;)r.n=n=t[i],n.p=r,r=n;r.n=n=t[0],n.p=r}}yb.invert=yb;var Pb=wy();function Ib(t){return Oy(t[0])<=Cy?t[0]:Uy(t[0])*((Oy(t[0])+Cy)%Py-Cy)}function Nb(t,e){var n=Ib(e),i=e[1],r=jy(i),o=[jy(n),-Dy(n),0],a=0,s=0;Pb.reset(),1===r?i=ky+Ty:-1===r&&(i=-ky-Ty);for(var l=0,c=t.length;l<c;++l)if(h=(u=t[l]).length)for(var u,h,d=u[h-1],p=Ib(d),f=d[1]/2+Ly,m=jy(f),g=Dy(f),_=0;_<h;++_,p=v,m=x,g=w,d=y){var y=u[_],v=Ib(y),b=y[1]/2+Ly,x=jy(b),w=Dy(b),S=v-p,M=S>=0?1:-1,E=M*S,T=E>Cy,A=m*x;if(Pb.add(zy(A*M*jy(E),g*w+A*Dy(E))),a+=T?S+M*Py:S,T^p>=n^v>=n){var C=_v(mv(d),mv(y));bv(C);var k=_v(o,C);bv(k);var L=(T^S>=0?-1:1)*Yy(k[2]);(i>L||i===L&&(C[0]||C[1]))&&(s+=T^S>=0?1:-1)}}return(a<-1e-6||a<Ty&&Pb<-1e-6)^1&s}function Ob(t,e,n,i){return function(r){var o,a,s,l=e(r),c=Tb(),u=e(c),h=!1,d={point:p,lineStart:m,lineEnd:g,polygonStart:function(){d.point=_,d.lineStart=y,d.lineEnd=v,a=[],o=[]},polygonEnd:function(){d.point=p,d.lineStart=m,d.lineEnd=g,a=ql(a);var t=Nb(o,i);a.length?(h||(r.polygonStart(),h=!0),kb(a,zb,t,n,r)):t&&(h||(r.polygonStart(),h=!0),r.lineStart(),n(null,null,1,r),r.lineEnd()),h&&(r.polygonEnd(),h=!1),a=o=null},sphere:function(){r.polygonStart(),r.lineStart(),n(null,null,1,r),r.lineEnd(),r.polygonEnd()}};function p(e,n){t(e,n)&&r.point(e,n)}function f(t,e){l.point(t,e)}function m(){d.point=f,l.lineStart()}function g(){d.point=p,l.lineEnd()}function _(t,e){s.push([t,e]),u.point(t,e)}function y(){u.lineStart(),s=[]}function v(){_(s[0][0],s[0][1]),u.lineEnd();var t,e,n,i,l=u.clean(),d=c.result(),p=d.length;if(s.pop(),o.push(s),s=null,p)if(1&l){if((e=(n=d[0]).length-1)>0){for(h||(r.polygonStart(),h=!0),r.lineStart(),t=0;t<e;++t)r.point((i=n[t])[0],i[1]);r.lineEnd()}}else p>1&&2&l&&d.push(d.pop().concat(d.shift())),a.push(d.filter(Rb))}return d}}function Rb(t){return t.length>1}function zb(t,e){return((t=t.x)[0]<0?t[1]-ky-Ty:ky-t[1])-((e=e.x)[0]<0?e[1]-ky-Ty:ky-e[1])}var Db=Ob((function(){return!0}),(function Bb(t){var e,n=NaN,i=NaN,r=NaN;return{lineStart:function(){t.lineStart(),e=1},point:function(o,a){var s=o>0?Cy:-Cy,l=Oy(o-n);Oy(l-Cy)<Ty?(t.point(n,i=(i+a)/2>0?ky:-ky),t.point(r,i),t.lineEnd(),t.lineStart(),t.point(s,i),t.point(o,i),e=0):r!==s&&l>=Cy&&(Oy(n-r)<Ty&&(n-=r*Ty),Oy(o-s)<Ty&&(o-=s*Ty),i=(function c(t,e,n,i){var r,o,a=jy(t-n);return Oy(a)>Ty?Ry((jy(e)*(o=Dy(i))*jy(n)-jy(i)*(r=Dy(e))*jy(t))/(r*o*a)):(e+i)/2})(n,i,o,a),t.point(r,i),t.lineEnd(),t.lineStart(),t.point(s,i),e=0),t.point(n=o,i=a),r=s},lineEnd:function(){t.lineEnd(),n=i=NaN},clean:function(){return 2-e}}}),(function Hb(t,e,n,i){var r;if(null==t)i.point(-Cy,r=n*ky),i.point(0,r),i.point(Cy,r),i.point(Cy,0),i.point(Cy,-r),i.point(0,-r),i.point(-Cy,-r),i.point(-Cy,0),i.point(-Cy,r);else if(Oy(t[0]-e[0])>Ty){var o=t[0]<e[0]?Cy:-Cy;i.point(-o,r=n*o/2),i.point(0,r),i.point(o,r)}else i.point(e[0],e[1])}),[-Cy,-ky]);function Fb(t){var e=Dy(t),n=6*Ny,i=e>0,r=Oy(e)>Ty;function o(t,n){return Dy(t)*Dy(n)>e}function a(t,n,i){var r=[1,0,0],o=_v(mv(t),mv(n)),a=gv(o,o),s=o[0],l=a-s*s;if(!l)return!i&&t;var c=e*a/l,u=-e*s/l,h=_v(r,o),d=vv(r,c);yv(d,vv(o,u));var p=h,f=gv(d,p),m=gv(p,p),g=f*f-m*(gv(d,d)-1);if(!(g<0)){var _=Gy(g),y=vv(p,(-f-_)/m);if(yv(y,d),y=fv(y),!i)return y;var v,b=t[0],x=n[0],w=t[1],S=n[1];x<b&&(v=b,b=x,x=v);var M=x-b,E=Oy(M-Cy)<Ty;if(!E&&S<w&&(v=w,w=S,S=v),E||M<Ty?E?w+S>0^y[1]<(Oy(y[0]-b)<Ty?w:S):w<=y[1]&&y[1]<=S:M>Cy^(b<=y[0]&&y[0]<=x)){var T=vv(p,(-f+_)/m);return yv(T,d),[y,fv(T)]}}}function s(e,n){var r=i?t:Cy-t,o=0;return e<-r?o|=1:e>r&&(o|=2),n<-r?o|=4:n>r&&(o|=8),o}return Ob(o,(function l(t){var e,n,l,c,u;return{lineStart:function(){c=l=!1,u=1},point:function(h,d){var p,f=[h,d],m=o(h,d),g=i?m?0:s(h,d):m?s(h+(h<0?Cy:-Cy),d):0;if(!e&&(c=l=m)&&t.lineStart(),m!==l&&(!(p=a(e,f))||Ab(e,p)||Ab(f,p))&&(f[2]=1),m!==l)u=0,m?(t.lineStart(),p=a(f,e),t.point(p[0],p[1])):(p=a(e,f),t.point(p[0],p[1],2),t.lineEnd()),e=p;else if(r&&e&&i^m){var _;g&n||!(_=a(f,e,!0))||(u=0,i?(t.lineStart(),t.point(_[0][0],_[0][1]),t.point(_[1][0],_[1][1]),t.lineEnd()):(t.point(_[1][0],_[1][1]),t.lineEnd(),t.lineStart(),t.point(_[0][0],_[0][1],3)))}!m||e&&Ab(e,f)||t.point(f[0],f[1]),e=f,l=m,n=g},lineEnd:function(){l&&t.lineEnd(),e=null},clean:function(){return u|(c&&l)<<1}}}),(function c(e,i,r,o){Mb(o,t,n,r,e,i)}),i?[0,-t]:[-Cy,t-Cy])}var Vb=1e9,jb=-Vb;function Ub(t,e,n,i){function r(r,o){return t<=r&&r<=n&&e<=o&&o<=i}function o(r,o,s,c){var u=0,h=0;if(null==r||(u=a(r,s))!==(h=a(o,s))||l(r,o)<0^s>0)do{c.point(0===u||3===u?t:n,u>1?i:e)}while((u=(u+s+4)%4)!==h);else c.point(o[0],o[1])}function a(i,r){return Oy(i[0]-t)<Ty?r>0?0:3:Oy(i[0]-n)<Ty?r>0?2:1:Oy(i[1]-e)<Ty?r>0?1:0:r>0?3:2}function s(t,e){return l(t.x,e.x)}function l(t,e){var n=a(t,1),i=a(e,1);return n!==i?n-i:0===n?e[1]-t[1]:1===n?t[0]-e[0]:2===n?t[1]-e[1]:e[0]-t[0]}return function(a){var l,c,u,h,d,p,f,m,g,_,y,v=a,b=Tb(),x={point:T,lineStart:function w(){x.point=A,c&&c.push(u=[]),_=!0,g=!1,f=m=NaN},lineEnd:function S(){l&&(A(h,d),p&&g&&b.rejoin(),l.push(b.result())),x.point=T,g&&v.lineEnd()},polygonStart:function M(){v=b,l=[],c=[],y=!0},polygonEnd:function E(){var e=(function n(){for(var e=0,n=0,r=c.length;n<r;++n)for(var o,a,s=c[n],l=1,u=s.length,h=s[0],d=h[0],p=h[1];l<u;++l)o=d,a=p,d=(h=s[l])[0],p=h[1],a<=i?p>i&&(d-o)*(i-a)>(p-a)*(t-o)&&++e:p<=i&&(d-o)*(i-a)<(p-a)*(t-o)&&--e;return e})(),r=y&&e,h=(l=ql(l)).length;(r||h)&&(a.polygonStart(),r&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),h&&kb(l,s,e,o,a),a.polygonEnd()),v=a,l=c=u=null}};function T(t,e){r(t,e)&&v.point(t,e)}function A(o,a){var s=r(o,a);if(c&&u.push([o,a]),_)h=o,d=a,p=s,_=!1,s&&(v.lineStart(),v.point(o,a));else if(s&&g)v.point(o,a);else{var l=[f=Math.max(jb,Math.min(Vb,f)),m=Math.max(jb,Math.min(Vb,m))],b=[o=Math.max(jb,Math.min(Vb,o)),a=Math.max(jb,Math.min(Vb,a))];!(function x(t,e,n,i,r,o){var a,s=t[0],l=t[1],c=0,u=1,h=e[0]-s,d=e[1]-l;if(a=n-s,h||!(a>0)){if(a/=h,h<0){if(a<c)return;a<u&&(u=a)}else if(h>0){if(a>u)return;a>c&&(c=a)}if(a=r-s,h||!(a<0)){if(a/=h,h<0){if(a>u)return;a>c&&(c=a)}else if(h>0){if(a<c)return;a<u&&(u=a)}if(a=i-l,d||!(a>0)){if(a/=d,d<0){if(a<c)return;a<u&&(u=a)}else if(d>0){if(a>u)return;a>c&&(c=a)}if(a=o-l,d||!(a<0)){if(a/=d,d<0){if(a>u)return;a>c&&(c=a)}else if(d>0){if(a<c)return;a<u&&(u=a)}return c>0&&(t[0]=s+c*h,t[1]=l+c*d),u<1&&(e[0]=s+u*h,e[1]=l+u*d),!0}}}}})(l,b,t,e,n,i)?s&&(v.lineStart(),v.point(o,a),y=!1):(g||(v.lineStart(),v.point(l[0],l[1])),v.point(b[0],b[1]),s||v.lineEnd(),y=!1)}f=o,m=a,g=s}return x}}var Gb,Wb,qb,Yb=wy(),Xb={sphere:$y,point:$y,lineStart:function $b(){Xb.point=Zb,Xb.lineEnd=Kb},lineEnd:$y,polygonStart:$y,polygonEnd:$y};function Kb(){Xb.point=Xb.lineEnd=$y}function Zb(t,e){Gb=t*=Ny,Wb=jy(e*=Ny),qb=Dy(e),Xb.point=Jb}function Jb(t,e){t*=Ny;var n=jy(e*=Ny),i=Dy(e),r=Oy(t-Gb),o=Dy(r),a=i*jy(r),s=qb*n-Wb*i*o,l=Wb*n+qb*i*o;Yb.add(zy(Gy(a*a+s*s),l)),Gb=t,Wb=n,qb=i}function Qb(t){return Yb.reset(),ev(t,Xb),+Yb}var tx=[null,null],ex={type:"LineString",coordinates:tx};function nx(t,e){return tx[0]=t,tx[1]=e,Qb(ex)}var ix={Feature:function(t,e){return ox(t.geometry,e)},FeatureCollection:function(t,e){for(var n=t.features,i=-1,r=n.length;++i<r;)if(ox(n[i].geometry,e))return!0;return!1}},rx={Sphere:function(){return!0},Point:function(t,e){return ax(t.coordinates,e)},MultiPoint:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(ax(n[i],e))return!0;return!1},LineString:function(t,e){return sx(t.coordinates,e)},MultiLineString:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(sx(n[i],e))return!0;return!1},Polygon:function(t,e){return lx(t.coordinates,e)},MultiPolygon:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(lx(n[i],e))return!0;return!1},GeometryCollection:function(t,e){for(var n=t.geometries,i=-1,r=n.length;++i<r;)if(ox(n[i],e))return!0;return!1}};function ox(t,e){return!(!t||!rx.hasOwnProperty(t.type))&&rx[t.type](t,e)}function ax(t,e){return 0===nx(t,e)}function sx(t,e){for(var n,i,r,o=0,a=t.length;o<a;o++){if(0===(i=nx(t[o],e)))return!0;if(o>0&&(r=nx(t[o],t[o-1]))>0&&n<=r&&i<=r&&(n+i-r)*(1-Math.pow((n-i)/r,2))<Ay*r)return!0;n=i}return!1}function lx(t,e){return!!Nb(t.map(cx),ux(e))}function cx(t){return(t=t.map(ux)).pop(),t}function ux(t){return[t[0]*Ny,t[1]*Ny]}function hx(t,e,n){var i=zl(t,e-Ty,n).concat(e);return function(t){return i.map((function(e){return[t,e]}))}}function dx(t,e,n){var i=zl(t,e-Ty,n).concat(e);return function(t){return i.map((function(e){return[e,t]}))}}function px(){var t,e,n,i,r,o,a,s,l,c,u,h,d=10,p=d,f=90,m=360,g=2.5;function _(){return{type:"MultiLineString",coordinates:y()}}function y(){return zl(By(i/f)*f,n,f).map(u).concat(zl(By(s/m)*m,a,m).map(h)).concat(zl(By(e/d)*d,t,d).filter((function(t){return Oy(t%f)>Ty})).map(l)).concat(zl(By(o/p)*p,r,p).filter((function(t){return Oy(t%m)>Ty})).map(c))}return _.lines=function(){return y().map((function(t){return{type:"LineString",coordinates:t}}))},_.outline=function(){return{type:"Polygon",coordinates:[u(i).concat(h(a).slice(1),u(n).reverse().slice(1),h(s).reverse().slice(1))]}},_.extent=function(t){return arguments.length?_.extentMajor(t).extentMinor(t):_.extentMinor()},_.extentMajor=function(t){return arguments.length?(s=+t[0][1],a=+t[1][1],(i=+t[0][0])>(n=+t[1][0])&&(t=i,i=n,n=t),s>a&&(t=s,s=a,a=t),_.precision(g)):[[i,s],[n,a]]},_.extentMinor=function(n){return arguments.length?(o=+n[0][1],r=+n[1][1],(e=+n[0][0])>(t=+n[1][0])&&(n=e,e=t,t=n),o>r&&(n=o,o=r,r=n),_.precision(g)):[[e,o],[t,r]]},_.step=function(t){return arguments.length?_.stepMajor(t).stepMinor(t):_.stepMinor()},_.stepMajor=function(t){return arguments.length?(f=+t[0],m=+t[1],_):[f,m]},_.stepMinor=function(t){return arguments.length?(d=+t[0],p=+t[1],_):[d,p]},_.precision=function(d){return arguments.length?(g=+d,l=hx(o,r,90),c=dx(e,t,g),u=hx(s,a,90),h=dx(i,n,g),_):g},_.extentMajor([[-180,-89.999999],[180,89.999999]]).extentMinor([[-180,-80.000001],[180,80.000001]])}function fx(t){return t}var mx,gx,_x,yx,vx=wy(),bx=wy(),xx={point:$y,lineStart:$y,lineEnd:$y,polygonStart:function(){xx.lineStart=wx,xx.lineEnd=Ex},polygonEnd:function(){xx.lineStart=xx.lineEnd=xx.point=$y,vx.add(Oy(bx)),bx.reset()},result:function(){var t=vx/2;return vx.reset(),t}};function wx(){xx.point=Sx}function Sx(t,e){xx.point=Mx,mx=_x=t,gx=yx=e}function Mx(t,e){bx.add(yx*t-_x*e),_x=t,yx=e}function Ex(){Mx(mx,gx)}var Tx,Ax,Cx,kx,Lx=1/0,Px=Lx,Ix=-Lx,Nx=Ix,Ox={point:function Rx(t,e){t<Lx&&(Lx=t),t>Ix&&(Ix=t),e<Px&&(Px=e),e>Nx&&(Nx=e)},lineStart:$y,lineEnd:$y,polygonStart:$y,polygonEnd:$y,result:function(){var t=[[Lx,Px],[Ix,Nx]];return Ix=Nx=-(Px=Lx=1/0),t}},zx=0,Dx=0,Bx=0,Hx=0,Fx=0,Vx=0,jx=0,Ux=0,Gx=0,Wx={point:qx,lineStart:Yx,lineEnd:Kx,polygonStart:function(){Wx.lineStart=Zx,Wx.lineEnd=Jx},polygonEnd:function(){Wx.point=qx,Wx.lineStart=Yx,Wx.lineEnd=Kx},result:function(){var t=Gx?[jx/Gx,Ux/Gx]:Vx?[Hx/Vx,Fx/Vx]:Bx?[zx/Bx,Dx/Bx]:[NaN,NaN];return zx=Dx=Bx=Hx=Fx=Vx=jx=Ux=Gx=0,t}};function qx(t,e){zx+=t,Dx+=e,++Bx}function Yx(){Wx.point=Xx}function Xx(t,e){Wx.point=$x,qx(Cx=t,kx=e)}function $x(t,e){var n=t-Cx,i=e-kx,r=Gy(n*n+i*i);Hx+=r*(Cx+t)/2,Fx+=r*(kx+e)/2,Vx+=r,qx(Cx=t,kx=e)}function Kx(){Wx.point=qx}function Zx(){Wx.point=Qx}function Jx(){tw(Tx,Ax)}function Qx(t,e){Wx.point=tw,qx(Tx=Cx=t,Ax=kx=e)}function tw(t,e){var n=t-Cx,i=e-kx,r=Gy(n*n+i*i);Hx+=r*(Cx+t)/2,Fx+=r*(kx+e)/2,Vx+=r,jx+=(r=kx*t-Cx*e)*(Cx+t),Ux+=r*(kx+e),Gx+=3*r,qx(Cx=t,kx=e)}function ew(t){this._context=t}ew.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,e){switch(this._point){case 0:this._context.moveTo(t,e),this._point=1;break;case 1:this._context.lineTo(t,e);break;default:this._context.moveTo(t+this._radius,e),this._context.arc(t,e,this._radius,0,Py)}},result:$y};var nw,iw,rw,ow,aw,sw=wy(),lw={point:$y,lineStart:function(){lw.point=cw},lineEnd:function(){nw&&uw(iw,rw),lw.point=$y},polygonStart:function(){nw=!0},polygonEnd:function(){nw=null},result:function(){var t=+sw;return sw.reset(),t}};function cw(t,e){lw.point=uw,iw=ow=t,rw=aw=e}function uw(t,e){sw.add(Gy((ow-=t)*ow+(aw-=e)*aw)),ow=t,aw=e}function hw(){this._string=[]}function dw(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function pw(t){return function(e){var n=new fw;for(var i in t)n[i]=t[i];return n.stream=e,n}}function fw(){}function mw(t,e,n){var i=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=i&&t.clipExtent(null),ev(n,t.stream(Ox)),e(Ox.result()),null!=i&&t.clipExtent(i),t}function gw(t,e,n){return mw(t,(function(n){var i=e[1][0]-e[0][0],r=e[1][1]-e[0][1],o=Math.min(i/(n[1][0]-n[0][0]),r/(n[1][1]-n[0][1])),a=+e[0][0]+(i-o*(n[1][0]+n[0][0]))/2,s=+e[0][1]+(r-o*(n[1][1]+n[0][1]))/2;t.scale(150*o).translate([a,s])}),n)}function _w(t,e,n){return gw(t,[[0,0],e],n)}function yw(t,e,n){return mw(t,(function(n){var i=+e,r=i/(n[1][0]-n[0][0]),o=(i-r*(n[1][0]+n[0][0]))/2,a=-r*n[0][1];t.scale(150*r).translate([o,a])}),n)}function vw(t,e,n){return mw(t,(function(n){var i=+e,r=i/(n[1][1]-n[0][1]),o=-r*n[0][0],a=(i-r*(n[1][1]+n[0][1]))/2;t.scale(150*r).translate([o,a])}),n)}hw.prototype={_radius:4.5,_circle:dw(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,e){switch(this._point){case 0:this._string.push("M",t,",",e),this._point=1;break;case 1:this._string.push("L",t,",",e);break;default:null==this._circle&&(this._circle=dw(this._radius)),this._string.push("M",t,",",e,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}return null}},fw.prototype={constructor:fw,point:function(t,e){this.stream.point(t,e)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};var bw=Dy(30*Ny);function xw(t,e){return+e?(function n(t,e){function n(i,r,o,a,s,l,c,u,h,d,p,f,m,g){var _=c-i,y=u-r,v=_*_+y*y;if(v>4*e&&m--){var b=a+d,x=s+p,w=l+f,S=Gy(b*b+x*x+w*w),M=Yy(w/=S),E=Oy(Oy(w)-1)<Ty||Oy(o-h)<Ty?(o+h)/2:zy(x,b),T=t(E,M),A=T[0],C=T[1],k=A-i,L=C-r,P=y*k-_*L;(P*P/v>e||Oy((_*k+y*L)/v-.5)>.3||a*d+s*p+l*f<bw)&&(n(i,r,o,a,s,l,A,C,E,b/=S,x/=S,w,m,g),g.point(A,C),n(A,C,E,b,x,w,c,u,h,d,p,f,m,g))}}return function(e){var i,r,o,a,s,l,c,u,h,d,p,f,m={point:g,lineStart:_,lineEnd:v,polygonStart:function(){e.polygonStart(),m.lineStart=b},polygonEnd:function(){e.polygonEnd(),m.lineStart=_}};function g(n,i){n=t(n,i),e.point(n[0],n[1])}function _(){u=NaN,m.point=y,e.lineStart()}function y(i,r){var o=mv([i,r]),a=t(i,r);n(u,h,c,d,p,f,u=a[0],h=a[1],c=i,d=o[0],p=o[1],f=o[2],16,e),e.point(u,h)}function v(){m.point=g,e.lineEnd()}function b(){_(),m.point=x,m.lineEnd=w}function x(t,e){y(i=t,e),r=u,o=h,a=d,s=p,l=f,m.point=y}function w(){n(u,h,c,d,p,f,r,o,i,a,s,l,16,e),m.lineEnd=v,v()}return m}})(t,e):(function i(t){return pw({point:function(e,n){e=t(e,n),this.stream.point(e[0],e[1])}})})(t)}var ww=pw({point:function(t,e){this.stream.point(t*Ny,e*Ny)}});function Sw(t,e,n,i,r){function o(o,a){return[e+t*(o*=i),n-t*(a*=r)]}return o.invert=function(o,a){return[(o-e)/t*i,(n-a)/t*r]},o}function Mw(t,e,n,i,r,o){var a=Dy(o),s=jy(o),l=a*t,c=s*t,u=a/t,h=s/t,d=(s*n-a*e)/t,p=(s*e+a*n)/t;function f(t,o){return[l*(t*=i)-c*(o*=r)+e,n-c*t-l*o]}return f.invert=function(t,e){return[i*(u*t-h*e+d),r*(p-h*t-u*e)]},f}function Ew(t){return Tw((function(){return t}))()}function Tw(t){var e,n,i,r,o,a,s,l,c,u,h=150,d=480,p=250,f=0,m=0,g=0,_=0,y=0,v=0,b=1,x=1,w=null,S=Db,M=null,E=fx,T=.5;function A(t){return l(t[0]*Ny,t[1]*Ny)}function C(t){return(t=l.invert(t[0],t[1]))&&[t[0]*Iy,t[1]*Iy]}function k(){var t=Mw(h,0,0,b,x,v).apply(null,e(f,m)),i=(v?Mw:Sw)(h,d-t[0],p-t[1],b,x,v);return n=vb(g,_,y),s=_b(e,i),l=_b(n,s),a=xw(s,T),L()}function L(){return c=u=null,A}return A.stream=function(t){return c&&u===t?c:c=ww((function e(t){return pw({point:function(e,n){var i=t(e,n);return this.stream.point(i[0],i[1])}})})(n)(S(a(E(u=t)))))},A.preclip=function(t){return arguments.length?(S=t,w=void 0,L()):S},A.postclip=function(t){return arguments.length?(E=t,M=i=r=o=null,L()):E},A.clipAngle=function(t){return arguments.length?(S=+t?Fb(w=t*Ny):(w=null,Db),L()):w*Iy},A.clipExtent=function(t){return arguments.length?(E=null==t?(M=i=r=o=null,fx):Ub(M=+t[0][0],i=+t[0][1],r=+t[1][0],o=+t[1][1]),L()):null==M?null:[[M,i],[r,o]]},A.scale=function(t){return arguments.length?(h=+t,k()):h},A.translate=function(t){return arguments.length?(d=+t[0],p=+t[1],k()):[d,p]},A.center=function(t){return arguments.length?(f=t[0]%360*Ny,m=t[1]%360*Ny,k()):[f*Iy,m*Iy]},A.rotate=function(t){return arguments.length?(g=t[0]%360*Ny,_=t[1]%360*Ny,y=t.length>2?t[2]%360*Ny:0,k()):[g*Iy,_*Iy,y*Iy]},A.angle=function(t){return arguments.length?(v=t%360*Ny,k()):v*Iy},A.reflectX=function(t){return arguments.length?(b=t?-1:1,k()):b<0},A.reflectY=function(t){return arguments.length?(x=t?-1:1,k()):x<0},A.precision=function(t){return arguments.length?(a=xw(s,T=t*t),L()):Gy(T)},A.fitExtent=function(t,e){return gw(A,t,e)},A.fitSize=function(t,e){return _w(A,t,e)},A.fitWidth=function(t,e){return yw(A,t,e)},A.fitHeight=function(t,e){return vw(A,t,e)},function(){return e=t.apply(this,arguments),A.invert=e.invert&&C,k()}}function Aw(t){var e=0,n=Cy/3,i=Tw(t),r=i(e,n);return r.parallels=function(t){return arguments.length?i(e=t[0]*Ny,n=t[1]*Ny):[e*Iy,n*Iy]},r}function Cw(t,e){var n=jy(t),i=(n+jy(e))/2;if(Oy(i)<Ty)return(function r(t){var e=Dy(t);function n(t,n){return[t*e,jy(n)/e]}return n.invert=function(t,n){return[t/e,Yy(n*e)]},n})(t);var o=1+n*(2*i-n),a=Gy(o)/i;function s(t,e){var n=Gy(o-2*i*jy(e))/i;return[n*jy(t*=i),a-n*Dy(t)]}return s.invert=function(t,e){var n=a-e,r=zy(t,Oy(n))*Uy(n);return n*i<0&&(r-=Cy*Uy(t)*Uy(n)),[r/i,Yy((o-(t*t+n*n)*i*i)/(2*i))]},s}function kw(){return Aw(Cw).scale(155.424).center([0,33.6442])}function Lw(){return kw().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function Pw(t){return function(e,n){var i=Dy(e),r=Dy(n),o=t(i*r);return[o*r*jy(e),o*jy(n)]}}function Iw(t){return function(e,n){var i=Gy(e*e+n*n),r=t(i),o=jy(r),a=Dy(r);return[zy(e*o,i*a),Yy(i&&n*o/i)]}}var Nw=Pw((function(t){return Gy(2/(1+t))}));Nw.invert=Iw((function(t){return 2*Yy(t/2)}));var Ow=Pw((function(t){return(t=qy(t))&&t/jy(t)}));function Rw(t,e){return[t,Fy(Wy((ky+e)/2))]}function zw(t){var e,n,i,r=Ew(t),o=r.center,a=r.scale,s=r.translate,l=r.clipExtent,c=null;function u(){var o=Cy*a(),s=r(Sb(r.rotate()).invert([0,0]));return l(null==c?[[s[0]-o,s[1]-o],[s[0]+o,s[1]+o]]:t===Rw?[[Math.max(s[0]-o,c),e],[Math.min(s[0]+o,n),i]]:[[c,Math.max(s[1]-o,e)],[n,Math.min(s[1]+o,i)]])}return r.scale=function(t){return arguments.length?(a(t),u()):a()},r.translate=function(t){return arguments.length?(s(t),u()):s()},r.center=function(t){return arguments.length?(o(t),u()):o()},r.clipExtent=function(t){return arguments.length?(null==t?c=e=n=i=null:(c=+t[0][0],e=+t[0][1],n=+t[1][0],i=+t[1][1]),u()):null==c?null:[[c,e],[n,i]]},u()}function Dw(t){return Wy((ky+t)/2)}function Bw(t,e){var n=Dy(t),i=t===e?jy(t):Fy(n/Dy(e))/Fy(Dw(e)/Dw(t)),r=n*Vy(Dw(t),i)/i;if(!i)return Rw;function o(t,e){r>0?e<-ky+Ty&&(e=-ky+Ty):e>ky-Ty&&(e=ky-Ty);var n=r/Vy(Dw(e),i);return[n*jy(i*t),r-n*Dy(i*t)]}return o.invert=function(t,e){var n=r-e,o=Uy(i)*Gy(t*t+n*n),a=zy(t,Oy(n))*Uy(n);return n*i<0&&(a-=Cy*Uy(t)*Uy(n)),[a/i,2*Ry(Vy(r/o,1/i))-ky]},o}function Hw(t,e){return[t,e]}function Fw(t,e){var n=Dy(t),i=t===e?jy(t):(n-Dy(e))/(e-t),r=n/i+t;if(Oy(i)<Ty)return Hw;function o(t,e){var n=r-e,o=i*t;return[n*jy(o),r-n*Dy(o)]}return o.invert=function(t,e){var n=r-e,o=zy(t,Oy(n))*Uy(n);return n*i<0&&(o-=Cy*Uy(t)*Uy(n)),[o/i,r-Uy(i)*Gy(t*t+n*n)]},o}Ow.invert=Iw((function(t){return t})),Rw.invert=function(t,e){return[t,2*Ry(Hy(e))-ky]},Hw.invert=Hw;var Vw=1.340264,jw=-.081106,Uw=893e-6,Gw=.003796,Ww=Gy(3)/2;function qw(t,e){var n=Yy(Ww*jy(e)),i=n*n,r=i*i*i;return[t*Dy(n)/(Ww*(Vw+3*jw*i+r*(7*Uw+9*Gw*i))),n*(Vw+jw*i+r*(Uw+Gw*i))]}function Yw(t,e){var n=Dy(e),i=Dy(t)*n;return[n*jy(t)/i,jy(e)/i]}function Xw(t,e){var n=e*e,i=n*n;return[t*(.8707-.131979*n+i*(i*(.003971*n-.001529*i)-.013791)),e*(1.007226+n*(.015085+i*(.028874*n-.044475-.005916*i)))]}function $w(t,e){return[Dy(e)*jy(t),jy(e)]}function Kw(t,e){var n=Dy(e),i=1+Dy(t)*n;return[n*jy(t)/i,jy(e)/i]}function Zw(t,e){return[Fy(Wy((ky+e)/2)),-t]}function Jw(t,e){return t.parent===e.parent?1:2}function Qw(t,e){return t+e.x}function tS(t,e){return Math.max(t,e.y)}function eS(t){var e=0,n=t.children,i=n&&n.length;if(i)for(;--i>=0;)e+=n[i].value;else e=1;t.value=e}function nS(t,e){var n,i,r,o,a,s=new aS(t),l=+t.value&&(s.value=t.value),c=[s];for(null==e&&(e=iS);n=c.pop();)if(l&&(n.value=+n.data.value),(r=e(n.data))&&(a=r.length))for(n.children=new Array(a),o=a-1;o>=0;--o)c.push(i=n.children[o]=new aS(r[o])),i.parent=n,i.depth=n.depth+1;return s.eachBefore(oS)}function iS(t){return t.children}function rS(t){t.data=t.data.data}function oS(t){var e=0;do{t.height=e}while((t=t.parent)&&t.height<++e)}function aS(t){this.data=t,this.depth=this.height=0,this.parent=null}qw.invert=function(t,e){for(var n,i=e,r=i*i,o=r*r*r,a=0;a<12&&(o=(r=(i-=n=(i*(Vw+jw*r+o*(Uw+Gw*r))-e)/(Vw+3*jw*r+o*(7*Uw+9*Gw*r)))*i)*r*r,!(Oy(n)<Ay));++a);return[Ww*t*(Vw+3*jw*r+o*(7*Uw+9*Gw*r))/Dy(i),Yy(jy(i)/Ww)]},Yw.invert=Iw(Ry),Xw.invert=function(t,e){var n,i=e,r=25;do{var o=i*i,a=o*o;i-=n=(i*(1.007226+o*(.015085+a*(.028874*o-.044475-.005916*a)))-e)/(1.007226+o*(.045255+a*(.259866*o-.311325-.005916*11*a)))}while(Oy(n)>Ty&&--r>0);return[t/(.8707+(o=i*i)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),i]},$w.invert=Iw(Yy),Kw.invert=Iw((function(t){return 2*Ry(t)})),Zw.invert=function(t,e){return[-e,2*Ry(Hy(t))-ky]},aS.prototype=nS.prototype={constructor:aS,count:function sS(){return this.eachAfter(eS)},each:function lS(t){var e,n,i,r,o=this,a=[o];do{for(e=a.reverse(),a=[];o=e.pop();)if(t(o),n=o.children)for(i=0,r=n.length;i<r;++i)a.push(n[i])}while(a.length);return this},eachAfter:function cS(t){for(var e,n,i,r=this,o=[r],a=[];r=o.pop();)if(a.push(r),e=r.children)for(n=0,i=e.length;n<i;++n)o.push(e[n]);for(;r=a.pop();)t(r);return this},eachBefore:function uS(t){for(var e,n,i=this,r=[i];i=r.pop();)if(t(i),e=i.children)for(n=e.length-1;n>=0;--n)r.push(e[n]);return this},sum:function hS(t){return this.eachAfter((function(e){for(var n=+t(e.data)||0,i=e.children,r=i&&i.length;--r>=0;)n+=i[r].value;e.value=n}))},sort:function dS(t){return this.eachBefore((function(e){e.children&&e.children.sort(t)}))},path:function pS(t){for(var e=this,n=(function i(t,e){if(t===e)return t;var n=t.ancestors(),i=e.ancestors(),r=null;for(t=n.pop(),e=i.pop();t===e;)r=t,t=n.pop(),e=i.pop();return r})(e,t),r=[e];e!==n;)r.push(e=e.parent);for(var o=r.length;t!==n;)r.splice(o,0,t),t=t.parent;return r},ancestors:function fS(){for(var t=this,e=[t];t=t.parent;)e.push(t);return e},descendants:function mS(){var t=[];return this.each((function(e){t.push(e)})),t},leaves:function gS(){var t=[];return this.eachBefore((function(e){e.children||t.push(e)})),t},links:function _S(){var t=this,e=[];return t.each((function(n){n!==t&&e.push({source:n.parent,target:n})})),e},copy:function yS(){return nS(this).eachBefore(rS)}};var vS=Array.prototype.slice;function bS(t){for(var e,n,i=0,r=(t=(function o(t){for(var e,n,i=t.length;i;)n=Math.random()*i--|0,e=t[i],t[i]=t[n],t[n]=e;return t})(vS.call(t))).length,a=[];i<r;)e=t[i],n&&SS(n,e)?++i:(n=ES(a=xS(a,e)),i=0);return n}function xS(t,e){var n,i;if(MS(e,t))return[e];for(n=0;n<t.length;++n)if(wS(e,t[n])&&MS(TS(t[n],e),t))return[t[n],e];for(n=0;n<t.length-1;++n)for(i=n+1;i<t.length;++i)if(wS(TS(t[n],t[i]),e)&&wS(TS(t[n],e),t[i])&&wS(TS(t[i],e),t[n])&&MS(AS(t[n],t[i],e),t))return[t[n],t[i],e];throw new Error}function wS(t,e){var n=t.r-e.r,i=e.x-t.x,r=e.y-t.y;return n<0||n*n<i*i+r*r}function SS(t,e){var n=t.r-e.r+1e-6,i=e.x-t.x,r=e.y-t.y;return n>0&&n*n>i*i+r*r}function MS(t,e){for(var n=0;n<e.length;++n)if(!SS(t,e[n]))return!1;return!0}function ES(t){switch(t.length){case 1:return(function e(t){return{x:t.x,y:t.y,r:t.r}})(t[0]);case 2:return TS(t[0],t[1]);case 3:return AS(t[0],t[1],t[2])}}function TS(t,e){var n=t.x,i=t.y,r=t.r,o=e.x,a=e.y,s=e.r,l=o-n,c=a-i,u=s-r,h=Math.sqrt(l*l+c*c);return{x:(n+o+l/h*u)/2,y:(i+a+c/h*u)/2,r:(h+r+s)/2}}function AS(t,e,n){var i=t.x,r=t.y,o=t.r,a=e.x,s=e.y,l=e.r,c=n.x,u=n.y,h=n.r,d=i-a,p=i-c,f=r-s,m=r-u,g=l-o,_=h-o,y=i*i+r*r-o*o,v=y-a*a-s*s+l*l,b=y-c*c-u*u+h*h,x=p*f-d*m,w=(f*b-m*v)/(2*x)-i,S=(m*g-f*_)/x,M=(p*v-d*b)/(2*x)-r,E=(d*_-p*g)/x,T=S*S+E*E-1,A=2*(o+w*S+M*E),C=w*w+M*M-o*o,k=-(T?(A+Math.sqrt(A*A-4*T*C))/(2*T):C/A);return{x:i+w+S*k,y:r+M+E*k,r:k}}function CS(t,e,n){var i,r,o,a,s=t.x-e.x,l=t.y-e.y,c=s*s+l*l;c?(r=e.r+n.r,a=t.r+n.r,(r*=r)>(a*=a)?(i=(c+a-r)/(2*c),o=Math.sqrt(Math.max(0,a/c-i*i)),n.x=t.x-i*s-o*l,n.y=t.y-i*l+o*s):(i=(c+r-a)/(2*c),o=Math.sqrt(Math.max(0,r/c-i*i)),n.x=e.x+i*s-o*l,n.y=e.y+i*l+o*s)):(n.x=e.x+n.r,n.y=e.y)}function kS(t,e){var n=t.r+e.r-1e-6,i=e.x-t.x,r=e.y-t.y;return n>0&&n*n>i*i+r*r}function LS(t){var e=t._,n=t.next._,i=e.r+n.r,r=(e.x*n.r+n.x*e.r)/i,o=(e.y*n.r+n.y*e.r)/i;return r*r+o*o}function PS(t){this._=t,this.next=null,this.previous=null}function IS(t){if(!(r=t.length))return 0;var e,n,i,r,o,a,s,l,c,u,h;if((e=t[0]).x=0,e.y=0,!(r>1))return e.r;if(e.x=-(n=t[1]).r,n.x=e.r,n.y=0,!(r>2))return e.r+n.r;CS(n,e,i=t[2]),e=new PS(e),n=new PS(n),i=new PS(i),e.next=i.previous=n,n.next=e.previous=i,i.next=n.previous=e;t:for(s=3;s<r;++s){CS(e._,n._,i=t[s]),i=new PS(i),l=n.next,c=e.previous,u=n._.r,h=e._.r;do{if(u<=h){if(kS(l._,i._)){e.next=n=l,n.previous=e,--s;continue t}u+=l._.r,l=l.next}else{if(kS(c._,i._)){(e=c).next=n,n.previous=e,--s;continue t}h+=c._.r,c=c.previous}}while(l!==c.next);for(i.previous=e,i.next=n,e.next=n.previous=n=i,o=LS(e);(i=i.next)!==n;)(a=LS(i))<o&&(e=i,o=a);n=e.next}for(e=[n._],i=n;(i=i.next)!==n;)e.push(i._);for(i=bS(e),s=0;s<r;++s)(e=t[s]).x-=i.x,e.y-=i.y;return i.r}function NS(t){return null==t?null:OS(t)}function OS(t){if("function"!=typeof t)throw new Error;return t}function RS(){return 0}function zS(t){return function(){return t}}function DS(t){return Math.sqrt(t.value)}function BS(t){return function(e){e.children||(e.r=Math.max(0,+t(e)||0))}}function HS(t,e){return function(n){if(i=n.children){var i,r,o,a=i.length,s=t(n)*e||0;if(s)for(r=0;r<a;++r)i[r].r+=s;if(o=IS(i),s)for(r=0;r<a;++r)i[r].r-=s;n.r=o+s}}}function FS(t){return function(e){var n=e.parent;e.r*=t,n&&(e.x=n.x+t*e.x,e.y=n.y+t*e.y)}}function VS(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function jS(t,e,n,i,r){for(var o,a=t.children,s=-1,l=a.length,c=t.value&&(i-e)/t.value;++s<l;)(o=a[s]).y0=n,o.y1=r,o.x0=e,o.x1=e+=o.value*c}var US={depth:-1},GS={};function WS(t){return t.id}function qS(t){return t.parentId}function YS(t,e){return t.parent===e.parent?1:2}function XS(t){var e=t.children;return e?e[0]:t.t}function $S(t){var e=t.children;return e?e[e.length-1]:t.t}function KS(t,e,n){var i=n/(e.i-t.i);e.c-=i,e.s+=n,t.c+=i,e.z+=n,e.m+=n}function ZS(t,e,n){return t.a.parent===e.parent?t.a:n}function JS(t,e){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=e}function QS(t,e,n,i,r){for(var o,a=t.children,s=-1,l=a.length,c=t.value&&(r-n)/t.value;++s<l;)(o=a[s]).x0=e,o.x1=i,o.y0=n,o.y1=n+=o.value*c}JS.prototype=Object.create(aS.prototype);var tM=(1+Math.sqrt(5))/2;function eM(t,e,n,i,r,o){for(var a,s,l,c,u,h,d,p,f,m,g,_=[],y=e.children,v=0,b=0,x=y.length,w=e.value;v<x;){l=r-n,c=o-i;do{u=y[b++].value}while(!u&&b<x);for(h=d=u,g=u*u*(m=Math.max(c/l,l/c)/(w*t)),f=Math.max(d/g,g/h);b<x;++b){if(u+=s=y[b].value,s<h&&(h=s),s>d&&(d=s),g=u*u*m,(p=Math.max(d/g,g/h))>f){u-=s;break}f=p}_.push(a={value:u,dice:l<c,children:y.slice(v,b)}),a.dice?jS(a,n,i,r,w?i+=c*u/w:o):QS(a,n,i,w?n+=l*u/w:r,o),w-=u,v=b}return _}var nM=(function t(e){function n(t,n,i,r,o){eM(e,t,n,i,r,o)}return n.ratio=function(e){return t((e=+e)>1?e:1)},n})(tM),iM=(function t(e){function n(t,n,i,r,o){if((a=t._squarify)&&a.ratio===e)for(var a,s,l,c,u,h=-1,d=a.length,p=t.value;++h<d;){for(l=(s=a[h]).children,c=s.value=0,u=l.length;c<u;++c)s.value+=l[c].value;s.dice?jS(s,n,i,r,i+=(o-i)*s.value/p):QS(s,n,i,n+=(r-n)*s.value/p,o),p-=s.value}else t._squarify=a=eM(e,t,n,i,r,o),a.ratio=e}return n.ratio=function(e){return t((e=+e)>1?e:1)},n})(tM);function rM(t,e,n){return(e[0]-t[0])*(n[1]-t[1])-(e[1]-t[1])*(n[0]-t[0])}function oM(t,e){return t[0]-e[0]||t[1]-e[1]}function aM(t){for(var e=t.length,n=[0,1],i=2,r=2;r<e;++r){for(;i>1&&rM(t[n[i-2]],t[n[i-1]],t[r])<=0;)--i;n[i++]=r}return n.slice(0,i)}function sM(){return Math.random()}var lM=(function t(e){function n(t,n){return t=null==t?0:+t,n=null==n?1:+n,1===arguments.length?(n=t,t=0):n-=t,function(){return e()*n+t}}return n.source=t,n})(sM),cM=(function t(e){function n(t,n){var i,r;return t=null==t?0:+t,n=null==n?1:+n,function(){var o;if(null!=i)o=i,i=null;else do{i=2*e()-1,o=2*e()-1,r=i*i+o*o}while(!r||r>1);return t+n*o*Math.sqrt(-2*Math.log(r)/r)}}return n.source=t,n})(sM),uM=(function t(e){function n(){var t=cM.source(e).apply(this,arguments);return function(){return Math.exp(t())}}return n.source=t,n})(sM),hM=(function t(e){function n(t){return function(){for(var n=0,i=0;i<t;++i)n+=e();return n}}return n.source=t,n})(sM),dM=(function t(e){function n(t){var n=hM.source(e)(t);return function(){return n()/t}}return n.source=t,n})(sM),pM=(function t(e){function n(t){return function(){return-Math.log(1-e())/t}}return n.source=t,n})(sM);function fM(t,e){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(e).domain(t)}return this}function mM(t,e){switch(arguments.length){case 0:break;case 1:this.interpolator(t);break;default:this.interpolator(e).domain(t)}return this}var gM=Array.prototype,_M=gM.map,yM=gM.slice,vM={name:"implicit"};function bM(){var t=xg(),e=[],n=[],i=vM;function r(r){var o=r+"",a=t.get(o);if(!a){if(i!==vM)return i;t.set(o,a=e.push(r))}return n[(a-1)%n.length]}return r.domain=function(n){if(!arguments.length)return e.slice();e=[],t=xg();for(var i,o,a=-1,s=n.length;++a<s;)t.has(o=(i=n[a])+"")||t.set(o,e.push(i));return r},r.range=function(t){return arguments.length?(n=yM.call(t),r):n.slice()},r.unknown=function(t){return arguments.length?(i=t,r):i},r.copy=function(){return bM(e,n).unknown(i)},fM.apply(r,arguments),r}function xM(){var t,e,n=bM().unknown(void 0),i=n.domain,r=n.range,o=[0,1],a=!1,s=0,l=0,c=.5;function u(){var n=i().length,u=o[1]<o[0],h=o[u-0],d=o[1-u];t=(d-h)/Math.max(1,n-s+2*l),a&&(t=Math.floor(t)),h+=(d-h-t*(n-s))*c,e=t*(1-s),a&&(h=Math.round(h),e=Math.round(e));var p=zl(n).map((function(e){return h+t*e}));return r(u?p.reverse():p)}return delete n.unknown,n.domain=function(t){return arguments.length?(i(t),u()):i()},n.range=function(t){return arguments.length?(o=[+t[0],+t[1]],u()):o.slice()},n.rangeRound=function(t){return o=[+t[0],+t[1]],a=!0,u()},n.bandwidth=function(){return e},n.step=function(){return t},n.round=function(t){return arguments.length?(a=!!t,u()):a},n.padding=function(t){return arguments.length?(s=Math.min(1,l=+t),u()):s},n.paddingInner=function(t){return arguments.length?(s=Math.min(1,t),u()):s},n.paddingOuter=function(t){return arguments.length?(l=+t,u()):l},n.align=function(t){return arguments.length?(c=Math.max(0,Math.min(1,t)),u()):c},n.copy=function(){return xM(i(),o).round(a).paddingInner(s).paddingOuter(l).align(c)},fM.apply(u(),arguments)}function wM(t){var e=t.copy;return t.padding=t.paddingOuter,delete t.paddingInner,delete t.paddingOuter,t.copy=function(){return wM(e())},t}function SM(){return wM(xM.apply(null,arguments).paddingInner(1))}function MM(t){return+t}var EM=[0,1];function TM(t){return t}function AM(t,e){return(e-=t=+t)?function(n){return(n-t)/e}:(function n(t){return function(){return t}})(isNaN(e)?NaN:.5)}function CM(t){var e,n=t[0],i=t[t.length-1];return n>i&&(e=n,n=i,i=e),function(t){return Math.max(n,Math.min(i,t))}}function kM(t,e,n){var i=t[0],r=t[1],o=e[0],a=e[1];return r<i?(i=AM(r,i),o=n(a,o)):(i=AM(i,r),o=n(o,a)),function(t){return o(i(t))}}function LM(t,e,n){var i=Math.min(t.length,e.length)-1,r=new Array(i),o=new Array(i),a=-1;for(t[i]<t[0]&&(t=t.slice().reverse(),e=e.slice().reverse());++a<i;)r[a]=AM(t[a],t[a+1]),o[a]=n(e[a],e[a+1]);return function(e){var n=Sl(t,e,1,i)-1;return o[n](r[n](e))}}function PM(t,e){return e.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown())}function IM(){var t,e,n,i,r,o,a=EM,s=EM,l=Ud,c=TM;function u(){return i=Math.min(a.length,s.length)>2?LM:kM,r=o=null,h}function h(e){return isNaN(e=+e)?n:(r||(r=i(a.map(t),s,l)))(t(c(e)))}return h.invert=function(n){return c(e((o||(o=i(s,a.map(t),Bd)))(n)))},h.domain=function(t){return arguments.length?(a=_M.call(t,MM),c===TM||(c=CM(a)),u()):a.slice()},h.range=function(t){return arguments.length?(s=yM.call(t),u()):s.slice()},h.rangeRound=function(t){return s=yM.call(t),l=Gd,u()},h.clamp=function(t){return arguments.length?(c=t?CM(a):TM,h):c!==TM},h.interpolate=function(t){return arguments.length?(l=t,u()):l},h.unknown=function(t){return arguments.length?(n=t,h):n},function(n,i){return t=n,e=i,u()}}function NM(t,e){return IM()(t,e)}function OM(t,e,n,i){var r,o=jl(t,e,n);switch((i=ay(null==i?",f":i)).type){case"s":var a=Math.max(Math.abs(t),Math.abs(e));return null!=i.precision||isNaN(r=by(o,a))||(i.precision=r),fy(i,a);case"":case"e":case"g":case"p":case"r":null!=i.precision||isNaN(r=xy(o,Math.max(Math.abs(t),Math.abs(e))))||(i.precision=r-("e"===i.type));break;case"f":case"%":null!=i.precision||isNaN(r=vy(o))||(i.precision=r-2*("%"===i.type))}return py(i)}function RM(t){var e=t.domain;return t.ticks=function(t){var n=e();return Fl(n[0],n[n.length-1],null==t?10:t)},t.tickFormat=function(t,n){var i=e();return OM(i[0],i[i.length-1],null==t?10:t,n)},t.nice=function(n){null==n&&(n=10);var i,r=e(),o=0,a=r.length-1,s=r[o],l=r[a];return l<s&&(i=s,s=l,l=i,i=o,o=a,a=i),(i=Vl(s,l,n))>0?i=Vl(s=Math.floor(s/i)*i,l=Math.ceil(l/i)*i,n):i<0&&(i=Vl(s=Math.ceil(s*i)/i,l=Math.floor(l*i)/i,n)),i>0?(r[o]=Math.floor(s/i)*i,r[a]=Math.ceil(l/i)*i,e(r)):i<0&&(r[o]=Math.ceil(s*i)/i,r[a]=Math.floor(l*i)/i,e(r)),t},t}function zM(){var t=NM(TM,TM);return t.copy=function(){return PM(t,zM())},fM.apply(t,arguments),RM(t)}function DM(t,e){var n,i=0,r=(t=t.slice()).length-1,o=t[i],a=t[r];return a<o&&(n=i,i=r,r=n,n=o,o=a,a=n),t[i]=e.floor(o),t[r]=e.ceil(a),t}function BM(t){return Math.log(t)}function HM(t){return Math.exp(t)}function FM(t){return-Math.log(-t)}function VM(t){return-Math.exp(-t)}function jM(t){return isFinite(t)?+("1e"+t):t<0?0:t}function UM(t){return function(e){return-t(-e)}}function GM(t){var e,n,i=t(BM,HM),r=i.domain,o=10;function a(){return e=(function a(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(e){return Math.log(e)/t})})(o),n=(function s(t){return 10===t?jM:t===Math.E?Math.exp:function(e){return Math.pow(t,e)}})(o),r()[0]<0?(e=UM(e),n=UM(n),t(FM,VM)):t(BM,HM),i}return i.base=function(t){return arguments.length?(o=+t,a()):o},i.domain=function(t){return arguments.length?(r(t),a()):r()},i.ticks=function(t){var i,a=r(),s=a[0],l=a[a.length-1];(i=l<s)&&(d=s,s=l,l=d);var c,u,h,d=e(s),p=e(l),f=null==t?10:+t,m=[];if(!(o%1)&&p-d<f){if(d=Math.round(d)-1,p=Math.round(p)+1,s>0){for(;d<p;++d)for(u=1,c=n(d);u<o;++u)if(!((h=c*u)<s)){if(h>l)break;m.push(h)}}else for(;d<p;++d)for(u=o-1,c=n(d);u>=1;--u)if(!((h=c*u)<s)){if(h>l)break;m.push(h)}}else m=Fl(d,p,Math.min(p-d,f)).map(n);return i?m.reverse():m},i.tickFormat=function(t,r){if(null==r&&(r=10===o?".0e":","),"function"!=typeof r&&(r=py(r)),t===1/0)return r;null==t&&(t=10);var a=Math.max(1,o*t/i.ticks().length);return function(t){var i=t/n(Math.round(e(t)));return i*o<o-.5&&(i*=o),i<=a?r(t):""}},i.nice=function(){return r(DM(r(),{floor:function(t){return n(Math.floor(e(t)))},ceil:function(t){return n(Math.ceil(e(t)))}}))},i}function WM(){var t=GM(IM()).domain([1,10]);return t.copy=function(){return PM(t,WM()).base(t.base())},fM.apply(t,arguments),t}function qM(t){return function(e){return Math.sign(e)*Math.log1p(Math.abs(e/t))}}function YM(t){return function(e){return Math.sign(e)*Math.expm1(Math.abs(e))*t}}function XM(t){var e=1,n=t(qM(e),YM(e));return n.constant=function(n){return arguments.length?t(qM(e=+n),YM(e)):e},RM(n)}function $M(t){return function(e){return e<0?-Math.pow(-e,t):Math.pow(e,t)}}function KM(t){return t<0?-Math.sqrt(-t):Math.sqrt(t)}function ZM(t){return t<0?-t*t:t*t}function JM(t){var e=t(TM,TM),n=1;function i(){return 1===n?t(TM,TM):.5===n?t(KM,ZM):t($M(n),$M(1/n))}return e.exponent=function(t){return arguments.length?(n=+t,i()):n},RM(e)}function QM(){var t=JM(IM());return t.copy=function(){return PM(t,QM()).exponent(t.exponent())},fM.apply(t,arguments),t}function tE(){var t,e=[],n=[],i=[];function r(){var t=0,r=Math.max(1,n.length);for(i=new Array(r-1);++t<r;)i[t-1]=Gl(e,t/r);return o}function o(e){return isNaN(e=+e)?t:n[Sl(i,e)]}return o.invertExtent=function(t){var r=n.indexOf(t);return r<0?[NaN,NaN]:[r>0?i[r-1]:e[0],r<i.length?i[r]:e[e.length-1]]},o.domain=function(t){if(!arguments.length)return e.slice();e=[];for(var n,i=0,o=t.length;i<o;++i)null==(n=t[i])||isNaN(n=+n)||e.push(n);return e.sort(bl),r()},o.range=function(t){return arguments.length?(n=yM.call(t),r()):n.slice()},o.unknown=function(e){return arguments.length?(t=e,o):t},o.quantiles=function(){return i.slice()},o.copy=function(){return tE().domain(e).range(n).unknown(t)},fM.apply(o,arguments)}function eE(){var t,e=0,n=1,i=1,r=[.5],o=[0,1];function a(e){return e<=e?o[Sl(r,e,0,i)]:t}function s(){var t=-1;for(r=new Array(i);++t<i;)r[t]=((t+1)*n-(t-i)*e)/(i+1);return a}return a.domain=function(t){return arguments.length?(e=+t[0],n=+t[1],s()):[e,n]},a.range=function(t){return arguments.length?(i=(o=yM.call(t)).length-1,s()):o.slice()},a.invertExtent=function(t){var a=o.indexOf(t);return a<0?[NaN,NaN]:a<1?[e,r[0]]:a>=i?[r[i-1],n]:[r[a-1],r[a]]},a.unknown=function(e){return arguments.length?(t=e,a):a},a.thresholds=function(){return r.slice()},a.copy=function(){return eE().domain([e,n]).range(o).unknown(t)},fM.apply(RM(a),arguments)}var nE=new Date,iE=new Date;function rE(t,e,n,i){function r(e){return t(e=0===arguments.length?new Date:new Date(+e)),e}return r.floor=function(e){return t(e=new Date(+e)),e},r.ceil=function(n){return t(n=new Date(n-1)),e(n,1),t(n),n},r.round=function(t){var e=r(t),n=r.ceil(t);return t-e<n-t?e:n},r.offset=function(t,n){return e(t=new Date(+t),null==n?1:Math.floor(n)),t},r.range=function(n,i,o){var a,s=[];if(n=r.ceil(n),o=null==o?1:Math.floor(o),!(n<i&&o>0))return s;do{s.push(a=new Date(+n)),e(n,o),t(n)}while(a<n&&n<i);return s},r.filter=function(n){return rE((function(e){if(e>=e)for(;t(e),!n(e);)e.setTime(e-1)}),(function(t,i){if(t>=t)if(i<0)for(;++i<=0;)for(;e(t,-1),!n(t););else for(;--i>=0;)for(;e(t,1),!n(t););}))},n&&(r.count=function(e,i){return nE.setTime(+e),iE.setTime(+i),t(nE),t(iE),Math.floor(n(nE,iE))},r.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?r.filter(i?function(e){return i(e)%t==0}:function(e){return r.count(0,e)%t==0}):r:null}),r}var oE=rE((function(){}),(function(t,e){t.setTime(+t+e)}),(function(t,e){return e-t}));oE.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?rE((function(e){e.setTime(Math.floor(e/t)*t)}),(function(e,n){e.setTime(+e+n*t)}),(function(e,n){return(n-e)/t})):oE:null};var aE=oE.range,sE=1e3,lE=6e4,cE=36e5,uE=864e5,hE=6048e5,dE=rE((function(t){t.setTime(t-t.getMilliseconds())}),(function(t,e){t.setTime(+t+e*sE)}),(function(t,e){return(e-t)/sE}),(function(t){return t.getUTCSeconds()})),pE=dE.range,fE=rE((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*sE)}),(function(t,e){t.setTime(+t+e*lE)}),(function(t,e){return(e-t)/lE}),(function(t){return t.getMinutes()})),mE=fE.range,gE=rE((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*sE-t.getMinutes()*lE)}),(function(t,e){t.setTime(+t+e*cE)}),(function(t,e){return(e-t)/cE}),(function(t){return t.getHours()})),_E=gE.range,yE=rE((function(t){t.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*lE)/uE}),(function(t){return t.getDate()-1})),vE=yE.range;function bE(t){return rE((function(e){e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+7*e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*lE)/hE}))}var xE=bE(0),wE=bE(1),SE=bE(2),ME=bE(3),EE=bE(4),TE=bE(5),AE=bE(6),CE=xE.range,kE=wE.range,LE=SE.range,PE=ME.range,IE=EE.range,NE=TE.range,OE=AE.range,RE=rE((function(t){t.setDate(1),t.setHours(0,0,0,0)}),(function(t,e){t.setMonth(t.getMonth()+e)}),(function(t,e){return e.getMonth()-t.getMonth()+12*(e.getFullYear()-t.getFullYear())}),(function(t){return t.getMonth()})),zE=RE.range,DE=rE((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,e){t.setFullYear(t.getFullYear()+e)}),(function(t,e){return e.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));DE.every=function(t){return isFinite(t=Math.floor(t))&&t>0?rE((function(e){e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)}),(function(e,n){e.setFullYear(e.getFullYear()+n*t)})):null};var BE=DE.range,HE=rE((function(t){t.setUTCSeconds(0,0)}),(function(t,e){t.setTime(+t+e*lE)}),(function(t,e){return(e-t)/lE}),(function(t){return t.getUTCMinutes()})),FE=HE.range,VE=rE((function(t){t.setUTCMinutes(0,0,0)}),(function(t,e){t.setTime(+t+e*cE)}),(function(t,e){return(e-t)/cE}),(function(t){return t.getUTCHours()})),jE=VE.range,UE=rE((function(t){t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+e)}),(function(t,e){return(e-t)/uE}),(function(t){return t.getUTCDate()-1})),GE=UE.range;function WE(t){return rE((function(e){e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+7*e)}),(function(t,e){return(e-t)/hE}))}var qE=WE(0),YE=WE(1),XE=WE(2),$E=WE(3),KE=WE(4),ZE=WE(5),JE=WE(6),QE=qE.range,tT=YE.range,eT=XE.range,nT=$E.range,iT=KE.range,rT=ZE.range,oT=JE.range,aT=rE((function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCMonth(t.getUTCMonth()+e)}),(function(t,e){return e.getUTCMonth()-t.getUTCMonth()+12*(e.getUTCFullYear()-t.getUTCFullYear())}),(function(t){return t.getUTCMonth()})),sT=aT.range,lT=rE((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e)}),(function(t,e){return e.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));lT.every=function(t){return isFinite(t=Math.floor(t))&&t>0?rE((function(e){e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)}),(function(e,n){e.setUTCFullYear(e.getUTCFullYear()+n*t)})):null};var cT=lT.range;function uT(t){if(0<=t.y&&t.y<100){var e=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return e.setFullYear(t.y),e}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function hT(t){if(0<=t.y&&t.y<100){var e=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return e.setUTCFullYear(t.y),e}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function dT(t,e,n){return{y:t,m:e,d:n,H:0,M:0,S:0,L:0}}function pT(t){var e=t.dateTime,n=t.date,i=t.time,r=t.periods,o=t.days,a=t.shortDays,s=t.months,l=t.shortMonths,c=ET(r),u=TT(r),h=ET(o),d=TT(o),p=ET(a),f=TT(a),m=ET(s),g=TT(s),_=ET(l),y=TT(l),v={a:function b(t){return a[t.getDay()]},A:function x(t){return o[t.getDay()]},b:function w(t){return l[t.getMonth()]},B:function S(t){return s[t.getMonth()]},c:null,d:YT,e:YT,f:JT,H:XT,I:$T,j:KT,L:ZT,m:QT,M:tA,p:function M(t){return r[+(t.getHours()>=12)]},q:function E(t){return 1+~~(t.getMonth()/3)},Q:CA,s:kA,S:eA,u:nA,U:iA,V:rA,w:oA,W:aA,x:null,X:null,y:sA,Y:lA,Z:cA,"%":AA},T={a:function A(t){return a[t.getUTCDay()]},A:function C(t){return o[t.getUTCDay()]},b:function k(t){return l[t.getUTCMonth()]},B:function L(t){return s[t.getUTCMonth()]},c:null,d:uA,e:uA,f:mA,H:hA,I:dA,j:pA,L:fA,m:gA,M:_A,p:function P(t){return r[+(t.getUTCHours()>=12)]},q:function I(t){return 1+~~(t.getUTCMonth()/3)},Q:CA,s:kA,S:yA,u:vA,U:bA,V:xA,w:wA,W:SA,x:null,X:null,y:MA,Y:EA,Z:TA,"%":AA},N={a:function O(t,e,n){var i=p.exec(e.slice(n));return i?(t.w=f[i[0].toLowerCase()],n+i[0].length):-1},A:function R(t,e,n){var i=h.exec(e.slice(n));return i?(t.w=d[i[0].toLowerCase()],n+i[0].length):-1},b:function z(t,e,n){var i=_.exec(e.slice(n));return i?(t.m=y[i[0].toLowerCase()],n+i[0].length):-1},B:function D(t,e,n){var i=m.exec(e.slice(n));return i?(t.m=g[i[0].toLowerCase()],n+i[0].length):-1},c:function B(t,n,i){return G(t,e,n,i)},d:DT,e:DT,f:UT,H:HT,I:HT,j:BT,L:jT,m:zT,M:FT,p:function H(t,e,n){var i=c.exec(e.slice(n));return i?(t.p=u[i[0].toLowerCase()],n+i[0].length):-1},q:RT,Q:WT,s:qT,S:VT,u:CT,U:kT,V:LT,w:AT,W:PT,x:function F(t,e,i){return G(t,n,e,i)},X:function V(t,e,n){return G(t,i,e,n)},y:NT,Y:IT,Z:OT,"%":GT};function j(t,e){return function(n){var i,r,o,a=[],s=-1,l=0,c=t.length;for(n instanceof Date||(n=new Date(+n));++s<c;)37===t.charCodeAt(s)&&(a.push(t.slice(l,s)),null!=(r=vT[i=t.charAt(++s)])?i=t.charAt(++s):r="e"===i?" ":"0",(o=e[i])&&(i=o(n,r)),a.push(i),l=s+1);return a.push(t.slice(l,s)),a.join("")}}function U(t,e){return function(n){var i,r,o=dT(1900,void 0,1);if(G(o,t,n+="",0)!=n.length)return null;if("Q"in o)return new Date(o.Q);if("s"in o)return new Date(1e3*o.s+("L"in o?o.L:0));if(e&&!("Z"in o)&&(o.Z=0),"p"in o&&(o.H=o.H%12+12*o.p),void 0===o.m&&(o.m="q"in o?o.q:0),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(r=(i=hT(dT(o.y,0,1))).getUTCDay(),i=r>4||0===r?YE.ceil(i):YE(i),i=UE.offset(i,7*(o.V-1)),o.y=i.getUTCFullYear(),o.m=i.getUTCMonth(),o.d=i.getUTCDate()+(o.w+6)%7):(r=(i=uT(dT(o.y,0,1))).getDay(),i=r>4||0===r?wE.ceil(i):wE(i),i=yE.offset(i,7*(o.V-1)),o.y=i.getFullYear(),o.m=i.getMonth(),o.d=i.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),r="Z"in o?hT(dT(o.y,0,1)).getUTCDay():uT(dT(o.y,0,1)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(r+5)%7:o.w+7*o.U-(r+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,hT(o)):uT(o)}}function G(t,e,n,i){for(var r,o,a=0,s=e.length,l=n.length;a<s;){if(i>=l)return-1;if(37===(r=e.charCodeAt(a++))){if(r=e.charAt(a++),!(o=N[r in vT?e.charAt(a++):r])||(i=o(t,n,i))<0)return-1}else if(r!=n.charCodeAt(i++))return-1}return i}return v.x=j(n,v),v.X=j(i,v),v.c=j(e,v),T.x=j(n,T),T.X=j(i,T),T.c=j(e,T),{format:function(t){var e=j(t+="",v);return e.toString=function(){return t},e},parse:function(t){var e=U(t+="",!1);return e.toString=function(){return t},e},utcFormat:function(t){var e=j(t+="",T);return e.toString=function(){return t},e},utcParse:function(t){var e=U(t+="",!0);return e.toString=function(){return t},e}}}var fT,mT,gT,_T,yT,vT={"-":"",_:" ",0:"0"},bT=/^\s*\d+/,xT=/^%/,wT=/[\\^$*+?|[\]().{}]/g;function ST(t,e,n){var i=t<0?"-":"",r=(i?-t:t)+"",o=r.length;return i+(o<n?new Array(n-o+1).join(e)+r:r)}function MT(t){return t.replace(wT,"\\$&")}function ET(t){return new RegExp("^(?:"+t.map(MT).join("|")+")","i")}function TT(t){for(var e={},n=-1,i=t.length;++n<i;)e[t[n].toLowerCase()]=n;return e}function AT(t,e,n){var i=bT.exec(e.slice(n,n+1));return i?(t.w=+i[0],n+i[0].length):-1}function CT(t,e,n){var i=bT.exec(e.slice(n,n+1));return i?(t.u=+i[0],n+i[0].length):-1}function kT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.U=+i[0],n+i[0].length):-1}function LT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.V=+i[0],n+i[0].length):-1}function PT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.W=+i[0],n+i[0].length):-1}function IT(t,e,n){var i=bT.exec(e.slice(n,n+4));return i?(t.y=+i[0],n+i[0].length):-1}function NT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.y=+i[0]+(+i[0]>68?1900:2e3),n+i[0].length):-1}function OT(t,e,n){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n,n+6));return i?(t.Z=i[1]?0:-(i[2]+(i[3]||"00")),n+i[0].length):-1}function RT(t,e,n){var i=bT.exec(e.slice(n,n+1));return i?(t.q=3*i[0]-3,n+i[0].length):-1}function zT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.m=i[0]-1,n+i[0].length):-1}function DT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.d=+i[0],n+i[0].length):-1}function BT(t,e,n){var i=bT.exec(e.slice(n,n+3));return i?(t.m=0,t.d=+i[0],n+i[0].length):-1}function HT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.H=+i[0],n+i[0].length):-1}function FT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.M=+i[0],n+i[0].length):-1}function VT(t,e,n){var i=bT.exec(e.slice(n,n+2));return i?(t.S=+i[0],n+i[0].length):-1}function jT(t,e,n){var i=bT.exec(e.slice(n,n+3));return i?(t.L=+i[0],n+i[0].length):-1}function UT(t,e,n){var i=bT.exec(e.slice(n,n+6));return i?(t.L=Math.floor(i[0]/1e3),n+i[0].length):-1}function GT(t,e,n){var i=xT.exec(e.slice(n,n+1));return i?n+i[0].length:-1}function WT(t,e,n){var i=bT.exec(e.slice(n));return i?(t.Q=+i[0],n+i[0].length):-1}function qT(t,e,n){var i=bT.exec(e.slice(n));return i?(t.s=+i[0],n+i[0].length):-1}function YT(t,e){return ST(t.getDate(),e,2)}function XT(t,e){return ST(t.getHours(),e,2)}function $T(t,e){return ST(t.getHours()%12||12,e,2)}function KT(t,e){return ST(1+yE.count(DE(t),t),e,3)}function ZT(t,e){return ST(t.getMilliseconds(),e,3)}function JT(t,e){return ZT(t,e)+"000"}function QT(t,e){return ST(t.getMonth()+1,e,2)}function tA(t,e){return ST(t.getMinutes(),e,2)}function eA(t,e){return ST(t.getSeconds(),e,2)}function nA(t){var e=t.getDay();return 0===e?7:e}function iA(t,e){return ST(xE.count(DE(t)-1,t),e,2)}function rA(t,e){var n=t.getDay();return t=n>=4||0===n?EE(t):EE.ceil(t),ST(EE.count(DE(t),t)+(4===DE(t).getDay()),e,2)}function oA(t){return t.getDay()}function aA(t,e){return ST(wE.count(DE(t)-1,t),e,2)}function sA(t,e){return ST(t.getFullYear()%100,e,2)}function lA(t,e){return ST(t.getFullYear()%1e4,e,4)}function cA(t){var e=t.getTimezoneOffset();return(e>0?"-":(e*=-1,"+"))+ST(e/60|0,"0",2)+ST(e%60,"0",2)}function uA(t,e){return ST(t.getUTCDate(),e,2)}function hA(t,e){return ST(t.getUTCHours(),e,2)}function dA(t,e){return ST(t.getUTCHours()%12||12,e,2)}function pA(t,e){return ST(1+UE.count(lT(t),t),e,3)}function fA(t,e){return ST(t.getUTCMilliseconds(),e,3)}function mA(t,e){return fA(t,e)+"000"}function gA(t,e){return ST(t.getUTCMonth()+1,e,2)}function _A(t,e){return ST(t.getUTCMinutes(),e,2)}function yA(t,e){return ST(t.getUTCSeconds(),e,2)}function vA(t){var e=t.getUTCDay();return 0===e?7:e}function bA(t,e){return ST(qE.count(lT(t)-1,t),e,2)}function xA(t,e){var n=t.getUTCDay();return t=n>=4||0===n?KE(t):KE.ceil(t),ST(KE.count(lT(t),t)+(4===lT(t).getUTCDay()),e,2)}function wA(t){return t.getUTCDay()}function SA(t,e){return ST(YE.count(lT(t)-1,t),e,2)}function MA(t,e){return ST(t.getUTCFullYear()%100,e,2)}function EA(t,e){return ST(t.getUTCFullYear()%1e4,e,4)}function TA(){return"+0000"}function AA(){return"%"}function CA(t){return+t}function kA(t){return Math.floor(+t/1e3)}function LA(t){return fT=pT(t),mT=fT.format,gT=fT.parse,_T=fT.utcFormat,yT=fT.utcParse,fT}LA({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var PA="%Y-%m-%dT%H:%M:%S.%LZ",IA=Date.prototype.toISOString?function NA(t){return t.toISOString()}:_T(PA),OA=+new Date("2000-01-01T00:00:00.000Z")?function RA(t){var e=new Date(t);return isNaN(e)?null:e}:yT(PA),zA=31536e6;function DA(t){return new Date(t)}function BA(t){return t instanceof Date?+t:+new Date(+t)}function HA(t,e,n,i,r,o,a,s,l){var c=NM(TM,TM),u=c.invert,h=c.domain,d=l(".%L"),p=l(":%S"),f=l("%I:%M"),m=l("%I %p"),g=l("%a %d"),_=l("%b %d"),y=l("%B"),v=l("%Y"),b=[[a,1,1e3],[a,5,5e3],[a,15,15e3],[a,30,3e4],[o,1,6e4],[o,5,3e5],[o,15,9e5],[o,30,18e5],[r,1,36e5],[r,3,108e5],[r,6,216e5],[r,12,432e5],[i,1,864e5],[i,2,1728e5],[n,1,6048e5],[e,1,2592e6],[e,3,7776e6],[t,1,zA]];function x(s){return(a(s)<s?d:o(s)<s?p:r(s)<s?f:i(s)<s?m:e(s)<s?n(s)<s?g:_:t(s)<s?y:v)(s)}function w(e,n,i,r){if(null==e&&(e=10),"number"==typeof e){var o=Math.abs(i-n)/e,a=xl((function(t){return t[2]})).right(b,o);a===b.length?(r=jl(n/zA,i/zA,e),e=t):a?(r=(a=b[o/b[a-1][2]<b[a][2]/o?a-1:a])[1],e=a[0]):(r=Math.max(jl(n,i,e),1),e=s)}return null==r?e:e.every(r)}return c.invert=function(t){return new Date(u(t))},c.domain=function(t){return arguments.length?h(_M.call(t,BA)):h().map(DA)},c.ticks=function(t,e){var n,i=h(),r=i[0],o=i[i.length-1],a=o<r;return a&&(n=r,r=o,o=n),n=(n=w(t,r,o,e))?n.range(r,o+1):[],a?n.reverse():n},c.tickFormat=function(t,e){return null==e?x:l(e)},c.nice=function(t,e){var n=h();return(t=w(t,n[0],n[n.length-1],e))?h(DM(n,t)):c},c.copy=function(){return PM(c,HA(t,e,n,i,r,o,a,s,l))},c}function FA(){return fM.apply(HA(DE,RE,xE,yE,gE,fE,dE,oE,mT).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function VA(){var t,e,n,i,r,o=0,a=1,s=TM,l=!1;function c(e){return isNaN(e=+e)?r:s(0===n?.5:(e=(i(e)-t)*n,l?Math.max(0,Math.min(1,e)):e))}return c.domain=function(r){return arguments.length?(t=i(o=+r[0]),e=i(a=+r[1]),n=t===e?0:1/(e-t),c):[o,a]},c.clamp=function(t){return arguments.length?(l=!!t,c):l},c.interpolator=function(t){return arguments.length?(s=t,c):s},c.unknown=function(t){return arguments.length?(r=t,c):r},function(r){return i=r,t=r(o),e=r(a),n=t===e?0:1/(e-t),c}}function jA(t,e){return e.domain(t.domain()).interpolator(t.interpolator()).clamp(t.clamp()).unknown(t.unknown())}function UA(){var t=JM(VA());return t.copy=function(){return jA(t,UA()).exponent(t.exponent())},mM.apply(t,arguments)}function GA(){var t,e,n,i,r,o,a,s=0,l=.5,c=1,u=TM,h=!1;function d(t){return isNaN(t=+t)?a:(t=.5+((t=+o(t))-e)*(t<e?i:r),u(h?Math.max(0,Math.min(1,t)):t))}return d.domain=function(a){return arguments.length?(t=o(s=+a[0]),e=o(l=+a[1]),n=o(c=+a[2]),i=t===e?0:.5/(e-t),r=e===n?0:.5/(n-e),d):[s,l,c]},d.clamp=function(t){return arguments.length?(h=!!t,d):h},d.interpolator=function(t){return arguments.length?(u=t,d):u},d.unknown=function(t){return arguments.length?(a=t,d):a},function(a){return o=a,t=a(s),e=a(l),n=a(c),i=t===e?0:.5/(e-t),r=e===n?0:.5/(n-e),d}}function WA(){var t=JM(GA());return t.copy=function(){return jA(t,WA()).exponent(t.exponent())},mM.apply(t,arguments)}function qA(t){for(var e=t.length/6|0,n=new Array(e),i=0;i<e;)n[i]="#"+t.slice(6*i,6*++i);return n}var YA=qA("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),XA=qA("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"),$A=qA("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"),KA=qA("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"),ZA=qA("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"),JA=qA("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"),QA=qA("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"),tC=qA("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"),eC=qA("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"),nC=qA("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");function iC(t){return Id(t[t.length-1])}var rC=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(qA),oC=iC(rC),aC=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(qA),sC=iC(aC),lC=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(qA),cC=iC(lC),uC=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(qA),hC=iC(uC),dC=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(qA),pC=iC(dC),fC=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(qA),mC=iC(fC),gC=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(qA),_C=iC(gC),yC=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(qA),vC=iC(yC),bC=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(qA),xC=iC(bC),wC=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(qA),SC=iC(wC),MC=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(qA),EC=iC(MC),TC=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(qA),AC=iC(TC),CC=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(qA),kC=iC(CC),LC=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(qA),PC=iC(LC),IC=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(qA),NC=iC(IC),OC=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(qA),RC=iC(OC),zC=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(qA),DC=iC(zC),BC=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(qA),HC=iC(BC),FC=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(qA),VC=iC(FC),jC=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(qA),UC=iC(jC),GC=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(qA),WC=iC(GC),qC=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(qA),YC=iC(qC),XC=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(qA),$C=iC(XC),KC=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(qA),ZC=iC(KC),JC=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(qA),QC=iC(JC),tk=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(qA),ek=iC(tk),nk=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(qA),ik=iC(nk),rk=_p(xd(300,.5,0),xd(-240,.5,1)),ok=_p(xd(-100,.75,.35),xd(80,1.5,.8)),ak=_p(xd(260,.75,.35),xd(80,1.5,.8)),sk=xd(),lk=jh(),ck=Math.PI/3,uk=2*Math.PI/3;function hk(t){var e=t.length;return function(n){return t[Math.max(0,Math.min(e-1,Math.floor(n*e)))]}}var dk=hk(qA("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),pk=hk(qA("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),fk=hk(qA("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),mk=hk(qA("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function gk(t){return function e(){return t}}var _k=Math.abs,yk=Math.atan2,vk=Math.cos,bk=Math.max,xk=Math.min,wk=Math.sin,Sk=Math.sqrt,Mk=1e-12,Ek=Math.PI,Tk=Ek/2,Ak=2*Ek;function Ck(t){return t>1?0:t<-1?Ek:Math.acos(t)}function kk(t){return t>=1?Tk:t<=-1?-Tk:Math.asin(t)}function Lk(t){return t.innerRadius}function Pk(t){return t.outerRadius}function Ik(t){return t.startAngle}function Nk(t){return t.endAngle}function Ok(t){return t&&t.padAngle}function Rk(t,e,n,i,r,o,a,s){var l=n-t,c=i-e,u=a-r,h=s-o,d=h*l-u*c;if(!(d*d<Mk))return[t+(d=(u*(e-o)-h*(t-r))/d)*l,e+d*c]}function zk(t,e,n,i,r,o,a){var s=t-n,l=e-i,c=(a?o:-o)/Sk(s*s+l*l),u=c*l,h=-c*s,d=t+u,p=e+h,f=n+u,m=i+h,g=(d+f)/2,_=(p+m)/2,y=f-d,v=m-p,b=y*y+v*v,x=r-o,w=d*m-f*p,S=(v<0?-1:1)*Sk(bk(0,x*x*b-w*w)),M=(w*v-y*S)/b,E=(-w*y-v*S)/b,T=(w*v+y*S)/b,A=(-w*y+v*S)/b,C=M-g,k=E-_,L=T-g,P=A-_;return C*C+k*k>L*L+P*P&&(M=T,E=A),{cx:M,cy:E,x01:-u,y01:-h,x11:M*(r/x-1),y11:E*(r/x-1)}}function Dk(t){this._context=t}function Bk(t){return new Dk(t)}function Hk(t){return t[0]}function Fk(t){return t[1]}function Vk(){var t=Hk,e=Fk,n=gk(!0),i=null,r=Bk,o=null;function a(a){var s,l,c,u=a.length,h=!1;for(null==i&&(o=r(c=pg())),s=0;s<=u;++s)!(s<u&&n(l=a[s],s,a))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+t(l,s,a),+e(l,s,a));if(c)return o=null,c+""||null}return a.x=function(e){return arguments.length?(t="function"==typeof e?e:gk(+e),a):t},a.y=function(t){return arguments.length?(e="function"==typeof t?t:gk(+t),a):e},a.defined=function(t){return arguments.length?(n="function"==typeof t?t:gk(!!t),a):n},a.curve=function(t){return arguments.length?(r=t,null!=i&&(o=r(i)),a):r},a.context=function(t){return arguments.length?(null==t?i=o=null:o=r(i=t),a):i},a}function jk(){var t=Hk,e=null,n=gk(0),i=Fk,r=gk(!0),o=null,a=Bk,s=null;function l(l){var c,u,h,d,p,f=l.length,m=!1,g=new Array(f),_=new Array(f);for(null==o&&(s=a(p=pg())),c=0;c<=f;++c){if(!(c<f&&r(d=l[c],c,l))===m)if(m=!m)u=c,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),h=c-1;h>=u;--h)s.point(g[h],_[h]);s.lineEnd(),s.areaEnd()}m&&(g[c]=+t(d,c,l),_[c]=+n(d,c,l),s.point(e?+e(d,c,l):g[c],i?+i(d,c,l):_[c]))}if(p)return s=null,p+""||null}function c(){return Vk().defined(r).curve(a).context(o)}return l.x=function(n){return arguments.length?(t="function"==typeof n?n:gk(+n),e=null,l):t},l.x0=function(e){return arguments.length?(t="function"==typeof e?e:gk(+e),l):t},l.x1=function(t){return arguments.length?(e=null==t?null:"function"==typeof t?t:gk(+t),l):e},l.y=function(t){return arguments.length?(n="function"==typeof t?t:gk(+t),i=null,l):n},l.y0=function(t){return arguments.length?(n="function"==typeof t?t:gk(+t),l):n},l.y1=function(t){return arguments.length?(i=null==t?null:"function"==typeof t?t:gk(+t),l):i},l.lineX0=l.lineY0=function(){return c().x(t).y(n)},l.lineY1=function(){return c().x(t).y(i)},l.lineX1=function(){return c().x(e).y(n)},l.defined=function(t){return arguments.length?(r="function"==typeof t?t:gk(!!t),l):r},l.curve=function(t){return arguments.length?(a=t,null!=o&&(s=a(o)),l):a},l.context=function(t){return arguments.length?(null==t?o=s=null:s=a(o=t),l):o},l}function Uk(t,e){return e<t?-1:e>t?1:e>=t?0:NaN}function Gk(t){return t}Dk.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:this._context.lineTo(t,e)}}};var Wk=Yk(Bk);function qk(t){this._curve=t}function Yk(t){function e(e){return new qk(t(e))}return e._curve=t,e}function Xk(t){var e=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?e(Yk(t)):e()._curve},t}function $k(){return Xk(Vk().curve(Wk))}function Kk(){var t=jk().curve(Wk),e=t.curve,n=t.lineX0,i=t.lineX1,r=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return Xk(n())},delete t.lineX0,t.lineEndAngle=function(){return Xk(i())},delete t.lineX1,t.lineInnerRadius=function(){return Xk(r())},delete t.lineY0,t.lineOuterRadius=function(){return Xk(o())},delete t.lineY1,t.curve=function(t){return arguments.length?e(Yk(t)):e()._curve},t}function Zk(t,e){return[(e=+e)*Math.cos(t-=Math.PI/2),e*Math.sin(t)]}qk.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,e){this._curve.point(e*Math.sin(t),e*-Math.cos(t))}};var Jk=Array.prototype.slice;function Qk(t){return t.source}function tL(t){return t.target}function eL(t){var e=Qk,n=tL,i=Hk,r=Fk,o=null;function a(){var a,s=Jk.call(arguments),l=e.apply(this,s),c=n.apply(this,s);if(o||(o=a=pg()),t(o,+i.apply(this,(s[0]=l,s)),+r.apply(this,s),+i.apply(this,(s[0]=c,s)),+r.apply(this,s)),a)return o=null,a+""||null}return a.source=function(t){return arguments.length?(e=t,a):e},a.target=function(t){return arguments.length?(n=t,a):n},a.x=function(t){return arguments.length?(i="function"==typeof t?t:gk(+t),a):i},a.y=function(t){return arguments.length?(r="function"==typeof t?t:gk(+t),a):r},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a}function nL(t,e,n,i,r){t.moveTo(e,n),t.bezierCurveTo(e=(e+i)/2,n,e,r,i,r)}function iL(t,e,n,i,r){t.moveTo(e,n),t.bezierCurveTo(e,n=(n+r)/2,i,n,i,r)}function rL(t,e,n,i,r){var o=Zk(e,n),a=Zk(e,n=(n+r)/2),s=Zk(i,n),l=Zk(i,r);t.moveTo(o[0],o[1]),t.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}var oL={draw:function(t,e){var n=Math.sqrt(e/Ek);t.moveTo(n,0),t.arc(0,0,n,0,Ak)}},aL={draw:function(t,e){var n=Math.sqrt(e/5)/2;t.moveTo(-3*n,-n),t.lineTo(-n,-n),t.lineTo(-n,-3*n),t.lineTo(n,-3*n),t.lineTo(n,-n),t.lineTo(3*n,-n),t.lineTo(3*n,n),t.lineTo(n,n),t.lineTo(n,3*n),t.lineTo(-n,3*n),t.lineTo(-n,n),t.lineTo(-3*n,n),t.closePath()}},sL=Math.sqrt(1/3),lL=2*sL,cL={draw:function(t,e){var n=Math.sqrt(e/lL),i=n*sL;t.moveTo(0,-n),t.lineTo(i,0),t.lineTo(0,n),t.lineTo(-i,0),t.closePath()}},uL=Math.sin(Ek/10)/Math.sin(7*Ek/10),hL=Math.sin(Ak/10)*uL,dL=-Math.cos(Ak/10)*uL,pL={draw:function(t,e){var n=Math.sqrt(.8908130915292852*e),i=hL*n,r=dL*n;t.moveTo(0,-n),t.lineTo(i,r);for(var o=1;o<5;++o){var a=Ak*o/5,s=Math.cos(a),l=Math.sin(a);t.lineTo(l*n,-s*n),t.lineTo(s*i-l*r,l*i+s*r)}t.closePath()}},fL={draw:function(t,e){var n=Math.sqrt(e),i=-n/2;t.rect(i,i,n,n)}},mL=Math.sqrt(3),gL={draw:function(t,e){var n=-Math.sqrt(e/(3*mL));t.moveTo(0,2*n),t.lineTo(-mL*n,-n),t.lineTo(mL*n,-n),t.closePath()}},_L=-.5,yL=Math.sqrt(3)/2,vL=1/Math.sqrt(12),bL=3*(vL/2+1),xL={draw:function(t,e){var n=Math.sqrt(e/bL),i=n/2,r=n*vL,o=i,a=n*vL+n,s=-o,l=a;t.moveTo(i,r),t.lineTo(o,a),t.lineTo(s,l),t.lineTo(_L*i-yL*r,yL*i+_L*r),t.lineTo(_L*o-yL*a,yL*o+_L*a),t.lineTo(_L*s-yL*l,yL*s+_L*l),t.lineTo(_L*i+yL*r,_L*r-yL*i),t.lineTo(_L*o+yL*a,_L*a-yL*o),t.lineTo(_L*s+yL*l,_L*l-yL*s),t.closePath()}},wL=[oL,aL,cL,fL,pL,gL,xL];function SL(){}function ML(t,e,n){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+e)/6,(t._y0+4*t._y1+n)/6)}function EL(t){this._context=t}function TL(t){return new EL(t)}function AL(t){this._context=t}function CL(t){this._context=t}function kL(t,e){this._basis=new EL(t),this._beta=e}EL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:ML(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:ML(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},AL.prototype={areaStart:SL,areaEnd:SL,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._x2=t,this._y2=e;break;case 1:this._point=2,this._x3=t,this._y3=e;break;case 2:this._point=3,this._x4=t,this._y4=e,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+e)/6);break;default:ML(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},CL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var n=(this._x0+4*this._x1+t)/6,i=(this._y0+4*this._y1+e)/6;this._line?this._context.lineTo(n,i):this._context.moveTo(n,i);break;case 3:this._point=4;default:ML(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},kL.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,e=this._y,n=t.length-1;if(n>0)for(var i,r=t[0],o=e[0],a=t[n]-r,s=e[n]-o,l=-1;++l<=n;)this._basis.point(this._beta*t[l]+(1-this._beta)*(r+(i=l/n)*a),this._beta*e[l]+(1-this._beta)*(o+i*s));this._x=this._y=null,this._basis.lineEnd()},point:function(t,e){this._x.push(+t),this._y.push(+e)}};var LL=(function t(e){function n(t){return 1===e?new EL(t):new kL(t,e)}return n.beta=function(e){return t(+e)},n})(.85);function PL(t,e,n){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-e),t._y2+t._k*(t._y1-n),t._x2,t._y2)}function IL(t,e){this._context=t,this._k=(1-e)/6}IL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:PL(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2,this._x1=t,this._y1=e;break;case 2:this._point=3;default:PL(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var NL=(function t(e){function n(t){return new IL(t,e)}return n.tension=function(e){return t(+e)},n})(0);function OL(t,e){this._context=t,this._k=(1-e)/6}OL.prototype={areaStart:SL,areaEnd:SL,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:PL(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var RL=(function t(e){function n(t){return new OL(t,e)}return n.tension=function(e){return t(+e)},n})(0);function zL(t,e){this._context=t,this._k=(1-e)/6}zL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:PL(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var DL=(function t(e){function n(t){return new zL(t,e)}return n.tension=function(e){return t(+e)},n})(0);function BL(t,e,n){var i=t._x1,r=t._y1,o=t._x2,a=t._y2;if(t._l01_a>Mk){var s=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,l=3*t._l01_a*(t._l01_a+t._l12_a);i=(i*s-t._x0*t._l12_2a+t._x2*t._l01_2a)/l,r=(r*s-t._y0*t._l12_2a+t._y2*t._l01_2a)/l}if(t._l23_a>Mk){var c=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,u=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*c+t._x1*t._l23_2a-e*t._l12_2a)/u,a=(a*c+t._y1*t._l23_2a-n*t._l12_2a)/u}t._context.bezierCurveTo(i,r,o,a,t._x2,t._y2)}function HL(t,e){this._context=t,this._alpha=e}HL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3;default:BL(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var FL=(function t(e){function n(t){return e?new HL(t,e):new IL(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function VL(t,e){this._context=t,this._alpha=e}VL.prototype={areaStart:SL,areaEnd:SL,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:BL(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var jL=(function t(e){function n(t){return e?new VL(t,e):new OL(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function UL(t,e){this._context=t,this._alpha=e}UL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:BL(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var GL=(function t(e){function n(t){return e?new UL(t,e):new zL(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function WL(t){this._context=t}function qL(t){return t<0?-1:1}function YL(t,e,n){var i=t._x1-t._x0,r=e-t._x1,o=(t._y1-t._y0)/(i||r<0&&-0),a=(n-t._y1)/(r||i<0&&-0),s=(o*r+a*i)/(i+r);return(qL(o)+qL(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function XL(t,e){var n=t._x1-t._x0;return n?(3*(t._y1-t._y0)/n-e)/2:e}function $L(t,e,n){var i=t._x0,r=t._x1,o=t._y1,a=(r-i)/3;t._context.bezierCurveTo(i+a,t._y0+a*e,r-a,o-a*n,r,o)}function KL(t){this._context=t}function ZL(t){this._context=new JL(t)}function JL(t){this._context=t}function QL(t){this._context=t}function tP(t){var e,n,i=t.length-1,r=new Array(i),o=new Array(i),a=new Array(i);for(r[0]=0,o[0]=2,a[0]=t[0]+2*t[1],e=1;e<i-1;++e)r[e]=1,o[e]=4,a[e]=4*t[e]+2*t[e+1];for(r[i-1]=2,o[i-1]=7,a[i-1]=8*t[i-1]+t[i],e=1;e<i;++e)o[e]-=n=r[e]/o[e-1],a[e]-=n*a[e-1];for(r[i-1]=a[i-1]/o[i-1],e=i-2;e>=0;--e)r[e]=(a[e]-r[e+1])/o[e];for(o[i-1]=(t[i]+r[i-1])/2,e=0;e<i-1;++e)o[e]=2*t[e+1]-r[e+1];return[r,o]}function eP(t,e){this._context=t,this._t=e}function nP(t,e){if((r=t.length)>1)for(var n,i,r,o=1,a=t[e[0]],s=a.length;o<r;++o)for(i=a,a=t[e[o]],n=0;n<s;++n)a[n][1]+=a[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function iP(t){for(var e=t.length,n=new Array(e);--e>=0;)n[e]=e;return n}function rP(t,e){return t[e]}function oP(t){var e=t.map(aP);return iP(t).sort((function(t,n){return e[t]-e[n]}))}function aP(t){for(var e,n=-1,i=0,r=t.length,o=-1/0;++n<r;)(e=+t[n][1])>o&&(o=e,i=n);return i}function sP(t){var e=t.map(lP);return iP(t).sort((function(t,n){return e[t]-e[n]}))}function lP(t){for(var e,n=0,i=-1,r=t.length;++i<r;)(e=+t[i][1])&&(n+=e);return n}function cP(t){return function(){return t}}function uP(t){return t[0]}function hP(t){return t[1]}function dP(){this._=null}function pP(t){t.U=t.C=t.L=t.R=t.P=t.N=null}function fP(t,e){var n=e,i=e.R,r=n.U;r?r.L===n?r.L=i:r.R=i:t._=i,i.U=r,n.U=i,n.R=i.L,n.R&&(n.R.U=n),i.L=n}function mP(t,e){var n=e,i=e.L,r=n.U;r?r.L===n?r.L=i:r.R=i:t._=i,i.U=r,n.U=i,n.L=i.R,n.L&&(n.L.U=n),i.R=n}function gP(t){for(;t.L;)t=t.L;return t}function _P(t,e,n,i){var r=[null,null],o=VP.push(r)-1;return r.left=t,r.right=e,n&&vP(r,t,e,n),i&&vP(r,e,t,i),HP[t.index].halfedges.push(o),HP[e.index].halfedges.push(o),r}function yP(t,e,n){var i=[e,n];return i.left=t,i}function vP(t,e,n,i){t[0]||t[1]?t.left===n?t[1]=i:t[0]=i:(t[0]=i,t.left=e,t.right=n)}function bP(t,e,n,i,r){var o,a=t[0],s=t[1],l=a[0],c=a[1],u=0,h=1,d=s[0]-l,p=s[1]-c;if(o=e-l,d||!(o>0)){if(o/=d,d<0){if(o<u)return;o<h&&(h=o)}else if(d>0){if(o>h)return;o>u&&(u=o)}if(o=i-l,d||!(o<0)){if(o/=d,d<0){if(o>h)return;o>u&&(u=o)}else if(d>0){if(o<u)return;o<h&&(h=o)}if(o=n-c,p||!(o>0)){if(o/=p,p<0){if(o<u)return;o<h&&(h=o)}else if(p>0){if(o>h)return;o>u&&(u=o)}if(o=r-c,p||!(o<0)){if(o/=p,p<0){if(o>h)return;o>u&&(u=o)}else if(p>0){if(o<u)return;o<h&&(h=o)}return!(u>0||h<1)||(u>0&&(t[0]=[l+u*d,c+u*p]),h<1&&(t[1]=[l+h*d,c+h*p]),!0)}}}}}function xP(t,e,n,i,r){var o=t[1];if(o)return!0;var a,s,l=t[0],c=t.left,u=t.right,h=c[0],d=c[1],p=u[0],f=u[1],m=(h+p)/2;if(f===d){if(m<e||m>=i)return;if(h>p){if(l){if(l[1]>=r)return}else l=[m,n];o=[m,r]}else{if(l){if(l[1]<n)return}else l=[m,r];o=[m,n]}}else if(s=(d+f)/2-(a=(h-p)/(f-d))*m,a<-1||a>1)if(h>p){if(l){if(l[1]>=r)return}else l=[(n-s)/a,n];o=[(r-s)/a,r]}else{if(l){if(l[1]<n)return}else l=[(r-s)/a,r];o=[(n-s)/a,n]}else if(d<f){if(l){if(l[0]>=i)return}else l=[e,a*e+s];o=[i,a*i+s]}else{if(l){if(l[0]<e)return}else l=[i,a*i+s];o=[e,a*e+s]}return t[0]=l,t[1]=o,!0}function wP(t,e){var n=t.site,i=e.left,r=e.right;return n===r&&(r=i,i=n),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(n===i?(i=e[1],r=e[0]):(i=e[0],r=e[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function SP(t,e){return e[+(e.left!==t.site)]}function MP(t,e){return e[+(e.left===t.site)]}WL.prototype={areaStart:SL,areaEnd:SL,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,e){t=+t,e=+e,this._point?this._context.lineTo(t,e):(this._point=1,this._context.moveTo(t,e))}},KL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:$L(this,this._t0,XL(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){var n=NaN;if(e=+e,(t=+t)!==this._x1||e!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3,$L(this,XL(this,n=YL(this,t,e)),n);break;default:$L(this,this._t0,n=YL(this,t,e))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e,this._t0=n}}},(ZL.prototype=Object.create(KL.prototype)).point=function(t,e){KL.prototype.point.call(this,e,t)},JL.prototype={moveTo:function(t,e){this._context.moveTo(e,t)},closePath:function(){this._context.closePath()},lineTo:function(t,e){this._context.lineTo(e,t)},bezierCurveTo:function(t,e,n,i,r,o){this._context.bezierCurveTo(e,t,i,n,o,r)}},QL.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,e=this._y,n=t.length;if(n)if(this._line?this._context.lineTo(t[0],e[0]):this._context.moveTo(t[0],e[0]),2===n)this._context.lineTo(t[1],e[1]);else for(var i=tP(t),r=tP(e),o=0,a=1;a<n;++o,++a)this._context.bezierCurveTo(i[0][o],r[0][o],i[1][o],r[1][o],t[a],e[a]);(this._line||0!==this._line&&1===n)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,e){this._x.push(+t),this._y.push(+e)}},eP.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,e),this._context.lineTo(t,e);else{var n=this._x*(1-this._t)+t*this._t;this._context.lineTo(n,this._y),this._context.lineTo(n,e)}}this._x=t,this._y=e}},dP.prototype={constructor:dP,insert:function(t,e){var n,i,r;if(t){if(e.P=t,e.N=t.N,t.N&&(t.N.P=e),t.N=e,t.R){for(t=t.R;t.L;)t=t.L;t.L=e}else t.R=e;n=t}else this._?(t=gP(this._),e.P=null,e.N=t,t.P=t.L=e,n=t):(e.P=e.N=null,this._=e,n=null);for(e.L=e.R=null,e.U=n,e.C=!0,t=e;n&&n.C;)n===(i=n.U).L?(r=i.R)&&r.C?(n.C=r.C=!1,i.C=!0,t=i):(t===n.R&&(fP(this,n),n=(t=n).U),n.C=!1,i.C=!0,mP(this,i)):(r=i.L)&&r.C?(n.C=r.C=!1,i.C=!0,t=i):(t===n.L&&(mP(this,n),n=(t=n).U),n.C=!1,i.C=!0,fP(this,i)),n=t.U;this._.C=!1},remove:function(t){t.N&&(t.N.P=t.P),t.P&&(t.P.N=t.N),t.N=t.P=null;var e,n,i,r=t.U,o=t.L,a=t.R;if(n=o?a?gP(a):o:a,r?r.L===t?r.L=n:r.R=n:this._=n,o&&a?(i=n.C,n.C=t.C,n.L=o,o.U=n,n!==a?(r=n.U,n.U=t.U,r.L=t=n.R,n.R=a,a.U=n):(n.U=r,r=n,t=n.R)):(i=t.C,t=n),t&&(t.U=r),!i)if(t&&t.C)t.C=!1;else{do{if(t===this._)break;if(t===r.L){if((e=r.R).C&&(e.C=!1,r.C=!0,fP(this,r),e=r.R),e.L&&e.L.C||e.R&&e.R.C){e.R&&e.R.C||(e.L.C=!1,e.C=!0,mP(this,e),e=r.R),e.C=r.C,r.C=e.R.C=!1,fP(this,r),t=this._;break}}else if((e=r.L).C&&(e.C=!1,r.C=!0,mP(this,r),e=r.L),e.L&&e.L.C||e.R&&e.R.C){e.L&&e.L.C||(e.R.C=!1,e.C=!0,fP(this,e),e=r.L),e.C=r.C,r.C=e.L.C=!1,mP(this,r),t=this._;break}e.C=!0,t=r,r=r.U}while(!t.C);t&&(t.C=!1)}}};var EP,TP=[];function AP(){pP(this),this.x=this.y=this.arc=this.site=this.cy=null}function CP(t){var e=t.P,n=t.N;if(e&&n){var i=e.site,r=t.site,o=n.site;if(i!==o){var a=r[0],s=r[1],l=i[0]-a,c=i[1]-s,u=o[0]-a,h=o[1]-s,d=2*(l*h-c*u);if(!(d>=-UP)){var p=l*l+c*c,f=u*u+h*h,m=(h*p-c*f)/d,g=(l*f-u*p)/d,_=TP.pop()||new AP;_.arc=t,_.site=r,_.x=m+a,_.y=(_.cy=g+s)+Math.sqrt(m*m+g*g),t.circle=_;for(var y=null,v=FP._;v;)if(_.y<v.y||_.y===v.y&&_.x<=v.x){if(!v.L){y=v.P;break}v=v.L}else{if(!v.R){y=v;break}v=v.R}FP.insert(y,_),y||(EP=_)}}}}function kP(t){var e=t.circle;e&&(e.P||(EP=e.N),FP.remove(e),TP.push(e),pP(e),t.circle=null)}var LP=[];function PP(){pP(this),this.edge=this.site=this.circle=null}function IP(t){var e=LP.pop()||new PP;return e.site=t,e}function NP(t){kP(t),BP.remove(t),LP.push(t),pP(t)}function OP(t){var e=t.circle,n=e.x,i=e.cy,r=[n,i],o=t.P,a=t.N,s=[t];NP(t);for(var l=o;l.circle&&Math.abs(n-l.circle.x)<jP&&Math.abs(i-l.circle.cy)<jP;)o=l.P,s.unshift(l),NP(l),l=o;s.unshift(l),kP(l);for(var c=a;c.circle&&Math.abs(n-c.circle.x)<jP&&Math.abs(i-c.circle.cy)<jP;)a=c.N,s.push(c),NP(c),c=a;s.push(c),kP(c);var u,h=s.length;for(u=1;u<h;++u)vP((c=s[u]).edge,(l=s[u-1]).site,c.site,r);(c=s[h-1]).edge=_P((l=s[0]).site,c.site,null,r),CP(l),CP(c)}function RP(t){for(var e,n,i,r,o=t[0],a=t[1],s=BP._;s;)if((i=zP(s,a)-o)>jP)s=s.L;else{if(!((r=o-DP(s,a))>jP)){i>-jP?(e=s.P,n=s):r>-jP?(e=s,n=s.N):e=n=s;break}if(!s.R){e=s;break}s=s.R}!(function l(t){HP[t.index]={site:t,halfedges:[]}})(t);var c=IP(t);if(BP.insert(e,c),e||n){if(e===n)return kP(e),n=IP(e.site),BP.insert(c,n),c.edge=n.edge=_P(e.site,c.site),CP(e),void CP(n);if(n){kP(e),kP(n);var u=e.site,h=u[0],d=u[1],p=t[0]-h,f=t[1]-d,m=n.site,g=m[0]-h,_=m[1]-d,y=2*(p*_-f*g),v=p*p+f*f,b=g*g+_*_,x=[(_*v-f*b)/y+h,(p*b-g*v)/y+d];vP(n.edge,u,m,x),c.edge=_P(u,t,null,x),n.edge=_P(t,m,null,x),CP(e),CP(n)}else c.edge=_P(e.site,c.site)}}function zP(t,e){var n=t.site,i=n[0],r=n[1],o=r-e;if(!o)return i;var a=t.P;if(!a)return-1/0;var s=(n=a.site)[0],l=n[1],c=l-e;if(!c)return s;var u=s-i,h=1/o-1/c,d=u/c;return h?(-d+Math.sqrt(d*d-2*h*(u*u/(-2*c)-l+c/2+r-o/2)))/h+i:(i+s)/2}function DP(t,e){var n=t.N;if(n)return zP(n,e);var i=t.site;return i[1]===e?i[0]:1/0}var BP,HP,FP,VP,jP=1e-6,UP=1e-12;function GP(t,e,n){return(t[0]-n[0])*(e[1]-t[1])-(t[0]-e[0])*(n[1]-t[1])}function WP(t,e){return e[1]-t[1]||e[0]-t[0]}function qP(t,e){var n,i,r,o=t.sort(WP).pop();for(VP=[],HP=new Array(t.length),BP=new dP,FP=new dP;;)if(r=EP,o&&(!r||o[1]<r.y||o[1]===r.y&&o[0]<r.x))o[0]===n&&o[1]===i||(RP(o),n=o[0],i=o[1]),o=t.pop();else{if(!r)break;OP(r.arc)}if((function a(){for(var t,e,n,i,r=0,o=HP.length;r<o;++r)if((t=HP[r])&&(i=(e=t.halfedges).length)){var a=new Array(i),s=new Array(i);for(n=0;n<i;++n)a[n]=n,s[n]=wP(t,VP[e[n]]);for(a.sort((function(t,e){return s[e]-s[t]})),n=0;n<i;++n)s[n]=e[a[n]];for(n=0;n<i;++n)e[n]=s[n]}})(),e){var s=+e[0][0],l=+e[0][1],c=+e[1][0],u=+e[1][1];!(function h(t,e,n,i){for(var r,o=VP.length;o--;)xP(r=VP[o],t,e,n,i)&&bP(r,t,e,n,i)&&(Math.abs(r[0][0]-r[1][0])>jP||Math.abs(r[0][1]-r[1][1])>jP)||delete VP[o]})(s,l,c,u),(function d(t,e,n,i){var r,o,a,s,l,c,u,h,d,p,f,m,g=HP.length,_=!0;for(r=0;r<g;++r)if(o=HP[r]){for(a=o.site,s=(l=o.halfedges).length;s--;)VP[l[s]]||l.splice(s,1);for(s=0,c=l.length;s<c;)f=(p=MP(o,VP[l[s]]))[0],m=p[1],h=(u=SP(o,VP[l[++s%c]]))[0],d=u[1],(Math.abs(f-h)>jP||Math.abs(m-d)>jP)&&(l.splice(s,0,VP.push(yP(a,p,Math.abs(f-t)<jP&&i-m>jP?[t,Math.abs(h-t)<jP?d:i]:Math.abs(m-i)<jP&&n-f>jP?[Math.abs(d-i)<jP?h:n,i]:Math.abs(f-n)<jP&&m-e>jP?[n,Math.abs(h-n)<jP?d:e]:Math.abs(m-e)<jP&&f-t>jP?[Math.abs(d-e)<jP?h:t,e]:null))-1),++c);c&&(_=!1)}if(_){var y,v,b,x=1/0;for(r=0,_=null;r<g;++r)(o=HP[r])&&(b=(y=(a=o.site)[0]-t)*y+(v=a[1]-e)*v)<x&&(x=b,_=o);if(_){var w=[t,e],S=[t,i],M=[n,i],E=[n,e];_.halfedges.push(VP.push(yP(a=_.site,w,S))-1,VP.push(yP(a,S,M))-1,VP.push(yP(a,M,E))-1,VP.push(yP(a,E,w))-1)}}for(r=0;r<g;++r)(o=HP[r])&&(o.halfedges.length||delete HP[r])})(s,l,c,u)}this.edges=VP,this.cells=HP,BP=FP=VP=HP=null}function YP(t){return function(){return t}}function XP(t,e,n){this.target=t,this.type=e,this.transform=n}function $P(t,e,n){this.k=t,this.x=e,this.y=n}qP.prototype={constructor:qP,polygons:function(){var t=this.edges;return this.cells.map((function(e){var n=e.halfedges.map((function(n){return SP(e,t[n])}));return n.data=e.site.data,n}))},triangles:function(){var t=[],e=this.edges;return this.cells.forEach((function(n,i){if(o=(r=n.halfedges).length)for(var r,o,a,s=n.site,l=-1,c=e[r[o-1]],u=c.left===s?c.right:c.left;++l<o;)a=u,u=(c=e[r[l]]).left===s?c.right:c.left,a&&u&&i<a.index&&i<u.index&&GP(s,a,u)<0&&t.push([s.data,a.data,u.data])})),t},links:function(){return this.edges.filter((function(t){return t.right})).map((function(t){return{source:t.left.data,target:t.right.data}}))},find:function(t,e,n){for(var i,r,o=this,a=o._found||0,s=o.cells.length;!(r=o.cells[a]);)if(++a>=s)return null;var l=t-r.site[0],c=e-r.site[1],u=l*l+c*c;do{r=o.cells[i=a],a=null,r.halfedges.forEach((function(n){var i=o.edges[n],s=i.left;if(s!==r.site&&s||(s=i.right)){var l=t-s[0],c=e-s[1],h=l*l+c*c;h<u&&(u=h,a=s.index)}}))}while(null!==a);return o._found=i,null==n||u<=n*n?r.site:null}},$P.prototype={constructor:$P,scale:function(t){return 1===t?this:new $P(this.k*t,this.x,this.y)},translate:function(t,e){return 0===t&0===e?this:new $P(this.k,this.x+this.k*t,this.y+this.k*e)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var KP=new $P(1,0,0);function ZP(t){for(;!t.__zoom;)if(!(t=t.parentNode))return KP;return t.__zoom}function JP(){uu.stopImmediatePropagation()}function QP(){uu.preventDefault(),uu.stopImmediatePropagation()}function tI(){return!uu.ctrlKey&&!uu.button}function eI(){var t=this;return t instanceof SVGElement?(t=t.ownerSVGElement||t).hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]:[[0,0],[t.clientWidth,t.clientHeight]]}function nI(){return this.__zoom||KP}function iI(){return-uu.deltaY*(1===uu.deltaMode?.05:uu.deltaMode?1:.002)}function rI(){return navigator.maxTouchPoints||"ontouchstart"in this}function oI(t,e,n){var i=t.invertX(e[0][0])-n[0][0],r=t.invertX(e[1][0])-n[1][0],o=t.invertY(e[0][1])-n[0][1],a=t.invertY(e[1][1])-n[1][1];return t.translate(r>i?(i+r)/2:Math.min(0,i)||Math.max(0,r),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}function aI(){var t,e,n=tI,i=eI,r=oI,o=iI,a=rI,s=[0,1/0],l=[[-1/0,-1/0],[1/0,1/0]],c=250,u=op,h=lc("start","zoom","end"),d=500,p=0;function f(t){t.property("__zoom",nI).on("wheel.zoom",x).on("mousedown.zoom",w).on("dblclick.zoom",S).filter(a).on("touchstart.zoom",M).on("touchmove.zoom",E).on("touchend.zoom touchcancel.zoom",T).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function m(t,e){return(e=Math.max(s[0],Math.min(s[1],e)))===t.k?t:new $P(e,t.x,t.y)}function g(t,e,n){var i=e[0]-n[0]*t.k,r=e[1]-n[1]*t.k;return i===t.x&&r===t.y?t:new $P(t.k,i,r)}function _(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function y(t,e,n){t.on("start.zoom",(function(){v(this,arguments).start()})).on("interrupt.zoom end.zoom",(function(){v(this,arguments).end()})).tween("zoom",(function(){var t=this,r=arguments,o=v(t,r),a=i.apply(t,r),s=null==n?_(a):"function"==typeof n?n.apply(t,r):n,l=Math.max(a[1][0]-a[0][0],a[1][1]-a[0][1]),c=t.__zoom,h="function"==typeof e?e.apply(t,r):e,d=u(c.invert(s).concat(l/c.k),h.invert(s).concat(l/h.k));return function(t){if(1===t)t=h;else{var e=d(t),n=l/e[2];t=new $P(n,s[0]-e[0]*n,s[1]-e[1]*n)}o.zoom(null,t)}}))}function v(t,e,n){return!n&&t.__zooming||new b(t,e)}function b(t,e){this.that=t,this.args=e,this.active=0,this.extent=i.apply(t,e),this.taps=0}function x(){if(n.apply(this,arguments)){var t=v(this,arguments),e=this.__zoom,i=Math.max(s[0],Math.min(s[1],e.k*Math.pow(2,o.apply(this,arguments)))),a=ah(this);if(t.wheel)t.mouse[0][0]===a[0]&&t.mouse[0][1]===a[1]||(t.mouse[1]=e.invert(t.mouse[0]=a)),clearTimeout(t.wheel);else{if(e.k===i)return;t.mouse=[a,e.invert(a)],Vp(this),t.start()}QP(),t.wheel=setTimeout(c,150),t.zoom("mouse",r(g(m(e,i),t.mouse[0],t.mouse[1]),t.extent,l))}function c(){t.wheel=null,t.end()}}function w(){if(!e&&n.apply(this,arguments)){var t=v(this,arguments,!0),i=Su(uu.view).on("mousemove.zoom",c,!0).on("mouseup.zoom",u,!0),o=ah(this),a=uu.clientX,s=uu.clientY;hh(uu.view),JP(),t.mouse=[o,this.__zoom.invert(o)],Vp(this),t.start()}function c(){if(QP(),!t.moved){var e=uu.clientX-a,n=uu.clientY-s;t.moved=e*e+n*n>p}t.zoom("mouse",r(g(t.that.__zoom,t.mouse[0]=ah(t.that),t.mouse[1]),t.extent,l))}function u(){i.on("mousemove.zoom mouseup.zoom",null),dh(uu.view,t.moved),QP(),t.end()}}function S(){if(n.apply(this,arguments)){var t=this.__zoom,e=ah(this),o=t.invert(e),a=t.k*(uu.shiftKey?.5:2),s=r(g(m(t,a),e,o),i.apply(this,arguments),l);QP(),c>0?Su(this).transition().duration(c).call(y,s,e):Su(this).call(f.transform,s)}}function M(){if(n.apply(this,arguments)){var e,i,r,o,a=uu.touches,s=a.length,l=v(this,arguments,uu.changedTouches.length===s);for(JP(),i=0;i<s;++i)o=[o=lh(this,a,(r=a[i]).identifier),this.__zoom.invert(o),r.identifier],l.touch0?l.touch1||l.touch0[2]===o[2]||(l.touch1=o,l.taps=0):(l.touch0=o,e=!0,l.taps=1+!!t);t&&(t=clearTimeout(t)),e&&(l.taps<2&&(t=setTimeout((function(){t=null}),d)),Vp(this),l.start())}}function E(){if(this.__zooming){var e,n,i,o,a=v(this,arguments),s=uu.changedTouches,c=s.length;for(QP(),t&&(t=clearTimeout(t)),a.taps=0,e=0;e<c;++e)i=lh(this,s,(n=s[e]).identifier),a.touch0&&a.touch0[2]===n.identifier?a.touch0[0]=i:a.touch1&&a.touch1[2]===n.identifier&&(a.touch1[0]=i);if(n=a.that.__zoom,a.touch1){var u=a.touch0[0],h=a.touch0[1],d=a.touch1[0],p=a.touch1[1],f=(f=d[0]-u[0])*f+(f=d[1]-u[1])*f,_=(_=p[0]-h[0])*_+(_=p[1]-h[1])*_;n=m(n,Math.sqrt(f/_)),i=[(u[0]+d[0])/2,(u[1]+d[1])/2],o=[(h[0]+p[0])/2,(h[1]+p[1])/2]}else{if(!a.touch0)return;i=a.touch0[0],o=a.touch0[1]}a.zoom("touch",r(g(n,i,o),a.extent,l))}}function T(){if(this.__zooming){var t,n,i=v(this,arguments),r=uu.changedTouches,o=r.length;for(JP(),e&&clearTimeout(e),e=setTimeout((function(){e=null}),d),t=0;t<o;++t)n=r[t],i.touch0&&i.touch0[2]===n.identifier?delete i.touch0:i.touch1&&i.touch1[2]===n.identifier&&delete i.touch1;if(i.touch1&&!i.touch0&&(i.touch0=i.touch1,delete i.touch1),i.touch0)i.touch0[1]=this.__zoom.invert(i.touch0[0]);else if(i.end(),2===i.taps){var a=Su(this).on("dblclick.zoom");a&&a.apply(this,arguments)}}}return f.transform=function(t,e,n){var i=t.selection?t.selection():t;i.property("__zoom",nI),t!==i?y(t,e,n):i.interrupt().each((function(){v(this,arguments).start().zoom(null,"function"==typeof e?e.apply(this,arguments):e).end()}))},f.scaleBy=function(t,e,n){f.scaleTo(t,(function(){var t=this.__zoom.k,n="function"==typeof e?e.apply(this,arguments):e;return t*n}),n)},f.scaleTo=function(t,e,n){f.transform(t,(function(){var t=i.apply(this,arguments),o=this.__zoom,a=null==n?_(t):"function"==typeof n?n.apply(this,arguments):n,s=o.invert(a),c="function"==typeof e?e.apply(this,arguments):e;return r(g(m(o,c),a,s),t,l)}),n)},f.translateBy=function(t,e,n){f.transform(t,(function(){return r(this.__zoom.translate("function"==typeof e?e.apply(this,arguments):e,"function"==typeof n?n.apply(this,arguments):n),i.apply(this,arguments),l)}))},f.translateTo=function(t,e,n,o){f.transform(t,(function(){var t=i.apply(this,arguments),a=this.__zoom,s=null==o?_(t):"function"==typeof o?o.apply(this,arguments):o;return r(KP.translate(s[0],s[1]).scale(a.k).translate("function"==typeof e?-e.apply(this,arguments):-e,"function"==typeof n?-n.apply(this,arguments):-n),t,l)}),o)},b.prototype={start:function(){return 1==++this.active&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(t,e){return this.mouse&&"mouse"!==t&&(this.mouse[1]=e.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=e.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=e.invert(this.touch1[0])),this.that.__zoom=e,this.emit("zoom"),this},end:function(){return 0==--this.active&&(delete this.that.__zooming,this.emit("end")),this},emit:function(t){gu(new XP(f,t,this.that.__zoom),h.apply,h,[t,this.that,this.args])}},f.wheelDelta=function(t){return arguments.length?(o="function"==typeof t?t:YP(+t),f):o},f.filter=function(t){return arguments.length?(n="function"==typeof t?t:YP(!!t),f):n},f.touchable=function(t){return arguments.length?(a="function"==typeof t?t:YP(!!t),f):a},f.extent=function(t){return arguments.length?(i="function"==typeof t?t:YP([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),f):i},f.scaleExtent=function(t){return arguments.length?(s[0]=+t[0],s[1]=+t[1],f):[s[0],s[1]]},f.translateExtent=function(t){return arguments.length?(l[0][0]=+t[0][0],l[1][0]=+t[1][0],l[0][1]=+t[0][1],l[1][1]=+t[1][1],f):[[l[0][0],l[0][1]],[l[1][0],l[1][1]]]},f.constrain=function(t){return arguments.length?(r=t,f):r},f.duration=function(t){return arguments.length?(c=+t,f):c},f.interpolate=function(t){return arguments.length?(u=t,f):u},f.on=function(){var t=h.on.apply(h,arguments);return t===h?f:t},f.clickDistance=function(t){return arguments.length?(p=(t=+t)*t,f):Math.sqrt(p)},f}ZP.prototype=$P.prototype;var sI=Object.freeze({__proto__:null,version:"5.7.0",bisect:Sl,bisectRight:Sl,bisectLeft:Ml,ascending:bl,bisector:xl,cross:Tl,descending:function lI(t,e){return e<t?-1:e>t?1:e>=t?0:NaN},deviation:kl,extent:Ll,histogram:function cI(){var t=Rl,e=Ll,n=Ul;function i(i){var r,o,a=i.length,s=new Array(a);for(r=0;r<a;++r)s[r]=t(i[r],r,i);var l=e(s),c=l[0],u=l[1],h=n(s,c,u);Array.isArray(h)||(h=jl(c,u,h),h=zl(Math.ceil(c/h)*h,u,h));for(var d=h.length;h[0]<=c;)h.shift(),--d;for(;h[d-1]>u;)h.pop(),--d;var p,f=new Array(d+1);for(r=0;r<=d;++r)(p=f[r]=[]).x0=r>0?h[r-1]:c,p.x1=r<d?h[r]:u;for(r=0;r<a;++r)c<=(o=s[r])&&o<=u&&f[Sl(h,o,0,d)].push(i[r]);return f}return i.value=function(e){return arguments.length?(t="function"==typeof e?e:Ol(e),i):t},i.domain=function(t){return arguments.length?(e="function"==typeof t?t:Ol([t[0],t[1]]),i):e},i.thresholds=function(t){return arguments.length?(n="function"==typeof t?t:Array.isArray(t)?Ol(Il.call(t)):Ol(t),i):n},i},thresholdFreedmanDiaconis:function uI(t,e,n){return t=Nl.call(t,Al).sort(bl),Math.ceil((n-e)/(2*(Gl(t,.75)-Gl(t,.25))*Math.pow(t.length,-1/3)))},thresholdScott:function hI(t,e,n){return Math.ceil((n-e)/(3.5*kl(t)*Math.pow(t.length,-1/3)))},thresholdSturges:Ul,max:Wl,mean:function dI(t,e){var n,i=t.length,r=i,o=-1,a=0;if(null==e)for(;++o<i;)isNaN(n=Al(t[o]))?--r:a+=n;else for(;++o<i;)isNaN(n=Al(e(t[o],o,t)))?--r:a+=n;if(r)return a/r},median:function pI(t,e){var n,i=t.length,r=-1,o=[];if(null==e)for(;++r<i;)isNaN(n=Al(t[r]))||o.push(n);else for(;++r<i;)isNaN(n=Al(e(t[r],r,t)))||o.push(n);return Gl(o.sort(bl),.5)},merge:ql,min:Yl,pairs:function fI(t,e){null==e&&(e=El);for(var n=0,i=t.length-1,r=t[0],o=new Array(i<0?0:i);n<i;)o[n]=e(r,r=t[++n]);return o},permute:function mI(t,e){for(var n=e.length,i=new Array(n);n--;)i[n]=t[e[n]];return i},quantile:Gl,range:zl,scan:function gI(t,e){if(n=t.length){var n,i,r=0,o=0,a=t[o];for(null==e&&(e=bl);++r<n;)(e(i=t[r],a)<0||0!==e(a,a))&&(a=i,o=r);return 0===e(a,a)?o:void 0}},shuffle:function _I(t,e,n){for(var i,r,o=(null==n?t.length:n)-(e=null==e?0:+e);o;)r=Math.random()*o--|0,i=t[o+e],t[o+e]=t[r+e],t[r+e]=i;return t},sum:function yI(t,e){var n,i=t.length,r=-1,o=0;if(null==e)for(;++r<i;)(n=+t[r])&&(o+=n);else for(;++r<i;)(n=+e(t[r],r,t))&&(o+=n);return o},ticks:Fl,tickIncrement:Vl,tickStep:jl,transpose:Xl,variance:Cl,zip:function vI(){return Xl(arguments)},axisTop:function bI(t){return rc(1,t)},axisRight:function xI(t){return rc(2,t)},axisBottom:oc,axisLeft:ac,brush:Zm,brushX:function wI(){return Jm(Rm)},brushY:Km,brushSelection:$m,chord:function SI(){var t=0,e=null,n=null,i=null;function r(r){var o,a,s,l,c,u,h=r.length,d=[],p=zl(h),f=[],m=[],g=m.groups=new Array(h),_=new Array(h*h);for(o=0,c=-1;++c<h;){for(a=0,u=-1;++u<h;)a+=r[c][u];d.push(a),f.push(zl(h)),o+=a}for(e&&p.sort((function(t,n){return e(d[t],d[n])})),n&&f.forEach((function(t,e){t.sort((function(t,i){return n(r[e][t],r[e][i])}))})),l=(o=rg(0,ig-t*h)/o)?t:ig/h,a=0,c=-1;++c<h;){for(s=a,u=-1;++u<h;){var y=p[c],v=f[y][u],b=r[y][v],x=a,w=a+=b*o;_[v*h+y]={index:y,subindex:v,startAngle:x,endAngle:w,value:b}}g[y]={index:y,startAngle:s,endAngle:a,value:d[y]},a+=l}for(c=-1;++c<h;)for(u=c-1;++u<h;){var S=_[u*h+c],M=_[c*h+u];(S.value||M.value)&&m.push(S.value<M.value?{source:M,target:S}:{source:S,target:M})}return i?m.sort(i):m}return r.padAngle=function(e){return arguments.length?(t=rg(0,e),r):t},r.sortGroups=function(t){return arguments.length?(e=t,r):e},r.sortSubgroups=function(t){return arguments.length?(n=t,r):n},r.sortChords=function(t){return arguments.length?(null==t?i=null:(i=og(t))._=t,r):i&&i._},r},ribbon:function MI(){var t=fg,e=mg,n=gg,i=_g,r=yg,o=null;function a(){var a,s=ag.call(arguments),l=t.apply(this,s),c=e.apply(this,s),u=+n.apply(this,(s[0]=l,s)),h=i.apply(this,s)-ng,d=r.apply(this,s)-ng,p=u*Qm(h),f=u*tg(h),m=+n.apply(this,(s[0]=c,s)),g=i.apply(this,s)-ng,_=r.apply(this,s)-ng;if(o||(o=a=pg()),o.moveTo(p,f),o.arc(0,0,u,h,d),h===g&&d===_||(o.quadraticCurveTo(0,0,m*Qm(g),m*tg(g)),o.arc(0,0,m,g,_)),o.quadraticCurveTo(0,0,p,f),o.closePath(),a)return o=null,a+""||null}return a.radius=function(t){return arguments.length?(n="function"==typeof t?t:sg(+t),a):n},a.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:sg(+t),a):i},a.endAngle=function(t){return arguments.length?(r="function"==typeof t?t:sg(+t),a):r},a.source=function(e){return arguments.length?(t=e,a):t},a.target=function(t){return arguments.length?(e=t,a):e},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a},nest:function EI(){var t,e,n,i=[],r=[];function o(n,r,a,s){if(r>=i.length)return null!=t&&n.sort(t),null!=e?e(n):n;for(var l,c,u,h=-1,d=n.length,p=i[r++],f=xg(),m=a();++h<d;)(u=f.get(l=p(c=n[h])+""))?u.push(c):f.set(l,[c]);return f.each((function(t,e){s(m,e,o(t,r,a,s))})),m}function a(t,n){if(++n>i.length)return t;var o,s=r[n-1];return null!=e&&n>=i.length?o=t.entries():(o=[],t.each((function(t,e){o.push({key:e,values:a(t,n)})}))),null!=s?o.sort((function(t,e){return s(t.key,e.key)})):o}return n={object:function(t){return o(t,0,wg,Sg)},map:function(t){return o(t,0,Mg,Eg)},entries:function(t){return a(o(t,0,Mg,Eg),0)},key:function(t){return i.push(t),n},sortKeys:function(t){return r[i.length-1]=t,n},sortValues:function(e){return t=e,n},rollup:function(t){return e=t,n}}},set:Cg,map:xg,keys:kg,values:function TI(t){var e=[];for(var n in t)e.push(t[n]);return e},entries:function AI(t){var e=[];for(var n in t)e.push({key:n,value:t[n]});return e},color:Bh,rgb:jh,hsl:$h,lab:sd,hcl:fd,lch:function CI(t,e,n,i){return 1===arguments.length?pd(t):new md(n,e,t,null==i?1:i)},gray:function kI(t,e){return new ld(t,0,0,null==e?1:e)},cubehelix:xd,contours:Bg,contourDensity:function LI(){var t=Vg,e=jg,n=Ug,i=960,r=500,o=20,a=2,s=3*o,l=i+2*s>>a,c=r+2*s>>a,u=Ig(20);function h(i){var r=new Float32Array(l*c),h=new Float32Array(l*c);i.forEach((function(i,o,u){var h=+t(i,o,u)+s>>a,d=+e(i,o,u)+s>>a,p=+n(i,o,u);h>=0&&h<l&&d>=0&&d<c&&(r[h+d*l]+=p)})),Hg({width:l,height:c,data:r},{width:l,height:c,data:h},o>>a),Fg({width:l,height:c,data:h},{width:l,height:c,data:r},o>>a),Hg({width:l,height:c,data:r},{width:l,height:c,data:h},o>>a),Fg({width:l,height:c,data:h},{width:l,height:c,data:r},o>>a),Hg({width:l,height:c,data:r},{width:l,height:c,data:h},o>>a),Fg({width:l,height:c,data:h},{width:l,height:c,data:r},o>>a);var p=u(r);if(!Array.isArray(p)){var f=Wl(r);p=jl(0,f,p),(p=zl(0,Math.floor(f/p)*p,p)).shift()}return Bg().thresholds(p).size([l,c])(r).map(d)}function d(t){return t.value*=Math.pow(2,-2*a),t.coordinates.forEach(p),t}function p(t){t.forEach(f)}function f(t){t.forEach(m)}function m(t){t[0]=t[0]*Math.pow(2,a)-s,t[1]=t[1]*Math.pow(2,a)-s}function g(){return l=i+2*(s=3*o)>>a,c=r+2*s>>a,h}return h.x=function(e){return arguments.length?(t="function"==typeof e?e:Ig(+e),h):t},h.y=function(t){return arguments.length?(e="function"==typeof t?t:Ig(+t),h):e},h.weight=function(t){return arguments.length?(n="function"==typeof t?t:Ig(+t),h):n},h.size=function(t){if(!arguments.length)return[i,r];var e=Math.ceil(t[0]),n=Math.ceil(t[1]);if(!(e>=0||e>=0))throw new Error("invalid size");return i=e,r=n,g()},h.cellSize=function(t){if(!arguments.length)return 1<<a;if(!((t=+t)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),g()},h.thresholds=function(t){return arguments.length?(u="function"==typeof t?t:Array.isArray(t)?Ig(Lg.call(t)):Ig(t),h):u},h.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*t*t+1)-1)/2),g()},h},dispatch:lc,drag:vh,dragDisable:hh,dragEnable:dh,dsvFormat:$g,csvParse:Zg,csvParseRows:Jg,csvFormat:Qg,csvFormatBody:t_,csvFormatRows:e_,csvFormatRow:n_,csvFormatValue:i_,tsvParse:o_,tsvParseRows:a_,tsvFormat:s_,tsvFormatBody:l_,tsvFormatRows:c_,tsvFormatRow:u_,tsvFormatValue:h_,autoType:function PI(t){for(var e in t){var n,i,r=t[e].trim();if(r)if("true"===r)r=!0;else if("false"===r)r=!1;else if("NaN"===r)r=NaN;else if(isNaN(n=+r)){if(!(i=r.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/)))continue;d_&&i[4]&&!i[7]&&(r=r.replace(/-/g,"/").replace(/T/," ")),r=new Date(r)}else r=n;else r=null;t[e]=r}return t},easeLinear:bf,easeQuad:Sf,easeQuadIn:xf,easeQuadOut:wf,easeQuadInOut:Sf,easeCubic:Tf,easeCubicIn:Mf,easeCubicOut:Ef,easeCubicInOut:Tf,easePoly:Xf,easePolyIn:qf,easePolyOut:Yf,easePolyInOut:Xf,easeSin:Qf,easeSinIn:Zf,easeSinOut:Jf,easeSinInOut:Qf,easeExp:nm,easeExpIn:tm,easeExpOut:em,easeExpInOut:nm,easeCircle:om,easeCircleIn:im,easeCircleOut:rm,easeCircleInOut:om,easeBounce:lm,easeBounceIn:sm,easeBounceOut:lm,easeBounceInOut:cm,easeBack:pm,easeBackIn:hm,easeBackOut:dm,easeBackInOut:pm,easeElastic:gm,easeElasticIn:mm,easeElasticOut:gm,easeElasticInOut:_m,blob:function II(t,e){return fetch(t,e).then(p_)},buffer:function NI(t,e){return fetch(t,e).then(f_)},dsv:function OI(t,e,n,i){3===arguments.length&&"function"==typeof n&&(i=n,n=void 0);var r=$g(t);return g_(e,n).then((function(t){return r.parse(t,i)}))},csv:y_,tsv:v_,image:function RI(t,e){return new Promise((function(n,i){var r=new Image;for(var o in e)r[o]=e[o];r.onerror=i,r.onload=function(){n(r)},r.src=t}))},json:function zI(t,e){return fetch(t,e).then(b_)},text:g_,xml:w_,html:S_,svg:M_,forceCenter:function DI(t,e){var n;function i(){var i,r,o=n.length,a=0,s=0;for(i=0;i<o;++i)a+=(r=n[i]).x,s+=r.y;for(a=a/o-t,s=s/o-e,i=0;i<o;++i)(r=n[i]).x-=a,r.y-=s}return null==t&&(t=0),null==e&&(e=0),i.initialize=function(t){n=t},i.x=function(e){return arguments.length?(t=+e,i):t},i.y=function(t){return arguments.length?(e=+t,i):e},i},forceCollide:function BI(t){var e,n,i=1,r=1;function o(){for(var t,o,s,l,c,u,h,d=e.length,p=0;p<r;++p)for(o=P_(e,R_,z_).visitAfter(a),t=0;t<d;++t)h=(u=n[(s=e[t]).index])*u,l=s.x+s.vx,c=s.y+s.vy,o.visit(f);function f(t,e,n,r,o){var a=t.data,d=t.r,p=u+d;if(!a)return e>l+p||r<l-p||n>c+p||o<c-p;if(a.index>s.index){var f=l-a.x-a.vx,m=c-a.y-a.vy,g=f*f+m*m;g<p*p&&(0===f&&(g+=(f=T_())*f),0===m&&(g+=(m=T_())*m),g=(p-(g=Math.sqrt(g)))/g*i,s.vx+=(f*=g)*(p=(d*=d)/(h+d)),s.vy+=(m*=g)*p,a.vx-=f*(p=1-p),a.vy-=m*p)}}}function a(t){if(t.data)return t.r=n[t.data.index];for(var e=t.r=0;e<4;++e)t[e]&&t[e].r>t.r&&(t.r=t[e].r)}function s(){if(e){var i,r,o=e.length;for(n=new Array(o),i=0;i<o;++i)n[(r=e[i]).index]=+t(r,i,e)}}return"function"!=typeof t&&(t=E_(null==t?1:+t)),o.initialize=function(t){e=t,s()},o.iterations=function(t){return arguments.length?(r=+t,o):r},o.strength=function(t){return arguments.length?(i=+t,o):i},o.radius=function(e){return arguments.length?(t="function"==typeof e?e:E_(+e),s(),o):t},o},forceLink:function HI(t){var e,n,i,r,o,a=D_,s=function l(t){return 1/Math.min(r[t.source.index],r[t.target.index])},c=E_(30),u=1;function h(i){for(var r=0,a=t.length;r<u;++r)for(var s,l,c,h,d,p,f,m=0;m<a;++m)h=(c=(s=t[m]).target).x+c.vx-(l=s.source).x-l.vx||T_(),d=c.y+c.vy-l.y-l.vy||T_(),d*=p=((p=Math.sqrt(h*h+d*d))-n[m])/p*i*e[m],c.vx-=(h*=p)*(f=o[m]),c.vy-=d*f,l.vx+=h*(f=1-f),l.vy+=d*f}function d(){if(i){var s,l,c=i.length,u=t.length,h=xg(i,a);for(s=0,r=new Array(c);s<u;++s)(l=t[s]).index=s,"object"!=typeof l.source&&(l.source=B_(h,l.source)),"object"!=typeof l.target&&(l.target=B_(h,l.target)),r[l.source.index]=(r[l.source.index]||0)+1,r[l.target.index]=(r[l.target.index]||0)+1;for(s=0,o=new Array(u);s<u;++s)o[s]=r[(l=t[s]).source.index]/(r[l.source.index]+r[l.target.index]);e=new Array(u),p(),n=new Array(u),f()}}function p(){if(i)for(var n=0,r=t.length;n<r;++n)e[n]=+s(t[n],n,t)}function f(){if(i)for(var e=0,r=t.length;e<r;++e)n[e]=+c(t[e],e,t)}return null==t&&(t=[]),h.initialize=function(t){i=t,d()},h.links=function(e){return arguments.length?(t=e,d(),h):t},h.id=function(t){return arguments.length?(a=t,h):a},h.iterations=function(t){return arguments.length?(u=+t,h):u},h.strength=function(t){return arguments.length?(s="function"==typeof t?t:E_(+t),p(),h):s},h.distance=function(t){return arguments.length?(c="function"==typeof t?t:E_(+t),f(),h):c},h},forceManyBody:function FI(){var t,e,n,i,r=E_(-30),o=1,a=1/0,s=.81;function l(i){var r,o=t.length,a=P_(t,H_,F_).visitAfter(u);for(n=i,r=0;r<o;++r)e=t[r],a.visit(h)}function c(){if(t){var e,n,o=t.length;for(i=new Array(o),e=0;e<o;++e)i[(n=t[e]).index]=+r(n,e,t)}}function u(t){var e,n,r,o,a,s=0,l=0;if(t.length){for(r=o=a=0;a<4;++a)(e=t[a])&&(n=Math.abs(e.value))&&(s+=e.value,l+=n,r+=n*e.x,o+=n*e.y);t.x=r/l,t.y=o/l}else{(e=t).x=e.data.x,e.y=e.data.y;do{s+=i[e.data.index]}while(e=e.next)}t.value=s}function h(t,r,l,c){if(!t.value)return!0;var u=t.x-e.x,h=t.y-e.y,d=c-r,p=u*u+h*h;if(d*d/s<p)return p<a&&(0===u&&(p+=(u=T_())*u),0===h&&(p+=(h=T_())*h),p<o&&(p=Math.sqrt(o*p)),e.vx+=u*t.value*n/p,e.vy+=h*t.value*n/p),!0;if(!(t.length||p>=a)){(t.data!==e||t.next)&&(0===u&&(p+=(u=T_())*u),0===h&&(p+=(h=T_())*h),p<o&&(p=Math.sqrt(o*p)));do{t.data!==e&&(e.vx+=u*(d=i[t.data.index]*n/p),e.vy+=h*d)}while(t=t.next)}}return l.initialize=function(e){t=e,c()},l.strength=function(t){return arguments.length?(r="function"==typeof t?t:E_(+t),c(),l):r},l.distanceMin=function(t){return arguments.length?(o=t*t,l):Math.sqrt(o)},l.distanceMax=function(t){return arguments.length?(a=t*t,l):Math.sqrt(a)},l.theta=function(t){return arguments.length?(s=t*t,l):Math.sqrt(s)},l},forceRadial:function VI(t,e,n){var i,r,o,a=E_(.1);function s(t){for(var a=0,s=i.length;a<s;++a){var l=i[a],c=l.x-e||1e-6,u=l.y-n||1e-6,h=Math.sqrt(c*c+u*u),d=(o[a]-h)*r[a]*t/h;l.vx+=c*d,l.vy+=u*d}}function l(){if(i){var e,n=i.length;for(r=new Array(n),o=new Array(n),e=0;e<n;++e)o[e]=+t(i[e],e,i),r[e]=isNaN(o[e])?0:+a(i[e],e,i)}}return"function"!=typeof t&&(t=E_(+t)),null==e&&(e=0),null==n&&(n=0),s.initialize=function(t){i=t,l()},s.strength=function(t){return arguments.length?(a="function"==typeof t?t:E_(+t),l(),s):a},s.radius=function(e){return arguments.length?(t="function"==typeof e?e:E_(+e),l(),s):t},s.x=function(t){return arguments.length?(e=+t,s):e},s.y=function(t){return arguments.length?(n=+t,s):n},s},forceSimulation:function jI(t){var e,n=1,i=.001,r=1-Math.pow(i,1/300),o=0,a=.6,s=xg(),l=kp(u),c=lc("tick","end");function u(){h(),c.call("tick",e),n<i&&(l.stop(),c.call("end",e))}function h(i){var l,c,u=t.length;void 0===i&&(i=1);for(var h=0;h<i;++h)for(n+=(o-n)*r,s.each((function(t){t(n)})),l=0;l<u;++l)null==(c=t[l]).fx?c.x+=c.vx*=a:(c.x=c.fx,c.vx=0),null==c.fy?c.y+=c.vy*=a:(c.y=c.fy,c.vy=0);return e}function d(){for(var e,n=0,i=t.length;n<i;++n){if((e=t[n]).index=n,null!=e.fx&&(e.x=e.fx),null!=e.fy&&(e.y=e.fy),isNaN(e.x)||isNaN(e.y)){var r=10*Math.sqrt(n),o=n*ey;e.x=r*Math.cos(o),e.y=r*Math.sin(o)}(isNaN(e.vx)||isNaN(e.vy))&&(e.vx=e.vy=0)}}function p(e){return e.initialize&&e.initialize(t),e}return null==t&&(t=[]),d(),e={tick:h,restart:function(){return l.restart(u),e},stop:function(){return l.stop(),e},nodes:function(n){return arguments.length?(t=n,d(),s.each(p),e):t},alpha:function(t){return arguments.length?(n=+t,e):n},alphaMin:function(t){return arguments.length?(i=+t,e):i},alphaDecay:function(t){return arguments.length?(r=+t,e):+r},alphaTarget:function(t){return arguments.length?(o=+t,e):o},velocityDecay:function(t){return arguments.length?(a=1-t,e):1-a},force:function(t,n){return arguments.length>1?(null==n?s.remove(t):s.set(t,p(n)),e):s.get(t)},find:function(e,n,i){var r,o,a,s,l,c=0,u=t.length;for(null==i?i=1/0:i*=i,c=0;c<u;++c)(a=(r=e-(s=t[c]).x)*r+(o=n-s.y)*o)<i&&(l=s,i=a);return l},on:function(t,n){return arguments.length>1?(c.on(t,n),e):c.on(t)}}},forceX:function UI(t){var e,n,i,r=E_(.1);function o(t){for(var r,o=0,a=e.length;o<a;++o)(r=e[o]).vx+=(i[o]-r.x)*n[o]*t}function a(){if(e){var o,a=e.length;for(n=new Array(a),i=new Array(a),o=0;o<a;++o)n[o]=isNaN(i[o]=+t(e[o],o,e))?0:+r(e[o],o,e)}}return"function"!=typeof t&&(t=E_(null==t?0:+t)),o.initialize=function(t){e=t,a()},o.strength=function(t){return arguments.length?(r="function"==typeof t?t:E_(+t),a(),o):r},o.x=function(e){return arguments.length?(t="function"==typeof e?e:E_(+e),a(),o):t},o},forceY:function GI(t){var e,n,i,r=E_(.1);function o(t){for(var r,o=0,a=e.length;o<a;++o)(r=e[o]).vy+=(i[o]-r.y)*n[o]*t}function a(){if(e){var o,a=e.length;for(n=new Array(a),i=new Array(a),o=0;o<a;++o)n[o]=isNaN(i[o]=+t(e[o],o,e))?0:+r(e[o],o,e)}}return"function"!=typeof t&&(t=E_(null==t?0:+t)),o.initialize=function(t){e=t,a()},o.strength=function(t){return arguments.length?(r="function"==typeof t?t:E_(+t),a(),o):r},o.y=function(e){return arguments.length?(t="function"==typeof e?e:E_(+e),a(),o):t},o},formatDefaultLocale:yy,get format(){return py},get formatPrefix(){return fy},formatLocale:_y,formatSpecifier:ay,FormatSpecifier:sy,precisionFixed:vy,precisionPrefix:by,precisionRound:xy,geoArea:function WI(t){return lv.reset(),ev(t,cv),2*lv},geoBounds:function qI(t){var e,n,i,r,o,a,s;if(Mv=Sv=-(xv=wv=1/0),kv=[],ev(t,Xv),n=kv.length){for(kv.sort(ib),e=1,o=[i=kv[0]];e<n;++e)rb(i,(r=kv[e])[0])||rb(i,r[1])?(nb(i[0],r[1])>nb(i[0],i[1])&&(i[1]=r[1]),nb(r[0],i[1])>nb(i[0],i[1])&&(i[0]=r[0])):o.push(i=r);for(a=-1/0,e=0,i=o[n=o.length-1];e<=n;i=r,++e)(s=nb(i[1],(r=o[e])[0]))>a&&(a=s,xv=r[0],Sv=i[1])}return kv=Lv=null,xv===1/0||wv===1/0?[[NaN,NaN],[NaN,NaN]]:[[xv,wv],[Sv,Mv]]},geoCentroid:function YI(t){Pv=Iv=Nv=Ov=Rv=zv=Dv=Bv=Hv=Fv=Vv=0,ev(t,ob);var e=Hv,n=Fv,i=Vv,r=e*e+n*n+i*i;return r<Ay&&(e=zv,n=Dv,i=Bv,Iv<Ty&&(e=Nv,n=Ov,i=Rv),(r=e*e+n*n+i*i)<Ay)?[NaN,NaN]:[zy(n,e)*Iy,Yy(i/Gy(r))*Iy]},geoCircle:function XI(){var t,e,n=gb([0,0]),i=gb(90),r=gb(6),o={point:function a(n,i){t.push(n=e(n,i)),n[0]*=Iy,n[1]*=Iy}};function s(){var a=n.apply(this,arguments),s=i.apply(this,arguments)*Ny,l=r.apply(this,arguments)*Ny;return t=[],e=vb(-a[0]*Ny,-a[1]*Ny,0).invert,Mb(o,s,l,1),a={type:"Polygon",coordinates:[t]},t=e=null,a}return s.center=function(t){return arguments.length?(n="function"==typeof t?t:gb([+t[0],+t[1]]),s):n},s.radius=function(t){return arguments.length?(i="function"==typeof t?t:gb(+t),s):i},s.precision=function(t){return arguments.length?(r="function"==typeof t?t:gb(+t),s):r},s},geoClipAntimeridian:Db,geoClipCircle:Fb,geoClipExtent:function $I(){var t,e,n,i=0,r=0,o=960,a=500;return n={stream:function(n){return t&&e===n?t:t=Ub(i,r,o,a)(e=n)},extent:function(s){return arguments.length?(i=+s[0][0],r=+s[0][1],o=+s[1][0],a=+s[1][1],t=e=null,n):[[i,r],[o,a]]}}},geoClipRectangle:Ub,geoContains:function KI(t,e){return(t&&ix.hasOwnProperty(t.type)?ix[t.type]:ox)(t,e)},geoDistance:nx,geoGraticule:px,geoGraticule10:function ZI(){return px()()},geoInterpolate:function JI(t,e){var n=t[0]*Ny,i=t[1]*Ny,r=e[0]*Ny,o=e[1]*Ny,a=Dy(i),s=jy(i),l=Dy(o),c=jy(o),u=a*Dy(n),h=a*jy(n),d=l*Dy(r),p=l*jy(r),f=2*Yy(Gy(Xy(o-i)+a*l*Xy(r-n))),m=jy(f),g=f?function(t){var e=jy(t*=f)/m,n=jy(f-t)/m,i=n*u+e*d,r=n*h+e*p,o=n*s+e*c;return[zy(r,i)*Iy,zy(o,Gy(i*i+r*r))*Iy]}:function(){return[n*Iy,i*Iy]};return g.distance=f,g},geoLength:Qb,geoPath:function QI(t,e){var n,i,r=4.5;function o(t){return t&&("function"==typeof r&&i.pointRadius(+r.apply(this,arguments)),ev(t,n(i))),i.result()}return o.area=function(t){return ev(t,n(xx)),xx.result()},o.measure=function(t){return ev(t,n(lw)),lw.result()},o.bounds=function(t){return ev(t,n(Ox)),Ox.result()},o.centroid=function(t){return ev(t,n(Wx)),Wx.result()},o.projection=function(e){return arguments.length?(n=null==e?(t=null,fx):(t=e).stream,o):t},o.context=function(t){return arguments.length?(i=null==t?(e=null,new hw):new ew(e=t),"function"!=typeof r&&i.pointRadius(r),o):e},o.pointRadius=function(t){return arguments.length?(r="function"==typeof t?t:(i.pointRadius(+t),+t),o):r},o.projection(t).context(e)},geoAlbers:Lw,geoAlbersUsa:function tN(){var t,e,n,i,r,o,a=Lw(),s=kw().rotate([154,0]).center([-2,58.5]).parallels([55,65]),l=kw().rotate([157,0]).center([-3,19.9]).parallels([8,18]),c={point:function(t,e){o=[t,e]}};function u(t){var e=t[0],a=t[1];return o=null,n.point(e,a),o||(i.point(e,a),o)||(r.point(e,a),o)}function h(){return t=e=null,u}return u.invert=function(t){var e=a.scale(),n=a.translate(),i=(t[0]-n[0])/e,r=(t[1]-n[1])/e;return(r>=.12&&r<.234&&i>=-.425&&i<-.214?s:r>=.166&&r<.234&&i>=-.214&&i<-.115?l:a).invert(t)},u.stream=function(n){return t&&e===n?t:t=(function i(t){var e=t.length;return{point:function(n,i){for(var r=-1;++r<e;)t[r].point(n,i)},sphere:function(){for(var n=-1;++n<e;)t[n].sphere()},lineStart:function(){for(var n=-1;++n<e;)t[n].lineStart()},lineEnd:function(){for(var n=-1;++n<e;)t[n].lineEnd()},polygonStart:function(){for(var n=-1;++n<e;)t[n].polygonStart()},polygonEnd:function(){for(var n=-1;++n<e;)t[n].polygonEnd()}}})([a.stream(e=n),s.stream(n),l.stream(n)])},u.precision=function(t){return arguments.length?(a.precision(t),s.precision(t),l.precision(t),h()):a.precision()},u.scale=function(t){return arguments.length?(a.scale(t),s.scale(.35*t),l.scale(t),u.translate(a.translate())):a.scale()},u.translate=function(t){if(!arguments.length)return a.translate();var e=a.scale(),o=+t[0],u=+t[1];return n=a.translate(t).clipExtent([[o-.455*e,u-.238*e],[o+.455*e,u+.238*e]]).stream(c),i=s.translate([o-.307*e,u+.201*e]).clipExtent([[o-.425*e+Ty,u+.12*e+Ty],[o-.214*e-Ty,u+.234*e-Ty]]).stream(c),r=l.translate([o-.205*e,u+.212*e]).clipExtent([[o-.214*e+Ty,u+.166*e+Ty],[o-.115*e-Ty,u+.234*e-Ty]]).stream(c),h()},u.fitExtent=function(t,e){return gw(u,t,e)},u.fitSize=function(t,e){return _w(u,t,e)},u.fitWidth=function(t,e){return yw(u,t,e)},u.fitHeight=function(t,e){return vw(u,t,e)},u.scale(1070)},geoAzimuthalEqualArea:function eN(){return Ew(Nw).scale(124.75).clipAngle(179.999)},geoAzimuthalEqualAreaRaw:Nw,geoAzimuthalEquidistant:function nN(){return Ew(Ow).scale(79.4188).clipAngle(179.999)},geoAzimuthalEquidistantRaw:Ow,geoConicConformal:function iN(){return Aw(Bw).scale(109.5).parallels([30,30])},geoConicConformalRaw:Bw,geoConicEqualArea:kw,geoConicEqualAreaRaw:Cw,geoConicEquidistant:function rN(){return Aw(Fw).scale(131.154).center([0,13.9389])},geoConicEquidistantRaw:Fw,geoEqualEarth:function oN(){return Ew(qw).scale(177.158)},geoEqualEarthRaw:qw,geoEquirectangular:function aN(){return Ew(Hw).scale(152.63)},geoEquirectangularRaw:Hw,geoGnomonic:function sN(){return Ew(Yw).scale(144.049).clipAngle(60)},geoGnomonicRaw:Yw,geoIdentity:function lN(){var t,e,n,i,r,o,a,s=1,l=0,c=0,u=1,h=1,d=0,p=null,f=1,m=1,g=pw({point:function(t,e){var n=v([t,e]);this.stream.point(n[0],n[1])}}),_=fx;function y(){return f=s*u,m=s*h,o=a=null,v}function v(n){var i=n[0]*f,r=n[1]*m;if(d){var o=r*t-i*e;i=i*t+r*e,r=o}return[i+l,r+c]}return v.invert=function(n){var i=n[0]-l,r=n[1]-c;if(d){var o=r*t+i*e;i=i*t-r*e,r=o}return[i/f,r/m]},v.stream=function(t){return o&&a===t?o:o=g(_(a=t))},v.postclip=function(t){return arguments.length?(_=t,p=n=i=r=null,y()):_},v.clipExtent=function(t){return arguments.length?(_=null==t?(p=n=i=r=null,fx):Ub(p=+t[0][0],n=+t[0][1],i=+t[1][0],r=+t[1][1]),y()):null==p?null:[[p,n],[i,r]]},v.scale=function(t){return arguments.length?(s=+t,y()):s},v.translate=function(t){return arguments.length?(l=+t[0],c=+t[1],y()):[l,c]},v.angle=function(n){return arguments.length?(e=jy(d=n%360*Ny),t=Dy(d),y()):d*Iy},v.reflectX=function(t){return arguments.length?(u=t?-1:1,y()):u<0},v.reflectY=function(t){return arguments.length?(h=t?-1:1,y()):h<0},v.fitExtent=function(t,e){return gw(v,t,e)},v.fitSize=function(t,e){return _w(v,t,e)},v.fitWidth=function(t,e){return yw(v,t,e)},v.fitHeight=function(t,e){return vw(v,t,e)},v},geoProjection:Ew,geoProjectionMutator:Tw,geoMercator:function cN(){return zw(Rw).scale(961/Py)},geoMercatorRaw:Rw,geoNaturalEarth1:function uN(){return Ew(Xw).scale(175.295)},geoNaturalEarth1Raw:Xw,geoOrthographic:function hN(){return Ew($w).scale(249.5).clipAngle(90.000001)},geoOrthographicRaw:$w,geoStereographic:function dN(){return Ew(Kw).scale(250).clipAngle(142)},geoStereographicRaw:Kw,geoTransverseMercator:function pN(){var t=zw(Zw),e=t.center,n=t.rotate;return t.center=function(t){return arguments.length?e([-t[1],t[0]]):[(t=e())[1],-t[0]]},t.rotate=function(t){return arguments.length?n([t[0],t[1],t.length>2?t[2]+90:90]):[(t=n())[0],t[1],t[2]-90]},n([0,0,90]).scale(159.155)},geoTransverseMercatorRaw:Zw,geoRotation:Sb,geoStream:ev,geoTransform:function fN(t){return{stream:pw(t)}},cluster:function mN(){var t=Jw,e=1,n=1,i=!1;function r(r){var o,a=0;r.eachAfter((function(e){var n=e.children;n?(e.x=(function i(t){return t.reduce(Qw,0)/t.length})(n),e.y=(function r(t){return 1+t.reduce(tS,0)})(n)):(e.x=o?a+=t(e,o):0,e.y=0,o=e)}));var s=(function l(t){for(var e;e=t.children;)t=e[0];return t})(r),c=(function u(t){for(var e;e=t.children;)t=e[e.length-1];return t})(r),h=s.x-t(s,c)/2,d=c.x+t(c,s)/2;return r.eachAfter(i?function(t){t.x=(t.x-r.x)*e,t.y=(r.y-t.y)*n}:function(t){t.x=(t.x-h)/(d-h)*e,t.y=(1-(r.y?t.y/r.y:1))*n})}return r.separation=function(e){return arguments.length?(t=e,r):t},r.size=function(t){return arguments.length?(i=!1,e=+t[0],n=+t[1],r):i?null:[e,n]},r.nodeSize=function(t){return arguments.length?(i=!0,e=+t[0],n=+t[1],r):i?[e,n]:null},r},hierarchy:nS,pack:function gN(){var t=null,e=1,n=1,i=RS;function r(r){return r.x=e/2,r.y=n/2,t?r.eachBefore(BS(t)).eachAfter(HS(i,.5)).eachBefore(FS(1)):r.eachBefore(BS(DS)).eachAfter(HS(RS,1)).eachAfter(HS(i,r.r/Math.min(e,n))).eachBefore(FS(Math.min(e,n)/(2*r.r))),r}return r.radius=function(e){return arguments.length?(t=NS(e),r):t},r.size=function(t){return arguments.length?(e=+t[0],n=+t[1],r):[e,n]},r.padding=function(t){return arguments.length?(i="function"==typeof t?t:zS(+t),r):i},r},packSiblings:function _N(t){return IS(t),t},packEnclose:bS,partition:function yN(){var t=1,e=1,n=0,i=!1;function r(r){var o=r.height+1;return r.x0=r.y0=n,r.x1=t,r.y1=e/o,r.eachBefore((function a(t,e){return function(i){i.children&&jS(i,i.x0,t*(i.depth+1)/e,i.x1,t*(i.depth+2)/e);var r=i.x0,o=i.y0,a=i.x1-n,s=i.y1-n;a<r&&(r=a=(r+a)/2),s<o&&(o=s=(o+s)/2),i.x0=r,i.y0=o,i.x1=a,i.y1=s}})(e,o)),i&&r.eachBefore(VS),r}return r.round=function(t){return arguments.length?(i=!!t,r):i},r.size=function(n){return arguments.length?(t=+n[0],e=+n[1],r):[t,e]},r.padding=function(t){return arguments.length?(n=+t,r):n},r},stratify:function vN(){var t=WS,e=qS;function n(n){var i,r,o,a,s,l,c,u=n.length,h=new Array(u),d={};for(r=0;r<u;++r)s=h[r]=new aS(i=n[r]),null!=(l=t(i,r,n))&&(l+="")&&(d[c="$"+(s.id=l)]=c in d?GS:s);for(r=0;r<u;++r)if(s=h[r],null!=(l=e(n[r],r,n))&&(l+="")){if(!(a=d["$"+l]))throw new Error("missing: "+l);if(a===GS)throw new Error("ambiguous: "+l);a.children?a.children.push(s):a.children=[s],s.parent=a}else{if(o)throw new Error("multiple roots");o=s}if(!o)throw new Error("no root");if(o.parent=US,o.eachBefore((function(t){t.depth=t.parent.depth+1,--u})).eachBefore(oS),o.parent=null,u>0)throw new Error("cycle");return o}return n.id=function(e){return arguments.length?(t=OS(e),n):t},n.parentId=function(t){return arguments.length?(e=OS(t),n):e},n},tree:function bN(){var t=YS,e=1,n=1,i=null;function r(r){var l=(function c(t){for(var e,n,i,r,o,a=new JS(t,0),s=[a];e=s.pop();)if(i=e._.children)for(e.children=new Array(o=i.length),r=o-1;r>=0;--r)s.push(n=e.children[r]=new JS(i[r],r)),n.parent=e;return(a.parent=new JS(null,0)).children=[a],a})(r);if(l.eachAfter(o),l.parent.m=-l.z,l.eachBefore(a),i)r.eachBefore(s);else{var u=r,h=r,d=r;r.eachBefore((function(t){t.x<u.x&&(u=t),t.x>h.x&&(h=t),t.depth>d.depth&&(d=t)}));var p=u===h?1:t(u,h)/2,f=p-u.x,m=e/(h.x+p+f),g=n/(d.depth||1);r.eachBefore((function(t){t.x=(t.x+f)*m,t.y=t.depth*g}))}return r}function o(e){var n=e.children,i=e.parent.children,r=e.i?i[e.i-1]:null;if(n){!(function o(t){for(var e,n=0,i=0,r=t.children,o=r.length;--o>=0;)(e=r[o]).z+=n,e.m+=n,n+=e.s+(i+=e.c)})(e);var a=(n[0].z+n[n.length-1].z)/2;r?(e.z=r.z+t(e._,r._),e.m=e.z-a):e.z=a}else r&&(e.z=r.z+t(e._,r._));e.parent.A=(function s(e,n,i){if(n){for(var r,o=e,a=e,s=n,l=o.parent.children[0],c=o.m,u=a.m,h=s.m,d=l.m;s=$S(s),o=XS(o),s&&o;)l=XS(l),(a=$S(a)).a=e,(r=s.z+h-o.z-c+t(s._,o._))>0&&(KS(ZS(s,e,i),e,r),c+=r,u+=r),h+=s.m,c+=o.m,d+=l.m,u+=a.m;s&&!$S(a)&&(a.t=s,a.m+=h-u),o&&!XS(l)&&(l.t=o,l.m+=c-d,i=e)}return i})(e,r,e.parent.A||i[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function s(t){t.x*=e,t.y=t.depth*n}return r.separation=function(e){return arguments.length?(t=e,r):t},r.size=function(t){return arguments.length?(i=!1,e=+t[0],n=+t[1],r):i?null:[e,n]},r.nodeSize=function(t){return arguments.length?(i=!0,e=+t[0],n=+t[1],r):i?[e,n]:null},r},treemap:function xN(){var t=nM,e=!1,n=1,i=1,r=[0],o=RS,a=RS,s=RS,l=RS,c=RS;function u(t){return t.x0=t.y0=0,t.x1=n,t.y1=i,t.eachBefore(h),r=[0],e&&t.eachBefore(VS),t}function h(e){var n=r[e.depth],i=e.x0+n,u=e.y0+n,h=e.x1-n,d=e.y1-n;h<i&&(i=h=(i+h)/2),d<u&&(u=d=(u+d)/2),e.x0=i,e.y0=u,e.x1=h,e.y1=d,e.children&&(n=r[e.depth+1]=o(e)/2,i+=c(e)-n,u+=a(e)-n,(h-=s(e)-n)<i&&(i=h=(i+h)/2),(d-=l(e)-n)<u&&(u=d=(u+d)/2),t(e,i,u,h,d))}return u.round=function(t){return arguments.length?(e=!!t,u):e},u.size=function(t){return arguments.length?(n=+t[0],i=+t[1],u):[n,i]},u.tile=function(e){return arguments.length?(t=OS(e),u):t},u.padding=function(t){return arguments.length?u.paddingInner(t).paddingOuter(t):u.paddingInner()},u.paddingInner=function(t){return arguments.length?(o="function"==typeof t?t:zS(+t),u):o},u.paddingOuter=function(t){return arguments.length?u.paddingTop(t).paddingRight(t).paddingBottom(t).paddingLeft(t):u.paddingTop()},u.paddingTop=function(t){return arguments.length?(a="function"==typeof t?t:zS(+t),u):a},u.paddingRight=function(t){return arguments.length?(s="function"==typeof t?t:zS(+t),u):s},u.paddingBottom=function(t){return arguments.length?(l="function"==typeof t?t:zS(+t),u):l},u.paddingLeft=function(t){return arguments.length?(c="function"==typeof t?t:zS(+t),u):c},u},treemapBinary:function wN(t,e,n,i,r){var o,a,s=t.children,l=s.length,c=new Array(l+1);for(c[0]=a=o=0;o<l;++o)c[o+1]=a+=s[o].value;!(function t(e,n,i,r,o,a,l){if(e>=n-1){var u=s[e];return u.x0=r,u.y0=o,u.x1=a,void(u.y1=l)}for(var h=c[e],d=i/2+h,p=e+1,f=n-1;p<f;){var m=p+f>>>1;c[m]<d?p=m+1:f=m}d-c[p-1]<c[p]-d&&e+1<p&&--p;var g=c[p]-h,_=i-g;if(a-r>l-o){var y=(r*_+a*g)/i;t(e,p,g,r,o,y,l),t(p,n,_,y,o,a,l)}else{var v=(o*_+l*g)/i;t(e,p,g,r,o,a,v),t(p,n,_,r,v,a,l)}})(0,l,t.value,e,n,i,r)},treemapDice:jS,treemapSlice:QS,treemapSliceDice:function SN(t,e,n,i,r){(1&t.depth?QS:jS)(t,e,n,i,r)},treemapSquarify:nM,treemapResquarify:iM,interpolate:Ud,interpolateArray:function MN(t,e){return(Rd(e)?Od:zd)(t,e)},interpolateBasis:Md,interpolateBasisClosed:Ed,interpolateDate:Dd,interpolateDiscrete:function EN(t){var e=t.length;return function(n){return t[Math.max(0,Math.min(e-1,Math.floor(n*e)))]}},interpolateHue:function TN(t,e){var n=Cd(+t,+e);return function(t){var e=n(t);return e-360*Math.floor(e/360)}},interpolateNumber:Bd,interpolateNumberArray:Od,interpolateObject:Hd,interpolateRound:Gd,interpolateString:jd,interpolateTransformCss:Qd,interpolateTransformSvg:ep,interpolateZoom:op,interpolateRgb:Ld,interpolateRgbBasis:Id,interpolateRgbBasisClosed:Nd,interpolateHsl:sp,interpolateHslLong:lp,interpolateLab:cp,interpolateHcl:hp,interpolateHclLong:dp,interpolateCubehelix:gp,interpolateCubehelixLong:_p,piecewise:function AN(t,e){for(var n=0,i=e.length-1,r=e[0],o=new Array(i<0?0:i);n<i;)o[n]=t(r,r=e[++n]);return function(t){var e=Math.max(0,Math.min(i-1,Math.floor(t*=i)));return o[e](t-e)}},quantize:function CN(t,e){for(var n=new Array(e),i=0;i<e;++i)n[i]=t(i/(e-1));return n},path:pg,polygonArea:function kN(t){for(var e,n=-1,i=t.length,r=t[i-1],o=0;++n<i;)o+=(e=r)[1]*(r=t[n])[0]-e[0]*r[1];return o/2},polygonCentroid:function LN(t){for(var e,n,i=-1,r=t.length,o=0,a=0,s=t[r-1],l=0;++i<r;)l+=n=(e=s)[0]*(s=t[i])[1]-s[0]*e[1],o+=(e[0]+s[0])*n,a+=(e[1]+s[1])*n;return[o/(l*=3),a/l]},polygonHull:function PN(t){if((n=t.length)<3)return null;var e,n,i=new Array(n),r=new Array(n);for(e=0;e<n;++e)i[e]=[+t[e][0],+t[e][1],e];for(i.sort(oM),e=0;e<n;++e)r[e]=[i[e][0],-i[e][1]];var o=aM(i),a=aM(r),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(e=o.length-1;e>=0;--e)c.push(t[i[o[e]][2]]);for(e=+s;e<a.length-l;++e)c.push(t[i[a[e]][2]]);return c},polygonContains:function IN(t,e){for(var n,i,r=t.length,o=t[r-1],a=e[0],s=e[1],l=o[0],c=o[1],u=!1,h=0;h<r;++h)n=(o=t[h])[0],(i=o[1])>s!=c>s&&a<(l-n)*(s-i)/(c-i)+n&&(u=!u),l=n,c=i;return u},polygonLength:function NN(t){for(var e,n,i=-1,r=t.length,o=t[r-1],a=o[0],s=o[1],l=0;++i<r;)e=a,n=s,e-=a=(o=t[i])[0],n-=s=o[1],l+=Math.sqrt(e*e+n*n);return l},quadtree:P_,randomUniform:lM,randomNormal:cM,randomLogNormal:uM,randomBates:dM,randomIrwinHall:hM,randomExponential:pM,scaleBand:xM,scalePoint:SM,scaleIdentity:function t(e){var n;function i(t){return isNaN(t=+t)?n:t}return i.invert=i,i.domain=i.range=function(t){return arguments.length?(e=_M.call(t,MM),i):e.slice()},i.unknown=function(t){return arguments.length?(n=t,i):n},i.copy=function(){return t(e).unknown(n)},e=arguments.length?_M.call(e,MM):[0,1],RM(i)},scaleLinear:zM,scaleLog:WM,scaleSymlog:function t(){var e=XM(IM());return e.copy=function(){return PM(e,t()).constant(e.constant())},fM.apply(e,arguments)},scaleOrdinal:bM,scaleImplicit:vM,scalePow:QM,scaleSqrt:function ON(){return QM.apply(null,arguments).exponent(.5)},scaleQuantile:tE,scaleQuantize:eE,scaleThreshold:function t(){var e,n=[.5],i=[0,1],r=1;function o(t){return t<=t?i[Sl(n,t,0,r)]:e}return o.domain=function(t){return arguments.length?(n=yM.call(t),r=Math.min(n.length,i.length-1),o):n.slice()},o.range=function(t){return arguments.length?(i=yM.call(t),r=Math.min(n.length,i.length-1),o):i.slice()},o.invertExtent=function(t){var e=i.indexOf(t);return[n[e-1],n[e]]},o.unknown=function(t){return arguments.length?(e=t,o):e},o.copy=function(){return t().domain(n).range(i).unknown(e)},fM.apply(o,arguments)},scaleTime:FA,scaleUtc:function RN(){return fM.apply(HA(lT,aT,qE,UE,VE,HE,dE,oE,_T).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)},scaleSequential:function t(){var e=RM(VA()(TM));return e.copy=function(){return jA(e,t())},mM.apply(e,arguments)},scaleSequentialLog:function t(){var e=GM(VA()).domain([1,10]);return e.copy=function(){return jA(e,t()).base(e.base())},mM.apply(e,arguments)},scaleSequentialPow:UA,scaleSequentialSqrt:function zN(){return UA.apply(null,arguments).exponent(.5)},scaleSequentialSymlog:function t(){var e=XM(VA());return e.copy=function(){return jA(e,t()).constant(e.constant())},mM.apply(e,arguments)},scaleSequentialQuantile:function t(){var e=[],n=TM;function i(t){if(!isNaN(t=+t))return n((Sl(e,t)-1)/(e.length-1))}return i.domain=function(t){if(!arguments.length)return e.slice();e=[];for(var n,r=0,o=t.length;r<o;++r)null==(n=t[r])||isNaN(n=+n)||e.push(n);return e.sort(bl),i},i.interpolator=function(t){return arguments.length?(n=t,i):n},i.copy=function(){return t(n).domain(e)},mM.apply(i,arguments)},scaleDiverging:function t(){var e=RM(GA()(TM));return e.copy=function(){return jA(e,t())},mM.apply(e,arguments)},scaleDivergingLog:function t(){var e=GM(GA()).domain([.1,1,10]);return e.copy=function(){return jA(e,t()).base(e.base())},mM.apply(e,arguments)},scaleDivergingPow:WA,scaleDivergingSqrt:function DN(){return WA.apply(null,arguments).exponent(.5)},scaleDivergingSymlog:function t(){var e=XM(GA());return e.copy=function(){return jA(e,t()).constant(e.constant())},mM.apply(e,arguments)},tickFormat:OM,schemeCategory10:YA,schemeAccent:XA,schemeDark2:$A,schemePaired:KA,schemePastel1:ZA,schemePastel2:JA,schemeSet1:QA,schemeSet2:tC,schemeSet3:eC,schemeTableau10:nC,interpolateBrBG:oC,schemeBrBG:rC,interpolatePRGn:sC,schemePRGn:aC,interpolatePiYG:cC,schemePiYG:lC,interpolatePuOr:hC,schemePuOr:uC,interpolateRdBu:pC,schemeRdBu:dC,interpolateRdGy:mC,schemeRdGy:fC,interpolateRdYlBu:_C,schemeRdYlBu:gC,interpolateRdYlGn:vC,schemeRdYlGn:yC,interpolateSpectral:xC,schemeSpectral:bC,interpolateBuGn:SC,schemeBuGn:wC,interpolateBuPu:EC,schemeBuPu:MC,interpolateGnBu:AC,schemeGnBu:TC,interpolateOrRd:kC,schemeOrRd:CC,interpolatePuBuGn:PC,schemePuBuGn:LC,interpolatePuBu:NC,schemePuBu:IC,interpolatePuRd:RC,schemePuRd:OC,interpolateRdPu:DC,schemeRdPu:zC,interpolateYlGnBu:HC,schemeYlGnBu:BC,interpolateYlGn:VC,schemeYlGn:FC,interpolateYlOrBr:UC,schemeYlOrBr:jC,interpolateYlOrRd:WC,schemeYlOrRd:GC,interpolateBlues:YC,schemeBlues:qC,interpolateGreens:$C,schemeGreens:XC,interpolateGreys:ZC,schemeGreys:KC,interpolatePurples:QC,schemePurples:JC,interpolateReds:ek,schemeReds:tk,interpolateOranges:ik,schemeOranges:nk,interpolateCividis:function BN(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-t*(35.34-t*(2381.73-t*(6402.7-t*(7024.72-2710.57*t)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+t*(170.73+t*(52.82-t*(131.46-t*(176.58-67.37*t)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+t*(442.36-t*(2482.43-t*(6167.24-t*(6614.94-2475.67*t)))))))+")"},interpolateCubehelixDefault:rk,interpolateRainbow:function HN(t){(t<0||t>1)&&(t-=Math.floor(t));var e=Math.abs(t-.5);return sk.h=360*t-100,sk.s=1.5-1.5*e,sk.l=.8-.9*e,sk+""},interpolateWarm:ok,interpolateCool:ak,interpolateSinebow:function FN(t){var e;return t=(.5-t)*Math.PI,lk.r=255*(e=Math.sin(t))*e,lk.g=255*(e=Math.sin(t+ck))*e,lk.b=255*(e=Math.sin(t+uk))*e,lk+""},interpolateTurbo:function VN(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+t*(1172.33-t*(10793.56-t*(33300.12-t*(38394.49-14825.05*t)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+t*(557.33+t*(1225.33-t*(3574.96-t*(1073.77+707.56*t)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+t*(3211.1-t*(15327.97-t*(27814-t*(22569.18-6838.66*t)))))))+")"},interpolateViridis:dk,interpolateMagma:pk,interpolateInferno:fk,interpolatePlasma:mk,create:function jN(t){return Su(yc(t).call(document.documentElement))},creator:yc,local:nh,matcher:Sc,mouse:ah,namespace:mc,namespaces:fc,clientPoint:oh,select:Su,selectAll:sh,selection:wu,selector:bc,selectorAll:wc,style:Hc,touch:lh,touches:function UN(t,e){null==e&&(e=rh().touches);for(var n=0,i=e?e.length:0,r=new Array(i);n<i;++n)r[n]=oh(t,e[n]);return r},window:Rc,get event(){return uu},customEvent:gu,arc:function GN(){var t=Lk,e=Pk,n=gk(0),i=null,r=Ik,o=Nk,a=Ok,s=null;function l(){var l,c,u=+t.apply(this,arguments),h=+e.apply(this,arguments),d=r.apply(this,arguments)-Tk,p=o.apply(this,arguments)-Tk,f=_k(p-d),m=p>d;if(s||(s=l=pg()),h<u&&(c=h,h=u,u=c),h>Mk)if(f>Ak-Mk)s.moveTo(h*vk(d),h*wk(d)),s.arc(0,0,h,d,p,!m),u>Mk&&(s.moveTo(u*vk(p),u*wk(p)),s.arc(0,0,u,p,d,m));else{var g,_,y=d,v=p,b=d,x=p,w=f,S=f,M=a.apply(this,arguments)/2,E=M>Mk&&(i?+i.apply(this,arguments):Sk(u*u+h*h)),T=xk(_k(h-u)/2,+n.apply(this,arguments)),A=T,C=T;if(E>Mk){var k=kk(E/u*wk(M)),L=kk(E/h*wk(M));(w-=2*k)>Mk?(b+=k*=m?1:-1,x-=k):(w=0,b=x=(d+p)/2),(S-=2*L)>Mk?(y+=L*=m?1:-1,v-=L):(S=0,y=v=(d+p)/2)}var P=h*vk(y),I=h*wk(y),N=u*vk(x),O=u*wk(x);if(T>Mk){var R,z=h*vk(v),D=h*wk(v),B=u*vk(b),H=u*wk(b);if(f<Ek&&(R=Rk(P,I,B,H,z,D,N,O))){var F=P-R[0],V=I-R[1],j=z-R[0],U=D-R[1],G=1/wk(Ck((F*j+V*U)/(Sk(F*F+V*V)*Sk(j*j+U*U)))/2),W=Sk(R[0]*R[0]+R[1]*R[1]);A=xk(T,(u-W)/(G-1)),C=xk(T,(h-W)/(G+1))}}S>Mk?C>Mk?(g=zk(B,H,P,I,h,C,m),_=zk(z,D,N,O,h,C,m),s.moveTo(g.cx+g.x01,g.cy+g.y01),C<T?s.arc(g.cx,g.cy,C,yk(g.y01,g.x01),yk(_.y01,_.x01),!m):(s.arc(g.cx,g.cy,C,yk(g.y01,g.x01),yk(g.y11,g.x11),!m),s.arc(0,0,h,yk(g.cy+g.y11,g.cx+g.x11),yk(_.cy+_.y11,_.cx+_.x11),!m),s.arc(_.cx,_.cy,C,yk(_.y11,_.x11),yk(_.y01,_.x01),!m))):(s.moveTo(P,I),s.arc(0,0,h,y,v,!m)):s.moveTo(P,I),u>Mk&&w>Mk?A>Mk?(g=zk(N,O,z,D,u,-A,m),_=zk(P,I,B,H,u,-A,m),s.lineTo(g.cx+g.x01,g.cy+g.y01),A<T?s.arc(g.cx,g.cy,A,yk(g.y01,g.x01),yk(_.y01,_.x01),!m):(s.arc(g.cx,g.cy,A,yk(g.y01,g.x01),yk(g.y11,g.x11),!m),s.arc(0,0,u,yk(g.cy+g.y11,g.cx+g.x11),yk(_.cy+_.y11,_.cx+_.x11),m),s.arc(_.cx,_.cy,A,yk(_.y11,_.x11),yk(_.y01,_.x01),!m))):s.arc(0,0,u,x,b,m):s.lineTo(N,O)}else s.moveTo(0,0);if(s.closePath(),l)return s=null,l+""||null}return l.centroid=function(){var n=(+t.apply(this,arguments)+ +e.apply(this,arguments))/2,i=(+r.apply(this,arguments)+ +o.apply(this,arguments))/2-Ek/2;return[vk(i)*n,wk(i)*n]},l.innerRadius=function(e){return arguments.length?(t="function"==typeof e?e:gk(+e),l):t},l.outerRadius=function(t){return arguments.length?(e="function"==typeof t?t:gk(+t),l):e},l.cornerRadius=function(t){return arguments.length?(n="function"==typeof t?t:gk(+t),l):n},l.padRadius=function(t){return arguments.length?(i=null==t?null:"function"==typeof t?t:gk(+t),l):i},l.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:gk(+t),l):r},l.endAngle=function(t){return arguments.length?(o="function"==typeof t?t:gk(+t),l):o},l.padAngle=function(t){return arguments.length?(a="function"==typeof t?t:gk(+t),l):a},l.context=function(t){return arguments.length?(s=null==t?null:t,l):s},l},area:jk,line:Vk,pie:function WN(){var t=Gk,e=Uk,n=null,i=gk(0),r=gk(Ak),o=gk(0);function a(a){var s,l,c,u,h,d=a.length,p=0,f=new Array(d),m=new Array(d),g=+i.apply(this,arguments),_=Math.min(Ak,Math.max(-Ak,r.apply(this,arguments)-g)),y=Math.min(Math.abs(_)/d,o.apply(this,arguments)),v=y*(_<0?-1:1);for(s=0;s<d;++s)(h=m[f[s]=s]=+t(a[s],s,a))>0&&(p+=h);for(null!=e?f.sort((function(t,n){return e(m[t],m[n])})):null!=n&&f.sort((function(t,e){return n(a[t],a[e])})),s=0,c=p?(_-d*v)/p:0;s<d;++s,g=u)m[l=f[s]]={data:a[l],index:s,value:h=m[l],startAngle:g,endAngle:u=g+(h>0?h*c:0)+v,padAngle:y};return m}return a.value=function(e){return arguments.length?(t="function"==typeof e?e:gk(+e),a):t},a.sortValues=function(t){return arguments.length?(e=t,n=null,a):e},a.sort=function(t){return arguments.length?(n=t,e=null,a):n},a.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:gk(+t),a):i},a.endAngle=function(t){return arguments.length?(r="function"==typeof t?t:gk(+t),a):r},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:gk(+t),a):o},a},areaRadial:Kk,radialArea:Kk,lineRadial:$k,radialLine:$k,pointRadial:Zk,linkHorizontal:function qN(){return eL(nL)},linkVertical:function YN(){return eL(iL)},linkRadial:function XN(){var t=eL(rL);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},symbol:function $N(){var t=gk(oL),e=gk(64),n=null;function i(){var i;if(n||(n=i=pg()),t.apply(this,arguments).draw(n,+e.apply(this,arguments)),i)return n=null,i+""||null}return i.type=function(e){return arguments.length?(t="function"==typeof e?e:gk(e),i):t},i.size=function(t){return arguments.length?(e="function"==typeof t?t:gk(+t),i):e},i.context=function(t){return arguments.length?(n=null==t?null:t,i):n},i},symbols:wL,symbolCircle:oL,symbolCross:aL,symbolDiamond:cL,symbolSquare:fL,symbolStar:pL,symbolTriangle:gL,symbolWye:xL,curveBasisClosed:function KN(t){return new AL(t)},curveBasisOpen:function ZN(t){return new CL(t)},curveBasis:TL,curveBundle:LL,curveCardinalClosed:RL,curveCardinalOpen:DL,curveCardinal:NL,curveCatmullRomClosed:jL,curveCatmullRomOpen:GL,curveCatmullRom:FL,curveLinearClosed:function JN(t){return new WL(t)},curveLinear:Bk,curveMonotoneX:function QN(t){return new KL(t)},curveMonotoneY:function tO(t){return new ZL(t)},curveNatural:function eO(t){return new QL(t)},curveStep:function nO(t){return new eP(t,.5)},curveStepAfter:function iO(t){return new eP(t,1)},curveStepBefore:function rO(t){return new eP(t,0)},stack:function oO(){var t=gk([]),e=iP,n=nP,i=rP;function r(r){var o,a,s=t.apply(this,arguments),l=r.length,c=s.length,u=new Array(c);for(o=0;o<c;++o){for(var h,d=s[o],p=u[o]=new Array(l),f=0;f<l;++f)p[f]=h=[0,+i(r[f],d,f,r)],h.data=r[f];p.key=d}for(o=0,a=e(u);o<c;++o)u[a[o]].index=o;return n(u,a),u}return r.keys=function(e){return arguments.length?(t="function"==typeof e?e:gk(Jk.call(e)),r):t},r.value=function(t){return arguments.length?(i="function"==typeof t?t:gk(+t),r):i},r.order=function(t){return arguments.length?(e=null==t?iP:"function"==typeof t?t:gk(Jk.call(t)),r):e},r.offset=function(t){return arguments.length?(n=null==t?nP:t,r):n},r},stackOffsetExpand:function aO(t,e){if((i=t.length)>0){for(var n,i,r,o=0,a=t[0].length;o<a;++o){for(r=n=0;n<i;++n)r+=t[n][o][1]||0;if(r)for(n=0;n<i;++n)t[n][o][1]/=r}nP(t,e)}},stackOffsetDiverging:function sO(t,e){if((s=t.length)>0)for(var n,i,r,o,a,s,l=0,c=t[e[0]].length;l<c;++l)for(o=a=0,n=0;n<s;++n)(r=(i=t[e[n]][l])[1]-i[0])>0?(i[0]=o,i[1]=o+=r):r<0?(i[1]=a,i[0]=a+=r):(i[0]=0,i[1]=r)},stackOffsetNone:nP,stackOffsetSilhouette:function lO(t,e){if((n=t.length)>0){for(var n,i=0,r=t[e[0]],o=r.length;i<o;++i){for(var a=0,s=0;a<n;++a)s+=t[a][i][1]||0;r[i][1]+=r[i][0]=-s/2}nP(t,e)}},stackOffsetWiggle:function cO(t,e){if((r=t.length)>0&&(i=(n=t[e[0]]).length)>0){for(var n,i,r,o=0,a=1;a<i;++a){for(var s=0,l=0,c=0;s<r;++s){for(var u=t[e[s]],h=u[a][1]||0,d=(h-(u[a-1][1]||0))/2,p=0;p<s;++p){var f=t[e[p]];d+=(f[a][1]||0)-(f[a-1][1]||0)}l+=h,c+=d*h}n[a-1][1]+=n[a-1][0]=o,l&&(o-=c/l)}n[a-1][1]+=n[a-1][0]=o,nP(t,e)}},stackOrderAppearance:oP,stackOrderAscending:sP,stackOrderDescending:function uO(t){return sP(t).reverse()},stackOrderInsideOut:function hO(t){var e,n,i=t.length,r=t.map(lP),o=oP(t),a=0,s=0,l=[],c=[];for(e=0;e<i;++e)n=o[e],a<s?(a+=r[n],l.push(n)):(s+=r[n],c.push(n));return c.reverse().concat(l)},stackOrderNone:iP,stackOrderReverse:function dO(t){return iP(t).reverse()},timeInterval:rE,timeMillisecond:oE,timeMilliseconds:aE,utcMillisecond:oE,utcMilliseconds:aE,timeSecond:dE,timeSeconds:pE,utcSecond:dE,utcSeconds:pE,timeMinute:fE,timeMinutes:mE,timeHour:gE,timeHours:_E,timeDay:yE,timeDays:vE,timeWeek:xE,timeWeeks:CE,timeSunday:xE,timeSundays:CE,timeMonday:wE,timeMondays:kE,timeTuesday:SE,timeTuesdays:LE,timeWednesday:ME,timeWednesdays:PE,timeThursday:EE,timeThursdays:IE,timeFriday:TE,timeFridays:NE,timeSaturday:AE,timeSaturdays:OE,timeMonth:RE,timeMonths:zE,timeYear:DE,timeYears:BE,utcMinute:HE,utcMinutes:FE,utcHour:VE,utcHours:jE,utcDay:UE,utcDays:GE,utcWeek:qE,utcWeeks:QE,utcSunday:qE,utcSundays:QE,utcMonday:YE,utcMondays:tT,utcTuesday:XE,utcTuesdays:eT,utcWednesday:$E,utcWednesdays:nT,utcThursday:KE,utcThursdays:iT,utcFriday:ZE,utcFridays:rT,utcSaturday:JE,utcSaturdays:oT,utcMonth:aT,utcMonths:sT,utcYear:lT,utcYears:cT,timeFormatDefaultLocale:LA,get timeFormat(){return mT},get timeParse(){return gT},get utcFormat(){return _T},get utcParse(){return yT},timeFormatLocale:pT,isoFormat:IA,isoParse:OA,now:Tp,timer:kp,timerFlush:Lp,timeout:Op,interval:function pO(t,e,n){var i=new Cp,r=e;return null==e?(i.restart(t,e,n),i):(e=+e,n=null==n?Tp():+n,i.restart((function o(a){a+=r,i.restart(o,r+=e,n),t(a)}),e,n),i)},transition:_f,active:function fO(t,e){var n,i,r=t.__transition;if(r)for(i in e=null==e?null:e+"",r)if((n=r[i]).state>1&&n.name===e)return new gf([[t]],Sm,e,+i);return null},interrupt:Vp,voronoi:function mO(){var t=uP,e=hP,n=null;function i(i){return new qP(i.map((function(n,r){var o=[Math.round(t(n,r,i)/jP)*jP,Math.round(e(n,r,i)/jP)*jP];return o.index=r,o.data=n,o})),n)}return i.polygons=function(t){return i(t).polygons()},i.links=function(t){return i(t).links()},i.triangles=function(t){return i(t).triangles()},i.x=function(e){return arguments.length?(t="function"==typeof e?e:cP(+e),i):t},i.y=function(t){return arguments.length?(e="function"==typeof t?t:cP(+t),i):e},i.extent=function(t){return arguments.length?(n=null==t?null:[[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]],i):n&&[[n[0][0],n[0][1]],[n[1][0],n[1][1]]]},i.size=function(t){return arguments.length?(n=null==t?null:[[0,0],[+t[0],+t[1]]],i):n&&[n[1][0]-n[0][0],n[1][1]-n[0][1]]},i},zoom:aI,zoomTransform:ZP,zoomIdentity:KP});const gO=["#ff7043","#0077bb","#cc3311","#33bbee","#ee3377","#009988","#bbbbbb"];class _O extends ml{constructor(){super(...arguments),this._experiments=[]}load(){const t=gr().experiments();return this.requestManager.request(t).then((t=>{we.isEqual(this._experiments,t)||(this._experiments=t,this.emitChange())}))}getExperiments(){return this._experiments.slice()}}const yO=new _O;class vO{constructor(t=gO){this.palette=t,this.identifiers=xg()}setDomain(t){return this.identifiers=xg(),t.forEach(((t,e)=>{this.identifiers.set(t,this.palette[e%this.palette.length])})),this}getColor(t){if(!this.identifiers.has(t))throw new Error(`String ${t} was not in the domain.`);return this.identifiers.get(t)}}function bO(t,e){const n=new vO;function i(){n.setDomain(e())}return t.addListener(i),i(),t=>n.getColor(t)}const xO=bO(vl,(()=>vl.getRuns()));bO(yO,(()=>yO.getExperiments().map((({name:t})=>t)))),nl({moduleName:"run-color-style",styleContent:"\n    [color-class='light-blue'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-light-blue-500);\n      --paper-checkbox-checked-ink-color: var(--paper-light-blue-500);\n      --paper-checkbox-unchecked-color: var(--paper-light-blue-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-light-blue-900);\n    }\n    [color-class='red'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-red-500);\n      --paper-checkbox-checked-ink-color: var(--paper-red-500);\n      --paper-checkbox-unchecked-color: var(--paper-red-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-red-900);\n    }\n    [color-class='green'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-green-500);\n      --paper-checkbox-checked-ink-color: var(--paper-green-500);\n      --paper-checkbox-unchecked-color: var(--paper-green-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-green-900);\n    }\n    [color-class='purple'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-purple-500);\n      --paper-checkbox-checked-ink-color: var(--paper-purple-500);\n      --paper-checkbox-unchecked-color: var(--paper-purple-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-purple-900);\n    }\n    [color-class='teal'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-teal-500);\n      --paper-checkbox-checked-ink-color: var(--paper-teal-500);\n      --paper-checkbox-unchecked-color: var(--paper-teal-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-teal-900);\n    }\n    [color-class='pink'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-pink-500);\n      --paper-checkbox-checked-ink-color: var(--paper-pink-500);\n      --paper-checkbox-unchecked-color: var(--paper-pink-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-pink-900);\n    }\n    [color-class='orange'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-orange-500);\n      --paper-checkbox-checked-ink-color: var(--paper-orange-500);\n      --paper-checkbox-unchecked-color: var(--paper-orange-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-orange-900);\n    }\n    [color-class='brown'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-brown-500);\n      --paper-checkbox-checked-ink-color: var(--paper-brown-500);\n      --paper-checkbox-unchecked-color: var(--paper-brown-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-brown-900);\n    }\n    [color-class='indigo'] paper-checkbox {\n      --paper-checkbox-checked-color: var(--paper-indigo-500);\n      --paper-checkbox-checked-ink-color: var(--paper-indigo-500);\n      --paper-checkbox-unchecked-color: var(--paper-indigo-900);\n      --paper-checkbox-unchecked-ink-color: var(--paper-indigo-900);\n    }\n  "});let wO=class extends(tr(ye)){constructor(){super(...arguments),this.names=[],this.coloring={getColor:()=>""},this.regex="",this.selectionState={},this.maxNamesToEnableByDefault=40,this._debouncedRegexChange=this._debouncedRegexChangeImpl()}_debouncedRegexChangeImpl(){var t=we.debounce((t=>{this.regex=t}),150,{leading:!1});return function(){var e=this.$$("#names-regex").value;""==e?this.async((()=>{this.regex=e}),30):t(e)}}get _regex(){var t=this.regex;try{return new RegExp(t)}catch(t){return null}}_setIsolatorIcon(){var t=this.selectionState,e=we.filter(we.values(t)).length;Array.prototype.slice.call(this.root.querySelectorAll(".isolator")).forEach((function(n){n.icon=1===e&&t[n.name]?"radio-button-checked":"radio-button-unchecked"}))}computeNamesMatchingRegex(t,e){const n=this._regex;return n?this.names.filter((t=>n.test(t))):this.names}computeOutSelected(t,e){var n=this.selectionState,i=this.namesMatchingRegex.length<=this.maxNamesToEnableByDefault;return this.namesMatchingRegex.filter((t=>null==n[t]?i:n[t]))}synchronizeColors(t){this._setIsolatorIcon(),this.root.querySelectorAll("paper-checkbox").forEach((t=>{const e=this.coloring.getColor(t.name);t.updateStyles({"--paper-checkbox-checked-color":e,"--paper-checkbox-checked-ink-color":e,"--paper-checkbox-unchecked-color":e,"--paper-checkbox-unchecked-ink-color":e})})),this.root.querySelectorAll(".isolator").forEach((t=>{const e=this.coloring.getColor(t.name);t.style.color=e})),window.requestAnimationFrame((()=>{this.updateStyles()}))}_isolateName(t){var e=t.target.name,n={};this.names.forEach((function(t){n[t]=t==e})),this.selectionState=n}_checkboxChange(t){var e=t.target;const n=we.clone(this.selectionState);n[e.name]=e.checked,this.selectionState=n}_isChecked(t,e){return-1!=this.outSelected.indexOf(t)}toggleAll(){const t=this.namesMatchingRegex.some((t=>this.outSelected.includes(t))),e={};this.names.forEach((n=>{e[n]=!t})),this.selectionState=e}};wO.template=_e`
    <style include="scrollbar-style"></style>
    <style include="run-color-style"></style>

    <paper-input
      id="names-regex"
      no-label-float=""
      label="Write a regex to filter runs"
      value="[[regex]]"
      on-bind-value-changed="_debouncedRegexChange"
    ></paper-input>
    <div id="outer-container" class="scrollbar">
      <template
        is="dom-repeat"
        items="[[namesMatchingRegex]]"
        on-dom-change="synchronizeColors"
      >
        <div class="name-row">
          <div
            class="icon-container checkbox-container vertical-align-container"
          >
            <paper-checkbox
              class="checkbox vertical-align-center"
              id$="checkbox-[[item]]"
              name="[[item]]"
              checked$="[[_isChecked(item, selectionState.*)]]"
              on-change="_checkboxChange"
            ></paper-checkbox>
          </div>
          <div
            class="icon-container isolator-container vertical-align-container"
          >
            <paper-icon-button
              icon="radio-button-unchecked"
              class="isolator vertical-align-center"
              on-tap="_isolateName"
              name="[[item]]"
            ></paper-icon-button>
          </div>
          <div class="item-label-container">
            <span>[[item]]</span>
          </div>
        </div>
      </template>
    </div>
    <style>
      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
      }
      :host {
        display: flex;
        flex-direction: column;
        height: 100%;
        overflow: hidden;
      }
      #outer-container {
        contain: content;
        flex-grow: 1;
        flex-shrink: 1;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
        word-wrap: break-word;
      }
      .name-row {
        contain: content;
        padding-top: 5px;
        padding-bottom: 5px;
        display: flex;
        flex-direction: row;
        font-size: 13px;
        word-break: break-all; /* makes wrapping of hyperparam strings better */
      }
      .icon-container {
        flex-grow: 0;
        flex-shrink: 0;
        padding-left: 2px;
      }
      .checkbox {
        padding-left: 2px;
        width: 18px;
        height: 18px;
      }
      .isolator {
        width: 18px;
        height: 18px;
        padding: 0px;
      }
      .isolator-container {
        padding-left: 6px;
        padding-right: 3px;
      }
      .checkbox-container {
        padding-left: 2px;
      }
      .item-label-container {
        padding-left: 5px;
        flex-grow: 1;
        flex-shrink: 1;
        width: 0px; /* hack to get the flex-grow to work properly */
      }
      .tooltip-value-container {
        display: flex;
        justify-content: center;
        flex-grow: 0;
        flex-shrink: 0;
        text-align: right;
        padding-left: 2px;
      }
      .vertical-align-container {
        display: flex;
        justify-content: center;
      }
      .vertical-align-container .vertical-align-center {
        align-self: center;
      }
      .vertical-align-container .vertical-align-top {
        align-self: start;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],wO.prototype,"names",void 0),t([o({type:Object}),e("design:type",Object)],wO.prototype,"coloring",void 0),t([o({type:String,notify:!0}),e("design:type",String)],wO.prototype,"regex",void 0),t([o({type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"}),e("design:type",Array)],wO.prototype,"namesMatchingRegex",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],wO.prototype,"selectionState",void 0),t([o({type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"}),e("design:type",Array)],wO.prototype,"outSelected",void 0),t([o({type:Number}),e("design:type",Number)],wO.prototype,"maxNamesToEnableByDefault",void 0),t([o({type:Object}),e("design:type",Object)],wO.prototype,"_debouncedRegexChange",void 0),t([s("regex"),e("design:type",RegExp),e("design:paramtypes",[])],wO.prototype,"_regex",null),t([a("selectionState","names"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],wO.prototype,"_setIsolatorIcon",null),wO=t([i("tf-multi-checkbox")],wO);let SO=class extends ye{get _parts(){var t=this.value,e=this.delimiterPattern;const n=[];for(;;){const i=new RegExp(e,"g");if(i.test(t),0===i.lastIndex){n.push(t);break}n.push(t.slice(0,i.lastIndex)),t=t.slice(i.lastIndex)}return n}};SO.template=_e`
    <!--
      This ugly formatting is required to prevent spaces from slipping
      into the HTML.
    -->
    <template is="dom-repeat" items="[[_parts]]" as="part"
      >[[part]]<wbr
    /></template>
  `,t([o({type:String}),e("design:type",String)],SO.prototype,"value",void 0),t([o({type:String}),e("design:type",String)],SO.prototype,"delimiterPattern",void 0),t([s("value","delimiterPattern"),e("design:type",Array),e("design:paramtypes",[])],SO.prototype,"_parts",null),SO=t([i("tf-wbr-string")],SO);let MO=class extends(tr(ye)){constructor(){super(...arguments),this.runSelectionState=qs("runSelectionState",{defaultValue:{}}).call(this),this.regexInput=Ps("regexInput",{defaultValue:""}).call(this),this._dataLocationClipLength=250,this._dataLocationDelimiterPattern="[/=_,-]",this.coloring={getColor:xO},this._storeRunSelectionState=Ys("runSelectionState",{defaultValue:{}}),this._regexObserver=Is("regexInput",{defaultValue:""})}attached(){this._runStoreListener=vl.addListener((()=>{this.set("runs",vl.getRuns())})),this.set("runs",vl.getRuns()),this._envStoreListener=_l.addListener((()=>{this.set("dataLocation",_l.getDataLocation())})),this.set("dataLocation",_l.getDataLocation())}detached(){vl.removeListenerByKey(this._runStoreListener),_l.removeListenerByKey(this._envStoreListener)}_toggleAll(){this.$.multiCheckbox.toggleAll()}get _clippedDataLocation(){var t=this.dataLocation,e=this._dataLocationClipLength;if(void 0!==t)return t.length>e?t.substring(0,e):t}_openDataLocationDialog(t){t.preventDefault(),this.$$("#data-location-dialog").open()}_shouldShowExpandDataLocationButton(t,e){return t&&t.length>e}};MO.template=_e`
    <paper-dialog with-backdrop="" id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string
        value="[[dataLocation]]"
        delimiter-pattern="[[_dataLocationDelimiterPattern]]"
      >
      </tf-wbr-string
    ></paper-dialog>
    <div id="top-text">
      <h3 id="tooltip-help" class="tooltip-container">Runs</h3>
    </div>
    <tf-multi-checkbox
      id="multiCheckbox"
      names="[[runs]]"
      selection-state="{{runSelectionState}}"
      out-selected="{{selectedRuns}}"
      regex="{{regexInput}}"
      coloring="[[coloring]]"
    ></tf-multi-checkbox>
    <paper-button class="x-button" id="toggle-all" on-tap="_toggleAll">
      Toggle All Runs
    </paper-button>
    <template is="dom-if" if="[[dataLocation]]">
      <div id="data-location">
        <tf-wbr-string
          value="[[_clippedDataLocation]]"
          delimiter-pattern="[[_dataLocationDelimiterPattern]]"
        ></tf-wbr-string
        ><!--
          We use HTML comments to remove spaces before the ellipsis.
        --><template
          is="dom-if"
          if="[[_shouldShowExpandDataLocationButton(dataLocation, _dataLocationClipLength)]]"
          ><!--
          --><a href="" on-click="_openDataLocationDialog">…</a>
        </template>
      </div>
    </template>
    <style>
      :host {
        box-sizing: border-box;
        display: flex;
        flex-direction: column;
        padding-bottom: 10px;
      }
      #top-text {
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
        color: var(--paper-grey-800);
      }
      tf-multi-checkbox {
        display: flex;
        flex-grow: 1;
        flex-shrink: 1;
        overflow: hidden;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      #tooltip-help {
        color: var(--paper-grey-800);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }
      paper-button {
        margin-left: 0;
      }
      #data-location {
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin: 5px 0 0 0;
        max-width: 288px;
      }
    </style>
  `,t([o({type:Object,observer:"_storeRunSelectionState"}),e("design:type",Object)],MO.prototype,"runSelectionState",void 0),t([o({type:String,observer:"_regexObserver"}),e("design:type",String)],MO.prototype,"regexInput",void 0),t([o({type:Array,notify:!0}),e("design:type",Array)],MO.prototype,"selectedRuns",void 0),t([o({type:Array}),e("design:type",Array)],MO.prototype,"runs",void 0),t([o({type:String,notify:!0}),e("design:type",String)],MO.prototype,"dataLocation",void 0),t([o({type:Number}),e("design:type",Number)],MO.prototype,"_dataLocationClipLength",void 0),t([o({type:String}),e("design:type",String)],MO.prototype,"_dataLocationDelimiterPattern",void 0),t([o({type:Object}),e("design:type",Object)],MO.prototype,"coloring",void 0),t([s("dataLocation","_dataLocationClipLength"),e("design:type",String),e("design:paramtypes",[])],MO.prototype,"_clippedDataLocation",null),MO=t([i("tf-runs-selector")],MO);class EO{constructor(){this.cancellationCount=0}cancellable(t){const e=this.cancellationCount;return n=>t({value:n,cancelled:this.cancellationCount!==e})}cancelAll(){this.cancellationCount++}}let TO=class extends(tr(ye)){constructor(){super(...arguments),this.html=""}get sanitizedHtml(){return this.html}attached(){window.requestAnimationFrame((()=>{this.scopeSubtree(this.$.markdown,!0)}))}};function AO(t){return t?t.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""}TO.template=_e`
    <div id="markdown" inner-h-t-m-l="[[sanitizedHtml]]"></div>
    <style>
      /*
       * Reduce topmost and bottommost margins from 16px to 0.3em (renders
       * at about 4.8px) to keep the layout compact. This improves the
       * appearance when there is only one line of text; standard Markdown
       * renderers will still include a \`<p>\` element.
       *
       * By targeting only the top-level, extremal elements, we preserve any
       * actual paragraph breaks and only change the padding against the
       * component edges.
       */
      #markdown > p:first-child {
        margin-top: 0.3em;
      }
      #markdown > p:last-child {
        margin-bottom: 0.3em;
      }

      /* Pleasant styles for Markdown tables. */
      #markdown table {
        border-collapse: collapse;
      }
      #markdown table th {
        font-weight: 600;
      }
      #markdown table th,
      #markdown table td {
        padding: 6px 13px;
        border: 1px solid #dfe2e5;
      }
      #markdown table tr {
        background-color: #fff;
        border-top: 1px solid #c6cbd1;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],TO.prototype,"html",void 0),t([s("html"),e("design:type",Object),e("design:paramtypes",[])],TO.prototype,"sanitizedHtml",null),TO=t([i("tf-markdown-view")],TO),nl({moduleName:"tf-card-heading-style",styleContent:"\n    figcaption {\n      width: 100%;\n    }\n\n    /** Horizontal line of labels. */\n    .heading-row {\n      margin-top: -4px;\n      display: flex;\n      flex-direction: row;\n      flex-wrap: wrap;\n    }\n\n    /** Piece of text in the figure caption. */\n    .heading-label {\n      flex-grow: 1;\n      margin-top: 4px;\n      max-width: 100%;\n      word-wrap: break-word;\n    }\n\n    /** Makes label show on the right. */\n    .heading-right {\n      flex-grow: 0;\n    }\n  "});let CO=class extends ye{constructor(){super(...arguments),this.displayName=null,this.tag=null,this.run=null,this.description=null,this.color=null}_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})}_computeRunBackground(t){return t||"none"}_computeRunColor(t){return(function e(t){const e=(function n(t){if(!t)return null;let e=t.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!e)return null;if(4==t.length)for(var n=1;n<=3;n++)e[n]=e[n]+e[n];return[parseInt(e[1],16),parseInt(e[2],16),parseInt(e[3],16)]})(t);return e?Math.round((299*e[0]+587*e[1]+114*e[2])/1e3)>125?"inherit":"#eee":"inherit"})(t)}get _nameLabel(){return this.displayName||this.tag||""}get _tagLabel(){var t=this.tag;return t&&t!==this.displayName?t:""}_toggleDescriptionDialog(t){const e=this.$.descriptionDialog;e.positionTarget=t.target,e.toggle()}};CO.template=_e`
    <div class="container">
      <figcaption class="content">
        <div class="heading-row">
          <template is="dom-if" if="[[_nameLabel]]">
            <div itemprop="name" class="heading-label name">[[_nameLabel]]</div>
          </template>
          <template is="dom-if" if="[[run]]">
            <!-- Extra wrapping span needed to avoid flexbox blockification. -->
            <!-- (see flexbox spec, section 4 "Flex Items") -->
            <span>
              <span
                itemprop="run"
                id="heading-run"
                class="heading-label heading-right run"
                >[[run]]</span
              >
            </span>
          </template>
        </div>
        <template is="dom-if" if="[[_tagLabel]]">
          <div class="heading-row">
            <div class="heading-label">
              tag: <span itemprop="tag">[[_tagLabel]]</span>
            </div>
          </div>
        </template>
        <slot></slot>
      </figcaption>
      <template is="dom-if" if="[[description]]">
        <paper-icon-button
          icon="info"
          on-tap="_toggleDescriptionDialog"
          title="Show summary description"
        ></paper-icon-button>
      </template>
      <paper-dialog
        id="descriptionDialog"
        no-overlap=""
        horizontal-align="auto"
        vertical-align="auto"
      >
        <paper-dialog-scrollable>
          <tf-markdown-view html="[[description]]"></tf-markdown-view>
        </paper-dialog-scrollable>
      </paper-dialog>
    </div>
    <style include="tf-card-heading-style">
      .container {
        display: flex;
      }
      .content {
        font-size: 12px;
        flex-grow: 1;
      }
      .name {
        font-size: 14px;
      }
      .run {
        font-size: 11px;
        width: auto;
        border-radius: 3px;
        font-weight: bold;
        padding: 1px 4px 2px;
      }
      paper-icon-button {
        flex-grow: 0;
      }
      paper-dialog-scrollable {
        max-width: 640px;
      }
      #heading-run {
        background: var(--tf-card-heading-background-color);
        color: var(--tf-card-heading-color);
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],CO.prototype,"displayName",void 0),t([o({type:String}),e("design:type",String)],CO.prototype,"tag",void 0),t([o({type:String}),e("design:type",String)],CO.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],CO.prototype,"description",void 0),t([o({type:String}),e("design:type",String)],CO.prototype,"color",void 0),t([o({type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"}),e("design:type",String)],CO.prototype,"_runBackground",void 0),t([o({type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"}),e("design:type",String)],CO.prototype,"_runColor",void 0),t([s("displayName","tag"),e("design:type",String),e("design:paramtypes",[])],CO.prototype,"_nameLabel",null),t([s("displayName","tag"),e("design:type",String),e("design:paramtypes",[])],CO.prototype,"_tagLabel",null),CO=t([i("tf-card-heading")],CO);let kO=class extends(tr(ye)){constructor(){super(...arguments),this._metadataCanceller=new EO,this._steps=[],this._attached=!1}get _runColor(){return xO(this.run)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _maxStepIndex(){return this._steps.length-1}get _currentDatum(){return this._steps[this._stepIndex]}get _sampleText(){return`${this.sample+1}`}get _hasMultipleSamples(){return this.totalSamples>1}attached(){this._attached=!0,this.reload()}_reloadOnRunTagChange(){this.reload()}reload(){if(!this._attached)return;this._metadataCanceller.cancelAll();const t=gr().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:String(this.sample)})),e=this._metadataCanceller.cancellable((t=>{if(t.cancelled)return;const e=t.value.map(this._createStepDatum.bind(this));this.set("_steps",e),this.set("_stepIndex",e.length-1)}));this.requestManager.request(t).then(e)}_createStepDatum(t){const e=new URLSearchParams(t.query);e.append("ts",String(t.wall_time));const n=gr().pluginRoute("audio","/individualAudio",e);return{wall_time:AO(new Date(1e3*t.wall_time)),step:t.step,label:t.label,contentType:t.contentType,url:n}}};kO.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div class="heading-row">
          <div class="heading-label">
            sample: [[_sampleText]] of [[totalSamples]]
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step <strong>[[_currentDatum.step]]</strong>
          </div>
          <template is="dom-if" if="[[_currentDatum.wall_time]]">
            <div class="heading-label heading-right">
              [[_currentDatum.wall_time]]
            </div>
          </template>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div class="heading-row">
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps=""
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <template is="dom-if" if="[[_hasAtLeastOneStep]]">
      <audio
        controls=""
        src$="[[_currentDatum.url]]"
        type$="[[_currentDatum.contentType]]"
      ></audio>
      <tf-markdown-view html="[[_currentDatum.label]]"></tf-markdown-view>
    </template>
    <div id="main-audio-container"></div>

    <style include="tf-card-heading-style">
      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        --step-slider-knob-color: #424242;
        margin-right: 15px;
        margin-bottom: 15px;
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        width: 100%;
        box-sizing: border-box;
        padding: 0 5px; /* so the slider knob doesn't butt out */
        margin-top: 5px;
        --paper-slider-active-color: var(--step-slider-knob-color);
        --paper-slider-knob-color: var(--step-slider-knob-color);
        --paper-slider-pin-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-color: var(--step-slider-knob-color);
        --paper-slider-knob-start-border-color: var(--step-slider-knob-color);
        --paper-slider-pin-start-color: var(--step-slider-knob-color);
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],kO.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],kO.prototype,"tag",void 0),t([o({type:Number}),e("design:type",Number)],kO.prototype,"sample",void 0),t([o({type:Number}),e("design:type",Number)],kO.prototype,"totalSamples",void 0),t([o({type:Object}),e("design:type",Object)],kO.prototype,"tagMetadata",void 0),t([o({type:Object}),e("design:type",hr)],kO.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",EO)],kO.prototype,"_metadataCanceller",void 0),t([o({type:Array}),e("design:type",Array)],kO.prototype,"_steps",void 0),t([o({type:Number}),e("design:type",Number)],kO.prototype,"_stepIndex",void 0),t([s("run"),e("design:type",String),e("design:paramtypes",[])],kO.prototype,"_runColor",null),t([s("_steps"),e("design:type",Boolean),e("design:paramtypes",[])],kO.prototype,"_hasAtLeastOneStep",null),t([s("_steps"),e("design:type",Boolean),e("design:paramtypes",[])],kO.prototype,"_hasMultipleSteps",null),t([s("_steps"),e("design:type",Number),e("design:paramtypes",[])],kO.prototype,"_maxStepIndex",null),t([s("_steps","_stepIndex"),e("design:type",Object),e("design:paramtypes",[])],kO.prototype,"_currentDatum",null),t([s("sample"),e("design:type",String),e("design:paramtypes",[])],kO.prototype,"_sampleText",null),t([s("totalSamples"),e("design:type",Boolean),e("design:paramtypes",[])],kO.prototype,"_hasMultipleSamples",null),t([a("run","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],kO.prototype,"_reloadOnRunTagChange",null),kO=t([i("tf-audio-loader")],kO);let LO=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._tagFilter="",this._requestManager=new hr}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadAudio()}))}_fetchTags(){const t=gr().pluginRoute("audio","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=or(we.mapValues(t,(t=>Object.keys(t))));this.set("_dataNotFound",0===e.length),this.set("_runToTagInfo",t)}))}_reloadAudio(){this.root.querySelectorAll("tf-audio-loader").forEach((t=>{t.reload()}))}_shouldOpen(t){return t<=2}get _categories(){var t=this._runToTagInfo,e=this._selectedRuns,n=this._tagFilter;function i(e){const n=t[e.run][e.tag].samples;return we.range(n).map((t=>Object.assign({},e,{sample:t,totalSamples:n})))}return Sr(we.mapValues(t,(t=>Object.keys(t))),e,n).map((t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(i))})))}_tagMetadata(t,e,n){return t[e][n]}};LO.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No audio data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any audio data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-audio-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  total-samples="[[item.totalSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                ></tf-audio-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],LO.prototype,"reloadOnReady",void 0),t([o({type:Array}),e("design:type",Array)],LO.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],LO.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],LO.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],LO.prototype,"_tagFilter",void 0),t([o({type:Object}),e("design:type",hr)],LO.prototype,"_requestManager",void 0),t([s("_runToTagInfo","_selectedRuns","_tagFilter"),e("design:type",Array),e("design:paramtypes",[])],LO.prototype,"_categories",null),LO=t([i("tf-audio-dashboard")],LO);let PO=class extends(tr(ye)){attached(){this.async((function(){this.getEffectiveChildren().forEach(function(t){this.listen(t,"tap","_selectTarget")}.bind(this))}))}_selectTarget(t){this.selectedId=t.currentTarget.id}_selectedIdChanged(){var t=this.queryEffectiveChildren("#"+this.selectedId);t&&(this.getEffectiveChildren().forEach((function(t){t.classList.remove("selected")})),t.classList.add("selected"))}};function IO(t,e){let n;const i={};return Object.keys(t).forEach((e=>{const r=t[e];void 0===n&&(n=r.displayName),n!==r.displayName&&(n=null),void 0===i[r.description]&&(i[r.description]=[]),i[r.description].push(e)})),{displayName:null!=n?n:e,description:(()=>{const t=Object.keys(i);return 0===t.length?"":1===t.length?t[0]:`<p><strong>Multiple descriptions:</strong></p><ul>${t.map((t=>{const e=i[t].map((t=>`<code>${t.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/&/g,"&amp;")}</code>`)),n=e.length>2?e.slice(0,e.length-1).join(", ")+", and "+e[e.length-1]:e.join(" and ");return`<li><p>For ${(function r(t,e,n){return 1===t?e:n})(e.length,"run","runs")} ${n}:</p>${t}</li>`})).join("")}</ul>`})()}}PO.template=_e`
    <div id="wrap">
      <h3>[[name]]</h3>
      <div class="content-wrapper"><slot></slot></div>
    </div>
    <style>
      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(*) {
        background: none;
        color: var(--tb-ui-dark-accent);
        font-size: 13px;
        margin-top: 10px;
      }

      .content-wrapper ::slotted(.selected) {
        background-color: var(--tb-ui-dark-accent);
        color: white !important;
      }

      h3 {
        color: var(--paper-grey-800);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],PO.prototype,"name",void 0),t([o({type:String,notify:!0,observer:"_selectedIdChanged"}),e("design:type",String)],PO.prototype,"selectedId",void 0),PO=t([i("tf-option-selector")],PO);let NO=class extends ye{constructor(){super(...arguments),this.weight=.6,this._updateWeight=we.debounce((function(t){this.weight=t}),250)}_immediateWeightNumberForPaperSliderChanged(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString(),this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)}_inputWeightStringForPaperInputChanged(){+this._inputWeightStringForPaperInput<0?this._inputWeightStringForPaperInput="0":+this._inputWeightStringForPaperInput>1&&(this._inputWeightStringForPaperInput="1");var t=+this._inputWeightStringForPaperInput;isNaN(t)||this._updateWeight.call(this,t)}};function OO(t,e){const n=Object.keys(e).sort().filter((t=>void 0!==e[t]));if(!n.length)return t;const i=-1!==t.indexOf("?")?"&":"?";return t+i+[].concat(...n.map((t=>{const n=e[t];return(Array.isArray(n)?n:[n]).map((e=>`${t}=${(function n(t){return encodeURIComponent(t).replace(/\(/g,"%28").replace(/\)/g,"%29")}
/*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */)(e)}`))}))).join("&")}NO.template=_e`
    <h3 class="title">Smoothing</h3>
    <div class="smoothing-block">
      <paper-slider
        id="slider"
        immediate-value="{{_immediateWeightNumberForPaperSlider}}"
        max="[[max]]"
        min="[[min]]"
        pin
        step="[[step]]"
        type="number"
        value="{{weight}}"
      ></paper-slider>
      <paper-input
        id="input"
        label="weight"
        no-label-float
        value="{{_inputWeightStringForPaperInput}}"
        type="number"
        step="[[step]]"
        min="[[min]]"
        max="[[max]]"
      ></paper-input>
    </div>
    <style>
      .title {
        color: var(--paper-grey-800);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .smoothing-block {
        display: flex;
      }

      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
        flex-grow: 2;
      }

      paper-input {
        --paper-input-container-focus-color: var(--tb-orange-strong);
        --paper-input-container-input: {
          font-size: 14px;
        }
        --paper-input-container-label: {
          font-size: 14px;
        }
        width: 60px;
      }
    </style>
  `,t([o({type:Number}),e("design:type",Number)],NO.prototype,"step",void 0),t([o({type:Number}),e("design:type",Number)],NO.prototype,"max",void 0),t([o({type:Number}),e("design:type",Number)],NO.prototype,"min",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],NO.prototype,"weight",void 0),t([o({type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"}),e("design:type",Number)],NO.prototype,"_immediateWeightNumberForPaperSlider",void 0),t([o({type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}),e("design:type",String)],NO.prototype,"_inputWeightStringForPaperInput",void 0),NO=t([i("tf-smoothing-input")],NO);var RO=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])},zO=Object.assign||function t(e){for(var n,i=1,r=arguments.length;i<r;i++)for(var o in n=arguments[i])Object.prototype.hasOwnProperty.call(n,o)&&(e[o]=n[o]);return e};function DO(t){var e="function"==typeof Symbol&&t[Symbol.iterator],n=0;return e?e.call(t):{next:function(){return t&&n>=t.length&&(t=void 0),{value:t&&t[n++],done:!t}}}}function BO(t,e){var n="function"==typeof Symbol&&t[Symbol.iterator];if(!n)return t;var i,r,o=n.call(t),a=[];try{for(;(void 0===e||e-- >0)&&!(i=o.next()).done;)a.push(i.value)}catch(t){r={error:t}}finally{try{i&&!i.done&&(n=o.return)&&n.call(o)}finally{if(r)throw r.error}}return a}function HO(t){return this instanceof HO?(this.v=t,this):new HO(t)}var FO=Object.freeze({__proto__:null,__extends:function VO(t,e){function n(){this.constructor=t}RO(t,e),t.prototype=null===e?Object.create(e):(n.prototype=e.prototype,new n)},__assign:zO,__rest:function jO(t,e){var n={};for(var i in t)Object.prototype.hasOwnProperty.call(t,i)&&e.indexOf(i)<0&&(n[i]=t[i]);if(null!=t&&"function"==typeof Object.getOwnPropertySymbols){var r=0;for(i=Object.getOwnPropertySymbols(t);r<i.length;r++)e.indexOf(i[r])<0&&(n[i[r]]=t[i[r]])}return n},__decorate:function UO(t,e,n,i){var r,o=arguments.length,a=o<3?e:null===i?i=Object.getOwnPropertyDescriptor(e,n):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)a=Reflect.decorate(t,e,n,i);else for(var s=t.length-1;s>=0;s--)(r=t[s])&&(a=(o<3?r(a):o>3?r(e,n,a):r(e,n))||a);return o>3&&a&&Object.defineProperty(e,n,a),a},__param:function GO(t,e){return function(n,i){e(n,i,t)}},__metadata:function WO(t,e){if("object"==typeof Reflect&&"function"==typeof Reflect.metadata)return Reflect.metadata(t,e)},__awaiter:function qO(t,e,n,i){return new(n||(n=Promise))((function(r,o){function a(t){try{l(i.next(t))}catch(t){o(t)}}function s(t){try{l(i.throw(t))}catch(t){o(t)}}function l(t){t.done?r(t.value):new n((function(e){e(t.value)})).then(a,s)}l((i=i.apply(t,e||[])).next())}))},__generator:function YO(t,e){var n,i,r,o,a={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function s(o){return function(s){return(function l(o){if(n)throw new TypeError("Generator is already executing.");for(;a;)try{if(n=1,i&&(r=i[2&o[0]?"return":o[0]?"throw":"next"])&&!(r=r.call(i,o[1])).done)return r;switch(i=0,r&&(o=[0,r.value]),o[0]){case 0:case 1:r=o;break;case 4:return a.label++,{value:o[1],done:!1};case 5:a.label++,i=o[1],o=[0];continue;case 7:o=a.ops.pop(),a.trys.pop();continue;default:if(!((r=(r=a.trys).length>0&&r[r.length-1])||6!==o[0]&&2!==o[0])){a=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){a.label=o[1];break}if(6===o[0]&&a.label<r[1]){a.label=r[1],r=o;break}if(r&&a.label<r[2]){a.label=r[2],a.ops.push(o);break}r[2]&&a.ops.pop(),a.trys.pop();continue}o=e.call(t,a)}catch(t){o=[6,t],i=0}finally{n=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}})([o,s])}}},__exportStar:function XO(t,e){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])},__values:DO,__read:BO,__spread:function $O(){for(var t=[],e=0;e<arguments.length;e++)t=t.concat(BO(arguments[e]));return t},__await:HO,__asyncGenerator:function KO(t,e,n){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var i,r=n.apply(t,e||[]),o=[];return i={},a("next"),a("throw"),a("return"),i[Symbol.asyncIterator]=function(){return this},i;function a(t){r[t]&&(i[t]=function(e){return new Promise((function(n,i){o.push([t,e,n,i])>1||s(t,e)}))})}function s(t,e){try{!(function n(t){t.value instanceof HO?Promise.resolve(t.value.v).then(l,c):u(o[0][2],t)})(r[t](e))}catch(t){u(o[0][3],t)}}function l(t){s("next",t)}function c(t){s("throw",t)}function u(t,e){t(e),o.shift(),o.length&&s(o[0][0],o[0][1])}},__asyncDelegator:function ZO(t){var e,n;return e={},i("next"),i("throw",(function(t){throw t})),i("return"),e[Symbol.iterator]=function(){return this},e;function i(i,r){t[i]&&(e[i]=function(e){return(n=!n)?{value:HO(t[i](e)),done:"return"===i}:r?r(e):e})}},__asyncValues:function JO(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=t[Symbol.asyncIterator];return e?e.call(t):DO(t)},__makeTemplateObject:function QO(t,e){return Object.defineProperty?Object.defineProperty(t,"raw",{value:e}):t.raw=e,t}});function tR(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function eR(t){return 1===t.length&&(t=(function e(t){return function(e,n){return tR(t(e),n)}})(t)),{left:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)<0?i=o+1:r=o}return i},right:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)>0?r=o:i=o+1}return i}}}var nR=eR(tR),iR=nR.right,rR=nR.left;function oR(t,e){return[t,e]}function aR(t){return null===t?NaN:+t}function sR(t,e){var n,i,r=t.length,o=0,a=-1,s=0,l=0;if(null==e)for(;++a<r;)isNaN(n=aR(t[a]))||(l+=(i=n-s)*(n-(s+=i/++o)));else for(;++a<r;)isNaN(n=aR(e(t[a],a,t)))||(l+=(i=n-s)*(n-(s+=i/++o)));if(o>1)return l/(o-1)}function lR(t,e){var n=sR(t,e);return n?Math.sqrt(n):n}function cR(t,e){var n,i,r,o=t.length,a=-1;if(null==e){for(;++a<o;)if(null!=(n=t[a])&&n>=n)for(i=r=n;++a<o;)null!=(n=t[a])&&(i>n&&(i=n),r<n&&(r=n))}else for(;++a<o;)if(null!=(n=e(t[a],a,t))&&n>=n)for(i=r=n;++a<o;)null!=(n=e(t[a],a,t))&&(i>n&&(i=n),r<n&&(r=n));return[i,r]}var uR=Array.prototype,hR=uR.slice,dR=uR.map;function pR(t){return function(){return t}}function fR(t){return t}function mR(t,e,n){t=+t,e=+e,n=(r=arguments.length)<2?(e=t,t=0,1):r<3?1:+n;for(var i=-1,r=0|Math.max(0,Math.ceil((e-t)/n)),o=new Array(r);++i<r;)o[i]=t+i*n;return o}var gR=Math.sqrt(50),_R=Math.sqrt(10),yR=Math.sqrt(2);function vR(t,e,n){var i=(e-t)/Math.max(0,n),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=gR?10:o>=_R?5:o>=yR?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=gR?10:o>=_R?5:o>=yR?2:1)}function bR(t,e,n){var i=Math.abs(e-t)/Math.max(0,n),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=gR?r*=10:o>=_R?r*=5:o>=yR&&(r*=2),e<t?-r:r}function xR(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function wR(t,e,n){if(null==n&&(n=aR),i=t.length){if((e=+e)<=0||i<2)return+n(t[0],0,t);if(e>=1)return+n(t[i-1],i-1,t);var i,r=(i-1)*e,o=Math.floor(r),a=+n(t[o],o,t);return a+(+n(t[o+1],o+1,t)-a)*(r-o)}}function SR(t,e){var n,i,r=t.length,o=-1;if(null==e){for(;++o<r;)if(null!=(n=t[o])&&n>=n)for(i=n;++o<r;)null!=(n=t[o])&&i>n&&(i=n)}else for(;++o<r;)if(null!=(n=e(t[o],o,t))&&n>=n)for(i=n;++o<r;)null!=(n=e(t[o],o,t))&&i>n&&(i=n);return i}function MR(t){if(!(r=t.length))return[];for(var e=-1,n=SR(t,ER),i=new Array(n);++e<n;)for(var r,o=-1,a=i[e]=new Array(r);++o<r;)a[o]=t[o][e];return i}function ER(t){return t.length}var TR=Array.prototype.slice;function AR(t){return t}var CR=1e-6;function kR(t){return"translate("+(t+.5)+",0)"}function LR(t){return"translate(0,"+(t+.5)+")"}function PR(t){return function(e){return+t(e)}}function IR(t){var e=Math.max(0,t.bandwidth()-1)/2;return t.round()&&(e=Math.round(e)),function(n){return+t(n)+e}}function NR(){return!this.__axis}function OR(t,e){var n=[],i=null,r=null,o=6,a=6,s=3,l=1===t||4===t?-1:1,c=4===t||2===t?"x":"y",u=1===t||3===t?kR:LR;function h(h){var d=null==i?e.ticks?e.ticks.apply(e,n):e.domain():i,p=null==r?e.tickFormat?e.tickFormat.apply(e,n):AR:r,f=Math.max(o,0)+s,m=e.range(),g=+m[0]+.5,_=+m[m.length-1]+.5,y=(e.bandwidth?IR:PR)(e.copy()),v=h.selection?h.selection():h,b=v.selectAll(".domain").data([null]),x=v.selectAll(".tick").data(d,e).order(),w=x.exit(),S=x.enter().append("g").attr("class","tick"),M=x.select("line"),E=x.select("text");b=b.merge(b.enter().insert("path",".tick").attr("class","domain").attr("stroke","#000")),x=x.merge(S),M=M.merge(S.append("line").attr("stroke","#000").attr(c+"2",l*o)),E=E.merge(S.append("text").attr("fill","#000").attr(c,l*f).attr("dy",1===t?"0em":3===t?"0.71em":"0.32em")),h!==v&&(b=b.transition(h),x=x.transition(h),M=M.transition(h),E=E.transition(h),w=w.transition(h).attr("opacity",CR).attr("transform",(function(t){return isFinite(t=y(t))?u(t):this.getAttribute("transform")})),S.attr("opacity",CR).attr("transform",(function(t){var e=this.parentNode.__axis;return u(e&&isFinite(e=e(t))?e:y(t))}))),w.remove(),b.attr("d",4===t||2==t?"M"+l*a+","+g+"H0.5V"+_+"H"+l*a:"M"+g+","+l*a+"V0.5H"+_+"V"+l*a),x.attr("opacity",1).attr("transform",(function(t){return u(y(t))})),M.attr(c+"2",l*o),E.attr(c,l*f).text(p),v.filter(NR).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",2===t?"start":4===t?"end":"middle"),v.each((function(){this.__axis=y}))}return h.scale=function(t){return arguments.length?(e=t,h):e},h.ticks=function(){return n=TR.call(arguments),h},h.tickArguments=function(t){return arguments.length?(n=null==t?[]:TR.call(t),h):n.slice()},h.tickValues=function(t){return arguments.length?(i=null==t?null:TR.call(t),h):i&&i.slice()},h.tickFormat=function(t){return arguments.length?(r=t,h):r},h.tickSize=function(t){return arguments.length?(o=a=+t,h):o},h.tickSizeInner=function(t){return arguments.length?(o=+t,h):o},h.tickSizeOuter=function(t){return arguments.length?(a=+t,h):a},h.tickPadding=function(t){return arguments.length?(s=+t,h):s},h}var RR={value:function(){}};function zR(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new DR(i)}function DR(t){this._=t}function BR(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function HR(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function FR(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=RR,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}DR.prototype=zR.prototype={constructor:DR,on:function(t,e){var n,i=this._,r=BR(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=FR(i[n],t.name,e);else if(null==e)for(n in i)i[n]=FR(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=HR(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new DR(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var VR="http://www.w3.org/1999/xhtml",jR={svg:"http://www.w3.org/2000/svg",xhtml:VR,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function UR(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),jR.hasOwnProperty(e)?{space:jR[e],local:t}:t}function GR(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===VR&&e.documentElement.namespaceURI===VR?e.createElement(t):e.createElementNS(n,t)}}function WR(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function qR(t){var e=UR(t);return(e.local?WR:GR)(e)}function YR(){}function XR(t){return null==t?YR:function(){return this.querySelector(t)}}function $R(){return[]}function KR(t){return null==t?$R:function(){return this.querySelectorAll(t)}}function ZR(t){return function(){return this.matches(t)}}function JR(t){return new Array(t.length)}function QR(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function tz(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new QR(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function ez(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new QR(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function nz(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function iz(t){return function(){this.removeAttribute(t)}}function rz(t){return function(){this.removeAttributeNS(t.space,t.local)}}function oz(t,e){return function(){this.setAttribute(t,e)}}function az(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function sz(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function lz(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function cz(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function uz(t){return function(){this.style.removeProperty(t)}}function hz(t,e,n){return function(){this.style.setProperty(t,e,n)}}function dz(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function pz(t,e){return t.style.getPropertyValue(e)||cz(t).getComputedStyle(t,null).getPropertyValue(e)}function fz(t){return function(){delete this[t]}}function mz(t,e){return function(){this[t]=e}}function gz(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function _z(t){return t.trim().split(/^|\s+/)}function yz(t){return t.classList||new vz(t)}function vz(t){this._node=t,this._names=_z(t.getAttribute("class")||"")}function bz(t,e){for(var n=yz(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function xz(t,e){for(var n=yz(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function wz(t){return function(){bz(this,t)}}function Sz(t){return function(){xz(this,t)}}function Mz(t,e){return function(){(e.apply(this,arguments)?bz:xz)(this,t)}}function Ez(){this.textContent=""}function Tz(t){return function(){this.textContent=t}}function Az(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function Cz(){this.innerHTML=""}function kz(t){return function(){this.innerHTML=t}}function Lz(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function Pz(){this.nextSibling&&this.parentNode.appendChild(this)}function Iz(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Nz(){return null}function Oz(){var t=this.parentNode;t&&t.removeChild(this)}function Rz(){var t=this.cloneNode(!1),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}function zz(){var t=this.cloneNode(!0),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}QR.prototype={constructor:QR,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},vz.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Dz={},Bz=null;function Hz(t,e,n){return t=Fz(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function Fz(t,e,n){return function(i){var r=Bz;Bz=i;try{t.call(this,this.__data__,e,n)}finally{Bz=r}}}function Vz(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function jz(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function Uz(t,e,n){var i=Dz.hasOwnProperty(t.type)?Hz:Fz;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function Gz(t,e,n){var i=cz(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function Wz(t,e){return function(){return Gz(this,t,e)}}function qz(t,e){return function(){return Gz(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(Dz={mouseenter:"mouseover",mouseleave:"mouseout"}));var Yz=[null];function Xz(t,e){this._groups=t,this._parents=e}function $z(){return new Xz([[document.documentElement]],Yz)}function Kz(t){return"string"==typeof t?new Xz([[document.querySelector(t)]],[document.documentElement]):new Xz([[t]],Yz)}function Zz(t){var e=(function n(){for(var t,e=Bz;t=e.sourceEvent;)e=t;return e})();return e.changedTouches&&(e=e.changedTouches[0]),(function i(t,e){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var i=n.createSVGPoint();return i.x=e.clientX,i.y=e.clientY,[(i=i.matrixTransform(t.getScreenCTM().inverse())).x,i.y]}var r=t.getBoundingClientRect();return[e.clientX-r.left-t.clientLeft,e.clientY-r.top-t.clientTop]})(t,e)}function Jz(){Bz.preventDefault(),Bz.stopImmediatePropagation()}function Qz(t){var e=t.document.documentElement,n=Kz(t).on("dragstart.drag",Jz,!0);"onselectstart"in e?n.on("selectstart.drag",Jz,!0):(e.__noselect=e.style.MozUserSelect,e.style.MozUserSelect="none")}function tD(t,e){var n=t.document.documentElement,i=Kz(t).on("dragstart.drag",null);e&&(i.on("click.drag",Jz,!0),setTimeout((function(){i.on("click.drag",null)}),0)),"onselectstart"in n?i.on("selectstart.drag",null):(n.style.MozUserSelect=n.__noselect,delete n.__noselect)}function eD(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function nD(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function iD(){}Xz.prototype=$z.prototype={constructor:Xz,select:function rD(t){"function"!=typeof t&&(t=XR(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new Xz(i,this._parents)},selectAll:function oD(t){"function"!=typeof t&&(t=KR(t));for(var e=this._groups,n=e.length,i=[],r=[],o=0;o<n;++o)for(var a,s=e[o],l=s.length,c=0;c<l;++c)(a=s[c])&&(i.push(t.call(a,a.__data__,c,s)),r.push(a));return new Xz(i,r)},filter:function aD(t){"function"!=typeof t&&(t=ZR(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new Xz(i,this._parents)},data:function sD(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?ez:tz,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new Xz(s,i))._enter=l,s._exit=c,s},enter:function lD(){return new Xz(this._enter||this._groups.map(JR),this._parents)},exit:function cD(){return new Xz(this._exit||this._groups.map(JR),this._parents)},join:function uD(t,e,n){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof t?t(i):i.append(t+""),null!=e&&(r=e(r)),null==n?o.remove():n(o),i&&r?i.merge(r).order():r},merge:function hD(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new Xz(o,this._parents)},order:function dD(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&4^i.compareDocumentPosition(a)&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function pD(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=nz);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new Xz(r,this._parents).order()},call:function fD(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function mD(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function gD(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function _D(){var t=0;return this.each((function(){++t})),t},empty:function yD(){return!this.node()},each:function vD(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function bD(t,e){var n=UR(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?rz:iz:"function"==typeof e?n.local?lz:sz:n.local?az:oz)(n,e))},style:function xD(t,e,n){return arguments.length>1?this.each((null==e?uz:"function"==typeof e?dz:hz)(t,e,null==n?"":n)):pz(this.node(),t)},property:function wD(t,e){return arguments.length>1?this.each((null==e?fz:"function"==typeof e?gz:mz)(t,e)):this.node()[t]},classed:function SD(t,e){var n=_z(t+"");if(arguments.length<2){for(var i=yz(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?Mz:e?wz:Sz)(n,e))},text:function MD(t){return arguments.length?this.each(null==t?Ez:("function"==typeof t?Az:Tz)(t)):this.node().textContent},html:function ED(t){return arguments.length?this.each(null==t?Cz:("function"==typeof t?Lz:kz)(t)):this.node().innerHTML},raise:function TD(){return this.each(Pz)},lower:function AD(){return this.each(Iz)},append:function CD(t){var e="function"==typeof t?t:qR(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function kD(t,e){var n="function"==typeof t?t:qR(t),i=null==e?Nz:"function"==typeof e?e:XR(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function LD(){return this.each(Oz)},clone:function PD(t){return this.select(t?zz:Rz)},datum:function ID(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function ND(t,e,n){var i,r,o=Vz(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?Uz:jz,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function OD(t,e){return this.each(("function"==typeof e?qz:Wz)(t,e))}};var RD=.7,zD=1/RD,DD="\\s*([+-]?\\d+)\\s*",BD="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",HD="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",FD=/^#([0-9a-f]{3,8})$/,VD=new RegExp("^rgb\\("+[DD,DD,DD]+"\\)$"),jD=new RegExp("^rgb\\("+[HD,HD,HD]+"\\)$"),UD=new RegExp("^rgba\\("+[DD,DD,DD,BD]+"\\)$"),GD=new RegExp("^rgba\\("+[HD,HD,HD,BD]+"\\)$"),WD=new RegExp("^hsl\\("+[BD,HD,HD]+"\\)$"),qD=new RegExp("^hsla\\("+[BD,HD,HD,BD]+"\\)$"),YD={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function XD(){return this.rgb().formatHex()}function $D(){return this.rgb().formatRgb()}function KD(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=FD.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?ZD(e):3===n?new eB(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?JD(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?JD(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=VD.exec(t))?new eB(e[1],e[2],e[3],1):(e=jD.exec(t))?new eB(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=UD.exec(t))?JD(e[1],e[2],e[3],e[4]):(e=GD.exec(t))?JD(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=WD.exec(t))?oB(e[1],e[2]/100,e[3]/100,1):(e=qD.exec(t))?oB(e[1],e[2]/100,e[3]/100,e[4]):YD.hasOwnProperty(t)?ZD(YD[t]):"transparent"===t?new eB(NaN,NaN,NaN,0):null}function ZD(t){return new eB(t>>16&255,t>>8&255,255&t,1)}function JD(t,e,n,i){return i<=0&&(t=e=n=NaN),new eB(t,e,n,i)}function QD(t){return t instanceof iD||(t=KD(t)),t?new eB((t=t.rgb()).r,t.g,t.b,t.opacity):new eB}function tB(t,e,n,i){return 1===arguments.length?QD(t):new eB(t,e,n,null==i?1:i)}function eB(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function nB(){return"#"+rB(this.r)+rB(this.g)+rB(this.b)}function iB(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function rB(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function oB(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new sB(t,e,n,i)}function aB(t){if(t instanceof sB)return new sB(t.h,t.s,t.l,t.opacity);if(t instanceof iD||(t=KD(t)),!t)return new sB;if(t instanceof sB)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new sB(a,s,l,t.opacity)}function sB(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function lB(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}function cB(t){return function(){return t}}function uB(t,e){var n=e-t;return n?(function i(t,e){return function(n){return t+n*e}})(t,n):cB(isNaN(t)?e:t)}eD(iD,KD,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:XD,formatHex:XD,formatHsl:function hB(){return aB(this).formatHsl()},formatRgb:$D,toString:$D}),eD(eB,tB,nD(iD,{brighter:function(t){return t=null==t?zD:Math.pow(zD,t),new eB(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?RD:Math.pow(RD,t),new eB(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:nB,formatHex:nB,formatRgb:iB,toString:iB})),eD(sB,(function dB(t,e,n,i){return 1===arguments.length?aB(t):new sB(t,e,n,null==i?1:i)}),nD(iD,{brighter:function(t){return t=null==t?zD:Math.pow(zD,t),new sB(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?RD:Math.pow(RD,t),new sB(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new eB(lB(t>=240?t-240:t+120,r,i),lB(t,r,i),lB(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var pB=(function t(e){var n=(function i(t){return 1==(t=+t)?uB:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):cB(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=tB(t)).r,(e=tB(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=uB(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function fB(t,e){e||(e=[]);var n,i=t?Math.min(e.length,t.length):0,r=e.slice();return function(o){for(n=0;n<i;++n)r[n]=t[n]*(1-o)+e[n]*o;return r}}function mB(t,e){var n,i=e?e.length:0,r=t?Math.min(i,t.length):0,o=new Array(r),a=new Array(i);for(n=0;n<r;++n)o[n]=wB(t[n],e[n]);for(;n<i;++n)a[n]=e[n];return function(t){for(n=0;n<r;++n)a[n]=o[n](t);return a}}function gB(t,e){var n=new Date;return t=+t,e=+e,function(i){return n.setTime(t*(1-i)+e*i),n}}function _B(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}function yB(t,e){var n,i={},r={};for(n in null!==t&&"object"==typeof t||(t={}),null!==e&&"object"==typeof e||(e={}),e)n in t?i[n]=wB(t[n],e[n]):r[n]=e[n];return function(t){for(n in i)r[n]=i[n](t);return r}}var vB=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,bB=new RegExp(vB.source,"g");function xB(t,e){var n,i,r,o=vB.lastIndex=bB.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=vB.exec(t))&&(i=bB.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:_B(n,i)})),o=bB.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}function wB(t,e){var n,i=typeof e;return null==e||"boolean"===i?cB(e):("number"===i?_B:"string"===i?(n=KD(e))?(e=n,pB):xB:e instanceof KD?pB:e instanceof Date?gB:(function r(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)})(e)?fB:Array.isArray(e)?mB:"function"!=typeof e.valueOf&&"function"!=typeof e.toString||isNaN(e)?yB:_B)(t,e)}var SB,MB,EB,TB,AB=180/Math.PI,CB={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function kB(t,e,n,i,r,o){var a,s,l;return(a=Math.sqrt(t*t+e*e))&&(t/=a,e/=a),(l=t*n+e*i)&&(n-=t*l,i-=e*l),(s=Math.sqrt(n*n+i*i))&&(n/=s,i/=s,l/=s),t*i<e*n&&(t=-t,e=-e,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(e,t)*AB,skewX:Math.atan(l)*AB,scaleX:a,scaleY:s}}function LB(t,e,n,i){function r(t){return t.length?t.pop()+" ":""}return function(o,a){var s=[],l=[];return o=t(o),a=t(a),(function c(t,i,r,o,a,s){if(t!==r||i!==o){var l=a.push("translate(",null,e,null,n);s.push({i:l-4,x:_B(t,r)},{i:l-2,x:_B(i,o)})}else(r||o)&&a.push("translate("+r+e+o+n)})(o.translateX,o.translateY,a.translateX,a.translateY,s,l),(function u(t,e,n,o){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),o.push({i:n.push(r(n)+"rotate(",null,i)-2,x:_B(t,e)})):e&&n.push(r(n)+"rotate("+e+i)})(o.rotate,a.rotate,s,l),(function h(t,e,n,o){t!==e?o.push({i:n.push(r(n)+"skewX(",null,i)-2,x:_B(t,e)}):e&&n.push(r(n)+"skewX("+e+i)})(o.skewX,a.skewX,s,l),(function d(t,e,n,i,o,a){if(t!==n||e!==i){var s=o.push(r(o)+"scale(",null,",",null,")");a.push({i:s-4,x:_B(t,n)},{i:s-2,x:_B(e,i)})}else 1===n&&1===i||o.push(r(o)+"scale("+n+","+i+")")})(o.scaleX,o.scaleY,a.scaleX,a.scaleY,s,l),o=a=null,function(t){for(var e,n=-1,i=l.length;++n<i;)s[(e=l[n]).i]=e.x(t);return s.join("")}}}var PB,IB,NB=LB((function OB(t){return"none"===t?CB:(SB||(SB=document.createElement("DIV"),MB=document.documentElement,EB=document.defaultView),SB.style.transform=t,t=EB.getComputedStyle(MB.appendChild(SB),null).getPropertyValue("transform"),MB.removeChild(SB),kB(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),RB=LB((function zB(t){return null==t?CB:(TB||(TB=document.createElementNS("http://www.w3.org/2000/svg","g")),TB.setAttribute("transform",t),(t=TB.transform.baseVal.consolidate())?kB((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):CB)}),", ",")",")"),DB=0,BB=0,HB=0,FB=0,VB=0,jB=0,UB="object"==typeof performance&&performance.now?performance:Date,GB="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function WB(){return VB||(GB(qB),VB=UB.now()+jB)}function qB(){VB=0}function YB(){this._call=this._time=this._next=null}function XB(t,e,n){var i=new YB;return i.restart(t,e,n),i}function $B(){VB=(FB=UB.now())+jB,DB=BB=0;try{!(function t(){WB(),++DB;for(var t,e=PB;e;)(t=VB-e._time)>=0&&e._call.call(null,t),e=e._next;--DB})()}finally{DB=0,(function e(){for(var t,e,n=PB,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:PB=e);IB=t,ZB(i)})(),VB=0}}function KB(){var t=UB.now(),e=t-FB;e>1e3&&(jB-=e,FB=t)}function ZB(t){DB||(BB&&(BB=clearTimeout(BB)),t-VB>24?(t<1/0&&(BB=setTimeout($B,t-UB.now()-jB)),HB&&(HB=clearInterval(HB))):(HB||(FB=UB.now(),HB=setInterval(KB,1e3)),DB=1,GB($B)))}function JB(t,e,n){var i=new YB;return i.restart((function(n){i.stop(),t(n+e)}),e=null==e?0:+e,n),i}YB.prototype=XB.prototype={constructor:YB,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?WB():+n)+(null==e?0:+e),this._next||IB===this||(IB?IB._next=this:PB=this,IB=this),this._call=t,this._time=n,ZB()},stop:function(){this._call&&(this._call=null,this._time=1/0,ZB())}};var QB=zR("start","end","cancel","interrupt"),tH=[];function eH(t,e,n,i,r,o){var a=t.__transition;if(a){if(n in a)return}else t.__transition={};!(function s(t,e,n){var i,r=t.__transition;function o(l){var c,u,h,d;if(1!==n.state)return s();for(c in r)if((d=r[c]).name===n.name){if(3===d.state)return JB(o);4===d.state?(d.state=6,d.timer.stop(),d.on.call("interrupt",t,t.__data__,d.index,d.group),delete r[c]):+c<e&&(d.state=6,d.timer.stop(),d.on.call("cancel",t,t.__data__,d.index,d.group),delete r[c])}if(JB((function(){3===n.state&&(n.state=4,n.timer.restart(a,n.delay,n.time),a(l))})),n.state=2,n.on.call("start",t,t.__data__,n.index,n.group),2===n.state){for(n.state=3,i=new Array(h=n.tween.length),c=0,u=-1;c<h;++c)(d=n.tween[c].value.call(t,t.__data__,n.index,n.group))&&(i[++u]=d);i.length=u+1}}function a(e){for(var r=e<n.duration?n.ease.call(null,e/n.duration):(n.timer.restart(s),n.state=5,1),o=-1,a=i.length;++o<a;)i[o].call(t,r);5===n.state&&(n.on.call("end",t,t.__data__,n.index,n.group),s())}function s(){for(var i in n.state=6,n.timer.stop(),delete r[e],r)return;delete t.__transition}r[e]=n,n.timer=XB((function l(t){n.state=1,n.timer.restart(o,n.delay,n.time),n.delay<=t&&o(t-n.delay)}),0,n.time)})(t,n,{name:e,index:i,group:r,on:QB,tween:tH,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:0})}function nH(t,e){var n=rH(t,e);if(n.state>0)throw new Error("too late; already scheduled");return n}function iH(t,e){var n=rH(t,e);if(n.state>3)throw new Error("too late; already running");return n}function rH(t,e){var n=t.__transition;if(!n||!(n=n[e]))throw new Error("transition not found");return n}function oH(t,e){var n,i,r,o=t.__transition,a=!0;if(o){for(r in e=null==e?null:e+"",o)(n=o[r]).name===e?(i=n.state>2&&n.state<5,n.state=6,n.timer.stop(),n.on.call(i?"interrupt":"cancel",t,t.__data__,n.index,n.group),delete o[r]):a=!1;a&&delete t.__transition}}function aH(t,e){var n,i;return function(){var r=iH(this,t),o=r.tween;if(o!==n)for(var a=0,s=(i=n=o).length;a<s;++a)if(i[a].name===e){(i=i.slice()).splice(a,1);break}r.tween=i}}function sH(t,e,n){var i,r;if("function"!=typeof n)throw new Error;return function(){var o=iH(this,t),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:e,value:n},l=0,c=r.length;l<c;++l)if(r[l].name===e){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function lH(t,e,n){var i=t._id;return t.each((function(){var t=iH(this,i);(t.value||(t.value={}))[e]=n.apply(this,arguments)})),function(t){return rH(t,i).value[e]}}function cH(t,e){var n;return("number"==typeof e?_B:e instanceof KD?pB:(n=KD(e))?(e=n,pB):xB)(t,e)}function uH(t){return function(){this.removeAttribute(t)}}function hH(t){return function(){this.removeAttributeNS(t.space,t.local)}}function dH(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttribute(t);return a===o?null:a===i?r:r=e(i=a,n)}}function pH(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttributeNS(t.space,t.local);return a===o?null:a===i?r:r=e(i=a,n)}}function fH(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttribute(t))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttribute(t)}}function mH(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttributeNS(t.space,t.local))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttributeNS(t.space,t.local)}}function gH(t,e){return function(n){this.setAttribute(t,e.call(this,n))}}function _H(t,e){return function(n){this.setAttributeNS(t.space,t.local,e.call(this,n))}}function yH(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&_H(t,r)),n}return r._value=e,r}function vH(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&gH(t,r)),n}return r._value=e,r}function bH(t,e){return function(){nH(this,t).delay=+e.apply(this,arguments)}}function xH(t,e){return e=+e,function(){nH(this,t).delay=e}}function wH(t,e){return function(){iH(this,t).duration=+e.apply(this,arguments)}}function SH(t,e){return e=+e,function(){iH(this,t).duration=e}}function MH(t,e){if("function"!=typeof e)throw new Error;return function(){iH(this,t).ease=e}}function EH(t,e,n){var i,r,o=(function a(t){return(t+"").trim().split(/^|\s+/).every((function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t}))})(e)?nH:iH;return function(){var a=o(this,t),s=a.on;s!==i&&(r=(i=s).copy()).on(e,n),a.on=r}}var TH=$z.prototype.constructor;function AH(t){return function(){this.style.removeProperty(t)}}function CH(t,e,n){return function(i){this.style.setProperty(t,e.call(this,i),n)}}function kH(t,e,n){var i,r;function o(){var o=e.apply(this,arguments);return o!==r&&(i=(r=o)&&CH(t,o,n)),i}return o._value=e,o}function LH(t){return function(e){this.textContent=t.call(this,e)}}function PH(t){var e,n;function i(){var i=t.apply(this,arguments);return i!==n&&(e=(n=i)&&LH(i)),e}return i._value=t,i}var IH=0;function NH(t,e,n,i){this._groups=t,this._parents=e,this._name=n,this._id=i}function OH(){return++IH}var RH=$z.prototype;NH.prototype={constructor:NH,select:function zH(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=XR(t));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var s,l,c=i[a],u=c.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=c[d])&&(l=t.call(s,s.__data__,d,c))&&("__data__"in s&&(l.__data__=s.__data__),h[d]=l,eH(h[d],e,n,d,h,rH(s,n)));return new NH(o,this._parents,e,n)},selectAll:function DH(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=KR(t));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var l,c=i[s],u=c.length,h=0;h<u;++h)if(l=c[h]){for(var d,p=t.call(l,l.__data__,h,c),f=rH(l,n),m=0,g=p.length;m<g;++m)(d=p[m])&&eH(d,e,n,m,p,f);o.push(p),a.push(l)}return new NH(o,a,e,n)},filter:function BH(t){"function"!=typeof t&&(t=ZR(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new NH(i,this._parents,this._name,this._id)},merge:function HH(t){if(t._id!==this._id)throw new Error;for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new NH(o,this._parents,this._name,this._id)},selection:function FH(){return new TH(this._groups,this._parents)},transition:function VH(){for(var t=this._name,e=this._id,n=OH(),i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)if(a=s[c]){var u=rH(a,e);eH(a,t,n,c,s,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new NH(i,this._parents,t,n)},call:RH.call,nodes:RH.nodes,node:RH.node,size:RH.size,empty:RH.empty,each:RH.each,on:function jH(t,e){var n=this._id;return arguments.length<2?rH(this.node(),n).on.on(t):this.each(EH(n,t,e))},attr:function UH(t,e){var n=UR(t),i="transform"===n?RB:cH;return this.attrTween(t,"function"==typeof e?(n.local?mH:fH)(n,i,lH(this,"attr."+t,e)):null==e?(n.local?hH:uH)(n):(n.local?pH:dH)(n,i,e))},attrTween:function GH(t,e){var n="attr."+t;if(arguments.length<2)return(n=this.tween(n))&&n._value;if(null==e)return this.tween(n,null);if("function"!=typeof e)throw new Error;var i=UR(t);return this.tween(n,(i.local?yH:vH)(i,e))},style:function WH(t,e,n){var i="transform"==(t+="")?NB:cH;return null==e?this.styleTween(t,(function r(t,e){var n,i,r;return function(){var o=pz(this,t),a=(this.style.removeProperty(t),pz(this,t));return o===a?null:o===n&&a===i?r:r=e(n=o,i=a)}})(t,i)).on("end.style."+t,AH(t)):"function"==typeof e?this.styleTween(t,(function a(t,e,n){var i,r,o;return function(){var a=pz(this,t),s=n(this),l=s+"";return null==s&&(this.style.removeProperty(t),l=s=pz(this,t)),a===l?null:a===i&&l===r?o:(r=l,o=e(i=a,s))}})(t,i,lH(this,"style."+t,e))).each((function o(t,e){var n,i,r,o,a="style."+e,s="end."+a;return function(){var l=iH(this,t),c=l.on,u=null==l.value[a]?o||(o=AH(e)):void 0;c===n&&r===u||(i=(n=c).copy()).on(s,r=u),l.on=i}})(this._id,t)):this.styleTween(t,(function s(t,e,n){var i,r,o=n+"";return function(){var a=pz(this,t);return a===o?null:a===i?r:r=e(i=a,n)}})(t,i,e),n).on("end.style."+t,null)},styleTween:function qH(t,e,n){var i="style."+(t+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==e)return this.tween(i,null);if("function"!=typeof e)throw new Error;return this.tween(i,kH(t,e,null==n?"":n))},text:function YH(t){return this.tween("text","function"==typeof t?(function e(t){return function(){var e=t(this);this.textContent=null==e?"":e}})(lH(this,"text",t)):(function n(t){return function(){this.textContent=t}})(null==t?"":t+""))},textTween:function XH(t){var e="text";if(arguments.length<1)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;return this.tween(e,PH(t))},remove:function $H(){return this.on("end.remove",(function t(e){return function(){var t=this.parentNode;for(var n in this.__transition)if(+n!==e)return;t&&t.removeChild(this)}})(this._id))},tween:function KH(t,e){var n=this._id;if(t+="",arguments.length<2){for(var i,r=rH(this.node(),n).tween,o=0,a=r.length;o<a;++o)if((i=r[o]).name===t)return i.value;return null}return this.each((null==e?aH:sH)(n,t,e))},delay:function ZH(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?bH:xH)(e,t)):rH(this.node(),e).delay},duration:function JH(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?wH:SH)(e,t)):rH(this.node(),e).duration},ease:function QH(t){var e=this._id;return arguments.length?this.each(MH(e,t)):rH(this.node(),e).ease},end:function tF(){var t,e,n=this,i=n._id,r=n.size();return new Promise((function(o,a){var s={value:a},l={value:function(){0==--r&&o()}};n.each((function(){var n=iH(this,i),r=n.on;r!==t&&((e=(t=r).copy())._.cancel.push(s),e._.interrupt.push(s),e._.end.push(l)),n.on=e}))}))}};var eF={time:null,delay:0,duration:250,ease:Tf};function nF(t,e){for(var n;!(n=t.__transition)||!(n=n[e]);)if(!(t=t.parentNode))return eF.time=WB(),eF;return n}function iF(t){return function(){return t}}function rF(t,e,n){this.target=t,this.type=e,this.selection=n}function oF(){Bz.stopImmediatePropagation()}function aF(){Bz.preventDefault(),Bz.stopImmediatePropagation()}$z.prototype.interrupt=function sF(t){return this.each((function(){oH(this,t)}))},$z.prototype.transition=function lF(t){var e,n;t instanceof NH?(e=t._id,t=t._name):(e=OH(),(n=eF).time=WB(),t=null==t?null:t+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)(a=s[c])&&eH(a,t,e,c,s,n||nF(a,e));return new NH(i,this._parents,t,e)};var cF={name:"drag"},uF={name:"space"},hF={name:"handle"},dF={name:"center"},pF={name:"x",handles:["e","w"].map(xF),input:function(t,e){return t&&[[t[0],e[0][1]],[t[1],e[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},fF={name:"y",handles:["n","s"].map(xF),input:function(t,e){return t&&[[e[0][0],t[0]],[e[1][0],t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},mF={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(xF),input:function(t){return t},output:function(t){return t}},gF={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},_F={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},yF={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},vF={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},bF={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function xF(t){return{type:t}}function wF(){return!Bz.button}function SF(){var t=this.ownerSVGElement||this;return[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function MF(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function EF(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function TF(t){var e,n=SF,i=wF,r=zR(a,"start","brush","end"),o=6;function a(e){var n=e.property("__brush",h).selectAll(".overlay").data([xF("overlay")]);n.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",gF.overlay).merge(n).each((function(){var t=MF(this).extent;Kz(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),e.selectAll(".selection").data([xF("selection")]).enter().append("rect").attr("class","selection").attr("cursor",gF.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var i=e.selectAll(".handle").data(t.handles,(function(t){return t.type}));i.exit().remove(),i.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return gF[t.type]})),e.each(s).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",u)}function s(){var t=Kz(this),e=MF(this).selection;e?(t.selectAll(".selection").style("display",null).attr("x",e[0][0]).attr("y",e[0][1]).attr("width",e[1][0]-e[0][0]).attr("height",e[1][1]-e[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?e[1][0]-o/2:e[0][0]-o/2})).attr("y",(function(t){return"s"===t.type[0]?e[1][1]-o/2:e[0][1]-o/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?e[1][0]-e[0][0]+o:o})).attr("height",(function(t){return"e"===t.type||"w"===t.type?e[1][1]-e[0][1]+o:o}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function l(t,e){return t.__brush.emitter||new c(t,e)}function c(t,e){this.that=t,this.args=e,this.state=t.__brush,this.active=0}function u(){if(Bz.touches){if(Bz.changedTouches.length<Bz.touches.length)return aF()}else if(e)return;if(i.apply(this,arguments)){var n,r,o,a,c,u,h,d,p,f,m,g,_,y=this,v=Bz.target.__data__.type,b="selection"===(Bz.metaKey?v="overlay":v)?cF:Bz.altKey?dF:hF,x=t===fF?null:vF[v],w=t===pF?null:bF[v],S=MF(y),M=S.extent,E=S.selection,T=M[0][0],A=M[0][1],C=M[1][0],k=M[1][1],L=x&&w&&Bz.shiftKey,P=Zz(y),I=P,N=l(y,arguments).beforestart();"overlay"===v?S.selection=E=[[n=t===fF?T:P[0],o=t===pF?A:P[1]],[c=t===fF?C:n,h=t===pF?k:o]]:(n=E[0][0],o=E[0][1],c=E[1][0],h=E[1][1]),r=n,a=o,u=c,d=h;var O=Kz(y).attr("pointer-events","none"),R=O.selectAll(".overlay").attr("cursor",gF[v]);if(Bz.touches)O.on("touchmove.brush",D,!0).on("touchend.brush touchcancel.brush",H,!0);else{var z=Kz(Bz.view).on("keydown.brush",F,!0).on("keyup.brush",V,!0).on("mousemove.brush",D,!0).on("mouseup.brush",H,!0);Qz(Bz.view)}oF(),oH(y),s.call(y),N.start()}function D(){var t=Zz(y);!L||g||_||(Math.abs(t[0]-I[0])>Math.abs(t[1]-I[1])?_=!0:g=!0),I=t,m=!0,aF(),B()}function B(){var t;switch(p=I[0]-P[0],f=I[1]-P[1],b){case uF:case cF:x&&(p=Math.max(T-n,Math.min(C-c,p)),r=n+p,u=c+p),w&&(f=Math.max(A-o,Math.min(k-h,f)),a=o+f,d=h+f);break;case hF:x<0?(p=Math.max(T-n,Math.min(C-n,p)),r=n+p,u=c):x>0&&(p=Math.max(T-c,Math.min(C-c,p)),r=n,u=c+p),w<0?(f=Math.max(A-o,Math.min(k-o,f)),a=o+f,d=h):w>0&&(f=Math.max(A-h,Math.min(k-h,f)),a=o,d=h+f);break;case dF:x&&(r=Math.max(T,Math.min(C,n-p*x)),u=Math.max(T,Math.min(C,c+p*x))),w&&(a=Math.max(A,Math.min(k,o-f*w)),d=Math.max(A,Math.min(k,h+f*w)))}u<r&&(x*=-1,t=n,n=c,c=t,t=r,r=u,u=t,v in _F&&R.attr("cursor",gF[v=_F[v]])),d<a&&(w*=-1,t=o,o=h,h=t,t=a,a=d,d=t,v in yF&&R.attr("cursor",gF[v=yF[v]])),S.selection&&(E=S.selection),g&&(r=E[0][0],u=E[1][0]),_&&(a=E[0][1],d=E[1][1]),E[0][0]===r&&E[0][1]===a&&E[1][0]===u&&E[1][1]===d||(S.selection=[[r,a],[u,d]],s.call(y),N.brush())}function H(){if(oF(),Bz.touches){if(Bz.touches.length)return;e&&clearTimeout(e),e=setTimeout((function(){e=null}),500),O.on("touchmove.brush touchend.brush touchcancel.brush",null)}else tD(Bz.view,m),z.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);O.attr("pointer-events","all"),R.attr("cursor",gF.overlay),S.selection&&(E=S.selection),EF(E)&&(S.selection=null,s.call(y)),N.end()}function F(){switch(Bz.keyCode){case 16:L=x&&w;break;case 18:b===hF&&(x&&(c=u-p*x,n=r+p*x),w&&(h=d-f*w,o=a+f*w),b=dF,B());break;case 32:b!==hF&&b!==dF||(x<0?c=u-p:x>0&&(n=r-p),w<0?h=d-f:w>0&&(o=a-f),b=uF,R.attr("cursor",gF.selection),B());break;default:return}aF()}function V(){switch(Bz.keyCode){case 16:L&&(g=_=L=!1,B());break;case 18:b===dF&&(x<0?c=u:x>0&&(n=r),w<0?h=d:w>0&&(o=a),b=hF,B());break;case 32:b===uF&&(Bz.altKey?(x&&(c=u-p*x,n=r+p*x),w&&(h=d-f*w,o=a+f*w),b=dF):(x<0?c=u:x>0&&(n=r),w<0?h=d:w>0&&(o=a),b=hF),R.attr("cursor",gF[v]),B());break;default:return}aF()}}function h(){var e=this.__brush||{selection:null};return e.extent=n.apply(this,arguments),e.dim=t,e}return a.move=function(e,n){e.selection?e.on("start.brush",(function(){l(this,arguments).beforestart().start()})).on("interrupt.brush end.brush",(function(){l(this,arguments).end()})).tween("brush",(function(){var e=this,i=e.__brush,r=l(e,arguments),o=i.selection,a=t.input("function"==typeof n?n.apply(this,arguments):n,i.extent),c=wB(o,a);function u(t){i.selection=1===t&&EF(a)?null:c(t),s.call(e),r.brush()}return o&&a?u:u(1)})):e.each((function(){var e=this,i=arguments,r=e.__brush,o=t.input("function"==typeof n?n.apply(e,i):n,r.extent),a=l(e,i).beforestart();oH(e),r.selection=null==o||EF(o)?null:o,s.call(e),a.start().brush().end()}))},c.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting&&(this.starting=!1,this.emit("start")),this},brush:function(){return this.emit("brush"),this},end:function(){return 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(e){!(function n(t,e,i,r){var o=Bz;t.sourceEvent=Bz,Bz=t;try{e.apply(i,r)}finally{Bz=o}})(new rF(a,e,t.output(this.state.selection)),r.apply,r,[e,this.that,this.args])}},a.extent=function(t){return arguments.length?(n="function"==typeof t?t:iF([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),a):n},a.filter=function(t){return arguments.length?(i="function"==typeof t?t:iF(!!t),a):i},a.handleSize=function(t){return arguments.length?(o=+t,a):o},a.on=function(){var t=r.on.apply(r,arguments);return t===r?a:t},a}function AF(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function CF(t,e,n){t=+t,e=+e,n=(r=arguments.length)<2?(e=t,t=0,1):r<3?1:+n;for(var i=-1,r=0|Math.max(0,Math.ceil((e-t)/n)),o=new Array(r);++i<r;)o[i]=t+i*n;return o}!(function kF(t){1===t.length&&(t=(function e(t){return function(e,n){return AF(t(e),n)}})(t))})(AF);var LF=Math.cos,PF=Math.sin,IF=Math.PI,NF=IF/2,OF=2*IF,RF=Math.max;function zF(t){return function(e,n){return t(e.source.value+e.target.value,n.source.value+n.target.value)}}var DF=Array.prototype.slice;function BF(t){return function(){return t}}var HF=Math.PI,FF=2*HF,VF=1e-6,jF=FF-VF;function UF(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function GF(){return new UF}function WF(t){return t.source}function qF(t){return t.target}function YF(t){return t.radius}function XF(t){return t.startAngle}function $F(t){return t.endAngle}UF.prototype=GF.prototype={constructor:UF,moveTo:function(t,e){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,e){this._+="L"+(this._x1=+t)+","+(this._y1=+e)},quadraticCurveTo:function(t,e,n,i){this._+="Q"+ +t+","+ +e+","+(this._x1=+n)+","+(this._y1=+i)},bezierCurveTo:function(t,e,n,i,r,o){this._+="C"+ +t+","+ +e+","+ +n+","+ +i+","+(this._x1=+r)+","+(this._y1=+o)},arcTo:function(t,e,n,i,r){var o=this._x1,a=this._y1,s=(n=+n)-(t=+t),l=(i=+i)-(e=+e),c=o-t,u=a-e,h=c*c+u*u;if((r=+r)<0)throw new Error("negative radius: "+r);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=e);else if(h>VF)if(Math.abs(u*s-l*c)>VF&&r){var d=n-o,p=i-a,f=s*s+l*l,m=d*d+p*p,g=Math.sqrt(f),_=Math.sqrt(h),y=r*Math.tan((HF-Math.acos((f+h-m)/(2*g*_)))/2),v=y/_,b=y/g;Math.abs(v-1)>VF&&(this._+="L"+(t+v*c)+","+(e+v*u)),this._+="A"+r+","+r+",0,0,"+ +(u*d>c*p)+","+(this._x1=t+b*s)+","+(this._y1=e+b*l)}else this._+="L"+(this._x1=t)+","+(this._y1=e)},arc:function(t,e,n,i,r,o){t=+t,e=+e,o=!!o;var a=(n=+n)*Math.cos(i),s=n*Math.sin(i),l=t+a,c=e+s,u=1^o,h=o?i-r:r-i;if(n<0)throw new Error("negative radius: "+n);null===this._x1?this._+="M"+l+","+c:(Math.abs(this._x1-l)>VF||Math.abs(this._y1-c)>VF)&&(this._+="L"+l+","+c),n&&(h<0&&(h=h%FF+FF),h>jF?this._+="A"+n+","+n+",0,1,"+u+","+(t-a)+","+(e-s)+"A"+n+","+n+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>VF&&(this._+="A"+n+","+n+",0,"+ +(h>=HF)+","+u+","+(this._x1=t+n*Math.cos(r))+","+(this._y1=e+n*Math.sin(r))))},rect:function(t,e,n,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)+"h"+ +n+"v"+ +i+"h"+-n+"Z"},toString:function(){return this._}};var KF="$";function ZF(){}function JF(t,e){var n=new ZF;if(t instanceof ZF)t.each((function(t,e){n.set(e,t)}));else if(Array.isArray(t)){var i,r=-1,o=t.length;if(null==e)for(;++r<o;)n.set(r,t[r]);else for(;++r<o;)n.set(e(i=t[r],r,t),i)}else if(t)for(var a in t)n.set(a,t[a]);return n}function QF(){return{}}function tV(t,e,n){t[e]=n}function eV(){return JF()}function nV(t,e,n){t.set(e,n)}function iV(){}ZF.prototype=JF.prototype={constructor:ZF,has:function(t){return KF+t in this},get:function(t){return this[KF+t]},set:function(t,e){return this[KF+t]=e,this},remove:function(t){var e=KF+t;return e in this&&delete this[e]},clear:function(){for(var t in this)t[0]===KF&&delete this[t]},keys:function(){var t=[];for(var e in this)e[0]===KF&&t.push(e.slice(1));return t},values:function(){var t=[];for(var e in this)e[0]===KF&&t.push(this[e]);return t},entries:function(){var t=[];for(var e in this)e[0]===KF&&t.push({key:e.slice(1),value:this[e]});return t},size:function(){var t=0;for(var e in this)e[0]===KF&&++t;return t},empty:function(){for(var t in this)if(t[0]===KF)return!1;return!0},each:function(t){for(var e in this)e[0]===KF&&t(this[e],e.slice(1),this)}};var rV=JF.prototype;function oV(t,e){var n=new iV;if(t instanceof iV)t.each((function(t){n.add(t)}));else if(t){var i=-1,r=t.length;if(null==e)for(;++i<r;)n.add(t[i]);else for(;++i<r;)n.add(e(t[i],i,t))}return n}function aV(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function sV(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function lV(){}iV.prototype=oV.prototype={constructor:iV,has:rV.has,add:function(t){return this[KF+(t+="")]=t,this},remove:rV.remove,clear:rV.clear,values:rV.keys,size:rV.size,empty:rV.empty,each:rV.each};var cV=.7,uV=1/cV,hV="\\s*([+-]?\\d+)\\s*",dV="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",pV="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",fV=/^#([0-9a-f]{3})$/,mV=/^#([0-9a-f]{6})$/,gV=new RegExp("^rgb\\("+[hV,hV,hV]+"\\)$"),_V=new RegExp("^rgb\\("+[pV,pV,pV]+"\\)$"),yV=new RegExp("^rgba\\("+[hV,hV,hV,dV]+"\\)$"),vV=new RegExp("^rgba\\("+[pV,pV,pV,dV]+"\\)$"),bV=new RegExp("^hsl\\("+[dV,pV,pV]+"\\)$"),xV=new RegExp("^hsla\\("+[dV,pV,pV,dV]+"\\)$"),wV={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function SV(t){var e;return t=(t+"").trim().toLowerCase(),(e=fV.exec(t))?new CV((e=parseInt(e[1],16))>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):(e=mV.exec(t))?MV(parseInt(e[1],16)):(e=gV.exec(t))?new CV(e[1],e[2],e[3],1):(e=_V.exec(t))?new CV(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=yV.exec(t))?EV(e[1],e[2],e[3],e[4]):(e=vV.exec(t))?EV(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=bV.exec(t))?kV(e[1],e[2]/100,e[3]/100,1):(e=xV.exec(t))?kV(e[1],e[2]/100,e[3]/100,e[4]):wV.hasOwnProperty(t)?MV(wV[t]):"transparent"===t?new CV(NaN,NaN,NaN,0):null}function MV(t){return new CV(t>>16&255,t>>8&255,255&t,1)}function EV(t,e,n,i){return i<=0&&(t=e=n=NaN),new CV(t,e,n,i)}function TV(t){return t instanceof lV||(t=SV(t)),t?new CV((t=t.rgb()).r,t.g,t.b,t.opacity):new CV}function AV(t,e,n,i){return 1===arguments.length?TV(t):new CV(t,e,n,null==i?1:i)}function CV(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function kV(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new IV(t,e,n,i)}function LV(t){if(t instanceof IV)return new IV(t.h,t.s,t.l,t.opacity);if(t instanceof lV||(t=SV(t)),!t)return new IV;if(t instanceof IV)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new IV(a,s,l,t.opacity)}function PV(t,e,n,i){return 1===arguments.length?LV(t):new IV(t,e,n,null==i?1:i)}function IV(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function NV(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}aV(lV,SV,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}}),aV(CV,AV,sV(lV,{brighter:function(t){return t=null==t?uV:Math.pow(uV,t),new CV(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?cV:Math.pow(cV,t),new CV(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}})),aV(IV,PV,sV(lV,{brighter:function(t){return t=null==t?uV:Math.pow(uV,t),new IV(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?cV:Math.pow(cV,t),new IV(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new CV(NV(t>=240?t-240:t+120,r,i),NV(t,r,i),NV(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}));var OV=Math.PI/180,RV=180/Math.PI,zV=.95047,DV=1.08883,BV=4/29,HV=6/29,FV=3*HV*HV;function VV(t){if(t instanceof UV)return new UV(t.l,t.a,t.b,t.opacity);if(t instanceof KV){var e=t.h*OV;return new UV(t.l,Math.cos(e)*t.c,Math.sin(e)*t.c,t.opacity)}t instanceof CV||(t=TV(t));var n=YV(t.r),i=YV(t.g),r=YV(t.b),o=GV((.4124564*n+.3575761*i+.1804375*r)/zV),a=GV((.2126729*n+.7151522*i+.072175*r)/1);return new UV(116*a-16,500*(o-a),200*(a-GV((.0193339*n+.119192*i+.9503041*r)/DV)),t.opacity)}function jV(t,e,n,i){return 1===arguments.length?VV(t):new UV(t,e,n,null==i?1:i)}function UV(t,e,n,i){this.l=+t,this.a=+e,this.b=+n,this.opacity=+i}function GV(t){return t>.008856451679035631?Math.pow(t,1/3):t/FV+BV}function WV(t){return t>HV?t*t*t:FV*(t-BV)}function qV(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function YV(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function XV(t){if(t instanceof KV)return new KV(t.h,t.c,t.l,t.opacity);t instanceof UV||(t=VV(t));var e=Math.atan2(t.b,t.a)*RV;return new KV(e<0?e+360:e,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function $V(t,e,n,i){return 1===arguments.length?XV(t):new KV(t,e,n,null==i?1:i)}function KV(t,e,n,i){this.h=+t,this.c=+e,this.l=+n,this.opacity=+i}aV(UV,jV,sV(lV,{brighter:function(t){return new UV(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new UV(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,n=isNaN(this.b)?t:t-this.b/200;return t=1*WV(t),new CV(qV(3.2404542*(e=zV*WV(e))-1.5371385*t-.4985314*(n=DV*WV(n))),qV(-.969266*e+1.8760108*t+.041556*n),qV(.0556434*e-.2040259*t+1.0572252*n),this.opacity)}})),aV(KV,$V,sV(lV,{brighter:function(t){return new KV(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new KV(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return VV(this).rgb()}}));var ZV=-.29227,JV=-.90649,QV=1.97294;function tj(t){if(t instanceof nj)return new nj(t.h,t.s,t.l,t.opacity);t instanceof CV||(t=TV(t));var e=t.g/255,n=t.b/255,i=(-.6557636667999999*n+t.r/255*-1.7884503806-3.5172982438*e)/-5.9615122912,r=n-i,o=(QV*(e-i)-ZV*r)/JV,a=Math.sqrt(o*o+r*r)/(QV*i*(1-i)),s=a?Math.atan2(o,r)*RV-120:NaN;return new nj(s<0?s+360:s,a,i,t.opacity)}function ej(t,e,n,i){return 1===arguments.length?tj(t):new nj(t,e,n,null==i?1:i)}function nj(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}aV(nj,ej,sV(lV,{brighter:function(t){return t=null==t?uV:Math.pow(uV,t),new nj(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?cV:Math.pow(cV,t),new nj(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*OV,e=+this.l,n=isNaN(this.s)?0:this.s*e*(1-e),i=Math.cos(t),r=Math.sin(t);return new CV(255*(e+n*(-.14861*i+1.78277*r)),255*(e+n*(ZV*i+JV*r)),255*(e+n*(QV*i)),this.opacity)}}));var ij={value:function(){}};function rj(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i)throw new Error("illegal type: "+t);i[t]=[]}return new oj(i)}function oj(t){this._=t}function aj(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function sj(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function lj(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=ij,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}oj.prototype=rj.prototype={constructor:oj,on:function(t,e){var n,i=this._,r=aj(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=lj(i[n],t.name,e);else if(null==e)for(n in i)i[n]=lj(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=sj(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new oj(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var cj={value:function(){}};function uj(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new hj(i)}function hj(t){this._=t}function dj(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function pj(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function fj(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=cj,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}hj.prototype=uj.prototype={constructor:hj,on:function(t,e){var n,i=this._,r=dj(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=fj(i[n],t.name,e);else if(null==e)for(n in i)i[n]=fj(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=pj(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new hj(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var mj="http://www.w3.org/1999/xhtml",gj={svg:"http://www.w3.org/2000/svg",xhtml:mj,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function _j(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),gj.hasOwnProperty(e)?{space:gj[e],local:t}:t}function yj(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===mj&&e.documentElement.namespaceURI===mj?e.createElement(t):e.createElementNS(n,t)}}function vj(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function bj(t){var e=_j(t);return(e.local?vj:yj)(e)}function xj(){}function wj(t){return null==t?xj:function(){return this.querySelector(t)}}function Sj(){return[]}function Mj(t){return new Array(t.length)}function Ej(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function Tj(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new Ej(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function Aj(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new Ej(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function Cj(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function kj(t){return function(){this.removeAttribute(t)}}function Lj(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Pj(t,e){return function(){this.setAttribute(t,e)}}function Ij(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function Nj(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function Oj(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function Rj(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function zj(t){return function(){this.style.removeProperty(t)}}function Dj(t,e,n){return function(){this.style.setProperty(t,e,n)}}function Bj(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function Hj(t,e){return t.style.getPropertyValue(e)||Rj(t).getComputedStyle(t,null).getPropertyValue(e)}function Fj(t){return function(){delete this[t]}}function Vj(t,e){return function(){this[t]=e}}function jj(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function Uj(t){return t.trim().split(/^|\s+/)}function Gj(t){return t.classList||new Wj(t)}function Wj(t){this._node=t,this._names=Uj(t.getAttribute("class")||"")}function qj(t,e){for(var n=Gj(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function Yj(t,e){for(var n=Gj(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function Xj(t){return function(){qj(this,t)}}function $j(t){return function(){Yj(this,t)}}function Kj(t,e){return function(){(e.apply(this,arguments)?qj:Yj)(this,t)}}function Zj(){this.textContent=""}function Jj(t){return function(){this.textContent=t}}function Qj(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function tU(){this.innerHTML=""}function eU(t){return function(){this.innerHTML=t}}function nU(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function iU(){this.nextSibling&&this.parentNode.appendChild(this)}function rU(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function oU(){return null}function aU(){var t=this.parentNode;t&&t.removeChild(this)}function sU(){var t=this.cloneNode(!1),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}function lU(){var t=this.cloneNode(!0),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}Ej.prototype={constructor:Ej,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},Wj.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var cU={},uU=null;function hU(t,e,n){return t=dU(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function dU(t,e,n){return function(i){var r=uU;uU=i;try{t.call(this,this.__data__,e,n)}finally{uU=r}}}function pU(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function fU(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function mU(t,e,n){var i=cU.hasOwnProperty(t.type)?hU:dU;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function gU(t,e,n,i){var r=uU;t.sourceEvent=uU,uU=t;try{return e.apply(n,i)}finally{uU=r}}function _U(t,e,n){var i=Rj(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function yU(t,e){return function(){return _U(this,t,e)}}function vU(t,e){return function(){return _U(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(cU={mouseenter:"mouseover",mouseleave:"mouseout"}));var bU=[null];function xU(t,e){this._groups=t,this._parents=e}function wU(t){return"string"==typeof t?new xU([[document.querySelector(t)]],[document.documentElement]):new xU([[t]],bU)}function SU(){for(var t,e=uU;t=e.sourceEvent;)e=t;return e}function MU(t,e){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var i=n.createSVGPoint();return i.x=e.clientX,i.y=e.clientY,[(i=i.matrixTransform(t.getScreenCTM().inverse())).x,i.y]}var r=t.getBoundingClientRect();return[e.clientX-r.left-t.clientLeft,e.clientY-r.top-t.clientTop]}function EU(t){var e=SU();return e.changedTouches&&(e=e.changedTouches[0]),MU(t,e)}function TU(t,e,n){arguments.length<3&&(n=e,e=SU().changedTouches);for(var i,r=0,o=e?e.length:0;r<o;++r)if((i=e[r]).identifier===n)return MU(t,i);return null}function AU(){uU.stopImmediatePropagation()}function CU(){uU.preventDefault(),uU.stopImmediatePropagation()}function kU(t){var e=t.document.documentElement,n=wU(t).on("dragstart.drag",CU,!0);"onselectstart"in e?n.on("selectstart.drag",CU,!0):(e.__noselect=e.style.MozUserSelect,e.style.MozUserSelect="none")}function LU(t,e){var n=t.document.documentElement,i=wU(t).on("dragstart.drag",null);e&&(i.on("click.drag",CU,!0),setTimeout((function(){i.on("click.drag",null)}),0)),"onselectstart"in n?i.on("selectstart.drag",null):(n.style.MozUserSelect=n.__noselect,delete n.__noselect)}function PU(t){return function(){return t}}function IU(t,e,n,i,r,o,a,s,l,c){this.target=t,this.type=e,this.subject=n,this.identifier=i,this.active=r,this.x=o,this.y=a,this.dx=s,this.dy=l,this._=c}function NU(){return!uU.button}function OU(){return this.parentNode}function RU(t){return null==t?{x:uU.x,y:uU.y}:t}function zU(){return"ontouchstart"in this}xU.prototype={constructor:xU,select:function DU(t){"function"!=typeof t&&(t=wj(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new xU(i,this._parents)},selectAll:function BU(t){"function"!=typeof t&&(t=(function e(t){return null==t?Sj:function(){return this.querySelectorAll(t)}})(t));for(var n=this._groups,i=n.length,r=[],o=[],a=0;a<i;++a)for(var s,l=n[a],c=l.length,u=0;u<c;++u)(s=l[u])&&(r.push(t.call(s,s.__data__,u,l)),o.push(s));return new xU(r,o)},filter:function HU(t){"function"!=typeof t&&(t=(function e(t){return function(){return this.matches(t)}})(t));for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o)for(var a,s=n[o],l=s.length,c=r[o]=[],u=0;u<l;++u)(a=s[u])&&t.call(a,a.__data__,u,s)&&c.push(a);return new xU(r,this._parents)},data:function FU(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?Aj:Tj,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new xU(s,i))._enter=l,s._exit=c,s},enter:function VU(){return new xU(this._enter||this._groups.map(Mj),this._parents)},exit:function jU(){return new xU(this._exit||this._groups.map(Mj),this._parents)},join:function UU(t,e,n){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof t?t(i):i.append(t+""),null!=e&&(r=e(r)),null==n?o.remove():n(o),i&&r?i.merge(r).order():r},merge:function GU(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new xU(o,this._parents)},order:function WU(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&4^i.compareDocumentPosition(a)&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function qU(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=Cj);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new xU(r,this._parents).order()},call:function YU(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function XU(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function $U(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function KU(){var t=0;return this.each((function(){++t})),t},empty:function ZU(){return!this.node()},each:function JU(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function QU(t,e){var n=_j(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?Lj:kj:"function"==typeof e?n.local?Oj:Nj:n.local?Ij:Pj)(n,e))},style:function tG(t,e,n){return arguments.length>1?this.each((null==e?zj:"function"==typeof e?Bj:Dj)(t,e,null==n?"":n)):Hj(this.node(),t)},property:function eG(t,e){return arguments.length>1?this.each((null==e?Fj:"function"==typeof e?jj:Vj)(t,e)):this.node()[t]},classed:function nG(t,e){var n=Uj(t+"");if(arguments.length<2){for(var i=Gj(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?Kj:e?Xj:$j)(n,e))},text:function iG(t){return arguments.length?this.each(null==t?Zj:("function"==typeof t?Qj:Jj)(t)):this.node().textContent},html:function rG(t){return arguments.length?this.each(null==t?tU:("function"==typeof t?nU:eU)(t)):this.node().innerHTML},raise:function oG(){return this.each(iU)},lower:function aG(){return this.each(rU)},append:function sG(t){var e="function"==typeof t?t:bj(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function lG(t,e){var n="function"==typeof t?t:bj(t),i=null==e?oU:"function"==typeof e?e:wj(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function cG(){return this.each(aU)},clone:function uG(t){return this.select(t?lU:sU)},datum:function hG(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function dG(t,e,n){var i,r,o=pU(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?mU:fU,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function pG(t,e){return this.each(("function"==typeof e?vU:yU)(t,e))}},IU.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var fG={},mG={};function gG(t){return new Function("d","return {"+t.map((function(t,e){return JSON.stringify(t)+": d["+e+"]"})).join(",")+"}")}function _G(t){var e=new RegExp('["'+t+"\n\r]"),n=t.charCodeAt(0);function i(t,e){var i,r=[],o=t.length,a=0,s=0,l=o<=0,c=!1;function u(){if(l)return mG;if(c)return c=!1,fG;var e,i,r=a;if(34===t.charCodeAt(r)){for(;a++<o&&34!==t.charCodeAt(a)||34===t.charCodeAt(++a););return(e=a)>=o?l=!0:10===(i=t.charCodeAt(a++))?c=!0:13===i&&(c=!0,10===t.charCodeAt(a)&&++a),t.slice(r+1,e-1).replace(/""/g,'"')}for(;a<o;){if(10===(i=t.charCodeAt(e=a++)))c=!0;else if(13===i)c=!0,10===t.charCodeAt(a)&&++a;else if(i!==n)continue;return t.slice(r,e)}return l=!0,t.slice(r,o)}for(10===t.charCodeAt(o-1)&&--o,13===t.charCodeAt(o-1)&&--o;(i=u())!==mG;){for(var h=[];i!==fG&&i!==mG;)h.push(i),i=u();e&&null==(h=e(h,s++))||r.push(h)}return r}function r(e){return e.map(o).join(t)}function o(t){return null==t?"":e.test(t+="")?'"'+t.replace(/"/g,'""')+'"':t}return{parse:function a(t,e){var n,r,o=i(t,(function(t,i){if(n)return n(t,i-1);r=t,n=e?(function o(t,e){var n=gG(t);return function(i,r){return e(n(i),r,t)}})(t,e):gG(t)}));return o.columns=r||[],o},parseRows:i,format:function s(e,n){return null==n&&(n=(function i(t){var e=Object.create(null),n=[];return t.forEach((function(t){for(var i in t)i in e||n.push(e[i]=i)})),n})(e)),[n.map(o).join(t)].concat(e.map((function(e){return n.map((function(t){return o(e[t])})).join(t)}))).join("\n")},formatRows:function l(t){return t.map(r).join("\n")}}}var yG=_G(","),vG=yG.parse,bG=yG.parseRows,xG=yG.format,wG=yG.formatRows,SG=_G("\t"),MG=SG.parse,EG=SG.parseRows,TG=SG.format,AG=SG.formatRows;function CG(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function kG(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}var LG=(function t(e){function n(t){return Math.pow(t,e)}return e=+e,n.exponent=t,n})(3),PG=(function t(e){function n(t){return 1-Math.pow(1-t,e)}return e=+e,n.exponent=t,n})(3),IG=(function t(e){function n(t){return((t*=2)<=1?Math.pow(t,e):2-Math.pow(2-t,e))/2}return e=+e,n.exponent=t,n})(3),NG=Math.PI,OG=NG/2;function RG(t){return(1-Math.cos(NG*t))/2}function zG(t){return((t*=2)<=1?Math.pow(2,10*t-10):2-Math.pow(2,10-10*t))/2}function DG(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}var BG=7.5625;function HG(t){return(t=+t)<.36363636363636365?BG*t*t:t<.7272727272727273?BG*(t-=.5454545454545454)*t+.75:t<.9090909090909091?BG*(t-=.8181818181818182)*t+.9375:BG*(t-=.9545454545454546)*t+.984375}var FG=1.70158,VG=(function t(e){function n(t){return t*t*((e+1)*t-e)}return e=+e,n.overshoot=t,n})(FG),jG=(function t(e){function n(t){return--t*t*((e+1)*t+e)+1}return e=+e,n.overshoot=t,n})(FG),UG=(function t(e){function n(t){return((t*=2)<1?t*t*((e+1)*t-e):(t-=2)*t*((e+1)*t+e)+2)/2}return e=+e,n.overshoot=t,n})(FG),GG=2*Math.PI,WG=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=GG);function r(t){return e*Math.pow(2,10*--t)*Math.sin((i-t)/n)}return r.amplitude=function(e){return t(e,n*GG)},r.period=function(n){return t(e,n)},r})(1,.3),qG=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=GG);function r(t){return 1-e*Math.pow(2,-10*(t=+t))*Math.sin((t+i)/n)}return r.amplitude=function(e){return t(e,n*GG)},r.period=function(n){return t(e,n)},r})(1,.3),YG=(function t(e,n){var i=Math.asin(1/(e=Math.max(1,e)))*(n/=GG);function r(t){return((t=2*t-1)<0?e*Math.pow(2,10*t)*Math.sin((i-t)/n):2-e*Math.pow(2,-10*t)*Math.sin((i+t)/n))/2}return r.amplitude=function(e){return t(e,n*GG)},r.period=function(n){return t(e,n)},r})(1,.3);function XG(t){return function(){return t}}function $G(){return 1e-6*(Math.random()-.5)}function KG(t,e,n,i){if(isNaN(e)||isNaN(n))return t;var r,o,a,s,l,c,u,h,d,p=t._root,f={data:i},m=t._x0,g=t._y0,_=t._x1,y=t._y1;if(!p)return t._root=f,t;for(;p.length;)if((c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a,r=p,!(p=p[h=u<<1|c]))return r[h]=f,t;if(s=+t._x.call(null,p.data),l=+t._y.call(null,p.data),e===s&&n===l)return f.next=p,r?r[h]=f:t._root=f,t;do{r=r?r[h]=new Array(4):t._root=new Array(4),(c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a}while((h=u<<1|c)==(d=(l>=a)<<1|s>=o));return r[d]=p,r[h]=f,t}function ZG(t,e,n,i,r){this.node=t,this.x0=e,this.y0=n,this.x1=i,this.y1=r}function JG(t){return t[0]}function QG(t){return t[1]}function tW(t,e,n){var i=new eW(null==e?JG:e,null==n?QG:n,NaN,NaN,NaN,NaN);return null==t?i:i.addAll(t)}function eW(t,e,n,i,r,o){this._x=t,this._y=e,this._x0=n,this._y0=i,this._x1=r,this._y1=o,this._root=void 0}function nW(t){for(var e={data:t.data},n=e;t=t.next;)n=n.next={data:t.data};return e}var iW=tW.prototype=eW.prototype;function rW(t){return t.x+t.vx}function oW(t){return t.y+t.vy}iW.copy=function(){var t,e,n=new eW(this._x,this._y,this._x0,this._y0,this._x1,this._y1),i=this._root;if(!i)return n;if(!i.length)return n._root=nW(i),n;for(t=[{source:i,target:n._root=new Array(4)}];i=t.pop();)for(var r=0;r<4;++r)(e=i.source[r])&&(e.length?t.push({source:e,target:i.target[r]=new Array(4)}):i.target[r]=nW(e));return n},iW.add=function aW(t){var e=+this._x.call(null,t),n=+this._y.call(null,t);return KG(this.cover(e,n),e,n,t)},iW.addAll=function sW(t){var e,n,i,r,o=t.length,a=new Array(o),s=new Array(o),l=1/0,c=1/0,u=-1/0,h=-1/0;for(n=0;n<o;++n)isNaN(i=+this._x.call(null,e=t[n]))||isNaN(r=+this._y.call(null,e))||(a[n]=i,s[n]=r,i<l&&(l=i),i>u&&(u=i),r<c&&(c=r),r>h&&(h=r));if(l>u||c>h)return this;for(this.cover(l,c).cover(u,h),n=0;n<o;++n)KG(this,a[n],s[n],t[n]);return this},iW.cover=function lW(t,e){if(isNaN(t=+t)||isNaN(e=+e))return this;var n=this._x0,i=this._y0,r=this._x1,o=this._y1;if(isNaN(n))r=(n=Math.floor(t))+1,o=(i=Math.floor(e))+1;else{for(var a,s,l=r-n,c=this._root;n>t||t>=r||i>e||e>=o;)switch(s=(e<i)<<1|t<n,(a=new Array(4))[s]=c,c=a,l*=2,s){case 0:r=n+l,o=i+l;break;case 1:n=r-l,o=i+l;break;case 2:r=n+l,i=o-l;break;case 3:n=r-l,i=o-l}this._root&&this._root.length&&(this._root=c)}return this._x0=n,this._y0=i,this._x1=r,this._y1=o,this},iW.data=function cW(){var t=[];return this.visit((function(e){if(!e.length)do{t.push(e.data)}while(e=e.next)})),t},iW.extent=function uW(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},iW.find=function hW(t,e,n){var i,r,o,a,s,l,c,u=this._x0,h=this._y0,d=this._x1,p=this._y1,f=[],m=this._root;for(m&&f.push(new ZG(m,u,h,d,p)),null==n?n=1/0:(u=t-n,h=e-n,d=t+n,p=e+n,n*=n);l=f.pop();)if(!(!(m=l.node)||(r=l.x0)>d||(o=l.y0)>p||(a=l.x1)<u||(s=l.y1)<h))if(m.length){var g=(r+a)/2,_=(o+s)/2;f.push(new ZG(m[3],g,_,a,s),new ZG(m[2],r,_,g,s),new ZG(m[1],g,o,a,_),new ZG(m[0],r,o,g,_)),(c=(e>=_)<<1|t>=g)&&(l=f[f.length-1],f[f.length-1]=f[f.length-1-c],f[f.length-1-c]=l)}else{var y=t-+this._x.call(null,m.data),v=e-+this._y.call(null,m.data),b=y*y+v*v;if(b<n){var x=Math.sqrt(n=b);u=t-x,h=e-x,d=t+x,p=e+x,i=m.data}}return i},iW.remove=function dW(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var e,n,i,r,o,a,s,l,c,u,h,d,p=this._root,f=this._x0,m=this._y0,g=this._x1,_=this._y1;if(!p)return this;if(p.length)for(;;){if((c=o>=(s=(f+g)/2))?f=s:g=s,(u=a>=(l=(m+_)/2))?m=l:_=l,e=p,!(p=p[h=u<<1|c]))return this;if(!p.length)break;(e[h+1&3]||e[h+2&3]||e[h+3&3])&&(n=e,d=h)}for(;p.data!==t;)if(i=p,!(p=p.next))return this;return(r=p.next)&&delete p.next,i?(r?i.next=r:delete i.next,this):e?(r?e[h]=r:delete e[h],(p=e[0]||e[1]||e[2]||e[3])&&p===(e[3]||e[2]||e[1]||e[0])&&!p.length&&(n?n[d]=p:this._root=p),this):(this._root=r,this)},iW.removeAll=function pW(t){for(var e=0,n=t.length;e<n;++e)this.remove(t[e]);return this},iW.root=function fW(){return this._root},iW.size=function mW(){var t=0;return this.visit((function(e){if(!e.length)do{++t}while(e=e.next)})),t},iW.visit=function gW(t){var e,n,i,r,o,a,s=[],l=this._root;for(l&&s.push(new ZG(l,this._x0,this._y0,this._x1,this._y1));e=s.pop();)if(!t(l=e.node,i=e.x0,r=e.y0,o=e.x1,a=e.y1)&&l.length){var c=(i+o)/2,u=(r+a)/2;(n=l[3])&&s.push(new ZG(n,c,u,o,a)),(n=l[2])&&s.push(new ZG(n,i,u,c,a)),(n=l[1])&&s.push(new ZG(n,c,r,o,u)),(n=l[0])&&s.push(new ZG(n,i,r,c,u))}return this},iW.visitAfter=function _W(t){var e,n=[],i=[];for(this._root&&n.push(new ZG(this._root,this._x0,this._y0,this._x1,this._y1));e=n.pop();){var r=e.node;if(r.length){var o,a=e.x0,s=e.y0,l=e.x1,c=e.y1,u=(a+l)/2,h=(s+c)/2;(o=r[0])&&n.push(new ZG(o,a,s,u,h)),(o=r[1])&&n.push(new ZG(o,u,s,l,h)),(o=r[2])&&n.push(new ZG(o,a,h,u,c)),(o=r[3])&&n.push(new ZG(o,u,h,l,c))}i.push(e)}for(;e=i.pop();)t(e.node,e.x0,e.y0,e.x1,e.y1);return this},iW.x=function yW(t){return arguments.length?(this._x=t,this):this._x},iW.y=function vW(t){return arguments.length?(this._y=t,this):this._y};var bW="$";function xW(){}function wW(t,e){var n=new xW;if(t instanceof xW)t.each((function(t,e){n.set(e,t)}));else if(Array.isArray(t)){var i,r=-1,o=t.length;if(null==e)for(;++r<o;)n.set(r,t[r]);else for(;++r<o;)n.set(e(i=t[r],r,t),i)}else if(t)for(var a in t)n.set(a,t[a]);return n}function SW(){}xW.prototype=wW.prototype={constructor:xW,has:function(t){return bW+t in this},get:function(t){return this[bW+t]},set:function(t,e){return this[bW+t]=e,this},remove:function(t){var e=bW+t;return e in this&&delete this[e]},clear:function(){for(var t in this)t[0]===bW&&delete this[t]},keys:function(){var t=[];for(var e in this)e[0]===bW&&t.push(e.slice(1));return t},values:function(){var t=[];for(var e in this)e[0]===bW&&t.push(this[e]);return t},entries:function(){var t=[];for(var e in this)e[0]===bW&&t.push({key:e.slice(1),value:this[e]});return t},size:function(){var t=0;for(var e in this)e[0]===bW&&++t;return t},empty:function(){for(var t in this)if(t[0]===bW)return!1;return!0},each:function(t){for(var e in this)e[0]===bW&&t(this[e],e.slice(1),this)}};var MW=wW.prototype;function EW(t){return t.index}function TW(t,e){var n=t.get(e);if(!n)throw new Error("missing: "+e);return n}SW.prototype={constructor:SW,has:MW.has,add:function(t){return this[bW+(t+="")]=t,this},remove:MW.remove,clear:MW.clear,values:MW.keys,size:MW.size,empty:MW.empty,each:MW.each};var AW={value:function(){}};function CW(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new kW(i)}function kW(t){this._=t}function LW(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function PW(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function IW(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=AW,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}kW.prototype=CW.prototype={constructor:kW,on:function(t,e){var n,i=this._,r=LW(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=IW(i[n],t.name,e);else if(null==e)for(n in i)i[n]=IW(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=PW(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new kW(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var NW,OW,RW=0,zW=0,DW=0,BW=0,HW=0,FW=0,VW="object"==typeof performance&&performance.now?performance:Date,jW="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function UW(){return HW||(jW(GW),HW=VW.now()+FW)}function GW(){HW=0}function WW(){this._call=this._time=this._next=null}function qW(t,e,n){var i=new WW;return i.restart(t,e,n),i}function YW(){HW=(BW=VW.now())+FW,RW=zW=0;try{!(function t(){UW(),++RW;for(var t,e=NW;e;)(t=HW-e._time)>=0&&e._call.call(null,t),e=e._next;--RW})()}finally{RW=0,(function e(){for(var t,e,n=NW,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:NW=e);OW=t,$W(i)})(),HW=0}}function XW(){var t=VW.now(),e=t-BW;e>1e3&&(FW-=e,BW=t)}function $W(t){RW||(zW&&(zW=clearTimeout(zW)),t-HW>24?(t<1/0&&(zW=setTimeout(YW,t-VW.now()-FW)),DW&&(DW=clearInterval(DW))):(DW||(BW=VW.now(),DW=setInterval(XW,1e3)),RW=1,jW(YW)))}function KW(t){return t.x}function ZW(t){return t.y}WW.prototype=qW.prototype={constructor:WW,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?UW():+n)+(null==e?0:+e),this._next||OW===this||(OW?OW._next=this:NW=this,OW=this),this._call=t,this._time=n,$W()},stop:function(){this._call&&(this._call=null,this._time=1/0,$W())}};var JW,QW=Math.PI*(3-Math.sqrt(5));function tq(t,e){if((n=(t=e?t.toExponential(e-1):t.toExponential()).indexOf("e"))<0)return null;var n,i=t.slice(0,n);return[i.length>1?i[0]+i.slice(2):i,+t.slice(n+1)]}function eq(t){return(t=tq(Math.abs(t)))?t[1]:NaN}function nq(t,e){var n=tq(t,e);if(!n)return t+"";var i=n[0],r=n[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}var iq={"":function rq(t,e){t:for(var n,i=(t=t.toPrecision(e)).length,r=1,o=-1;r<i;++r)switch(t[r]){case".":o=n=r;break;case"0":0===o&&(o=r),n=r;break;case"e":break t;default:o>0&&(o=0)}return o>0?t.slice(0,o)+t.slice(n+1):t},"%":function(t,e){return(100*t).toFixed(e)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,e){return t.toExponential(e)},f:function(t,e){return t.toFixed(e)},g:function(t,e){return t.toPrecision(e)},o:function(t){return Math.round(t).toString(8)},p:function(t,e){return nq(100*t,e)},r:nq,s:function oq(t,e){var n=tq(t,e);if(!n)return t+"";var i=n[0],r=n[1],o=r-(JW=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,a=i.length;return o===a?i:o>a?i+new Array(o-a+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+tq(t,Math.max(0,e+o-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}},aq=/^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;function sq(t){return new lq(t)}function lq(t){if(!(e=aq.exec(t)))throw new Error("invalid format: "+t);var e,n=e[1]||" ",i=e[2]||">",r=e[3]||"-",o=e[4]||"",a=!!e[5],s=e[6]&&+e[6],l=!!e[7],c=e[8]&&+e[8].slice(1),u=e[9]||"";"n"===u?(l=!0,u="g"):iq[u]||(u=""),(a||"0"===n&&"="===i)&&(a=!0,n="0",i="="),this.fill=n,this.align=i,this.sign=r,this.symbol=o,this.zero=a,this.width=s,this.comma=l,this.precision=c,this.type=u}function cq(t){return t}sq.prototype=lq.prototype,lq.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(null==this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(null==this.precision?"":"."+Math.max(0,0|this.precision))+this.type};var uq,hq,dq,pq=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function fq(t){var e=t.grouping&&t.thousands?(function n(t,e){return function(n,i){for(var r=n.length,o=[],a=0,s=t[0],l=0;r>0&&s>0&&(l+s+1>i&&(s=Math.max(1,i-l)),o.push(n.substring(r-=s,r+s)),!((l+=s+1)>i));)s=t[a=(a+1)%t.length];return o.reverse().join(e)}})(t.grouping,t.thousands):cq,i=t.currency,r=t.decimal,o=t.numerals?(function a(t){return function(e){return e.replace(/[0-9]/g,(function(e){return t[+e]}))}})(t.numerals):cq,s=t.percent||"%";function l(t){var n=(t=sq(t)).fill,a=t.align,l=t.sign,c=t.symbol,u=t.zero,h=t.width,d=t.comma,p=t.precision,f=t.type,m="$"===c?i[0]:"#"===c&&/[boxX]/.test(f)?"0"+f.toLowerCase():"",g="$"===c?i[1]:/[%p]/.test(f)?s:"",_=iq[f],y=!f||/[defgprs%]/.test(f);function v(t){var i,s,c,v=m,b=g;if("c"===f)b=_(t)+b,t="";else{var x=(t=+t)<0;if(t=_(Math.abs(t),p),x&&0==+t&&(x=!1),v=(x?"("===l?l:"-":"-"===l||"("===l?"":l)+v,b=("s"===f?pq[8+JW/3]:"")+b+(x&&"("===l?")":""),y)for(i=-1,s=t.length;++i<s;)if(48>(c=t.charCodeAt(i))||c>57){b=(46===c?r+t.slice(i+1):t.slice(i))+b,t=t.slice(0,i);break}}d&&!u&&(t=e(t,1/0));var w=v.length+t.length+b.length,S=w<h?new Array(h-w+1).join(n):"";switch(d&&u&&(t=e(S+t,S.length?h-b.length:1/0),S=""),a){case"<":t=v+t+b+S;break;case"=":t=v+S+t+b;break;case"^":t=S.slice(0,w=S.length>>1)+v+t+b+S.slice(w);break;default:t=S+v+t+b}return o(t)}return p=null==p?f?6:12:/[gprs]/.test(f)?Math.max(1,Math.min(21,p)):Math.max(0,Math.min(20,p)),v.toString=function(){return t+""},v}return{format:l,formatPrefix:function c(t,e){var n=l(((t=sq(t)).type="f",t)),i=3*Math.max(-8,Math.min(8,Math.floor(eq(e)/3))),r=Math.pow(10,-i),o=pq[8+i/3];return function(t){return n(r*t)+o}}}}function mq(t){return uq=fq(t),hq=uq.format,dq=uq.formatPrefix,uq}function gq(){return new _q}function _q(){this.reset()}mq({decimal:".",thousands:",",grouping:[3],currency:["$",""]}),_q.prototype={constructor:_q,reset:function(){this.s=this.t=0},add:function(t){vq(yq,t,this.t),vq(this,yq.s,this.s),this.s?this.t+=yq.t:this.s=yq.t},valueOf:function(){return this.s}};var yq=new _q;function vq(t,e,n){var i=t.s=e+n,r=i-e;t.t=e-(i-r)+(n-r)}var bq=1e-6,xq=Math.PI,wq=xq/2,Sq=xq/4,Mq=2*xq,Eq=180/xq,Tq=xq/180,Aq=Math.abs,Cq=Math.atan,kq=Math.atan2,Lq=Math.cos,Pq=Math.ceil,Iq=Math.exp,Nq=Math.log,Oq=Math.pow,Rq=Math.sin,zq=Math.sign||function(t){return t>0?1:t<0?-1:0},Dq=Math.sqrt,Bq=Math.tan;function Hq(t){return t>1?0:t<-1?xq:Math.acos(t)}function Fq(t){return t>1?wq:t<-1?-wq:Math.asin(t)}function Vq(t){return(t=Rq(t/2))*t}function jq(){}function Uq(t,e){t&&Wq.hasOwnProperty(t.type)&&Wq[t.type](t,e)}var Gq={Feature:function(t,e){Uq(t.geometry,e)},FeatureCollection:function(t,e){for(var n=t.features,i=-1,r=n.length;++i<r;)Uq(n[i].geometry,e)}},Wq={Sphere:function(t,e){e.sphere()},Point:function(t,e){e.point((t=t.coordinates)[0],t[1],t[2])},MultiPoint:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)e.point((t=n[i])[0],t[1],t[2])},LineString:function(t,e){qq(t.coordinates,e,0)},MultiLineString:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)qq(n[i],e,0)},Polygon:function(t,e){Yq(t.coordinates,e)},MultiPolygon:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)Yq(n[i],e)},GeometryCollection:function(t,e){for(var n=t.geometries,i=-1,r=n.length;++i<r;)Uq(n[i],e)}};function qq(t,e,n){var i,r=-1,o=t.length-n;for(e.lineStart();++r<o;)e.point((i=t[r])[0],i[1],i[2]);e.lineEnd()}function Yq(t,e){var n=-1,i=t.length;for(e.polygonStart();++n<i;)qq(t[n],e,1);e.polygonEnd()}function Xq(t,e){t&&Gq.hasOwnProperty(t.type)?Gq[t.type](t,e):Uq(t,e)}var $q,Kq,Zq,Jq,Qq,tY=gq(),eY=gq(),nY={point:jq,lineStart:jq,lineEnd:jq,polygonStart:function(){tY.reset(),nY.lineStart=iY,nY.lineEnd=rY},polygonEnd:function(){var t=+tY;eY.add(t<0?Mq+t:t),this.lineStart=this.lineEnd=this.point=jq},sphere:function(){eY.add(Mq)}};function iY(){nY.point=oY}function rY(){aY($q,Kq)}function oY(t,e){nY.point=aY,$q=t,Kq=e,Zq=t*=Tq,Jq=Lq(e=(e*=Tq)/2+Sq),Qq=Rq(e)}function aY(t,e){var n=(t*=Tq)-Zq,i=n>=0?1:-1,r=i*n,o=Lq(e=(e*=Tq)/2+Sq),a=Rq(e),s=Qq*a,l=Jq*o+s*Lq(r),c=s*i*Rq(r);tY.add(kq(c,l)),Zq=t,Jq=o,Qq=a}function sY(t){return[kq(t[1],t[0]),Fq(t[2])]}function lY(t){var e=t[0],n=t[1],i=Lq(n);return[i*Lq(e),i*Rq(e),Rq(n)]}function cY(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function uY(t,e){return[t[1]*e[2]-t[2]*e[1],t[2]*e[0]-t[0]*e[2],t[0]*e[1]-t[1]*e[0]]}function hY(t,e){t[0]+=e[0],t[1]+=e[1],t[2]+=e[2]}function dY(t,e){return[t[0]*e,t[1]*e,t[2]*e]}function pY(t){var e=Dq(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=e,t[1]/=e,t[2]/=e}var fY,mY,gY,_Y,yY,vY,bY,xY,wY,SY,MY,EY,TY,AY,CY,kY,LY,PY,IY,NY,OY,RY,zY,DY,BY,HY,FY=gq(),VY={point:jY,lineStart:GY,lineEnd:WY,polygonStart:function(){VY.point=qY,VY.lineStart=YY,VY.lineEnd=XY,FY.reset(),nY.polygonStart()},polygonEnd:function(){nY.polygonEnd(),VY.point=jY,VY.lineStart=GY,VY.lineEnd=WY,tY<0?(fY=-(gY=180),mY=-(_Y=90)):FY>bq?_Y=90:FY<-1e-6&&(mY=-90),SY[0]=fY,SY[1]=gY}};function jY(t,e){wY.push(SY=[fY=t,gY=t]),e<mY&&(mY=e),e>_Y&&(_Y=e)}function UY(t,e){var n=lY([t*Tq,e*Tq]);if(xY){var i=uY(xY,n),r=uY([i[1],-i[0],0],i);pY(r),r=sY(r);var o,a=t-yY,s=a>0?1:-1,l=r[0]*Eq*s,c=Aq(a)>180;c^(s*yY<l&&l<s*t)?(o=r[1]*Eq)>_Y&&(_Y=o):c^(s*yY<(l=(l+360)%360-180)&&l<s*t)?(o=-r[1]*Eq)<mY&&(mY=o):(e<mY&&(mY=e),e>_Y&&(_Y=e)),c?t<yY?$Y(fY,t)>$Y(fY,gY)&&(gY=t):$Y(t,gY)>$Y(fY,gY)&&(fY=t):gY>=fY?(t<fY&&(fY=t),t>gY&&(gY=t)):t>yY?$Y(fY,t)>$Y(fY,gY)&&(gY=t):$Y(t,gY)>$Y(fY,gY)&&(fY=t)}else wY.push(SY=[fY=t,gY=t]);e<mY&&(mY=e),e>_Y&&(_Y=e),xY=n,yY=t}function GY(){VY.point=UY}function WY(){SY[0]=fY,SY[1]=gY,VY.point=jY,xY=null}function qY(t,e){if(xY){var n=t-yY;FY.add(Aq(n)>180?n+(n>0?360:-360):n)}else vY=t,bY=e;nY.point(t,e),UY(t,e)}function YY(){nY.lineStart()}function XY(){qY(vY,bY),nY.lineEnd(),Aq(FY)>bq&&(fY=-(gY=180)),SY[0]=fY,SY[1]=gY,xY=null}function $Y(t,e){return(e-=t)<0?e+360:e}function KY(t,e){return t[0]-e[0]}function ZY(t,e){return t[0]<=t[1]?t[0]<=e&&e<=t[1]:e<t[0]||t[1]<e}var JY={sphere:jq,point:QY,lineStart:eX,lineEnd:rX,polygonStart:function(){JY.lineStart=oX,JY.lineEnd=aX},polygonEnd:function(){JY.lineStart=eX,JY.lineEnd=rX}};function QY(t,e){t*=Tq;var n=Lq(e*=Tq);tX(n*Lq(t),n*Rq(t),Rq(e))}function tX(t,e,n){++MY,TY+=(t-TY)/MY,AY+=(e-AY)/MY,CY+=(n-CY)/MY}function eX(){JY.point=nX}function nX(t,e){t*=Tq;var n=Lq(e*=Tq);DY=n*Lq(t),BY=n*Rq(t),HY=Rq(e),JY.point=iX,tX(DY,BY,HY)}function iX(t,e){t*=Tq;var n=Lq(e*=Tq),i=n*Lq(t),r=n*Rq(t),o=Rq(e),a=kq(Dq((a=BY*o-HY*r)*a+(a=HY*i-DY*o)*a+(a=DY*r-BY*i)*a),DY*i+BY*r+HY*o);EY+=a,kY+=a*(DY+(DY=i)),LY+=a*(BY+(BY=r)),PY+=a*(HY+(HY=o)),tX(DY,BY,HY)}function rX(){JY.point=QY}function oX(){JY.point=sX}function aX(){lX(RY,zY),JY.point=QY}function sX(t,e){RY=t,zY=e,t*=Tq,e*=Tq,JY.point=lX;var n=Lq(e);DY=n*Lq(t),BY=n*Rq(t),HY=Rq(e),tX(DY,BY,HY)}function lX(t,e){t*=Tq;var n=Lq(e*=Tq),i=n*Lq(t),r=n*Rq(t),o=Rq(e),a=BY*o-HY*r,s=HY*i-DY*o,l=DY*r-BY*i,c=Dq(a*a+s*s+l*l),u=Fq(c),h=c&&-u/c;IY+=h*a,NY+=h*s,OY+=h*l,EY+=u,kY+=u*(DY+(DY=i)),LY+=u*(BY+(BY=r)),PY+=u*(HY+(HY=o)),tX(DY,BY,HY)}function cX(t){return function(){return t}}function uX(t,e){function n(n,i){return n=t(n,i),e(n[0],n[1])}return t.invert&&e.invert&&(n.invert=function(n,i){return(n=e.invert(n,i))&&t.invert(n[0],n[1])}),n}function hX(t,e){return[t>xq?t-Mq:t<-xq?t+Mq:t,e]}function dX(t,e,n){return(t%=Mq)?e||n?uX(fX(t),mX(e,n)):fX(t):e||n?mX(e,n):hX}function pX(t){return function(e,n){return[(e+=t)>xq?e-Mq:e<-xq?e+Mq:e,n]}}function fX(t){var e=pX(t);return e.invert=pX(-t),e}function mX(t,e){var n=Lq(t),i=Rq(t),r=Lq(e),o=Rq(e);function a(t,e){var a=Lq(e),s=Lq(t)*a,l=Rq(t)*a,c=Rq(e),u=c*n+s*i;return[kq(l*r-u*o,s*n-c*i),Fq(u*r+l*o)]}return a.invert=function(t,e){var a=Lq(e),s=Lq(t)*a,l=Rq(t)*a,c=Rq(e),u=c*r-l*o;return[kq(l*r+c*o,s*n+u*i),Fq(u*n-s*i)]},a}function gX(t){function e(e){return(e=t(e[0]*Tq,e[1]*Tq))[0]*=Eq,e[1]*=Eq,e}return t=dX(t[0]*Tq,t[1]*Tq,t.length>2?t[2]*Tq:0),e.invert=function(e){return(e=t.invert(e[0]*Tq,e[1]*Tq))[0]*=Eq,e[1]*=Eq,e},e}function _X(t,e,n,i,r,o){if(n){var a=Lq(e),s=Rq(e),l=i*n;null==r?(r=e+i*Mq,o=e-l/2):(r=yX(a,r),o=yX(a,o),(i>0?r<o:r>o)&&(r+=i*Mq));for(var c,u=r;i>0?u>o:u<o;u-=l)c=sY([a,-s*Lq(u),-s*Rq(u)]),t.point(c[0],c[1])}}function yX(t,e){(e=lY(e))[0]-=t,pY(e);var n=Hq(-e[1]);return((-e[2]<0?-n:n)+Mq-bq)%Mq}function vX(){var t,e=[];return{point:function(e,n){t.push([e,n])},lineStart:function(){e.push(t=[])},lineEnd:jq,rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))},result:function(){var n=e;return e=[],t=null,n}}}function bX(t,e){return Aq(t[0]-e[0])<bq&&Aq(t[1]-e[1])<bq}function xX(t,e,n,i){this.x=t,this.z=e,this.o=n,this.e=i,this.v=!1,this.n=this.p=null}function wX(t,e,n,i,r){var o,a,s=[],l=[];if(t.forEach((function(t){if(!((e=t.length-1)<=0)){var e,n,i=t[0],a=t[e];if(bX(i,a)){for(r.lineStart(),o=0;o<e;++o)r.point((i=t[o])[0],i[1]);r.lineEnd()}else s.push(n=new xX(i,t,null,!0)),l.push(n.o=new xX(i,null,n,!1)),s.push(n=new xX(a,t,null,!1)),l.push(n.o=new xX(a,null,n,!0))}})),s.length){for(l.sort(e),SX(s),SX(l),o=0,a=l.length;o<a;++o)l[o].e=n=!n;for(var c,u,h=s[0];;){for(var d=h,p=!0;d.v;)if((d=d.n)===h)return;c=d.z,r.lineStart();do{if(d.v=d.o.v=!0,d.e){if(p)for(o=0,a=c.length;o<a;++o)r.point((u=c[o])[0],u[1]);else i(d.x,d.n.x,1,r);d=d.n}else{if(p)for(o=(c=d.p.z).length-1;o>=0;--o)r.point((u=c[o])[0],u[1]);else i(d.x,d.p.x,-1,r);d=d.p}c=(d=d.o).z,p=!p}while(!d.v);r.lineEnd()}}}function SX(t){if(e=t.length){for(var e,n,i=0,r=t[0];++i<e;)r.n=n=t[i],n.p=r,r=n;r.n=n=t[0],n.p=r}}hX.invert=hX;var MX=gq();function EX(t,e){var n=e[0],i=e[1],r=[Rq(n),-Lq(n),0],o=0,a=0;MX.reset();for(var s=0,l=t.length;s<l;++s)if(u=(c=t[s]).length)for(var c,u,h=c[u-1],d=h[0],p=h[1]/2+Sq,f=Rq(p),m=Lq(p),g=0;g<u;++g,d=y,f=b,m=x,h=_){var _=c[g],y=_[0],v=_[1]/2+Sq,b=Rq(v),x=Lq(v),w=y-d,S=w>=0?1:-1,M=S*w,E=M>xq,T=f*b;if(MX.add(kq(T*S*Rq(M),m*x+T*Lq(M))),o+=E?w+S*Mq:w,E^d>=n^y>=n){var A=uY(lY(h),lY(_));pY(A);var C=uY(r,A);pY(C);var k=(E^w>=0?-1:1)*Fq(C[2]);(i>k||i===k&&(A[0]||A[1]))&&(a+=E^w>=0?1:-1)}}return(o<-1e-6||o<bq&&MX<-1e-6)^1&a}function TX(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function AX(t,e,n){t=+t,e=+e,n=(r=arguments.length)<2?(e=t,t=0,1):r<3?1:+n;for(var i=-1,r=0|Math.max(0,Math.ceil((e-t)/n)),o=new Array(r);++i<r;)o[i]=t+i*n;return o}function CX(t){for(var e,n,i,r=t.length,o=-1,a=0;++o<r;)a+=t[o].length;for(n=new Array(a);--r>=0;)for(e=(i=t[r]).length;--e>=0;)n[--a]=i[e];return n}function kX(t,e,n,i){return function(r){var o,a,s,l=e(r),c=vX(),u=e(c),h=!1,d={point:p,lineStart:m,lineEnd:g,polygonStart:function(){d.point=_,d.lineStart=y,d.lineEnd=v,a=[],o=[]},polygonEnd:function(){d.point=p,d.lineStart=m,d.lineEnd=g,a=CX(a);var t=EX(o,i);a.length?(h||(r.polygonStart(),h=!0),wX(a,PX,t,n,r)):t&&(h||(r.polygonStart(),h=!0),r.lineStart(),n(null,null,1,r),r.lineEnd()),h&&(r.polygonEnd(),h=!1),a=o=null},sphere:function(){r.polygonStart(),r.lineStart(),n(null,null,1,r),r.lineEnd(),r.polygonEnd()}};function p(e,n){t(e,n)&&r.point(e,n)}function f(t,e){l.point(t,e)}function m(){d.point=f,l.lineStart()}function g(){d.point=p,l.lineEnd()}function _(t,e){s.push([t,e]),u.point(t,e)}function y(){u.lineStart(),s=[]}function v(){_(s[0][0],s[0][1]),u.lineEnd();var t,e,n,i,l=u.clean(),d=c.result(),p=d.length;if(s.pop(),o.push(s),s=null,p)if(1&l){if((e=(n=d[0]).length-1)>0){for(h||(r.polygonStart(),h=!0),r.lineStart(),t=0;t<e;++t)r.point((i=n[t])[0],i[1]);r.lineEnd()}}else p>1&&2&l&&d.push(d.pop().concat(d.shift())),a.push(d.filter(LX))}return d}}function LX(t){return t.length>1}function PX(t,e){return((t=t.x)[0]<0?t[1]-wq-bq:wq-t[1])-((e=e.x)[0]<0?e[1]-wq-bq:wq-e[1])}!(function IX(t){1===t.length&&(t=(function e(t){return function(e,n){return TX(t(e),n)}})(t))})(TX);var NX=kX((function(){return!0}),(function OX(t){var e,n=NaN,i=NaN,r=NaN;return{lineStart:function(){t.lineStart(),e=1},point:function(o,a){var s=o>0?xq:-xq,l=Aq(o-n);Aq(l-xq)<bq?(t.point(n,i=(i+a)/2>0?wq:-wq),t.point(r,i),t.lineEnd(),t.lineStart(),t.point(s,i),t.point(o,i),e=0):r!==s&&l>=xq&&(Aq(n-r)<bq&&(n-=r*bq),Aq(o-s)<bq&&(o-=s*bq),i=(function c(t,e,n,i){var r,o,a=Rq(t-n);return Aq(a)>bq?Cq((Rq(e)*(o=Lq(i))*Rq(n)-Rq(i)*(r=Lq(e))*Rq(t))/(r*o*a)):(e+i)/2})(n,i,o,a),t.point(r,i),t.lineEnd(),t.lineStart(),t.point(s,i),e=0),t.point(n=o,i=a),r=s},lineEnd:function(){t.lineEnd(),n=i=NaN},clean:function(){return 2-e}}}),(function RX(t,e,n,i){var r;if(null==t)i.point(-xq,r=n*wq),i.point(0,r),i.point(xq,r),i.point(xq,0),i.point(xq,-r),i.point(0,-r),i.point(-xq,-r),i.point(-xq,0),i.point(-xq,r);else if(Aq(t[0]-e[0])>bq){var o=t[0]<e[0]?xq:-xq;i.point(-o,r=n*o/2),i.point(0,r),i.point(o,r)}else i.point(e[0],e[1])}),[-xq,-wq]);function zX(t){var e=Lq(t),n=6*Tq,i=e>0,r=Aq(e)>bq;function o(t,n){return Lq(t)*Lq(n)>e}function a(t,n,i){var r=[1,0,0],o=uY(lY(t),lY(n)),a=cY(o,o),s=o[0],l=a-s*s;if(!l)return!i&&t;var c=e*a/l,u=-e*s/l,h=uY(r,o),d=dY(r,c);hY(d,dY(o,u));var p=h,f=cY(d,p),m=cY(p,p),g=f*f-m*(cY(d,d)-1);if(!(g<0)){var _=Dq(g),y=dY(p,(-f-_)/m);if(hY(y,d),y=sY(y),!i)return y;var v,b=t[0],x=n[0],w=t[1],S=n[1];x<b&&(v=b,b=x,x=v);var M=x-b,E=Aq(M-xq)<bq;if(!E&&S<w&&(v=w,w=S,S=v),E||M<bq?E?w+S>0^y[1]<(Aq(y[0]-b)<bq?w:S):w<=y[1]&&y[1]<=S:M>xq^(b<=y[0]&&y[0]<=x)){var T=dY(p,(-f+_)/m);return hY(T,d),[y,sY(T)]}}}function s(e,n){var r=i?t:xq-t,o=0;return e<-r?o|=1:e>r&&(o|=2),n<-r?o|=4:n>r&&(o|=8),o}return kX(o,(function l(t){var e,n,l,c,u;return{lineStart:function(){c=l=!1,u=1},point:function(h,d){var p,f=[h,d],m=o(h,d),g=i?m?0:s(h,d):m?s(h+(h<0?xq:-xq),d):0;if(!e&&(c=l=m)&&t.lineStart(),m!==l&&(!(p=a(e,f))||bX(e,p)||bX(f,p))&&(f[0]+=bq,f[1]+=bq,m=o(f[0],f[1])),m!==l)u=0,m?(t.lineStart(),p=a(f,e),t.point(p[0],p[1])):(p=a(e,f),t.point(p[0],p[1]),t.lineEnd()),e=p;else if(r&&e&&i^m){var _;g&n||!(_=a(f,e,!0))||(u=0,i?(t.lineStart(),t.point(_[0][0],_[0][1]),t.point(_[1][0],_[1][1]),t.lineEnd()):(t.point(_[1][0],_[1][1]),t.lineEnd(),t.lineStart(),t.point(_[0][0],_[0][1])))}!m||e&&bX(e,f)||t.point(f[0],f[1]),e=f,l=m,n=g},lineEnd:function(){l&&t.lineEnd(),e=null},clean:function(){return u|(c&&l)<<1}}}),(function c(e,i,r,o){_X(o,t,n,r,e,i)}),i?[0,-t]:[-xq,t-xq])}var DX=1e9,BX=-DX;function HX(t,e,n,i){function r(r,o){return t<=r&&r<=n&&e<=o&&o<=i}function o(r,o,s,c){var u=0,h=0;if(null==r||(u=a(r,s))!==(h=a(o,s))||l(r,o)<0^s>0)do{c.point(0===u||3===u?t:n,u>1?i:e)}while((u=(u+s+4)%4)!==h);else c.point(o[0],o[1])}function a(i,r){return Aq(i[0]-t)<bq?r>0?0:3:Aq(i[0]-n)<bq?r>0?2:1:Aq(i[1]-e)<bq?r>0?1:0:r>0?3:2}function s(t,e){return l(t.x,e.x)}function l(t,e){var n=a(t,1),i=a(e,1);return n!==i?n-i:0===n?e[1]-t[1]:1===n?t[0]-e[0]:2===n?t[1]-e[1]:e[0]-t[0]}return function(a){var l,c,u,h,d,p,f,m,g,_,y,v=a,b=vX(),x={point:T,lineStart:function w(){x.point=A,c&&c.push(u=[]),_=!0,g=!1,f=m=NaN},lineEnd:function S(){l&&(A(h,d),p&&g&&b.rejoin(),l.push(b.result())),x.point=T,g&&v.lineEnd()},polygonStart:function M(){v=b,l=[],c=[],y=!0},polygonEnd:function E(){var e=(function n(){for(var e=0,n=0,r=c.length;n<r;++n)for(var o,a,s=c[n],l=1,u=s.length,h=s[0],d=h[0],p=h[1];l<u;++l)o=d,a=p,d=(h=s[l])[0],p=h[1],a<=i?p>i&&(d-o)*(i-a)>(p-a)*(t-o)&&++e:p<=i&&(d-o)*(i-a)<(p-a)*(t-o)&&--e;return e})(),r=y&&e,h=(l=CX(l)).length;(r||h)&&(a.polygonStart(),r&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),h&&wX(l,s,e,o,a),a.polygonEnd()),v=a,l=c=u=null}};function T(t,e){r(t,e)&&v.point(t,e)}function A(o,a){var s=r(o,a);if(c&&u.push([o,a]),_)h=o,d=a,p=s,_=!1,s&&(v.lineStart(),v.point(o,a));else if(s&&g)v.point(o,a);else{var l=[f=Math.max(BX,Math.min(DX,f)),m=Math.max(BX,Math.min(DX,m))],b=[o=Math.max(BX,Math.min(DX,o)),a=Math.max(BX,Math.min(DX,a))];!(function x(t,e,n,i,r,o){var a,s=t[0],l=t[1],c=0,u=1,h=e[0]-s,d=e[1]-l;if(a=n-s,h||!(a>0)){if(a/=h,h<0){if(a<c)return;a<u&&(u=a)}else if(h>0){if(a>u)return;a>c&&(c=a)}if(a=r-s,h||!(a<0)){if(a/=h,h<0){if(a>u)return;a>c&&(c=a)}else if(h>0){if(a<c)return;a<u&&(u=a)}if(a=i-l,d||!(a>0)){if(a/=d,d<0){if(a<c)return;a<u&&(u=a)}else if(d>0){if(a>u)return;a>c&&(c=a)}if(a=o-l,d||!(a<0)){if(a/=d,d<0){if(a>u)return;a>c&&(c=a)}else if(d>0){if(a<c)return;a<u&&(u=a)}return c>0&&(t[0]=s+c*h,t[1]=l+c*d),u<1&&(e[0]=s+u*h,e[1]=l+u*d),!0}}}}})(l,b,t,e,n,i)?s&&(v.lineStart(),v.point(o,a),y=!1):(g||(v.lineStart(),v.point(l[0],l[1])),v.point(b[0],b[1]),s||v.lineEnd(),y=!1)}f=o,m=a,g=s}return x}}var FX,VX,jX,UX=gq(),GX={sphere:jq,point:jq,lineStart:function WX(){GX.point=YX,GX.lineEnd=qX},lineEnd:jq,polygonStart:jq,polygonEnd:jq};function qX(){GX.point=GX.lineEnd=jq}function YX(t,e){FX=t*=Tq,VX=Rq(e*=Tq),jX=Lq(e),GX.point=XX}function XX(t,e){t*=Tq;var n=Rq(e*=Tq),i=Lq(e),r=Aq(t-FX),o=Lq(r),a=i*Rq(r),s=jX*n-VX*i*o,l=VX*n+jX*i*o;UX.add(kq(Dq(a*a+s*s),l)),FX=t,VX=n,jX=i}function $X(t){return UX.reset(),Xq(t,GX),+UX}var KX=[null,null],ZX={type:"LineString",coordinates:KX};function JX(t,e){return KX[0]=t,KX[1]=e,$X(ZX)}var QX={Feature:function(t,e){return e$(t.geometry,e)},FeatureCollection:function(t,e){for(var n=t.features,i=-1,r=n.length;++i<r;)if(e$(n[i].geometry,e))return!0;return!1}},t$={Sphere:function(){return!0},Point:function(t,e){return n$(t.coordinates,e)},MultiPoint:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(n$(n[i],e))return!0;return!1},LineString:function(t,e){return i$(t.coordinates,e)},MultiLineString:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(i$(n[i],e))return!0;return!1},Polygon:function(t,e){return r$(t.coordinates,e)},MultiPolygon:function(t,e){for(var n=t.coordinates,i=-1,r=n.length;++i<r;)if(r$(n[i],e))return!0;return!1},GeometryCollection:function(t,e){for(var n=t.geometries,i=-1,r=n.length;++i<r;)if(e$(n[i],e))return!0;return!1}};function e$(t,e){return!(!t||!t$.hasOwnProperty(t.type))&&t$[t.type](t,e)}function n$(t,e){return 0===JX(t,e)}function i$(t,e){var n=JX(t[0],t[1]);return JX(t[0],e)+JX(e,t[1])<=n+bq}function r$(t,e){return!!EX(t.map(o$),a$(e))}function o$(t){return(t=t.map(a$)).pop(),t}function a$(t){return[t[0]*Tq,t[1]*Tq]}function s$(t,e,n){var i=AX(t,e-bq,n).concat(e);return function(t){return i.map((function(e){return[t,e]}))}}function l$(t,e,n){var i=AX(t,e-bq,n).concat(e);return function(t){return i.map((function(e){return[e,t]}))}}function c$(){var t,e,n,i,r,o,a,s,l,c,u,h,d=10,p=d,f=90,m=360,g=2.5;function _(){return{type:"MultiLineString",coordinates:y()}}function y(){return AX(Pq(i/f)*f,n,f).map(u).concat(AX(Pq(s/m)*m,a,m).map(h)).concat(AX(Pq(e/d)*d,t,d).filter((function(t){return Aq(t%f)>bq})).map(l)).concat(AX(Pq(o/p)*p,r,p).filter((function(t){return Aq(t%m)>bq})).map(c))}return _.lines=function(){return y().map((function(t){return{type:"LineString",coordinates:t}}))},_.outline=function(){return{type:"Polygon",coordinates:[u(i).concat(h(a).slice(1),u(n).reverse().slice(1),h(s).reverse().slice(1))]}},_.extent=function(t){return arguments.length?_.extentMajor(t).extentMinor(t):_.extentMinor()},_.extentMajor=function(t){return arguments.length?(s=+t[0][1],a=+t[1][1],(i=+t[0][0])>(n=+t[1][0])&&(t=i,i=n,n=t),s>a&&(t=s,s=a,a=t),_.precision(g)):[[i,s],[n,a]]},_.extentMinor=function(n){return arguments.length?(o=+n[0][1],r=+n[1][1],(e=+n[0][0])>(t=+n[1][0])&&(n=e,e=t,t=n),o>r&&(n=o,o=r,r=n),_.precision(g)):[[e,o],[t,r]]},_.step=function(t){return arguments.length?_.stepMajor(t).stepMinor(t):_.stepMinor()},_.stepMajor=function(t){return arguments.length?(f=+t[0],m=+t[1],_):[f,m]},_.stepMinor=function(t){return arguments.length?(d=+t[0],p=+t[1],_):[d,p]},_.precision=function(d){return arguments.length?(g=+d,l=s$(o,r,90),c=l$(e,t,g),u=s$(s,a,90),h=l$(i,n,g),_):g},_.extentMajor([[-180,-89.999999],[180,89.999999]]).extentMinor([[-180,-80.000001],[180,80.000001]])}function u$(t){return t}var h$,d$,p$,f$,m$=gq(),g$=gq(),_$={point:jq,lineStart:jq,lineEnd:jq,polygonStart:function(){_$.lineStart=y$,_$.lineEnd=x$},polygonEnd:function(){_$.lineStart=_$.lineEnd=_$.point=jq,m$.add(Aq(g$)),g$.reset()},result:function(){var t=m$/2;return m$.reset(),t}};function y$(){_$.point=v$}function v$(t,e){_$.point=b$,h$=p$=t,d$=f$=e}function b$(t,e){g$.add(f$*t-p$*e),p$=t,f$=e}function x$(){b$(h$,d$)}var w$,S$,M$,E$,T$=1/0,A$=T$,C$=-T$,k$=C$,L$={point:function P$(t,e){t<T$&&(T$=t),t>C$&&(C$=t),e<A$&&(A$=e),e>k$&&(k$=e)},lineStart:jq,lineEnd:jq,polygonStart:jq,polygonEnd:jq,result:function(){var t=[[T$,A$],[C$,k$]];return C$=k$=-(A$=T$=1/0),t}},I$=0,N$=0,O$=0,R$=0,z$=0,D$=0,B$=0,H$=0,F$=0,V$={point:j$,lineStart:U$,lineEnd:q$,polygonStart:function(){V$.lineStart=Y$,V$.lineEnd=X$},polygonEnd:function(){V$.point=j$,V$.lineStart=U$,V$.lineEnd=q$},result:function(){var t=F$?[B$/F$,H$/F$]:D$?[R$/D$,z$/D$]:O$?[I$/O$,N$/O$]:[NaN,NaN];return I$=N$=O$=R$=z$=D$=B$=H$=F$=0,t}};function j$(t,e){I$+=t,N$+=e,++O$}function U$(){V$.point=G$}function G$(t,e){V$.point=W$,j$(M$=t,E$=e)}function W$(t,e){var n=t-M$,i=e-E$,r=Dq(n*n+i*i);R$+=r*(M$+t)/2,z$+=r*(E$+e)/2,D$+=r,j$(M$=t,E$=e)}function q$(){V$.point=j$}function Y$(){V$.point=$$}function X$(){K$(w$,S$)}function $$(t,e){V$.point=K$,j$(w$=M$=t,S$=E$=e)}function K$(t,e){var n=t-M$,i=e-E$,r=Dq(n*n+i*i);R$+=r*(M$+t)/2,z$+=r*(E$+e)/2,D$+=r,B$+=(r=E$*t-M$*e)*(M$+t),H$+=r*(E$+e),F$+=3*r,j$(M$=t,E$=e)}function Z$(t){this._context=t}Z$.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,e){switch(this._point){case 0:this._context.moveTo(t,e),this._point=1;break;case 1:this._context.lineTo(t,e);break;default:this._context.moveTo(t+this._radius,e),this._context.arc(t,e,this._radius,0,Mq)}},result:jq};var J$,Q$,tK,eK,nK,iK=gq(),rK={point:jq,lineStart:function(){rK.point=oK},lineEnd:function(){J$&&aK(Q$,tK),rK.point=jq},polygonStart:function(){J$=!0},polygonEnd:function(){J$=null},result:function(){var t=+iK;return iK.reset(),t}};function oK(t,e){rK.point=aK,Q$=eK=t,tK=nK=e}function aK(t,e){iK.add(Dq((eK-=t)*eK+(nK-=e)*nK)),eK=t,nK=e}function sK(){this._string=[]}function lK(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function cK(t){return function(e){var n=new uK;for(var i in t)n[i]=t[i];return n.stream=e,n}}function uK(){}function hK(t,e,n){var i=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=i&&t.clipExtent(null),Xq(n,t.stream(L$)),e(L$.result()),null!=i&&t.clipExtent(i),t}function dK(t,e,n){return hK(t,(function(n){var i=e[1][0]-e[0][0],r=e[1][1]-e[0][1],o=Math.min(i/(n[1][0]-n[0][0]),r/(n[1][1]-n[0][1])),a=+e[0][0]+(i-o*(n[1][0]+n[0][0]))/2,s=+e[0][1]+(r-o*(n[1][1]+n[0][1]))/2;t.scale(150*o).translate([a,s])}),n)}function pK(t,e,n){return dK(t,[[0,0],e],n)}function fK(t,e,n){return hK(t,(function(n){var i=+e,r=i/(n[1][0]-n[0][0]),o=(i-r*(n[1][0]+n[0][0]))/2,a=-r*n[0][1];t.scale(150*r).translate([o,a])}),n)}function mK(t,e,n){return hK(t,(function(n){var i=+e,r=i/(n[1][1]-n[0][1]),o=-r*n[0][0],a=(i-r*(n[1][1]+n[0][1]))/2;t.scale(150*r).translate([o,a])}),n)}sK.prototype={_radius:4.5,_circle:lK(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,e){switch(this._point){case 0:this._string.push("M",t,",",e),this._point=1;break;case 1:this._string.push("L",t,",",e);break;default:null==this._circle&&(this._circle=lK(this._radius)),this._string.push("M",t,",",e,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}return null}},uK.prototype={constructor:uK,point:function(t,e){this.stream.point(t,e)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};var gK=Lq(30*Tq);function _K(t,e){return+e?(function n(t,e){function n(i,r,o,a,s,l,c,u,h,d,p,f,m,g){var _=c-i,y=u-r,v=_*_+y*y;if(v>4*e&&m--){var b=a+d,x=s+p,w=l+f,S=Dq(b*b+x*x+w*w),M=Fq(w/=S),E=Aq(Aq(w)-1)<bq||Aq(o-h)<bq?(o+h)/2:kq(x,b),T=t(E,M),A=T[0],C=T[1],k=A-i,L=C-r,P=y*k-_*L;(P*P/v>e||Aq((_*k+y*L)/v-.5)>.3||a*d+s*p+l*f<gK)&&(n(i,r,o,a,s,l,A,C,E,b/=S,x/=S,w,m,g),g.point(A,C),n(A,C,E,b,x,w,c,u,h,d,p,f,m,g))}}return function(e){var i,r,o,a,s,l,c,u,h,d,p,f,m={point:g,lineStart:_,lineEnd:v,polygonStart:function(){e.polygonStart(),m.lineStart=b},polygonEnd:function(){e.polygonEnd(),m.lineStart=_}};function g(n,i){n=t(n,i),e.point(n[0],n[1])}function _(){u=NaN,m.point=y,e.lineStart()}function y(i,r){var o=lY([i,r]),a=t(i,r);n(u,h,c,d,p,f,u=a[0],h=a[1],c=i,d=o[0],p=o[1],f=o[2],16,e),e.point(u,h)}function v(){m.point=g,e.lineEnd()}function b(){_(),m.point=x,m.lineEnd=w}function x(t,e){y(i=t,e),r=u,o=h,a=d,s=p,l=f,m.point=y}function w(){n(u,h,c,d,p,f,r,o,i,a,s,l,16,e),m.lineEnd=v,v()}return m}})(t,e):(function i(t){return cK({point:function(e,n){e=t(e,n),this.stream.point(e[0],e[1])}})})(t)}var yK=cK({point:function(t,e){this.stream.point(t*Tq,e*Tq)}});function vK(t){return bK((function(){return t}))()}function bK(t){var e,n,i,r,o,a,s,l,c,u,h=150,d=480,p=250,f=0,m=0,g=0,_=0,y=0,v=null,b=NX,x=null,w=u$,S=.5,M=_K(A,S);function E(t){return[(t=o(t[0]*Tq,t[1]*Tq))[0]*h+n,i-t[1]*h]}function T(t){return(t=o.invert((t[0]-n)/h,(i-t[1])/h))&&[t[0]*Eq,t[1]*Eq]}function A(t,r){return[(t=e(t,r))[0]*h+n,i-t[1]*h]}function C(){o=uX(r=dX(g,_,y),e);var t=e(f,m);return n=d-t[0]*h,i=p+t[1]*h,k()}function k(){return c=u=null,E}return E.stream=function(t){return c&&u===t?c:c=yK((function e(t){return cK({point:function(e,n){var i=t(e,n);return this.stream.point(i[0],i[1])}})})(r)(b(M(w(u=t)))))},E.preclip=function(t){return arguments.length?(b=t,v=void 0,k()):b},E.postclip=function(t){return arguments.length?(w=t,x=a=s=l=null,k()):w},E.clipAngle=function(t){return arguments.length?(b=+t?zX(v=t*Tq):(v=null,NX),k()):v*Eq},E.clipExtent=function(t){return arguments.length?(w=null==t?(x=a=s=l=null,u$):HX(x=+t[0][0],a=+t[0][1],s=+t[1][0],l=+t[1][1]),k()):null==x?null:[[x,a],[s,l]]},E.scale=function(t){return arguments.length?(h=+t,C()):h},E.translate=function(t){return arguments.length?(d=+t[0],p=+t[1],C()):[d,p]},E.center=function(t){return arguments.length?(f=t[0]%360*Tq,m=t[1]%360*Tq,C()):[f*Eq,m*Eq]},E.rotate=function(t){return arguments.length?(g=t[0]%360*Tq,_=t[1]%360*Tq,y=t.length>2?t[2]%360*Tq:0,C()):[g*Eq,_*Eq,y*Eq]},E.precision=function(t){return arguments.length?(M=_K(A,S=t*t),k()):Dq(S)},E.fitExtent=function(t,e){return dK(E,t,e)},E.fitSize=function(t,e){return pK(E,t,e)},E.fitWidth=function(t,e){return fK(E,t,e)},E.fitHeight=function(t,e){return mK(E,t,e)},function(){return e=t.apply(this,arguments),E.invert=e.invert&&T,C()}}function xK(t){var e=0,n=xq/3,i=bK(t),r=i(e,n);return r.parallels=function(t){return arguments.length?i(e=t[0]*Tq,n=t[1]*Tq):[e*Eq,n*Eq]},r}function wK(t,e){var n=Rq(t),i=(n+Rq(e))/2;if(Aq(i)<bq)return(function r(t){var e=Lq(t);function n(t,n){return[t*e,Rq(n)/e]}return n.invert=function(t,n){return[t/e,Fq(n*e)]},n})(t);var o=1+n*(2*i-n),a=Dq(o)/i;function s(t,e){var n=Dq(o-2*i*Rq(e))/i;return[n*Rq(t*=i),a-n*Lq(t)]}return s.invert=function(t,e){var n=a-e;return[kq(t,Aq(n))/i*zq(n),Fq((o-(t*t+n*n)*i*i)/(2*i))]},s}function SK(){return xK(wK).scale(155.424).center([0,33.6442])}function MK(){return SK().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function EK(t){return function(e,n){var i=Lq(e),r=Lq(n),o=t(i*r);return[o*r*Rq(e),o*Rq(n)]}}function TK(t){return function(e,n){var i=Dq(e*e+n*n),r=t(i),o=Rq(r),a=Lq(r);return[kq(e*o,i*a),Fq(i&&n*o/i)]}}var AK=EK((function(t){return Dq(2/(1+t))}));AK.invert=TK((function(t){return 2*Fq(t/2)}));var CK=EK((function(t){return(t=Hq(t))&&t/Rq(t)}));function kK(t,e){return[t,Nq(Bq((wq+e)/2))]}function LK(t){var e,n,i,r=vK(t),o=r.center,a=r.scale,s=r.translate,l=r.clipExtent,c=null;function u(){var o=xq*a(),s=r(gX(r.rotate()).invert([0,0]));return l(null==c?[[s[0]-o,s[1]-o],[s[0]+o,s[1]+o]]:t===kK?[[Math.max(s[0]-o,c),e],[Math.min(s[0]+o,n),i]]:[[c,Math.max(s[1]-o,e)],[n,Math.min(s[1]+o,i)]])}return r.scale=function(t){return arguments.length?(a(t),u()):a()},r.translate=function(t){return arguments.length?(s(t),u()):s()},r.center=function(t){return arguments.length?(o(t),u()):o()},r.clipExtent=function(t){return arguments.length?(null==t?c=e=n=i=null:(c=+t[0][0],e=+t[0][1],n=+t[1][0],i=+t[1][1]),u()):null==c?null:[[c,e],[n,i]]},u()}function PK(t){return Bq((wq+t)/2)}function IK(t,e){var n=Lq(t),i=t===e?Rq(t):Nq(n/Lq(e))/Nq(PK(e)/PK(t)),r=n*Oq(PK(t),i)/i;if(!i)return kK;function o(t,e){r>0?e<-wq+bq&&(e=-wq+bq):e>wq-bq&&(e=wq-bq);var n=r/Oq(PK(e),i);return[n*Rq(i*t),r-n*Lq(i*t)]}return o.invert=function(t,e){var n=r-e,o=zq(i)*Dq(t*t+n*n);return[kq(t,Aq(n))/i*zq(n),2*Cq(Oq(r/o,1/i))-wq]},o}function NK(t,e){return[t,e]}function OK(t,e){var n=Lq(t),i=t===e?Rq(t):(n-Lq(e))/(e-t),r=n/i+t;if(Aq(i)<bq)return NK;function o(t,e){var n=r-e,o=i*t;return[n*Rq(o),r-n*Lq(o)]}return o.invert=function(t,e){var n=r-e;return[kq(t,Aq(n))/i*zq(n),r-zq(i)*Dq(t*t+n*n)]},o}function RK(t,e){var n=Lq(e),i=Lq(t)*n;return[n*Rq(t)/i,Rq(e)/i]}function zK(t,e,n,i){return 1===t&&1===e&&0===n&&0===i?u$:cK({point:function(r,o){this.stream.point(r*t+n,o*e+i)}})}function DK(t,e){var n=e*e,i=n*n;return[t*(.8707-.131979*n+i*(i*(.003971*n-.001529*i)-.013791)),e*(1.007226+n*(.015085+i*(.028874*n-.044475-.005916*i)))]}function BK(t,e){return[Lq(e)*Rq(t),Rq(e)]}function HK(t,e){var n=Lq(e),i=1+Lq(t)*n;return[n*Rq(t)/i,Rq(e)/i]}function FK(t,e){return[Nq(Bq((wq+e)/2)),-t]}function VK(t,e){return t.parent===e.parent?1:2}function jK(t,e){return t+e.x}function UK(t,e){return Math.max(t,e.y)}function GK(t){var e=0,n=t.children,i=n&&n.length;if(i)for(;--i>=0;)e+=n[i].value;else e=1;t.value=e}function WK(t,e){var n,i,r,o,a,s=new $K(t),l=+t.value&&(s.value=t.value),c=[s];for(null==e&&(e=qK);n=c.pop();)if(l&&(n.value=+n.data.value),(r=e(n.data))&&(a=r.length))for(n.children=new Array(a),o=a-1;o>=0;--o)c.push(i=n.children[o]=new $K(r[o])),i.parent=n,i.depth=n.depth+1;return s.eachBefore(XK)}function qK(t){return t.children}function YK(t){t.data=t.data.data}function XK(t){var e=0;do{t.height=e}while((t=t.parent)&&t.height<++e)}function $K(t){this.data=t,this.depth=this.height=0,this.parent=null}CK.invert=TK((function(t){return t})),kK.invert=function(t,e){return[t,2*Cq(Iq(e))-wq]},NK.invert=NK,RK.invert=TK(Cq),DK.invert=function(t,e){var n,i=e,r=25;do{var o=i*i,a=o*o;i-=n=(i*(1.007226+o*(.015085+a*(.028874*o-.044475-.005916*a)))-e)/(1.007226+o*(.045255+a*(.259866*o-.311325-.005916*11*a)))}while(Aq(n)>bq&&--r>0);return[t/(.8707+(o=i*i)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),i]},BK.invert=TK(Fq),HK.invert=TK((function(t){return 2*Cq(t)})),FK.invert=function(t,e){return[-e,2*Cq(Iq(t))-wq]},$K.prototype=WK.prototype={constructor:$K,count:function KK(){return this.eachAfter(GK)},each:function ZK(t){var e,n,i,r,o=this,a=[o];do{for(e=a.reverse(),a=[];o=e.pop();)if(t(o),n=o.children)for(i=0,r=n.length;i<r;++i)a.push(n[i])}while(a.length);return this},eachAfter:function JK(t){for(var e,n,i,r=this,o=[r],a=[];r=o.pop();)if(a.push(r),e=r.children)for(n=0,i=e.length;n<i;++n)o.push(e[n]);for(;r=a.pop();)t(r);return this},eachBefore:function QK(t){for(var e,n,i=this,r=[i];i=r.pop();)if(t(i),e=i.children)for(n=e.length-1;n>=0;--n)r.push(e[n]);return this},sum:function tZ(t){return this.eachAfter((function(e){for(var n=+t(e.data)||0,i=e.children,r=i&&i.length;--r>=0;)n+=i[r].value;e.value=n}))},sort:function eZ(t){return this.eachBefore((function(e){e.children&&e.children.sort(t)}))},path:function nZ(t){for(var e=this,n=(function i(t,e){if(t===e)return t;var n=t.ancestors(),i=e.ancestors(),r=null;for(t=n.pop(),e=i.pop();t===e;)r=t,t=n.pop(),e=i.pop();return r})(e,t),r=[e];e!==n;)r.push(e=e.parent);for(var o=r.length;t!==n;)r.splice(o,0,t),t=t.parent;return r},ancestors:function iZ(){for(var t=this,e=[t];t=t.parent;)e.push(t);return e},descendants:function rZ(){var t=[];return this.each((function(e){t.push(e)})),t},leaves:function oZ(){var t=[];return this.eachBefore((function(e){e.children||t.push(e)})),t},links:function aZ(){var t=this,e=[];return t.each((function(n){n!==t&&e.push({source:n.parent,target:n})})),e},copy:function sZ(){return WK(this).eachBefore(YK)}};var lZ=Array.prototype.slice;function cZ(t){for(var e,n,i=0,r=(t=(function o(t){for(var e,n,i=t.length;i;)n=Math.random()*i--|0,e=t[i],t[i]=t[n],t[n]=e;return t})(lZ.call(t))).length,a=[];i<r;)e=t[i],n&&dZ(n,e)?++i:(n=fZ(a=uZ(a,e)),i=0);return n}function uZ(t,e){var n,i;if(pZ(e,t))return[e];for(n=0;n<t.length;++n)if(hZ(e,t[n])&&pZ(mZ(t[n],e),t))return[t[n],e];for(n=0;n<t.length-1;++n)for(i=n+1;i<t.length;++i)if(hZ(mZ(t[n],t[i]),e)&&hZ(mZ(t[n],e),t[i])&&hZ(mZ(t[i],e),t[n])&&pZ(gZ(t[n],t[i],e),t))return[t[n],t[i],e];throw new Error}function hZ(t,e){var n=t.r-e.r,i=e.x-t.x,r=e.y-t.y;return n<0||n*n<i*i+r*r}function dZ(t,e){var n=t.r-e.r+1e-6,i=e.x-t.x,r=e.y-t.y;return n>0&&n*n>i*i+r*r}function pZ(t,e){for(var n=0;n<e.length;++n)if(!dZ(t,e[n]))return!1;return!0}function fZ(t){switch(t.length){case 1:return(function e(t){return{x:t.x,y:t.y,r:t.r}})(t[0]);case 2:return mZ(t[0],t[1]);case 3:return gZ(t[0],t[1],t[2])}}function mZ(t,e){var n=t.x,i=t.y,r=t.r,o=e.x,a=e.y,s=e.r,l=o-n,c=a-i,u=s-r,h=Math.sqrt(l*l+c*c);return{x:(n+o+l/h*u)/2,y:(i+a+c/h*u)/2,r:(h+r+s)/2}}function gZ(t,e,n){var i=t.x,r=t.y,o=t.r,a=e.x,s=e.y,l=e.r,c=n.x,u=n.y,h=n.r,d=i-a,p=i-c,f=r-s,m=r-u,g=l-o,_=h-o,y=i*i+r*r-o*o,v=y-a*a-s*s+l*l,b=y-c*c-u*u+h*h,x=p*f-d*m,w=(f*b-m*v)/(2*x)-i,S=(m*g-f*_)/x,M=(p*v-d*b)/(2*x)-r,E=(d*_-p*g)/x,T=S*S+E*E-1,A=2*(o+w*S+M*E),C=w*w+M*M-o*o,k=-(T?(A+Math.sqrt(A*A-4*T*C))/(2*T):C/A);return{x:i+w+S*k,y:r+M+E*k,r:k}}function _Z(t,e,n){var i=t.x,r=t.y,o=e.r+n.r,a=t.r+n.r,s=e.x-i,l=e.y-r,c=s*s+l*l;if(c){var u=.5+((a*=a)-(o*=o))/(2*c),h=Math.sqrt(Math.max(0,2*o*(a+c)-(a-=c)*a-o*o))/(2*c);n.x=i+u*s+h*l,n.y=r+u*l-h*s}else n.x=i+a,n.y=r}function yZ(t,e){var n=e.x-t.x,i=e.y-t.y,r=t.r+e.r;return r*r-1e-6>n*n+i*i}function vZ(t){var e=t._,n=t.next._,i=e.r+n.r,r=(e.x*n.r+n.x*e.r)/i,o=(e.y*n.r+n.y*e.r)/i;return r*r+o*o}function bZ(t){this._=t,this.next=null,this.previous=null}function xZ(t){if(!(r=t.length))return 0;var e,n,i,r,o,a,s,l,c,u,h;if((e=t[0]).x=0,e.y=0,!(r>1))return e.r;if(e.x=-(n=t[1]).r,n.x=e.r,n.y=0,!(r>2))return e.r+n.r;_Z(n,e,i=t[2]),e=new bZ(e),n=new bZ(n),i=new bZ(i),e.next=i.previous=n,n.next=e.previous=i,i.next=n.previous=e;t:for(s=3;s<r;++s){_Z(e._,n._,i=t[s]),i=new bZ(i),l=n.next,c=e.previous,u=n._.r,h=e._.r;do{if(u<=h){if(yZ(l._,i._)){e.next=n=l,n.previous=e,--s;continue t}u+=l._.r,l=l.next}else{if(yZ(c._,i._)){(e=c).next=n,n.previous=e,--s;continue t}h+=c._.r,c=c.previous}}while(l!==c.next);for(i.previous=e,i.next=n,e.next=n.previous=n=i,o=vZ(e);(i=i.next)!==n;)(a=vZ(i))<o&&(e=i,o=a);n=e.next}for(e=[n._],i=n;(i=i.next)!==n;)e.push(i._);for(i=cZ(e),s=0;s<r;++s)(e=t[s]).x-=i.x,e.y-=i.y;return i.r}function wZ(t){return null==t?null:SZ(t)}function SZ(t){if("function"!=typeof t)throw new Error;return t}function MZ(){return 0}function EZ(t){return function(){return t}}function TZ(t){return Math.sqrt(t.value)}function AZ(t){return function(e){e.children||(e.r=Math.max(0,+t(e)||0))}}function CZ(t,e){return function(n){if(i=n.children){var i,r,o,a=i.length,s=t(n)*e||0;if(s)for(r=0;r<a;++r)i[r].r+=s;if(o=xZ(i),s)for(r=0;r<a;++r)i[r].r-=s;n.r=o+s}}}function kZ(t){return function(e){var n=e.parent;e.r*=t,n&&(e.x=n.x+t*e.x,e.y=n.y+t*e.y)}}function LZ(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function PZ(t,e,n,i,r){for(var o,a=t.children,s=-1,l=a.length,c=t.value&&(i-e)/t.value;++s<l;)(o=a[s]).y0=n,o.y1=r,o.x0=e,o.x1=e+=o.value*c}var IZ={depth:-1},NZ={};function OZ(t){return t.id}function RZ(t){return t.parentId}function zZ(t,e){return t.parent===e.parent?1:2}function DZ(t){var e=t.children;return e?e[0]:t.t}function BZ(t){var e=t.children;return e?e[e.length-1]:t.t}function HZ(t,e,n){var i=n/(e.i-t.i);e.c-=i,e.s+=n,t.c+=i,e.z+=n,e.m+=n}function FZ(t,e,n){return t.a.parent===e.parent?t.a:n}function VZ(t,e){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=e}function jZ(t,e,n,i,r){for(var o,a=t.children,s=-1,l=a.length,c=t.value&&(r-n)/t.value;++s<l;)(o=a[s]).x0=e,o.x1=i,o.y0=n,o.y1=n+=o.value*c}VZ.prototype=Object.create($K.prototype);var UZ=(1+Math.sqrt(5))/2;function GZ(t,e,n,i,r,o){for(var a,s,l,c,u,h,d,p,f,m,g,_=[],y=e.children,v=0,b=0,x=y.length,w=e.value;v<x;){l=r-n,c=o-i;do{u=y[b++].value}while(!u&&b<x);for(h=d=u,g=u*u*(m=Math.max(c/l,l/c)/(w*t)),f=Math.max(d/g,g/h);b<x;++b){if(u+=s=y[b].value,s<h&&(h=s),s>d&&(d=s),g=u*u*m,(p=Math.max(d/g,g/h))>f){u-=s;break}f=p}_.push(a={value:u,dice:l<c,children:y.slice(v,b)}),a.dice?PZ(a,n,i,r,w?i+=c*u/w:o):jZ(a,n,i,w?n+=l*u/w:r,o),w-=u,v=b}return _}var WZ=(function t(e){function n(t,n,i,r,o){GZ(e,t,n,i,r,o)}return n.ratio=function(e){return t((e=+e)>1?e:1)},n})(UZ),qZ=(function t(e){function n(t,n,i,r,o){if((a=t._squarify)&&a.ratio===e)for(var a,s,l,c,u,h=-1,d=a.length,p=t.value;++h<d;){for(l=(s=a[h]).children,c=s.value=0,u=l.length;c<u;++c)s.value+=l[c].value;s.dice?PZ(s,n,i,r,i+=(o-i)*s.value/p):jZ(s,n,i,n+=(r-n)*s.value/p,o),p-=s.value}else t._squarify=a=GZ(e,t,n,i,r,o),a.ratio=e}return n.ratio=function(e){return t((e=+e)>1?e:1)},n})(UZ);function YZ(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function XZ(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function $Z(){}var KZ=.7,ZZ=1/KZ,JZ="\\s*([+-]?\\d+)\\s*",QZ="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",tJ="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",eJ=/^#([0-9a-f]{3,8})$/,nJ=new RegExp("^rgb\\("+[JZ,JZ,JZ]+"\\)$"),iJ=new RegExp("^rgb\\("+[tJ,tJ,tJ]+"\\)$"),rJ=new RegExp("^rgba\\("+[JZ,JZ,JZ,QZ]+"\\)$"),oJ=new RegExp("^rgba\\("+[tJ,tJ,tJ,QZ]+"\\)$"),aJ=new RegExp("^hsl\\("+[QZ,tJ,tJ]+"\\)$"),sJ=new RegExp("^hsla\\("+[QZ,tJ,tJ,QZ]+"\\)$"),lJ={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function cJ(){return this.rgb().formatHex()}function uJ(){return this.rgb().formatRgb()}function hJ(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=eJ.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?dJ(e):3===n?new gJ(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?pJ(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?pJ(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=nJ.exec(t))?new gJ(e[1],e[2],e[3],1):(e=iJ.exec(t))?new gJ(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=rJ.exec(t))?pJ(e[1],e[2],e[3],e[4]):(e=oJ.exec(t))?pJ(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=aJ.exec(t))?bJ(e[1],e[2]/100,e[3]/100,1):(e=sJ.exec(t))?bJ(e[1],e[2]/100,e[3]/100,e[4]):lJ.hasOwnProperty(t)?dJ(lJ[t]):"transparent"===t?new gJ(NaN,NaN,NaN,0):null}function dJ(t){return new gJ(t>>16&255,t>>8&255,255&t,1)}function pJ(t,e,n,i){return i<=0&&(t=e=n=NaN),new gJ(t,e,n,i)}function fJ(t){return t instanceof $Z||(t=hJ(t)),t?new gJ((t=t.rgb()).r,t.g,t.b,t.opacity):new gJ}function mJ(t,e,n,i){return 1===arguments.length?fJ(t):new gJ(t,e,n,null==i?1:i)}function gJ(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function _J(){return"#"+vJ(this.r)+vJ(this.g)+vJ(this.b)}function yJ(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function vJ(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function bJ(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new SJ(t,e,n,i)}function xJ(t){if(t instanceof SJ)return new SJ(t.h,t.s,t.l,t.opacity);if(t instanceof $Z||(t=hJ(t)),!t)return new SJ;if(t instanceof SJ)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new SJ(a,s,l,t.opacity)}function wJ(t,e,n,i){return 1===arguments.length?xJ(t):new SJ(t,e,n,null==i?1:i)}function SJ(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function MJ(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}YZ($Z,hJ,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:cJ,formatHex:cJ,formatHsl:function EJ(){return xJ(this).formatHsl()},formatRgb:uJ,toString:uJ}),YZ(gJ,mJ,XZ($Z,{brighter:function(t){return t=null==t?ZZ:Math.pow(ZZ,t),new gJ(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?KZ:Math.pow(KZ,t),new gJ(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:_J,formatHex:_J,formatRgb:yJ,toString:yJ})),YZ(SJ,wJ,XZ($Z,{brighter:function(t){return t=null==t?ZZ:Math.pow(ZZ,t),new SJ(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?KZ:Math.pow(KZ,t),new SJ(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new gJ(MJ(t>=240?t-240:t+120,r,i),MJ(t,r,i),MJ(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var TJ=Math.PI/180,AJ=180/Math.PI,CJ=.96422,kJ=.82521,LJ=4/29,PJ=6/29,IJ=3*PJ*PJ;function NJ(t){if(t instanceof RJ)return new RJ(t.l,t.a,t.b,t.opacity);if(t instanceof jJ)return UJ(t);t instanceof gJ||(t=fJ(t));var e,n,i=HJ(t.r),r=HJ(t.g),o=HJ(t.b),a=zJ((.2225045*i+.7168786*r+.0606169*o)/1);return i===r&&r===o?e=n=a:(e=zJ((.4360747*i+.3850649*r+.1430804*o)/CJ),n=zJ((.0139322*i+.0971045*r+.7141733*o)/kJ)),new RJ(116*a-16,500*(e-a),200*(a-n),t.opacity)}function OJ(t,e,n,i){return 1===arguments.length?NJ(t):new RJ(t,e,n,null==i?1:i)}function RJ(t,e,n,i){this.l=+t,this.a=+e,this.b=+n,this.opacity=+i}function zJ(t){return t>.008856451679035631?Math.pow(t,1/3):t/IJ+LJ}function DJ(t){return t>PJ?t*t*t:IJ*(t-LJ)}function BJ(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function HJ(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function FJ(t){if(t instanceof jJ)return new jJ(t.h,t.c,t.l,t.opacity);if(t instanceof RJ||(t=NJ(t)),0===t.a&&0===t.b)return new jJ(NaN,0<t.l&&t.l<100?0:NaN,t.l,t.opacity);var e=Math.atan2(t.b,t.a)*AJ;return new jJ(e<0?e+360:e,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function VJ(t,e,n,i){return 1===arguments.length?FJ(t):new jJ(t,e,n,null==i?1:i)}function jJ(t,e,n,i){this.h=+t,this.c=+e,this.l=+n,this.opacity=+i}function UJ(t){if(isNaN(t.h))return new RJ(t.l,0,0,t.opacity);var e=t.h*TJ;return new RJ(t.l,Math.cos(e)*t.c,Math.sin(e)*t.c,t.opacity)}YZ(RJ,OJ,XZ($Z,{brighter:function(t){return new RJ(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new RJ(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,n=isNaN(this.b)?t:t-this.b/200;return new gJ(BJ(3.1338561*(e=CJ*DJ(e))-1.6168667*(t=1*DJ(t))-.4906146*(n=kJ*DJ(n))),BJ(-.9787684*e+1.9161415*t+.033454*n),BJ(.0719453*e-.2289914*t+1.4052427*n),this.opacity)}})),YZ(jJ,VJ,XZ($Z,{brighter:function(t){return new jJ(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new jJ(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return UJ(this).rgb()}}));var GJ=-.29227,WJ=-.90649,qJ=1.97294;function YJ(t){if(t instanceof $J)return new $J(t.h,t.s,t.l,t.opacity);t instanceof gJ||(t=fJ(t));var e=t.g/255,n=t.b/255,i=(-.6557636667999999*n+t.r/255*-1.7884503806-3.5172982438*e)/-5.9615122912,r=n-i,o=(qJ*(e-i)-GJ*r)/WJ,a=Math.sqrt(o*o+r*r)/(qJ*i*(1-i)),s=a?Math.atan2(o,r)*AJ-120:NaN;return new $J(s<0?s+360:s,a,i,t.opacity)}function XJ(t,e,n,i){return 1===arguments.length?YJ(t):new $J(t,e,n,null==i?1:i)}function $J(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function KJ(t,e,n,i,r){var o=t*t,a=o*t;return((1-3*t+3*o-a)*e+(4-6*o+3*a)*n+(1+3*t+3*o-3*a)*i+a*r)/6}function ZJ(t){var e=t.length-1;return function(n){var i=n<=0?n=0:n>=1?(n=1,e-1):Math.floor(n*e),r=t[i],o=t[i+1];return KJ((n-i/e)*e,i>0?t[i-1]:2*r-o,r,o,i<e-1?t[i+2]:2*o-r)}}function JJ(t){var e=t.length;return function(n){var i=Math.floor(((n%=1)<0?++n:n)*e);return KJ((n-i/e)*e,t[(i+e-1)%e],t[i%e],t[(i+1)%e],t[(i+2)%e])}}function QJ(t){return function(){return t}}function tQ(t,e){return function(n){return t+n*e}}function eQ(t,e){var n=e-t;return n?tQ(t,n>180||n<-180?n-360*Math.round(n/360):n):QJ(isNaN(t)?e:t)}function nQ(t,e){var n=e-t;return n?tQ(t,n):QJ(isNaN(t)?e:t)}YZ($J,XJ,XZ($Z,{brighter:function(t){return t=null==t?ZZ:Math.pow(ZZ,t),new $J(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?KZ:Math.pow(KZ,t),new $J(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*TJ,e=+this.l,n=isNaN(this.s)?0:this.s*e*(1-e),i=Math.cos(t),r=Math.sin(t);return new gJ(255*(e+n*(-.14861*i+1.78277*r)),255*(e+n*(GJ*i+WJ*r)),255*(e+n*(qJ*i)),this.opacity)}}));var iQ=(function t(e){var n=(function i(t){return 1==(t=+t)?nQ:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):QJ(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=mJ(t)).r,(e=mJ(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=nQ(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function rQ(t){return function(e){var n,i,r=e.length,o=new Array(r),a=new Array(r),s=new Array(r);for(n=0;n<r;++n)i=mJ(e[n]),o[n]=i.r||0,a[n]=i.g||0,s[n]=i.b||0;return o=t(o),a=t(a),s=t(s),i.opacity=1,function(t){return i.r=o(t),i.g=a(t),i.b=s(t),i+""}}}var oQ=rQ(ZJ),aQ=rQ(JJ);function sQ(t,e){var n,i=e?e.length:0,r=t?Math.min(i,t.length):0,o=new Array(r),a=new Array(i);for(n=0;n<r;++n)o[n]=fQ(t[n],e[n]);for(;n<i;++n)a[n]=e[n];return function(t){for(n=0;n<r;++n)a[n]=o[n](t);return a}}function lQ(t,e){var n=new Date;return e-=t=+t,function(i){return n.setTime(t+e*i),n}}function cQ(t,e){return e-=t=+t,function(n){return t+e*n}}function uQ(t,e){var n,i={},r={};for(n in null!==t&&"object"==typeof t||(t={}),null!==e&&"object"==typeof e||(e={}),e)n in t?i[n]=fQ(t[n],e[n]):r[n]=e[n];return function(t){for(n in i)r[n]=i[n](t);return r}}var hQ=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,dQ=new RegExp(hQ.source,"g");function pQ(t,e){var n,i,r,o=hQ.lastIndex=dQ.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=hQ.exec(t))&&(i=dQ.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:cQ(n,i)})),o=dQ.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}function fQ(t,e){var n,i=typeof e;return null==e||"boolean"===i?QJ(e):("number"===i?cQ:"string"===i?(n=hJ(e))?(e=n,iQ):pQ:e instanceof hJ?iQ:e instanceof Date?lQ:Array.isArray(e)?sQ:"function"!=typeof e.valueOf&&"function"!=typeof e.toString||isNaN(e)?uQ:cQ)(t,e)}var mQ,gQ,_Q,yQ,vQ=180/Math.PI,bQ={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function xQ(t,e,n,i,r,o){var a,s,l;return(a=Math.sqrt(t*t+e*e))&&(t/=a,e/=a),(l=t*n+e*i)&&(n-=t*l,i-=e*l),(s=Math.sqrt(n*n+i*i))&&(n/=s,i/=s,l/=s),t*i<e*n&&(t=-t,e=-e,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(e,t)*vQ,skewX:Math.atan(l)*vQ,scaleX:a,scaleY:s}}function wQ(t,e,n,i){function r(t){return t.length?t.pop()+" ":""}return function(o,a){var s=[],l=[];return o=t(o),a=t(a),(function c(t,i,r,o,a,s){if(t!==r||i!==o){var l=a.push("translate(",null,e,null,n);s.push({i:l-4,x:cQ(t,r)},{i:l-2,x:cQ(i,o)})}else(r||o)&&a.push("translate("+r+e+o+n)})(o.translateX,o.translateY,a.translateX,a.translateY,s,l),(function u(t,e,n,o){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),o.push({i:n.push(r(n)+"rotate(",null,i)-2,x:cQ(t,e)})):e&&n.push(r(n)+"rotate("+e+i)})(o.rotate,a.rotate,s,l),(function h(t,e,n,o){t!==e?o.push({i:n.push(r(n)+"skewX(",null,i)-2,x:cQ(t,e)}):e&&n.push(r(n)+"skewX("+e+i)})(o.skewX,a.skewX,s,l),(function d(t,e,n,i,o,a){if(t!==n||e!==i){var s=o.push(r(o)+"scale(",null,",",null,")");a.push({i:s-4,x:cQ(t,n)},{i:s-2,x:cQ(e,i)})}else 1===n&&1===i||o.push(r(o)+"scale("+n+","+i+")")})(o.scaleX,o.scaleY,a.scaleX,a.scaleY,s,l),o=a=null,function(t){for(var e,n=-1,i=l.length;++n<i;)s[(e=l[n]).i]=e.x(t);return s.join("")}}}var SQ=wQ((function MQ(t){return"none"===t?bQ:(mQ||(mQ=document.createElement("DIV"),gQ=document.documentElement,_Q=document.defaultView),mQ.style.transform=t,t=_Q.getComputedStyle(gQ.appendChild(mQ),null).getPropertyValue("transform"),gQ.removeChild(mQ),xQ(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),EQ=wQ((function TQ(t){return null==t?bQ:(yQ||(yQ=document.createElementNS("http://www.w3.org/2000/svg","g")),yQ.setAttribute("transform",t),(t=yQ.transform.baseVal.consolidate())?xQ((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):bQ)}),", ",")",")"),AQ=Math.SQRT2;function CQ(t){return((t=Math.exp(t))+1/t)/2}function kQ(t){return function(e,n){var i=t((e=wJ(e)).h,(n=wJ(n)).h),r=nQ(e.s,n.s),o=nQ(e.l,n.l),a=nQ(e.opacity,n.opacity);return function(t){return e.h=i(t),e.s=r(t),e.l=o(t),e.opacity=a(t),e+""}}}var LQ=kQ(eQ),PQ=kQ(nQ);function IQ(t){return function(e,n){var i=t((e=VJ(e)).h,(n=VJ(n)).h),r=nQ(e.c,n.c),o=nQ(e.l,n.l),a=nQ(e.opacity,n.opacity);return function(t){return e.h=i(t),e.c=r(t),e.l=o(t),e.opacity=a(t),e+""}}}var NQ=IQ(eQ),OQ=IQ(nQ);function RQ(t){return(function e(n){function i(e,i){var r=t((e=XJ(e)).h,(i=XJ(i)).h),o=nQ(e.s,i.s),a=nQ(e.l,i.l),s=nQ(e.opacity,i.opacity);return function(t){return e.h=r(t),e.s=o(t),e.l=a(Math.pow(t,n)),e.opacity=s(t),e+""}}return n=+n,i.gamma=e,i})(1)}var zQ=RQ(eQ),DQ=RQ(nQ),BQ=Math.PI,HQ=2*BQ,FQ=1e-6,VQ=HQ-FQ;function jQ(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function UQ(){return new jQ}function GQ(t,e,n){return(e[0]-t[0])*(n[1]-t[1])-(e[1]-t[1])*(n[0]-t[0])}function WQ(t,e){return t[0]-e[0]||t[1]-e[1]}function qQ(t){for(var e=t.length,n=[0,1],i=2,r=2;r<e;++r){for(;i>1&&GQ(t[n[i-2]],t[n[i-1]],t[r])<=0;)--i;n[i++]=r}return n.slice(0,i)}function YQ(t,e,n,i){if(isNaN(e)||isNaN(n))return t;var r,o,a,s,l,c,u,h,d,p=t._root,f={data:i},m=t._x0,g=t._y0,_=t._x1,y=t._y1;if(!p)return t._root=f,t;for(;p.length;)if((c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a,r=p,!(p=p[h=u<<1|c]))return r[h]=f,t;if(s=+t._x.call(null,p.data),l=+t._y.call(null,p.data),e===s&&n===l)return f.next=p,r?r[h]=f:t._root=f,t;do{r=r?r[h]=new Array(4):t._root=new Array(4),(c=e>=(o=(m+_)/2))?m=o:_=o,(u=n>=(a=(g+y)/2))?g=a:y=a}while((h=u<<1|c)==(d=(l>=a)<<1|s>=o));return r[d]=p,r[h]=f,t}function XQ(t,e,n,i,r){this.node=t,this.x0=e,this.y0=n,this.x1=i,this.y1=r}function $Q(t){return t[0]}function KQ(t){return t[1]}function ZQ(t,e,n){var i=new JQ(null==e?$Q:e,null==n?KQ:n,NaN,NaN,NaN,NaN);return null==t?i:i.addAll(t)}function JQ(t,e,n,i,r,o){this._x=t,this._y=e,this._x0=n,this._y0=i,this._x1=r,this._y1=o,this._root=void 0}function QQ(t){for(var e={data:t.data},n=e;t=t.next;)n=n.next={data:t.data};return e}jQ.prototype=UQ.prototype={constructor:jQ,moveTo:function(t,e){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,e){this._+="L"+(this._x1=+t)+","+(this._y1=+e)},quadraticCurveTo:function(t,e,n,i){this._+="Q"+ +t+","+ +e+","+(this._x1=+n)+","+(this._y1=+i)},bezierCurveTo:function(t,e,n,i,r,o){this._+="C"+ +t+","+ +e+","+ +n+","+ +i+","+(this._x1=+r)+","+(this._y1=+o)},arcTo:function(t,e,n,i,r){var o=this._x1,a=this._y1,s=(n=+n)-(t=+t),l=(i=+i)-(e=+e),c=o-t,u=a-e,h=c*c+u*u;if((r=+r)<0)throw new Error("negative radius: "+r);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=e);else if(h>FQ)if(Math.abs(u*s-l*c)>FQ&&r){var d=n-o,p=i-a,f=s*s+l*l,m=d*d+p*p,g=Math.sqrt(f),_=Math.sqrt(h),y=r*Math.tan((BQ-Math.acos((f+h-m)/(2*g*_)))/2),v=y/_,b=y/g;Math.abs(v-1)>FQ&&(this._+="L"+(t+v*c)+","+(e+v*u)),this._+="A"+r+","+r+",0,0,"+ +(u*d>c*p)+","+(this._x1=t+b*s)+","+(this._y1=e+b*l)}else this._+="L"+(this._x1=t)+","+(this._y1=e)},arc:function(t,e,n,i,r,o){t=+t,e=+e;var a=(n=+n)*Math.cos(i),s=n*Math.sin(i),l=t+a,c=e+s,u=1^o,h=o?i-r:r-i;if(n<0)throw new Error("negative radius: "+n);null===this._x1?this._+="M"+l+","+c:(Math.abs(this._x1-l)>FQ||Math.abs(this._y1-c)>FQ)&&(this._+="L"+l+","+c),n&&(h<0&&(h=h%HQ+HQ),h>VQ?this._+="A"+n+","+n+",0,1,"+u+","+(t-a)+","+(e-s)+"A"+n+","+n+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>FQ&&(this._+="A"+n+","+n+",0,"+ +(h>=BQ)+","+u+","+(this._x1=t+n*Math.cos(r))+","+(this._y1=e+n*Math.sin(r))))},rect:function(t,e,n,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)+"h"+ +n+"v"+ +i+"h"+-n+"Z"},toString:function(){return this._}};var t1=ZQ.prototype=JQ.prototype;t1.copy=function(){var t,e,n=new JQ(this._x,this._y,this._x0,this._y0,this._x1,this._y1),i=this._root;if(!i)return n;if(!i.length)return n._root=QQ(i),n;for(t=[{source:i,target:n._root=new Array(4)}];i=t.pop();)for(var r=0;r<4;++r)(e=i.source[r])&&(e.length?t.push({source:e,target:i.target[r]=new Array(4)}):i.target[r]=QQ(e));return n},t1.add=function e1(t){var e=+this._x.call(null,t),n=+this._y.call(null,t);return YQ(this.cover(e,n),e,n,t)},t1.addAll=function n1(t){var e,n,i,r,o=t.length,a=new Array(o),s=new Array(o),l=1/0,c=1/0,u=-1/0,h=-1/0;for(n=0;n<o;++n)isNaN(i=+this._x.call(null,e=t[n]))||isNaN(r=+this._y.call(null,e))||(a[n]=i,s[n]=r,i<l&&(l=i),i>u&&(u=i),r<c&&(c=r),r>h&&(h=r));for(u<l&&(l=this._x0,u=this._x1),h<c&&(c=this._y0,h=this._y1),this.cover(l,c).cover(u,h),n=0;n<o;++n)YQ(this,a[n],s[n],t[n]);return this},t1.cover=function i1(t,e){if(isNaN(t=+t)||isNaN(e=+e))return this;var n=this._x0,i=this._y0,r=this._x1,o=this._y1;if(isNaN(n))r=(n=Math.floor(t))+1,o=(i=Math.floor(e))+1;else{if(!(n>t||t>r||i>e||e>o))return this;var a,s,l=r-n,c=this._root;switch(s=(e<(i+o)/2)<<1|t<(n+r)/2){case 0:do{(a=new Array(4))[s]=c,c=a}while(o=i+(l*=2),t>(r=n+l)||e>o);break;case 1:do{(a=new Array(4))[s]=c,c=a}while(o=i+(l*=2),(n=r-l)>t||e>o);break;case 2:do{(a=new Array(4))[s]=c,c=a}while(i=o-(l*=2),t>(r=n+l)||i>e);break;case 3:do{(a=new Array(4))[s]=c,c=a}while(i=o-(l*=2),(n=r-l)>t||i>e)}this._root&&this._root.length&&(this._root=c)}return this._x0=n,this._y0=i,this._x1=r,this._y1=o,this},t1.data=function r1(){var t=[];return this.visit((function(e){if(!e.length)do{t.push(e.data)}while(e=e.next)})),t},t1.extent=function o1(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},t1.find=function a1(t,e,n){var i,r,o,a,s,l,c,u=this._x0,h=this._y0,d=this._x1,p=this._y1,f=[],m=this._root;for(m&&f.push(new XQ(m,u,h,d,p)),null==n?n=1/0:(u=t-n,h=e-n,d=t+n,p=e+n,n*=n);l=f.pop();)if(!(!(m=l.node)||(r=l.x0)>d||(o=l.y0)>p||(a=l.x1)<u||(s=l.y1)<h))if(m.length){var g=(r+a)/2,_=(o+s)/2;f.push(new XQ(m[3],g,_,a,s),new XQ(m[2],r,_,g,s),new XQ(m[1],g,o,a,_),new XQ(m[0],r,o,g,_)),(c=(e>=_)<<1|t>=g)&&(l=f[f.length-1],f[f.length-1]=f[f.length-1-c],f[f.length-1-c]=l)}else{var y=t-+this._x.call(null,m.data),v=e-+this._y.call(null,m.data),b=y*y+v*v;if(b<n){var x=Math.sqrt(n=b);u=t-x,h=e-x,d=t+x,p=e+x,i=m.data}}return i},t1.remove=function s1(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var e,n,i,r,o,a,s,l,c,u,h,d,p=this._root,f=this._x0,m=this._y0,g=this._x1,_=this._y1;if(!p)return this;if(p.length)for(;;){if((c=o>=(s=(f+g)/2))?f=s:g=s,(u=a>=(l=(m+_)/2))?m=l:_=l,e=p,!(p=p[h=u<<1|c]))return this;if(!p.length)break;(e[h+1&3]||e[h+2&3]||e[h+3&3])&&(n=e,d=h)}for(;p.data!==t;)if(i=p,!(p=p.next))return this;return(r=p.next)&&delete p.next,i?(r?i.next=r:delete i.next,this):e?(r?e[h]=r:delete e[h],(p=e[0]||e[1]||e[2]||e[3])&&p===(e[3]||e[2]||e[1]||e[0])&&!p.length&&(n?n[d]=p:this._root=p),this):(this._root=r,this)},t1.removeAll=function l1(t){for(var e=0,n=t.length;e<n;++e)this.remove(t[e]);return this},t1.root=function c1(){return this._root},t1.size=function u1(){var t=0;return this.visit((function(e){if(!e.length)do{++t}while(e=e.next)})),t},t1.visit=function h1(t){var e,n,i,r,o,a,s=[],l=this._root;for(l&&s.push(new XQ(l,this._x0,this._y0,this._x1,this._y1));e=s.pop();)if(!t(l=e.node,i=e.x0,r=e.y0,o=e.x1,a=e.y1)&&l.length){var c=(i+o)/2,u=(r+a)/2;(n=l[3])&&s.push(new XQ(n,c,u,o,a)),(n=l[2])&&s.push(new XQ(n,i,u,c,a)),(n=l[1])&&s.push(new XQ(n,c,r,o,u)),(n=l[0])&&s.push(new XQ(n,i,r,c,u))}return this},t1.visitAfter=function d1(t){var e,n=[],i=[];for(this._root&&n.push(new XQ(this._root,this._x0,this._y0,this._x1,this._y1));e=n.pop();){var r=e.node;if(r.length){var o,a=e.x0,s=e.y0,l=e.x1,c=e.y1,u=(a+l)/2,h=(s+c)/2;(o=r[0])&&n.push(new XQ(o,a,s,u,h)),(o=r[1])&&n.push(new XQ(o,u,s,l,h)),(o=r[2])&&n.push(new XQ(o,a,h,u,c)),(o=r[3])&&n.push(new XQ(o,u,h,l,c))}i.push(e)}for(;e=i.pop();)t(e.node,e.x0,e.y0,e.x1,e.y1);return this},t1.x=function p1(t){return arguments.length?(this._x=t,this):this._x},t1.y=function f1(t){return arguments.length?(this._y=t,this):this._y};var m1=[].slice,g1={};function _1(t){this._size=t,this._call=this._error=null,this._tasks=[],this._data=[],this._waiting=this._active=this._ended=this._start=0}function y1(t){if(!t._start)try{!(function e(t){for(;t._start=t._waiting&&t._active<t._size;){var e=t._ended+t._active,n=t._tasks[e],i=n.length-1,r=n[i];n[i]=v1(t,e),--t._waiting,++t._active,n=r.apply(null,n),t._tasks[e]&&(t._tasks[e]=n||g1)}})(t)}catch(e){if(t._tasks[t._ended+t._active-1])b1(t,e);else if(!t._data)throw e}}function v1(t,e){return function(n,i){t._tasks[e]&&(--t._active,++t._ended,t._tasks[e]=null,null==t._error&&(null!=n?b1(t,n):(t._data[e]=i,t._waiting?y1(t):x1(t))))}}function b1(t,e){var n,i=t._tasks.length;for(t._error=e,t._data=void 0,t._waiting=NaN;--i>=0;)if((n=t._tasks[i])&&(t._tasks[i]=null,n.abort))try{n.abort()}catch(e){}t._active=NaN,x1(t)}function x1(t){if(!t._active&&t._call){var e=t._data;t._data=void 0,t._call(t._error,e)}}function w1(t){if(null==t)t=1/0;else if(!((t=+t)>=1))throw new Error("invalid concurrency");return new _1(t)}function S1(){return Math.random()}_1.prototype=w1.prototype={constructor:_1,defer:function(t){if("function"!=typeof t)throw new Error("invalid callback");if(this._call)throw new Error("defer after await");if(null!=this._error)return this;var e=m1.call(arguments,1);return e.push(t),++this._waiting,this._tasks.push(e),y1(this),this},abort:function(){return null==this._error&&b1(this,new Error("abort")),this},await:function(t){if("function"!=typeof t)throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=function(e,n){t.apply(null,[e].concat(n))},x1(this),this},awaitAll:function(t){if("function"!=typeof t)throw new Error("invalid callback");if(this._call)throw new Error("multiple await");return this._call=t,x1(this),this}};var M1=(function t(e){function n(t,n){return t=null==t?0:+t,n=null==n?1:+n,1===arguments.length?(n=t,t=0):n-=t,function(){return e()*n+t}}return n.source=t,n})(S1),E1=(function t(e){function n(t,n){var i,r;return t=null==t?0:+t,n=null==n?1:+n,function(){var o;if(null!=i)o=i,i=null;else do{i=2*e()-1,o=2*e()-1,r=i*i+o*o}while(!r||r>1);return t+n*o*Math.sqrt(-2*Math.log(r)/r)}}return n.source=t,n})(S1),T1=(function t(e){function n(){var t=E1.source(e).apply(this,arguments);return function(){return Math.exp(t())}}return n.source=t,n})(S1),A1=(function t(e){function n(t){return function(){for(var n=0,i=0;i<t;++i)n+=e();return n}}return n.source=t,n})(S1),C1=(function t(e){function n(t){var n=A1.source(e)(t);return function(){return n()/t}}return n.source=t,n})(S1),k1=(function t(e){function n(t){return function(){return-Math.log(1-e())/t}}return n.source=t,n})(S1);function L1(t,e){var n,i,r,o,a=lc("beforesend","progress","load","error"),s=xg(),l=new XMLHttpRequest,c=null,u=null,h=0;function d(t){var e,i=l.status;if(!i&&(function o(t){var e=t.responseType;return e&&"text"!==e?t.response:t.responseText})(l)||i>=200&&i<300||304===i){if(r)try{e=r.call(n,l)}catch(t){return void a.call("error",n,t)}else e=l;a.call("load",n,e)}else a.call("error",n,t)}if("undefined"!=typeof XDomainRequest&&!("withCredentials"in l)&&/^(http(s)?:)?\/\//.test(t)&&(l=new XDomainRequest),"onload"in l?l.onload=l.onerror=l.ontimeout=d:l.onreadystatechange=function(t){l.readyState>3&&d(t)},l.onprogress=function(t){a.call("progress",n,t)},n={header:function(t,e){return t=(t+"").toLowerCase(),arguments.length<2?s.get(t):(null==e?s.remove(t):s.set(t,e+""),n)},mimeType:function(t){return arguments.length?(i=null==t?null:t+"",n):i},responseType:function(t){return arguments.length?(o=t,n):o},timeout:function(t){return arguments.length?(h=+t,n):h},user:function(t){return arguments.length<1?c:(c=null==t?null:t+"",n)},password:function(t){return arguments.length<1?u:(u=null==t?null:t+"",n)},response:function(t){return r=t,n},get:function(t,e){return n.send("GET",t,e)},post:function(t,e){return n.send("POST",t,e)},send:function(e,r,d){return l.open(e,t,!0,c,u),null==i||s.has("accept")||s.set("accept",i+",*/*"),l.setRequestHeader&&s.each((function(t,e){l.setRequestHeader(e,t)})),null!=i&&l.overrideMimeType&&l.overrideMimeType(i),null!=o&&(l.responseType=o),h>0&&(l.timeout=h),null==d&&"function"==typeof r&&(d=r,r=null),null!=d&&1===d.length&&(d=(function p(t){return function(e,n){t(null==e?n:null)}})(d)),null!=d&&n.on("error",d).on("load",(function(t){d(null,t)})),a.call("beforesend",n,l),l.send(null==r?null:r),n},abort:function(){return l.abort(),n},on:function(){var t=a.on.apply(a,arguments);return t===a?n:t}},null!=e){if("function"!=typeof e)throw new Error("invalid callback: "+e);return n.get(e)}return n}function P1(t,e){return function(n,i){var r=L1(n).mimeType(t).response(e);if(null!=i){if("function"!=typeof i)throw new Error("invalid callback: "+i);return r.get(i)}return r}}var I1=P1("text/html",(function(t){return document.createRange().createContextualFragment(t.responseText)})),N1=P1("application/json",(function(t){return JSON.parse(t.responseText)})),O1=P1("text/plain",(function(t){return t.responseText})),R1=P1("application/xml",(function(t){var e=t.responseXML;if(!e)throw new Error("parse error");return e}));function z1(t,e){return function(n,i,r){arguments.length<3&&(r=i,i=null);var o=L1(n).mimeType(t);return o.row=function(t){return arguments.length?o.response(D1(e,i=t)):i},o.row(i),r?o.get(r):o}}function D1(t,e){return function(n){return t(n.responseText,e)}}var B1=z1("text/csv",Zg),H1=z1("text/tab-separated-values",o_);function F1(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function V1(t){return 1===t.length&&(t=(function e(t){return function(e,n){return F1(t(e),n)}})(t)),{left:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)<0?i=o+1:r=o}return i},right:function(e,n,i,r){for(null==i&&(i=0),null==r&&(r=e.length);i<r;){var o=i+r>>>1;t(e[o],n)>0?r=o:i=o+1}return i}}}var j1=V1(F1).right;function U1(t){return null===t?NaN:+t}var G1=Math.sqrt(50),W1=Math.sqrt(10),q1=Math.sqrt(2);function Y1(t,e,n){var i,r,o,a,s=-1;if(n=+n,(t=+t)==(e=+e)&&n>0)return[t];if((i=e<t)&&(r=t,t=e,e=r),0===(a=X1(t,e,n))||!isFinite(a))return[];if(a>0)for(t=Math.ceil(t/a),e=Math.floor(e/a),o=new Array(r=Math.ceil(e-t+1));++s<r;)o[s]=(t+s)*a;else for(t=Math.floor(t*a),e=Math.ceil(e*a),o=new Array(r=Math.ceil(t-e+1));++s<r;)o[s]=(t-s)/a;return i&&o.reverse(),o}function X1(t,e,n){var i=(e-t)/Math.max(0,n),r=Math.floor(Math.log(i)/Math.LN10),o=i/Math.pow(10,r);return r>=0?(o>=G1?10:o>=W1?5:o>=q1?2:1)*Math.pow(10,r):-Math.pow(10,-r)/(o>=G1?10:o>=W1?5:o>=q1?2:1)}function $1(t,e,n){var i=Math.abs(e-t)/Math.max(0,n),r=Math.pow(10,Math.floor(Math.log(i)/Math.LN10)),o=i/r;return o>=G1?r*=10:o>=W1?r*=5:o>=q1&&(r*=2),e<t?-r:r}function K1(t,e,n){if(null==n&&(n=U1),i=t.length){if((e=+e)<=0||i<2)return+n(t[0],0,t);if(e>=1)return+n(t[i-1],i-1,t);var i,r=(i-1)*e,o=Math.floor(r),a=+n(t[o],o,t);return a+(+n(t[o+1],o+1,t)-a)*(r-o)}}var Z1="$";function J1(){}function Q1(t,e){var n=new J1;if(t instanceof J1)t.each((function(t,e){n.set(e,t)}));else if(Array.isArray(t)){var i,r=-1,o=t.length;if(null==e)for(;++r<o;)n.set(r,t[r]);else for(;++r<o;)n.set(e(i=t[r],r,t),i)}else if(t)for(var a in t)n.set(a,t[a]);return n}function t0(){}J1.prototype=Q1.prototype={constructor:J1,has:function(t){return Z1+t in this},get:function(t){return this[Z1+t]},set:function(t,e){return this[Z1+t]=e,this},remove:function(t){var e=Z1+t;return e in this&&delete this[e]},clear:function(){for(var t in this)t[0]===Z1&&delete this[t]},keys:function(){var t=[];for(var e in this)e[0]===Z1&&t.push(e.slice(1));return t},values:function(){var t=[];for(var e in this)e[0]===Z1&&t.push(this[e]);return t},entries:function(){var t=[];for(var e in this)e[0]===Z1&&t.push({key:e.slice(1),value:this[e]});return t},size:function(){var t=0;for(var e in this)e[0]===Z1&&++t;return t},empty:function(){for(var t in this)if(t[0]===Z1)return!1;return!0},each:function(t){for(var e in this)e[0]===Z1&&t(this[e],e.slice(1),this)}};var e0=Q1.prototype;t0.prototype={constructor:t0,has:e0.has,add:function(t){return this[Z1+(t+="")]=t,this},remove:e0.remove,clear:e0.clear,values:e0.keys,size:e0.size,empty:e0.empty,each:e0.each};var n0=Array.prototype,i0=n0.map,r0=n0.slice,o0={name:"implicit"};function a0(t){var e=Q1(),n=[],i=o0;function r(r){var o=r+"",a=e.get(o);if(!a){if(i!==o0)return i;e.set(o,a=n.push(r))}return t[(a-1)%t.length]}return t=null==t?[]:r0.call(t),r.domain=function(t){if(!arguments.length)return n.slice();n=[],e=Q1();for(var i,o,a=-1,s=t.length;++a<s;)e.has(o=(i=t[a])+"")||e.set(o,n.push(i));return r},r.range=function(e){return arguments.length?(t=r0.call(e),r):t.slice()},r.unknown=function(t){return arguments.length?(i=t,r):i},r.copy=function(){return a0().domain(n).range(t).unknown(i)},r}function s0(){var t,e,n=a0().unknown(void 0),i=n.domain,r=n.range,o=[0,1],a=!1,s=0,l=0,c=.5;function u(){var n=i().length,u=o[1]<o[0],h=o[u-0],d=o[1-u];t=(d-h)/Math.max(1,n-s+2*l),a&&(t=Math.floor(t)),h+=(d-h-t*(n-s))*c,e=t*(1-s),a&&(h=Math.round(h),e=Math.round(e));var p=(function f(t,e,n){t=+t,e=+e,n=(r=arguments.length)<2?(e=t,t=0,1):r<3?1:+n;for(var i=-1,r=0|Math.max(0,Math.ceil((e-t)/n)),o=new Array(r);++i<r;)o[i]=t+i*n;return o})(n).map((function(e){return h+t*e}));return r(u?p.reverse():p)}return delete n.unknown,n.domain=function(t){return arguments.length?(i(t),u()):i()},n.range=function(t){return arguments.length?(o=[+t[0],+t[1]],u()):o.slice()},n.rangeRound=function(t){return o=[+t[0],+t[1]],a=!0,u()},n.bandwidth=function(){return e},n.step=function(){return t},n.round=function(t){return arguments.length?(a=!!t,u()):a},n.padding=function(t){return arguments.length?(s=l=Math.max(0,Math.min(1,t)),u()):s},n.paddingInner=function(t){return arguments.length?(s=Math.max(0,Math.min(1,t)),u()):s},n.paddingOuter=function(t){return arguments.length?(l=Math.max(0,Math.min(1,t)),u()):l},n.align=function(t){return arguments.length?(c=Math.max(0,Math.min(1,t)),u()):c},n.copy=function(){return s0().domain(i()).range(o).round(a).paddingInner(s).paddingOuter(l).align(c)},u()}function l0(t){var e=t.copy;return t.padding=t.paddingOuter,delete t.paddingInner,delete t.paddingOuter,t.copy=function(){return l0(e())},t}function c0(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function u0(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function h0(){}var d0=.7,p0=1/d0,f0="\\s*([+-]?\\d+)\\s*",m0="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",g0="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",_0=/^#([0-9a-f]{3,8})$/,y0=new RegExp("^rgb\\("+[f0,f0,f0]+"\\)$"),v0=new RegExp("^rgb\\("+[g0,g0,g0]+"\\)$"),b0=new RegExp("^rgba\\("+[f0,f0,f0,m0]+"\\)$"),x0=new RegExp("^rgba\\("+[g0,g0,g0,m0]+"\\)$"),w0=new RegExp("^hsl\\("+[m0,g0,g0]+"\\)$"),S0=new RegExp("^hsla\\("+[m0,g0,g0,m0]+"\\)$"),M0={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function E0(){return this.rgb().formatHex()}function T0(){return this.rgb().formatRgb()}function A0(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=_0.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?C0(e):3===n?new I0(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?k0(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?k0(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=y0.exec(t))?new I0(e[1],e[2],e[3],1):(e=v0.exec(t))?new I0(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=b0.exec(t))?k0(e[1],e[2],e[3],e[4]):(e=x0.exec(t))?k0(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=w0.exec(t))?z0(e[1],e[2]/100,e[3]/100,1):(e=S0.exec(t))?z0(e[1],e[2]/100,e[3]/100,e[4]):M0.hasOwnProperty(t)?C0(M0[t]):"transparent"===t?new I0(NaN,NaN,NaN,0):null}function C0(t){return new I0(t>>16&255,t>>8&255,255&t,1)}function k0(t,e,n,i){return i<=0&&(t=e=n=NaN),new I0(t,e,n,i)}function L0(t){return t instanceof h0||(t=A0(t)),t?new I0((t=t.rgb()).r,t.g,t.b,t.opacity):new I0}function P0(t,e,n,i){return 1===arguments.length?L0(t):new I0(t,e,n,null==i?1:i)}function I0(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function N0(){return"#"+R0(this.r)+R0(this.g)+R0(this.b)}function O0(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function R0(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function z0(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new B0(t,e,n,i)}function D0(t){if(t instanceof B0)return new B0(t.h,t.s,t.l,t.opacity);if(t instanceof h0||(t=A0(t)),!t)return new B0;if(t instanceof B0)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new B0(a,s,l,t.opacity)}function B0(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function H0(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}c0(h0,A0,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:E0,formatHex:E0,formatHsl:function F0(){return D0(this).formatHsl()},formatRgb:T0,toString:T0}),c0(I0,P0,u0(h0,{brighter:function(t){return t=null==t?p0:Math.pow(p0,t),new I0(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?d0:Math.pow(d0,t),new I0(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:N0,formatHex:N0,formatRgb:O0,toString:O0})),c0(B0,(function V0(t,e,n,i){return 1===arguments.length?D0(t):new B0(t,e,n,null==i?1:i)}),u0(h0,{brighter:function(t){return t=null==t?p0:Math.pow(p0,t),new B0(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?d0:Math.pow(d0,t),new B0(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new I0(H0(t>=240?t-240:t+120,r,i),H0(t,r,i),H0(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var j0=Math.PI/180,U0=180/Math.PI,G0=-.14861,W0=1.78277,q0=-.29227,Y0=-.90649,X0=1.97294,$0=X0*Y0,K0=X0*W0,Z0=W0*q0-Y0*G0;function J0(t){if(t instanceof t2)return new t2(t.h,t.s,t.l,t.opacity);t instanceof I0||(t=L0(t));var e=t.g/255,n=t.b/255,i=(Z0*n+$0*(t.r/255)-K0*e)/(Z0+$0-K0),r=n-i,o=(X0*(e-i)-q0*r)/Y0,a=Math.sqrt(o*o+r*r)/(X0*i*(1-i)),s=a?Math.atan2(o,r)*U0-120:NaN;return new t2(s<0?s+360:s,a,i,t.opacity)}function Q0(t,e,n,i){return 1===arguments.length?J0(t):new t2(t,e,n,null==i?1:i)}function t2(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function e2(t){return function(){return t}}function n2(t,e){return function(n){return t+n*e}}function i2(t,e){var n=e-t;return n?n2(t,n):e2(isNaN(t)?e:t)}c0(t2,Q0,u0(h0,{brighter:function(t){return t=null==t?p0:Math.pow(p0,t),new t2(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?d0:Math.pow(d0,t),new t2(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*j0,e=+this.l,n=isNaN(this.s)?0:this.s*e*(1-e),i=Math.cos(t),r=Math.sin(t);return new I0(255*(e+n*(G0*i+W0*r)),255*(e+n*(q0*i+Y0*r)),255*(e+n*(X0*i)),this.opacity)}}));var r2=(function t(e){var n=(function i(t){return 1==(t=+t)?i2:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):e2(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=P0(t)).r,(e=P0(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=i2(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function o2(t,e){e||(e=[]);var n,i=t?Math.min(e.length,t.length):0,r=e.slice();return function(o){for(n=0;n<i;++n)r[n]=t[n]*(1-o)+e[n]*o;return r}}function a2(t,e){var n,i=e?e.length:0,r=t?Math.min(i,t.length):0,o=new Array(r),a=new Array(i);for(n=0;n<r;++n)o[n]=p2(t[n],e[n]);for(;n<i;++n)a[n]=e[n];return function(t){for(n=0;n<r;++n)a[n]=o[n](t);return a}}function s2(t,e){var n=new Date;return t=+t,e=+e,function(i){return n.setTime(t*(1-i)+e*i),n}}function l2(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}function c2(t,e){var n,i={},r={};for(n in null!==t&&"object"==typeof t||(t={}),null!==e&&"object"==typeof e||(e={}),e)n in t?i[n]=p2(t[n],e[n]):r[n]=e[n];return function(t){for(n in i)r[n]=i[n](t);return r}}var u2=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,h2=new RegExp(u2.source,"g");function d2(t,e){var n,i,r,o=u2.lastIndex=h2.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=u2.exec(t))&&(i=h2.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:l2(n,i)})),o=h2.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}function p2(t,e){var n,i=typeof e;return null==e||"boolean"===i?e2(e):("number"===i?l2:"string"===i?(n=A0(e))?(e=n,r2):d2:e instanceof A0?r2:e instanceof Date?s2:(function r(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)})(e)?o2:Array.isArray(e)?a2:"function"!=typeof e.valueOf&&"function"!=typeof e.toString||isNaN(e)?c2:l2)(t,e)}function f2(t,e){return t=+t,e=+e,function(n){return Math.round(t*(1-n)+e*n)}}function m2(t){return(function e(n){function i(e,i){var r=t((e=Q0(e)).h,(i=Q0(i)).h),o=i2(e.s,i.s),a=i2(e.l,i.l),s=i2(e.opacity,i.opacity);return function(t){return e.h=r(t),e.s=o(t),e.l=a(Math.pow(t,n)),e.opacity=s(t),e+""}}return n=+n,i.gamma=e,i})(1)}m2((function g2(t,e){var n=e-t;return n?n2(t,n>180||n<-180?n-360*Math.round(n/360):n):e2(isNaN(t)?e:t)}));var _2=m2(i2);function y2(t){return function(){return t}}function v2(t){return+t}var b2=[0,1];function x2(t,e){return(e-=t=+t)?function(n){return(n-t)/e}:y2(e)}function w2(t,e,n,i){var r=t[0],o=t[1],a=e[0],s=e[1];return o<r?(r=n(o,r),a=i(s,a)):(r=n(r,o),a=i(a,s)),function(t){return a(r(t))}}function S2(t,e,n,i){var r=Math.min(t.length,e.length)-1,o=new Array(r),a=new Array(r),s=-1;for(t[r]<t[0]&&(t=t.slice().reverse(),e=e.slice().reverse());++s<r;)o[s]=n(t[s],t[s+1]),a[s]=i(e[s],e[s+1]);return function(e){var n=j1(t,e,1,r)-1;return a[n](o[n](e))}}function M2(t,e){return e.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp())}function E2(t,e){var n,i,r,o=b2,a=b2,s=p2,l=!1;function c(){return n=Math.min(o.length,a.length)>2?S2:w2,i=r=null,u}function u(e){return(i||(i=n(o,a,l?(function r(t){return function(e,n){var i=t(e=+e,n=+n);return function(t){return t<=e?0:t>=n?1:i(t)}}})(t):t,s)))(+e)}return u.invert=function(t){return(r||(r=n(a,o,x2,l?(function i(t){return function(e,n){var i=t(e=+e,n=+n);return function(t){return t<=0?e:t>=1?n:i(t)}}})(e):e)))(+t)},u.domain=function(t){return arguments.length?(o=i0.call(t,v2),c()):o.slice()},u.range=function(t){return arguments.length?(a=r0.call(t),c()):a.slice()},u.rangeRound=function(t){return a=r0.call(t),s=f2,c()},u.clamp=function(t){return arguments.length?(l=!!t,c()):l},u.interpolate=function(t){return arguments.length?(s=t,c()):s},c()}function T2(t,e){if((n=(t=e?t.toExponential(e-1):t.toExponential()).indexOf("e"))<0)return null;var n,i=t.slice(0,n);return[i.length>1?i[0]+i.slice(2):i,+t.slice(n+1)]}function A2(t){return(t=T2(Math.abs(t)))?t[1]:NaN}var C2,k2=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function L2(t){if(!(e=k2.exec(t)))throw new Error("invalid format: "+t);var e;return new P2({fill:e[1],align:e[2],sign:e[3],symbol:e[4],zero:e[5],width:e[6],comma:e[7],precision:e[8]&&e[8].slice(1),trim:e[9],type:e[10]})}function P2(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function I2(t,e){var n=T2(t,e);if(!n)return t+"";var i=n[0],r=n[1];return r<0?"0."+new Array(-r).join("0")+i:i.length>r+1?i.slice(0,r+1)+"."+i.slice(r+1):i+new Array(r-i.length+2).join("0")}L2.prototype=P2.prototype,P2.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var N2={"%":function(t,e){return(100*t).toFixed(e)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,e){return t.toExponential(e)},f:function(t,e){return t.toFixed(e)},g:function(t,e){return t.toPrecision(e)},o:function(t){return Math.round(t).toString(8)},p:function(t,e){return I2(100*t,e)},r:I2,s:function O2(t,e){var n=T2(t,e);if(!n)return t+"";var i=n[0],r=n[1],o=r-(C2=3*Math.max(-8,Math.min(8,Math.floor(r/3))))+1,a=i.length;return o===a?i:o>a?i+new Array(o-a+1).join("0"):o>0?i.slice(0,o)+"."+i.slice(o):"0."+new Array(1-o).join("0")+T2(t,Math.max(0,e+o-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}};function R2(t){return t}var z2,D2,B2,H2=Array.prototype.map,F2=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function V2(t){var e=t.domain;return t.ticks=function(t){var n=e();return Y1(n[0],n[n.length-1],null==t?10:t)},t.tickFormat=function(t,n){return(function i(t,e,n){var i,r=t[0],o=t[t.length-1],a=$1(r,o,null==e?10:e);switch((n=L2(null==n?",f":n)).type){case"s":var s=Math.max(Math.abs(r),Math.abs(o));return null!=n.precision||isNaN(i=(function l(t,e){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(A2(e)/3)))-A2(Math.abs(t)))})(a,s))||(n.precision=i),B2(n,s);case"":case"e":case"g":case"p":case"r":null!=n.precision||isNaN(i=(function c(t,e){return t=Math.abs(t),e=Math.abs(e)-t,Math.max(0,A2(e)-A2(t))+1})(a,Math.max(Math.abs(r),Math.abs(o))))||(n.precision=i-("e"===n.type));break;case"f":case"%":null!=n.precision||isNaN(i=(function u(t){return Math.max(0,-A2(Math.abs(t)))})(a))||(n.precision=i-2*("%"===n.type))}return D2(n)})(e(),t,n)},t.nice=function(n){null==n&&(n=10);var i,r=e(),o=0,a=r.length-1,s=r[o],l=r[a];return l<s&&(i=s,s=l,l=i,i=o,o=a,a=i),(i=X1(s,l,n))>0?i=X1(s=Math.floor(s/i)*i,l=Math.ceil(l/i)*i,n):i<0&&(i=X1(s=Math.ceil(s*i)/i,l=Math.floor(l*i)/i,n)),i>0?(r[o]=Math.floor(s/i)*i,r[a]=Math.ceil(l/i)*i,e(r)):i<0&&(r[o]=Math.ceil(s*i)/i,r[a]=Math.floor(l*i)/i,e(r)),t},t}function j2(t,e){var n,i=0,r=(t=t.slice()).length-1,o=t[i],a=t[r];return a<o&&(n=i,i=r,r=n,n=o,o=a,a=n),t[i]=e.floor(o),t[r]=e.ceil(a),t}function U2(t,e){return(e=Math.log(e/t))?function(n){return Math.log(n/t)/e}:y2(e)}function G2(t,e){return t<0?function(n){return-Math.pow(-e,n)*Math.pow(-t,1-n)}:function(n){return Math.pow(e,n)*Math.pow(t,1-n)}}function W2(t){return isFinite(t)?+("1e"+t):t<0?0:t}function q2(t){return 10===t?W2:t===Math.E?Math.exp:function(e){return Math.pow(t,e)}}function Y2(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(e){return Math.log(e)/t})}function X2(t){return function(e){return-t(-e)}}function $2(t,e){return t<0?-Math.pow(-t,e):Math.pow(t,e)}function K2(){var t=1,e=E2((function n(e,i){return(i=$2(i,t)-(e=$2(e,t)))?function(n){return($2(n,t)-e)/i}:y2(i)}),(function i(e,n){return n=$2(n,t)-(e=$2(e,t)),function(i){return $2(e+n*i,1/t)}})),r=e.domain;return e.exponent=function(e){return arguments.length?(t=+e,r(r())):t},e.copy=function(){return M2(e,K2().exponent(t))},V2(e)}!(function Z2(t){z2=(function e(t){var e=void 0===t.grouping||void 0===t.thousands?R2:(function n(t,e){return function(n,i){for(var r=n.length,o=[],a=0,s=t[0],l=0;r>0&&s>0&&(l+s+1>i&&(s=Math.max(1,i-l)),o.push(n.substring(r-=s,r+s)),!((l+=s+1)>i));)s=t[a=(a+1)%t.length];return o.reverse().join(e)}})(H2.call(t.grouping,Number),t.thousands+""),i=void 0===t.currency?"":t.currency[0]+"",r=void 0===t.currency?"":t.currency[1]+"",o=void 0===t.decimal?".":t.decimal+"",a=void 0===t.numerals?R2:(function s(t){return function(e){return e.replace(/[0-9]/g,(function(e){return t[+e]}))}})(H2.call(t.numerals,String)),l=void 0===t.percent?"%":t.percent+"",c=void 0===t.minus?"-":t.minus+"",u=void 0===t.nan?"NaN":t.nan+"";function h(t){var n=(t=L2(t)).fill,s=t.align,h=t.sign,d=t.symbol,p=t.zero,f=t.width,m=t.comma,g=t.precision,_=t.trim,y=t.type;"n"===y?(m=!0,y="g"):N2[y]||(void 0===g&&(g=12),_=!0,y="g"),(p||"0"===n&&"="===s)&&(p=!0,n="0",s="=");var v="$"===d?i:"#"===d&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",b="$"===d?r:/[%p]/.test(y)?l:"",x=N2[y],w=/[defgprs%]/.test(y);function S(t){var i,r,l,d=v,S=b;if("c"===y)S=x(t)+S,t="";else{var M=(t=+t)<0||1/t<0;if(t=isNaN(t)?u:x(Math.abs(t),g),_&&(t=(function E(t){t:for(var e,n=t.length,i=1,r=-1;i<n;++i)switch(t[i]){case".":r=e=i;break;case"0":0===r&&(r=i),e=i;break;default:if(!+t[i])break t;r>0&&(r=0)}return r>0?t.slice(0,r)+t.slice(e+1):t})(t)),M&&0==+t&&"+"!==h&&(M=!1),d=(M?"("===h?h:c:"-"===h||"("===h?"":h)+d,S=("s"===y?F2[8+C2/3]:"")+S+(M&&"("===h?")":""),w)for(i=-1,r=t.length;++i<r;)if(48>(l=t.charCodeAt(i))||l>57){S=(46===l?o+t.slice(i+1):t.slice(i))+S,t=t.slice(0,i);break}}m&&!p&&(t=e(t,1/0));var T=d.length+t.length+S.length,A=T<f?new Array(f-T+1).join(n):"";switch(m&&p&&(t=e(A+t,A.length?f-S.length:1/0),A=""),s){case"<":t=d+t+S+A;break;case"=":t=d+A+t+S;break;case"^":t=A.slice(0,T=A.length>>1)+d+t+S+A.slice(T);break;default:t=A+d+t+S}return a(t)}return g=void 0===g?6:/[gprs]/.test(y)?Math.max(1,Math.min(21,g)):Math.max(0,Math.min(20,g)),S.toString=function(){return t+""},S}return{format:h,formatPrefix:function d(t,e){var n=h(((t=L2(t)).type="f",t)),i=3*Math.max(-8,Math.min(8,Math.floor(A2(e)/3))),r=Math.pow(10,-i),o=F2[8+i/3];return function(t){return n(r*t)+o}}}})(t),D2=z2.format,B2=z2.formatPrefix})({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});var J2=new Date,Q2=new Date;function t5(t,e,n,i){function r(e){return t(e=0===arguments.length?new Date:new Date(+e)),e}return r.floor=function(e){return t(e=new Date(+e)),e},r.ceil=function(n){return t(n=new Date(n-1)),e(n,1),t(n),n},r.round=function(t){var e=r(t),n=r.ceil(t);return t-e<n-t?e:n},r.offset=function(t,n){return e(t=new Date(+t),null==n?1:Math.floor(n)),t},r.range=function(n,i,o){var a,s=[];if(n=r.ceil(n),o=null==o?1:Math.floor(o),!(n<i&&o>0))return s;do{s.push(a=new Date(+n)),e(n,o),t(n)}while(a<n&&n<i);return s},r.filter=function(n){return t5((function(e){if(e>=e)for(;t(e),!n(e);)e.setTime(e-1)}),(function(t,i){if(t>=t)if(i<0)for(;++i<=0;)for(;e(t,-1),!n(t););else for(;--i>=0;)for(;e(t,1),!n(t););}))},n&&(r.count=function(e,i){return J2.setTime(+e),Q2.setTime(+i),t(J2),t(Q2),Math.floor(n(J2,Q2))},r.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?r.filter(i?function(e){return i(e)%t==0}:function(e){return r.count(0,e)%t==0}):r:null}),r}var e5=t5((function(){}),(function(t,e){t.setTime(+t+e)}),(function(t,e){return e-t}));e5.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?t5((function(e){e.setTime(Math.floor(e/t)*t)}),(function(e,n){e.setTime(+e+n*t)}),(function(e,n){return(n-e)/t})):e5:null};var n5=1e3,i5=6e4,r5=36e5,o5=864e5,a5=6048e5,s5=t5((function(t){t.setTime(t-t.getMilliseconds())}),(function(t,e){t.setTime(+t+e*n5)}),(function(t,e){return(e-t)/n5}),(function(t){return t.getUTCSeconds()})),l5=t5((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*n5)}),(function(t,e){t.setTime(+t+e*i5)}),(function(t,e){return(e-t)/i5}),(function(t){return t.getMinutes()})),c5=t5((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*n5-t.getMinutes()*i5)}),(function(t,e){t.setTime(+t+e*r5)}),(function(t,e){return(e-t)/r5}),(function(t){return t.getHours()})),u5=t5((function(t){t.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*i5)/o5}),(function(t){return t.getDate()-1}));function h5(t){return t5((function(e){e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+7*e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*i5)/a5}))}var d5=h5(0),p5=h5(1);h5(2),h5(3);var f5=h5(4);h5(5),h5(6);var m5=t5((function(t){t.setDate(1),t.setHours(0,0,0,0)}),(function(t,e){t.setMonth(t.getMonth()+e)}),(function(t,e){return e.getMonth()-t.getMonth()+12*(e.getFullYear()-t.getFullYear())}),(function(t){return t.getMonth()})),g5=t5((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,e){t.setFullYear(t.getFullYear()+e)}),(function(t,e){return e.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));g5.every=function(t){return isFinite(t=Math.floor(t))&&t>0?t5((function(e){e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)}),(function(e,n){e.setFullYear(e.getFullYear()+n*t)})):null};var _5=t5((function(t){t.setUTCSeconds(0,0)}),(function(t,e){t.setTime(+t+e*i5)}),(function(t,e){return(e-t)/i5}),(function(t){return t.getUTCMinutes()})),y5=t5((function(t){t.setUTCMinutes(0,0,0)}),(function(t,e){t.setTime(+t+e*r5)}),(function(t,e){return(e-t)/r5}),(function(t){return t.getUTCHours()})),v5=t5((function(t){t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+e)}),(function(t,e){return(e-t)/o5}),(function(t){return t.getUTCDate()-1}));function b5(t){return t5((function(e){e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+7*e)}),(function(t,e){return(e-t)/a5}))}var x5=b5(0),w5=b5(1);b5(2),b5(3);var S5=b5(4);b5(5),b5(6);var M5=t5((function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCMonth(t.getUTCMonth()+e)}),(function(t,e){return e.getUTCMonth()-t.getUTCMonth()+12*(e.getUTCFullYear()-t.getUTCFullYear())}),(function(t){return t.getUTCMonth()})),E5=t5((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e)}),(function(t,e){return e.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));function T5(t){if(0<=t.y&&t.y<100){var e=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return e.setFullYear(t.y),e}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function A5(t){if(0<=t.y&&t.y<100){var e=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return e.setUTCFullYear(t.y),e}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function C5(t,e,n){return{y:t,m:e,d:n,H:0,M:0,S:0,L:0}}E5.every=function(t){return isFinite(t=Math.floor(t))&&t>0?t5((function(e){e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)}),(function(e,n){e.setUTCFullYear(e.getUTCFullYear()+n*t)})):null};var k5,L5,P5,I5={"-":"",_:" ",0:"0"},N5=/^\s*\d+/,O5=/^%/,R5=/[\\^$*+?|[\]().{}]/g;function z5(t,e,n){var i=t<0?"-":"",r=(i?-t:t)+"",o=r.length;return i+(o<n?new Array(n-o+1).join(e)+r:r)}function D5(t){return t.replace(R5,"\\$&")}function B5(t){return new RegExp("^(?:"+t.map(D5).join("|")+")","i")}function H5(t){for(var e={},n=-1,i=t.length;++n<i;)e[t[n].toLowerCase()]=n;return e}function F5(t,e,n){var i=N5.exec(e.slice(n,n+1));return i?(t.w=+i[0],n+i[0].length):-1}function V5(t,e,n){var i=N5.exec(e.slice(n,n+1));return i?(t.u=+i[0],n+i[0].length):-1}function j5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.U=+i[0],n+i[0].length):-1}function U5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.V=+i[0],n+i[0].length):-1}function G5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.W=+i[0],n+i[0].length):-1}function W5(t,e,n){var i=N5.exec(e.slice(n,n+4));return i?(t.y=+i[0],n+i[0].length):-1}function q5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.y=+i[0]+(+i[0]>68?1900:2e3),n+i[0].length):-1}function Y5(t,e,n){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n,n+6));return i?(t.Z=i[1]?0:-(i[2]+(i[3]||"00")),n+i[0].length):-1}function X5(t,e,n){var i=N5.exec(e.slice(n,n+1));return i?(t.q=3*i[0]-3,n+i[0].length):-1}function $5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.m=i[0]-1,n+i[0].length):-1}function K5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.d=+i[0],n+i[0].length):-1}function Z5(t,e,n){var i=N5.exec(e.slice(n,n+3));return i?(t.m=0,t.d=+i[0],n+i[0].length):-1}function J5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.H=+i[0],n+i[0].length):-1}function Q5(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.M=+i[0],n+i[0].length):-1}function t3(t,e,n){var i=N5.exec(e.slice(n,n+2));return i?(t.S=+i[0],n+i[0].length):-1}function e3(t,e,n){var i=N5.exec(e.slice(n,n+3));return i?(t.L=+i[0],n+i[0].length):-1}function n3(t,e,n){var i=N5.exec(e.slice(n,n+6));return i?(t.L=Math.floor(i[0]/1e3),n+i[0].length):-1}function i3(t,e,n){var i=O5.exec(e.slice(n,n+1));return i?n+i[0].length:-1}function r3(t,e,n){var i=N5.exec(e.slice(n));return i?(t.Q=+i[0],n+i[0].length):-1}function o3(t,e,n){var i=N5.exec(e.slice(n));return i?(t.s=+i[0],n+i[0].length):-1}function a3(t,e){return z5(t.getDate(),e,2)}function s3(t,e){return z5(t.getHours(),e,2)}function l3(t,e){return z5(t.getHours()%12||12,e,2)}function c3(t,e){return z5(1+u5.count(g5(t),t),e,3)}function u3(t,e){return z5(t.getMilliseconds(),e,3)}function h3(t,e){return u3(t,e)+"000"}function d3(t,e){return z5(t.getMonth()+1,e,2)}function p3(t,e){return z5(t.getMinutes(),e,2)}function f3(t,e){return z5(t.getSeconds(),e,2)}function m3(t){var e=t.getDay();return 0===e?7:e}function g3(t,e){return z5(d5.count(g5(t)-1,t),e,2)}function _3(t,e){var n=t.getDay();return t=n>=4||0===n?f5(t):f5.ceil(t),z5(f5.count(g5(t),t)+(4===g5(t).getDay()),e,2)}function y3(t){return t.getDay()}function v3(t,e){return z5(p5.count(g5(t)-1,t),e,2)}function b3(t,e){return z5(t.getFullYear()%100,e,2)}function x3(t,e){return z5(t.getFullYear()%1e4,e,4)}function w3(t){var e=t.getTimezoneOffset();return(e>0?"-":(e*=-1,"+"))+z5(e/60|0,"0",2)+z5(e%60,"0",2)}function S3(t,e){return z5(t.getUTCDate(),e,2)}function M3(t,e){return z5(t.getUTCHours(),e,2)}function E3(t,e){return z5(t.getUTCHours()%12||12,e,2)}function T3(t,e){return z5(1+v5.count(E5(t),t),e,3)}function A3(t,e){return z5(t.getUTCMilliseconds(),e,3)}function C3(t,e){return A3(t,e)+"000"}function k3(t,e){return z5(t.getUTCMonth()+1,e,2)}function L3(t,e){return z5(t.getUTCMinutes(),e,2)}function P3(t,e){return z5(t.getUTCSeconds(),e,2)}function I3(t){var e=t.getUTCDay();return 0===e?7:e}function N3(t,e){return z5(x5.count(E5(t)-1,t),e,2)}function O3(t,e){var n=t.getUTCDay();return t=n>=4||0===n?S5(t):S5.ceil(t),z5(S5.count(E5(t),t)+(4===E5(t).getUTCDay()),e,2)}function R3(t){return t.getUTCDay()}function z3(t,e){return z5(w5.count(E5(t)-1,t),e,2)}function D3(t,e){return z5(t.getUTCFullYear()%100,e,2)}function B3(t,e){return z5(t.getUTCFullYear()%1e4,e,4)}function H3(){return"+0000"}function F3(){return"%"}function V3(t){return+t}function j3(t){return Math.floor(+t/1e3)}!(function U3(t){k5=(function e(t){var e=t.dateTime,n=t.date,i=t.time,r=t.periods,o=t.days,a=t.shortDays,s=t.months,l=t.shortMonths,c=B5(r),u=H5(r),h=B5(o),d=H5(o),p=B5(a),f=H5(a),m=B5(s),g=H5(s),_=B5(l),y=H5(l),v={a:function b(t){return a[t.getDay()]},A:function x(t){return o[t.getDay()]},b:function w(t){return l[t.getMonth()]},B:function S(t){return s[t.getMonth()]},c:null,d:a3,e:a3,f:h3,H:s3,I:l3,j:c3,L:u3,m:d3,M:p3,p:function M(t){return r[+(t.getHours()>=12)]},q:function E(t){return 1+~~(t.getMonth()/3)},Q:V3,s:j3,S:f3,u:m3,U:g3,V:_3,w:y3,W:v3,x:null,X:null,y:b3,Y:x3,Z:w3,"%":F3},T={a:function A(t){return a[t.getUTCDay()]},A:function C(t){return o[t.getUTCDay()]},b:function k(t){return l[t.getUTCMonth()]},B:function L(t){return s[t.getUTCMonth()]},c:null,d:S3,e:S3,f:C3,H:M3,I:E3,j:T3,L:A3,m:k3,M:L3,p:function P(t){return r[+(t.getUTCHours()>=12)]},q:function I(t){return 1+~~(t.getUTCMonth()/3)},Q:V3,s:j3,S:P3,u:I3,U:N3,V:O3,w:R3,W:z3,x:null,X:null,y:D3,Y:B3,Z:H3,"%":F3},N={a:function O(t,e,n){var i=p.exec(e.slice(n));return i?(t.w=f[i[0].toLowerCase()],n+i[0].length):-1},A:function R(t,e,n){var i=h.exec(e.slice(n));return i?(t.w=d[i[0].toLowerCase()],n+i[0].length):-1},b:function z(t,e,n){var i=_.exec(e.slice(n));return i?(t.m=y[i[0].toLowerCase()],n+i[0].length):-1},B:function D(t,e,n){var i=m.exec(e.slice(n));return i?(t.m=g[i[0].toLowerCase()],n+i[0].length):-1},c:function B(t,n,i){return G(t,e,n,i)},d:K5,e:K5,f:n3,H:J5,I:J5,j:Z5,L:e3,m:$5,M:Q5,p:function H(t,e,n){var i=c.exec(e.slice(n));return i?(t.p=u[i[0].toLowerCase()],n+i[0].length):-1},q:X5,Q:r3,s:o3,S:t3,u:V5,U:j5,V:U5,w:F5,W:G5,x:function F(t,e,i){return G(t,n,e,i)},X:function V(t,e,n){return G(t,i,e,n)},y:q5,Y:W5,Z:Y5,"%":i3};function j(t,e){return function(n){var i,r,o,a=[],s=-1,l=0,c=t.length;for(n instanceof Date||(n=new Date(+n));++s<c;)37===t.charCodeAt(s)&&(a.push(t.slice(l,s)),null!=(r=I5[i=t.charAt(++s)])?i=t.charAt(++s):r="e"===i?" ":"0",(o=e[i])&&(i=o(n,r)),a.push(i),l=s+1);return a.push(t.slice(l,s)),a.join("")}}function U(t,e){return function(n){var i,r,o=C5(1900,void 0,1);if(G(o,t,n+="",0)!=n.length)return null;if("Q"in o)return new Date(o.Q);if("s"in o)return new Date(1e3*o.s+("L"in o?o.L:0));if(e&&!("Z"in o)&&(o.Z=0),"p"in o&&(o.H=o.H%12+12*o.p),void 0===o.m&&(o.m="q"in o?o.q:0),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(r=(i=A5(C5(o.y,0,1))).getUTCDay(),i=r>4||0===r?w5.ceil(i):w5(i),i=v5.offset(i,7*(o.V-1)),o.y=i.getUTCFullYear(),o.m=i.getUTCMonth(),o.d=i.getUTCDate()+(o.w+6)%7):(r=(i=T5(C5(o.y,0,1))).getDay(),i=r>4||0===r?p5.ceil(i):p5(i),i=u5.offset(i,7*(o.V-1)),o.y=i.getFullYear(),o.m=i.getMonth(),o.d=i.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),r="Z"in o?A5(C5(o.y,0,1)).getUTCDay():T5(C5(o.y,0,1)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(r+5)%7:o.w+7*o.U-(r+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,A5(o)):T5(o)}}function G(t,e,n,i){for(var r,o,a=0,s=e.length,l=n.length;a<s;){if(i>=l)return-1;if(37===(r=e.charCodeAt(a++))){if(r=e.charAt(a++),!(o=N[r in I5?e.charAt(a++):r])||(i=o(t,n,i))<0)return-1}else if(r!=n.charCodeAt(i++))return-1}return i}return v.x=j(n,v),v.X=j(i,v),v.c=j(e,v),T.x=j(n,T),T.X=j(i,T),T.c=j(e,T),{format:function(t){var e=j(t+="",v);return e.toString=function(){return t},e},parse:function(t){var e=U(t+="",!1);return e.toString=function(){return t},e},utcFormat:function(t){var e=j(t+="",T);return e.toString=function(){return t},e},utcParse:function(t){var e=U(t+="",!0);return e.toString=function(){return t},e}}})(t),L5=k5.format,P5=k5.utcFormat})({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var G3=31536e6;function W3(t){return new Date(t)}function q3(t){return t instanceof Date?+t:+new Date(+t)}function Y3(t,e,n,i,r,o,a,s,l){var c=E2(x2,l2),u=c.invert,h=c.domain,d=l(".%L"),p=l(":%S"),f=l("%I:%M"),m=l("%I %p"),g=l("%a %d"),_=l("%b %d"),y=l("%B"),v=l("%Y"),b=[[a,1,1e3],[a,5,5e3],[a,15,15e3],[a,30,3e4],[o,1,6e4],[o,5,3e5],[o,15,9e5],[o,30,18e5],[r,1,36e5],[r,3,108e5],[r,6,216e5],[r,12,432e5],[i,1,864e5],[i,2,1728e5],[n,1,6048e5],[e,1,2592e6],[e,3,7776e6],[t,1,G3]];function x(s){return(a(s)<s?d:o(s)<s?p:r(s)<s?f:i(s)<s?m:e(s)<s?n(s)<s?g:_:t(s)<s?y:v)(s)}function w(e,n,i,r){if(null==e&&(e=10),"number"==typeof e){var o=Math.abs(i-n)/e,a=V1((function(t){return t[2]})).right(b,o);a===b.length?(r=$1(n/G3,i/G3,e),e=t):a?(r=(a=b[o/b[a-1][2]<b[a][2]/o?a-1:a])[1],e=a[0]):(r=Math.max($1(n,i,e),1),e=s)}return null==r?e:e.every(r)}return c.invert=function(t){return new Date(u(t))},c.domain=function(t){return arguments.length?h(i0.call(t,q3)):h().map(W3)},c.ticks=function(t,e){var n,i=h(),r=i[0],o=i[i.length-1],a=o<r;return a&&(n=r,r=o,o=n),n=(n=w(t,r,o,e))?n.range(r,o+1):[],a?n.reverse():n},c.tickFormat=function(t,e){return null==e?x:l(e)},c.nice=function(t,e){var n=h();return(t=w(t,n[0],n[n.length-1],e))?h(j2(n,t)):c},c.copy=function(){return M2(c,Y3(t,e,n,i,r,o,a,s,l))},c}function X3(t){return t.match(/.{6}/g).map((function(t){return"#"+t}))}var $3=X3("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),K3=X3("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6"),Z3=X3("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"),J3=X3("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"),Q3=_2(Q0(300,.5,0),Q0(-240,.5,1)),t4=_2(Q0(-100,.75,.35),Q0(80,1.5,.8)),e4=_2(Q0(260,.75,.35),Q0(80,1.5,.8)),n4=Q0();function i4(t){var e=t.length;return function(n){return t[Math.max(0,Math.min(e-1,Math.floor(n*e)))]}}var r4=i4(X3("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),o4=i4(X3("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),a4=i4(X3("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),s4=i4(X3("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")),l4="http://www.w3.org/1999/xhtml",c4={svg:"http://www.w3.org/2000/svg",xhtml:l4,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function u4(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),c4.hasOwnProperty(e)?{space:c4[e],local:t}:t}function h4(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===l4&&e.documentElement.namespaceURI===l4?e.createElement(t):e.createElementNS(n,t)}}function d4(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function p4(t){var e=u4(t);return(e.local?d4:h4)(e)}function f4(){}function m4(t){return null==t?f4:function(){return this.querySelector(t)}}function g4(){return[]}function _4(t){return null==t?g4:function(){return this.querySelectorAll(t)}}var y4=function(t){return function(){return this.matches(t)}};if("undefined"!=typeof document){var v4=document.documentElement;if(!v4.matches){var b4=v4.webkitMatchesSelector||v4.msMatchesSelector||v4.mozMatchesSelector||v4.oMatchesSelector;y4=function(t){return function(){return b4.call(this,t)}}}}var x4=y4;function w4(t){return new Array(t.length)}function S4(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function M4(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new S4(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function E4(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new S4(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function T4(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function A4(t){return function(){this.removeAttribute(t)}}function C4(t){return function(){this.removeAttributeNS(t.space,t.local)}}function k4(t,e){return function(){this.setAttribute(t,e)}}function L4(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function P4(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function I4(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function N4(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function O4(t){return function(){this.style.removeProperty(t)}}function R4(t,e,n){return function(){this.style.setProperty(t,e,n)}}function z4(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function D4(t,e){return t.style.getPropertyValue(e)||N4(t).getComputedStyle(t,null).getPropertyValue(e)}function B4(t){return function(){delete this[t]}}function H4(t,e){return function(){this[t]=e}}function F4(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function V4(t){return t.trim().split(/^|\s+/)}function j4(t){return t.classList||new U4(t)}function U4(t){this._node=t,this._names=V4(t.getAttribute("class")||"")}function G4(t,e){for(var n=j4(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function W4(t,e){for(var n=j4(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function q4(t){return function(){G4(this,t)}}function Y4(t){return function(){W4(this,t)}}function X4(t,e){return function(){(e.apply(this,arguments)?G4:W4)(this,t)}}function $4(){this.textContent=""}function K4(t){return function(){this.textContent=t}}function Z4(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function J4(){this.innerHTML=""}function Q4(t){return function(){this.innerHTML=t}}function t6(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function e6(){this.nextSibling&&this.parentNode.appendChild(this)}function n6(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function i6(){return null}function r6(){var t=this.parentNode;t&&t.removeChild(this)}function o6(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function a6(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}S4.prototype={constructor:S4,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},U4.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var s6={},l6=null;function c6(t,e,n){return t=u6(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function u6(t,e,n){return function(i){var r=l6;l6=i;try{t.call(this,this.__data__,e,n)}finally{l6=r}}}function h6(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function d6(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function p6(t,e,n){var i=s6.hasOwnProperty(t.type)?c6:u6;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function f6(t,e,n){var i=N4(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function m6(t,e){return function(){return f6(this,t,e)}}function g6(t,e){return function(){return f6(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(s6={mouseenter:"mouseover",mouseleave:"mouseout"}));var _6=[null];function y6(t,e){this._groups=t,this._parents=e}function v6(){return new y6([[document.documentElement]],_6)}function b6(t){return"string"==typeof t?new y6([[document.querySelector(t)]],[document.documentElement]):new y6([[t]],_6)}y6.prototype=v6.prototype={constructor:y6,select:function x6(t){"function"!=typeof t&&(t=m4(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new y6(i,this._parents)},selectAll:function w6(t){"function"!=typeof t&&(t=_4(t));for(var e=this._groups,n=e.length,i=[],r=[],o=0;o<n;++o)for(var a,s=e[o],l=s.length,c=0;c<l;++c)(a=s[c])&&(i.push(t.call(a,a.__data__,c,s)),r.push(a));return new y6(i,r)},filter:function S6(t){"function"!=typeof t&&(t=x4(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new y6(i,this._parents)},data:function M6(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?E4:M4,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new y6(s,i))._enter=l,s._exit=c,s},enter:function E6(){return new y6(this._enter||this._groups.map(w4),this._parents)},exit:function T6(){return new y6(this._exit||this._groups.map(w4),this._parents)},merge:function A6(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new y6(o,this._parents)},order:function C6(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&a!==i.nextSibling&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function k6(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=T4);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new y6(r,this._parents).order()},call:function L6(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function P6(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function I6(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function N6(){var t=0;return this.each((function(){++t})),t},empty:function O6(){return!this.node()},each:function R6(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function z6(t,e){var n=u4(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?C4:A4:"function"==typeof e?n.local?I4:P4:n.local?L4:k4)(n,e))},style:function D6(t,e,n){return arguments.length>1?this.each((null==e?O4:"function"==typeof e?z4:R4)(t,e,null==n?"":n)):D4(this.node(),t)},property:function B6(t,e){return arguments.length>1?this.each((null==e?B4:"function"==typeof e?F4:H4)(t,e)):this.node()[t]},classed:function H6(t,e){var n=V4(t+"");if(arguments.length<2){for(var i=j4(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?X4:e?q4:Y4)(n,e))},text:function F6(t){return arguments.length?this.each(null==t?$4:("function"==typeof t?Z4:K4)(t)):this.node().textContent},html:function V6(t){return arguments.length?this.each(null==t?J4:("function"==typeof t?t6:Q4)(t)):this.node().innerHTML},raise:function j6(){return this.each(e6)},lower:function U6(){return this.each(n6)},append:function G6(t){var e="function"==typeof t?t:p4(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function W6(t,e){var n="function"==typeof t?t:p4(t),i=null==e?i6:"function"==typeof e?e:m4(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function q6(){return this.each(r6)},clone:function Y6(t){return this.select(t?a6:o6)},datum:function X6(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function $6(t,e,n){var i,r,o=h6(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?p6:d6,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function K6(t,e){return this.each(("function"==typeof e?g6:m6)(t,e))}};var Z6=0;function J6(){return new Q6}function Q6(){this._="@"+(++Z6).toString(36)}function t9(){for(var t,e=l6;t=e.sourceEvent;)e=t;return e}function e9(t,e){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var i=n.createSVGPoint();return i.x=e.clientX,i.y=e.clientY,[(i=i.matrixTransform(t.getScreenCTM().inverse())).x,i.y]}var r=t.getBoundingClientRect();return[e.clientX-r.left-t.clientLeft,e.clientY-r.top-t.clientTop]}Q6.prototype=J6.prototype={constructor:Q6,get:function(t){for(var e=this._;!(e in t);)if(!(t=t.parentNode))return;return t[e]},set:function(t,e){return t[this._]=e},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}};var n9=Math.PI,i9=2*n9,r9=1e-6,o9=i9-r9;function a9(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function s9(){return new a9}function l9(t){return function e(){return t}}a9.prototype=s9.prototype={constructor:a9,moveTo:function(t,e){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,e){this._+="L"+(this._x1=+t)+","+(this._y1=+e)},quadraticCurveTo:function(t,e,n,i){this._+="Q"+ +t+","+ +e+","+(this._x1=+n)+","+(this._y1=+i)},bezierCurveTo:function(t,e,n,i,r,o){this._+="C"+ +t+","+ +e+","+ +n+","+ +i+","+(this._x1=+r)+","+(this._y1=+o)},arcTo:function(t,e,n,i,r){var o=this._x1,a=this._y1,s=(n=+n)-(t=+t),l=(i=+i)-(e=+e),c=o-t,u=a-e,h=c*c+u*u;if((r=+r)<0)throw new Error("negative radius: "+r);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=e);else if(h>r9)if(Math.abs(u*s-l*c)>r9&&r){var d=n-o,p=i-a,f=s*s+l*l,m=d*d+p*p,g=Math.sqrt(f),_=Math.sqrt(h),y=r*Math.tan((n9-Math.acos((f+h-m)/(2*g*_)))/2),v=y/_,b=y/g;Math.abs(v-1)>r9&&(this._+="L"+(t+v*c)+","+(e+v*u)),this._+="A"+r+","+r+",0,0,"+ +(u*d>c*p)+","+(this._x1=t+b*s)+","+(this._y1=e+b*l)}else this._+="L"+(this._x1=t)+","+(this._y1=e)},arc:function(t,e,n,i,r,o){t=+t,e=+e,o=!!o;var a=(n=+n)*Math.cos(i),s=n*Math.sin(i),l=t+a,c=e+s,u=1^o,h=o?i-r:r-i;if(n<0)throw new Error("negative radius: "+n);null===this._x1?this._+="M"+l+","+c:(Math.abs(this._x1-l)>r9||Math.abs(this._y1-c)>r9)&&(this._+="L"+l+","+c),n&&(h<0&&(h=h%i9+i9),h>o9?this._+="A"+n+","+n+",0,1,"+u+","+(t-a)+","+(e-s)+"A"+n+","+n+",0,1,"+u+","+(this._x1=l)+","+(this._y1=c):h>r9&&(this._+="A"+n+","+n+",0,"+ +(h>=n9)+","+u+","+(this._x1=t+n*Math.cos(r))+","+(this._y1=e+n*Math.sin(r))))},rect:function(t,e,n,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+e)+"h"+ +n+"v"+ +i+"h"+-n+"Z"},toString:function(){return this._}};var c9=Math.abs,u9=Math.atan2,h9=Math.cos,d9=Math.max,p9=Math.min,f9=Math.sin,m9=Math.sqrt,g9=1e-12,_9=Math.PI,y9=_9/2,v9=2*_9;function b9(t){return t>1?0:t<-1?_9:Math.acos(t)}function x9(t){return t>=1?y9:t<=-1?-y9:Math.asin(t)}function w9(t){return t.innerRadius}function S9(t){return t.outerRadius}function M9(t){return t.startAngle}function E9(t){return t.endAngle}function T9(t){return t&&t.padAngle}function A9(t,e,n,i,r,o,a,s){var l=n-t,c=i-e,u=a-r,h=s-o,d=(u*(e-o)-h*(t-r))/(h*l-u*c);return[t+d*l,e+d*c]}function C9(t,e,n,i,r,o,a){var s=t-n,l=e-i,c=(a?o:-o)/m9(s*s+l*l),u=c*l,h=-c*s,d=t+u,p=e+h,f=n+u,m=i+h,g=(d+f)/2,_=(p+m)/2,y=f-d,v=m-p,b=y*y+v*v,x=r-o,w=d*m-f*p,S=(v<0?-1:1)*m9(d9(0,x*x*b-w*w)),M=(w*v-y*S)/b,E=(-w*y-v*S)/b,T=(w*v+y*S)/b,A=(-w*y+v*S)/b,C=M-g,k=E-_,L=T-g,P=A-_;return C*C+k*k>L*L+P*P&&(M=T,E=A),{cx:M,cy:E,x01:-u,y01:-h,x11:M*(r/x-1),y11:E*(r/x-1)}}function k9(t){this._context=t}function L9(t){return new k9(t)}function P9(t){return t[0]}function I9(t){return t[1]}function N9(){var t=P9,e=I9,n=l9(!0),i=null,r=L9,o=null;function a(a){var s,l,c,u=a.length,h=!1;for(null==i&&(o=r(c=s9())),s=0;s<=u;++s)!(s<u&&n(l=a[s],s,a))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+t(l,s,a),+e(l,s,a));if(c)return o=null,c+""||null}return a.x=function(e){return arguments.length?(t="function"==typeof e?e:l9(+e),a):t},a.y=function(t){return arguments.length?(e="function"==typeof t?t:l9(+t),a):e},a.defined=function(t){return arguments.length?(n="function"==typeof t?t:l9(!!t),a):n},a.curve=function(t){return arguments.length?(r=t,null!=i&&(o=r(i)),a):r},a.context=function(t){return arguments.length?(null==t?i=o=null:o=r(i=t),a):i},a}function O9(){var t=P9,e=null,n=l9(0),i=I9,r=l9(!0),o=null,a=L9,s=null;function l(l){var c,u,h,d,p,f=l.length,m=!1,g=new Array(f),_=new Array(f);for(null==o&&(s=a(p=s9())),c=0;c<=f;++c){if(!(c<f&&r(d=l[c],c,l))===m)if(m=!m)u=c,s.areaStart(),s.lineStart();else{for(s.lineEnd(),s.lineStart(),h=c-1;h>=u;--h)s.point(g[h],_[h]);s.lineEnd(),s.areaEnd()}m&&(g[c]=+t(d,c,l),_[c]=+n(d,c,l),s.point(e?+e(d,c,l):g[c],i?+i(d,c,l):_[c]))}if(p)return s=null,p+""||null}function c(){return N9().defined(r).curve(a).context(o)}return l.x=function(n){return arguments.length?(t="function"==typeof n?n:l9(+n),e=null,l):t},l.x0=function(e){return arguments.length?(t="function"==typeof e?e:l9(+e),l):t},l.x1=function(t){return arguments.length?(e=null==t?null:"function"==typeof t?t:l9(+t),l):e},l.y=function(t){return arguments.length?(n="function"==typeof t?t:l9(+t),i=null,l):n},l.y0=function(t){return arguments.length?(n="function"==typeof t?t:l9(+t),l):n},l.y1=function(t){return arguments.length?(i=null==t?null:"function"==typeof t?t:l9(+t),l):i},l.lineX0=l.lineY0=function(){return c().x(t).y(n)},l.lineY1=function(){return c().x(t).y(i)},l.lineX1=function(){return c().x(e).y(n)},l.defined=function(t){return arguments.length?(r="function"==typeof t?t:l9(!!t),l):r},l.curve=function(t){return arguments.length?(a=t,null!=o&&(s=a(o)),l):a},l.context=function(t){return arguments.length?(null==t?o=s=null:s=a(o=t),l):o},l}function R9(t,e){return e<t?-1:e>t?1:e>=t?0:NaN}function z9(t){return t}k9.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:this._context.lineTo(t,e)}}};var D9=H9(L9);function B9(t){this._curve=t}function H9(t){function e(e){return new B9(t(e))}return e._curve=t,e}function F9(t){var e=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?e(H9(t)):e()._curve},t}function V9(){return F9(N9().curve(D9))}function j9(){var t=O9().curve(D9),e=t.curve,n=t.lineX0,i=t.lineX1,r=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return F9(n())},delete t.lineX0,t.lineEndAngle=function(){return F9(i())},delete t.lineX1,t.lineInnerRadius=function(){return F9(r())},delete t.lineY0,t.lineOuterRadius=function(){return F9(o())},delete t.lineY1,t.curve=function(t){return arguments.length?e(H9(t)):e()._curve},t}function U9(t,e){return[(e=+e)*Math.cos(t-=Math.PI/2),e*Math.sin(t)]}B9.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,e){this._curve.point(e*Math.sin(t),e*-Math.cos(t))}};var G9=Array.prototype.slice;function W9(t){return t.source}function q9(t){return t.target}function Y9(t){var e=W9,n=q9,i=P9,r=I9,o=null;function a(){var a,s=G9.call(arguments),l=e.apply(this,s),c=n.apply(this,s);if(o||(o=a=s9()),t(o,+i.apply(this,(s[0]=l,s)),+r.apply(this,s),+i.apply(this,(s[0]=c,s)),+r.apply(this,s)),a)return o=null,a+""||null}return a.source=function(t){return arguments.length?(e=t,a):e},a.target=function(t){return arguments.length?(n=t,a):n},a.x=function(t){return arguments.length?(i="function"==typeof t?t:l9(+t),a):i},a.y=function(t){return arguments.length?(r="function"==typeof t?t:l9(+t),a):r},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a}function X9(t,e,n,i,r){t.moveTo(e,n),t.bezierCurveTo(e=(e+i)/2,n,e,r,i,r)}function $9(t,e,n,i,r){t.moveTo(e,n),t.bezierCurveTo(e,n=(n+r)/2,i,n,i,r)}function K9(t,e,n,i,r){var o=U9(e,n),a=U9(e,n=(n+r)/2),s=U9(i,n),l=U9(i,r);t.moveTo(o[0],o[1]),t.bezierCurveTo(a[0],a[1],s[0],s[1],l[0],l[1])}var Z9={draw:function(t,e){var n=Math.sqrt(e/_9);t.moveTo(n,0),t.arc(0,0,n,0,v9)}},J9={draw:function(t,e){var n=Math.sqrt(e/5)/2;t.moveTo(-3*n,-n),t.lineTo(-n,-n),t.lineTo(-n,-3*n),t.lineTo(n,-3*n),t.lineTo(n,-n),t.lineTo(3*n,-n),t.lineTo(3*n,n),t.lineTo(n,n),t.lineTo(n,3*n),t.lineTo(-n,3*n),t.lineTo(-n,n),t.lineTo(-3*n,n),t.closePath()}},Q9=Math.sqrt(1/3),t8=2*Q9,e8={draw:function(t,e){var n=Math.sqrt(e/t8),i=n*Q9;t.moveTo(0,-n),t.lineTo(i,0),t.lineTo(0,n),t.lineTo(-i,0),t.closePath()}},n8=Math.sin(_9/10)/Math.sin(7*_9/10),i8=Math.sin(v9/10)*n8,r8=-Math.cos(v9/10)*n8,o8={draw:function(t,e){var n=Math.sqrt(.8908130915292852*e),i=i8*n,r=r8*n;t.moveTo(0,-n),t.lineTo(i,r);for(var o=1;o<5;++o){var a=v9*o/5,s=Math.cos(a),l=Math.sin(a);t.lineTo(l*n,-s*n),t.lineTo(s*i-l*r,l*i+s*r)}t.closePath()}},a8={draw:function(t,e){var n=Math.sqrt(e),i=-n/2;t.rect(i,i,n,n)}},s8=Math.sqrt(3),l8={draw:function(t,e){var n=-Math.sqrt(e/(3*s8));t.moveTo(0,2*n),t.lineTo(-s8*n,-n),t.lineTo(s8*n,-n),t.closePath()}},c8=-.5,u8=Math.sqrt(3)/2,h8=1/Math.sqrt(12),d8=3*(h8/2+1),p8={draw:function(t,e){var n=Math.sqrt(e/d8),i=n/2,r=n*h8,o=i,a=n*h8+n,s=-o,l=a;t.moveTo(i,r),t.lineTo(o,a),t.lineTo(s,l),t.lineTo(c8*i-u8*r,u8*i+c8*r),t.lineTo(c8*o-u8*a,u8*o+c8*a),t.lineTo(c8*s-u8*l,u8*s+c8*l),t.lineTo(c8*i+u8*r,c8*r-u8*i),t.lineTo(c8*o+u8*a,c8*a-u8*o),t.lineTo(c8*s+u8*l,c8*l-u8*s),t.closePath()}},f8=[Z9,J9,e8,a8,o8,l8,p8];function m8(){}function g8(t,e,n){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+e)/6,(t._y0+4*t._y1+n)/6)}function _8(t){this._context=t}function y8(t){this._context=t}function v8(t){this._context=t}function b8(t,e){this._basis=new _8(t),this._beta=e}_8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:g8(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:g8(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},y8.prototype={areaStart:m8,areaEnd:m8,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._x2=t,this._y2=e;break;case 1:this._point=2,this._x3=t,this._y3=e;break;case 2:this._point=3,this._x4=t,this._y4=e,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+e)/6);break;default:g8(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},v8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var n=(this._x0+4*this._x1+t)/6,i=(this._y0+4*this._y1+e)/6;this._line?this._context.lineTo(n,i):this._context.moveTo(n,i);break;case 3:this._point=4;default:g8(this,t,e)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e}},b8.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,e=this._y,n=t.length-1;if(n>0)for(var i,r=t[0],o=e[0],a=t[n]-r,s=e[n]-o,l=-1;++l<=n;)this._basis.point(this._beta*t[l]+(1-this._beta)*(r+(i=l/n)*a),this._beta*e[l]+(1-this._beta)*(o+i*s));this._x=this._y=null,this._basis.lineEnd()},point:function(t,e){this._x.push(+t),this._y.push(+e)}};var x8=(function t(e){function n(t){return 1===e?new _8(t):new b8(t,e)}return n.beta=function(e){return t(+e)},n})(.85);function w8(t,e,n){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-e),t._y2+t._k*(t._y1-n),t._x2,t._y2)}function S8(t,e){this._context=t,this._k=(1-e)/6}S8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:w8(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2,this._x1=t,this._y1=e;break;case 2:this._point=3;default:w8(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var M8=(function t(e){function n(t){return new S8(t,e)}return n.tension=function(e){return t(+e)},n})(0);function E8(t,e){this._context=t,this._k=(1-e)/6}E8.prototype={areaStart:m8,areaEnd:m8,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:w8(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var T8=(function t(e){function n(t){return new E8(t,e)}return n.tension=function(e){return t(+e)},n})(0);function A8(t,e){this._context=t,this._k=(1-e)/6}A8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:w8(this,t,e)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var C8=(function t(e){function n(t){return new A8(t,e)}return n.tension=function(e){return t(+e)},n})(0);function k8(t,e,n){var i=t._x1,r=t._y1,o=t._x2,a=t._y2;if(t._l01_a>g9){var s=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,l=3*t._l01_a*(t._l01_a+t._l12_a);i=(i*s-t._x0*t._l12_2a+t._x2*t._l01_2a)/l,r=(r*s-t._y0*t._l12_2a+t._y2*t._l01_2a)/l}if(t._l23_a>g9){var c=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,u=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*c+t._x1*t._l23_2a-e*t._l12_2a)/u,a=(a*c+t._y1*t._l23_2a-n*t._l12_2a)/u}t._context.bezierCurveTo(i,r,o,a,t._x2,t._y2)}function L8(t,e){this._context=t,this._alpha=e}L8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3;default:k8(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var P8=(function t(e){function n(t){return e?new L8(t,e):new S8(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function I8(t,e){this._context=t,this._alpha=e}I8.prototype={areaStart:m8,areaEnd:m8,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=e;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=e);break;case 2:this._point=3,this._x5=t,this._y5=e;break;default:k8(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var N8=(function t(e){function n(t){return e?new I8(t,e):new E8(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function O8(t,e){this._context=t,this._alpha=e}O8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){if(t=+t,e=+e,this._point){var n=this._x2-t,i=this._y2-e;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(n*n+i*i,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:k8(this,t,e)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=e}};var R8=(function t(e){function n(t){return e?new O8(t,e):new A8(t,0)}return n.alpha=function(e){return t(+e)},n})(.5);function z8(t){this._context=t}function D8(t){return t<0?-1:1}function B8(t,e,n){var i=t._x1-t._x0,r=e-t._x1,o=(t._y1-t._y0)/(i||r<0&&-0),a=(n-t._y1)/(r||i<0&&-0),s=(o*r+a*i)/(i+r);return(D8(o)+D8(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(s))||0}function H8(t,e){var n=t._x1-t._x0;return n?(3*(t._y1-t._y0)/n-e)/2:e}function F8(t,e,n){var i=t._x0,r=t._x1,o=t._y1,a=(r-i)/3;t._context.bezierCurveTo(i+a,t._y0+a*e,r-a,o-a*n,r,o)}function V8(t){this._context=t}function j8(t){this._context=new U8(t)}function U8(t){this._context=t}function G8(t){this._context=t}function W8(t){var e,n,i=t.length-1,r=new Array(i),o=new Array(i),a=new Array(i);for(r[0]=0,o[0]=2,a[0]=t[0]+2*t[1],e=1;e<i-1;++e)r[e]=1,o[e]=4,a[e]=4*t[e]+2*t[e+1];for(r[i-1]=2,o[i-1]=7,a[i-1]=8*t[i-1]+t[i],e=1;e<i;++e)o[e]-=n=r[e]/o[e-1],a[e]-=n*a[e-1];for(r[i-1]=a[i-1]/o[i-1],e=i-2;e>=0;--e)r[e]=(a[e]-r[e+1])/o[e];for(o[i-1]=(t[i]+r[i-1])/2,e=0;e<i-1;++e)o[e]=2*t[e+1]-r[e+1];return[r,o]}function q8(t,e){this._context=t,this._t=e}function Y8(t,e){if((r=t.length)>1)for(var n,i,r,o=1,a=t[e[0]],s=a.length;o<r;++o)for(i=a,a=t[e[o]],n=0;n<s;++n)a[n][1]+=a[n][0]=isNaN(i[n][1])?i[n][0]:i[n][1]}function X8(t){for(var e=t.length,n=new Array(e);--e>=0;)n[e]=e;return n}function $8(t,e){return t[e]}function K8(t){var e=t.map(Z8);return X8(t).sort((function(t,n){return e[t]-e[n]}))}function Z8(t){for(var e,n=0,i=-1,r=t.length;++i<r;)(e=+t[i][1])&&(n+=e);return n}z8.prototype={areaStart:m8,areaEnd:m8,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,e){t=+t,e=+e,this._point?this._context.lineTo(t,e):(this._point=1,this._context.moveTo(t,e))}},V8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:F8(this,this._t0,H8(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,e){var n=NaN;if(e=+e,(t=+t)!==this._x1||e!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;break;case 2:this._point=3,F8(this,H8(this,n=B8(this,t,e)),n);break;default:F8(this,this._t0,n=B8(this,t,e))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=e,this._t0=n}}},(j8.prototype=Object.create(V8.prototype)).point=function(t,e){V8.prototype.point.call(this,e,t)},U8.prototype={moveTo:function(t,e){this._context.moveTo(e,t)},closePath:function(){this._context.closePath()},lineTo:function(t,e){this._context.lineTo(e,t)},bezierCurveTo:function(t,e,n,i,r,o){this._context.bezierCurveTo(e,t,i,n,o,r)}},G8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,e=this._y,n=t.length;if(n)if(this._line?this._context.lineTo(t[0],e[0]):this._context.moveTo(t[0],e[0]),2===n)this._context.lineTo(t[1],e[1]);else for(var i=W8(t),r=W8(e),o=0,a=1;a<n;++o,++a)this._context.bezierCurveTo(i[0][o],r[0][o],i[1][o],r[1][o],t[a],e[a]);(this._line||0!==this._line&&1===n)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,e){this._x.push(+t),this._y.push(+e)}},q8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,e){switch(t=+t,e=+e,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,e):this._context.moveTo(t,e);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,e),this._context.lineTo(t,e);else{var n=this._x*(1-this._t)+t*this._t;this._context.lineTo(n,this._y),this._context.lineTo(n,e)}}this._x=t,this._y=e}};var J8=new Date,Q8=new Date;function t7(t,e,n,i){function r(e){return t(e=new Date(+e)),e}return r.floor=r,r.ceil=function(n){return t(n=new Date(n-1)),e(n,1),t(n),n},r.round=function(t){var e=r(t),n=r.ceil(t);return t-e<n-t?e:n},r.offset=function(t,n){return e(t=new Date(+t),null==n?1:Math.floor(n)),t},r.range=function(n,i,o){var a,s=[];if(n=r.ceil(n),o=null==o?1:Math.floor(o),!(n<i&&o>0))return s;do{s.push(a=new Date(+n)),e(n,o),t(n)}while(a<n&&n<i);return s},r.filter=function(n){return t7((function(e){if(e>=e)for(;t(e),!n(e);)e.setTime(e-1)}),(function(t,i){if(t>=t)if(i<0)for(;++i<=0;)for(;e(t,-1),!n(t););else for(;--i>=0;)for(;e(t,1),!n(t););}))},n&&(r.count=function(e,i){return J8.setTime(+e),Q8.setTime(+i),t(J8),t(Q8),Math.floor(n(J8,Q8))},r.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?r.filter(i?function(e){return i(e)%t==0}:function(e){return r.count(0,e)%t==0}):r:null}),r}var e7=t7((function(){}),(function(t,e){t.setTime(+t+e)}),(function(t,e){return e-t}));e7.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?t7((function(e){e.setTime(Math.floor(e/t)*t)}),(function(e,n){e.setTime(+e+n*t)}),(function(e,n){return(n-e)/t})):e7:null};var n7=e7.range,i7=1e3,r7=6e4,o7=36e5,a7=864e5,s7=6048e5,l7=t7((function(t){t.setTime(Math.floor(t/i7)*i7)}),(function(t,e){t.setTime(+t+e*i7)}),(function(t,e){return(e-t)/i7}),(function(t){return t.getUTCSeconds()})),c7=l7.range,u7=t7((function(t){t.setTime(Math.floor(t/r7)*r7)}),(function(t,e){t.setTime(+t+e*r7)}),(function(t,e){return(e-t)/r7}),(function(t){return t.getMinutes()})),h7=u7.range,d7=t7((function(t){var e=t.getTimezoneOffset()*r7%o7;e<0&&(e+=o7),t.setTime(Math.floor((+t-e)/o7)*o7+e)}),(function(t,e){t.setTime(+t+e*o7)}),(function(t,e){return(e-t)/o7}),(function(t){return t.getHours()})),p7=d7.range,f7=t7((function(t){t.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*r7)/a7}),(function(t){return t.getDate()-1})),m7=f7.range;function g7(t){return t7((function(e){e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+7*e)}),(function(t,e){return(e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*r7)/s7}))}var _7=g7(0),y7=g7(1),v7=g7(2),b7=g7(3),x7=g7(4),w7=g7(5),S7=g7(6),M7=_7.range,E7=y7.range,T7=v7.range,A7=b7.range,C7=x7.range,k7=w7.range,L7=S7.range,P7=t7((function(t){t.setDate(1),t.setHours(0,0,0,0)}),(function(t,e){t.setMonth(t.getMonth()+e)}),(function(t,e){return e.getMonth()-t.getMonth()+12*(e.getFullYear()-t.getFullYear())}),(function(t){return t.getMonth()})),I7=P7.range,N7=t7((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,e){t.setFullYear(t.getFullYear()+e)}),(function(t,e){return e.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));N7.every=function(t){return isFinite(t=Math.floor(t))&&t>0?t7((function(e){e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)}),(function(e,n){e.setFullYear(e.getFullYear()+n*t)})):null};var O7=N7.range,R7=t7((function(t){t.setUTCSeconds(0,0)}),(function(t,e){t.setTime(+t+e*r7)}),(function(t,e){return(e-t)/r7}),(function(t){return t.getUTCMinutes()})),z7=R7.range,D7=t7((function(t){t.setUTCMinutes(0,0,0)}),(function(t,e){t.setTime(+t+e*o7)}),(function(t,e){return(e-t)/o7}),(function(t){return t.getUTCHours()})),B7=D7.range,H7=t7((function(t){t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+e)}),(function(t,e){return(e-t)/a7}),(function(t){return t.getUTCDate()-1})),F7=H7.range;function V7(t){return t7((function(e){e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+7*e)}),(function(t,e){return(e-t)/s7}))}var j7=V7(0),U7=V7(1),G7=V7(2),W7=V7(3),q7=V7(4),Y7=V7(5),X7=V7(6),$7=j7.range,K7=U7.range,Z7=G7.range,J7=W7.range,Q7=q7.range,ttt=Y7.range,ett=X7.range,ntt=t7((function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCMonth(t.getUTCMonth()+e)}),(function(t,e){return e.getUTCMonth()-t.getUTCMonth()+12*(e.getUTCFullYear()-t.getUTCFullYear())}),(function(t){return t.getUTCMonth()})),itt=ntt.range,rtt=t7((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e)}),(function(t,e){return e.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));rtt.every=function(t){return isFinite(t=Math.floor(t))&&t>0?t7((function(e){e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)}),(function(e,n){e.setUTCFullYear(e.getUTCFullYear()+n*t)})):null};var ott=rtt.range,att=new Date,stt=new Date;function ltt(t,e,n,i){function r(e){return t(e=0===arguments.length?new Date:new Date(+e)),e}return r.floor=function(e){return t(e=new Date(+e)),e},r.ceil=function(n){return t(n=new Date(n-1)),e(n,1),t(n),n},r.round=function(t){var e=r(t),n=r.ceil(t);return t-e<n-t?e:n},r.offset=function(t,n){return e(t=new Date(+t),null==n?1:Math.floor(n)),t},r.range=function(n,i,o){var a,s=[];if(n=r.ceil(n),o=null==o?1:Math.floor(o),!(n<i&&o>0))return s;do{s.push(a=new Date(+n)),e(n,o),t(n)}while(a<n&&n<i);return s},r.filter=function(n){return ltt((function(e){if(e>=e)for(;t(e),!n(e);)e.setTime(e-1)}),(function(t,i){if(t>=t)if(i<0)for(;++i<=0;)for(;e(t,-1),!n(t););else for(;--i>=0;)for(;e(t,1),!n(t););}))},n&&(r.count=function(e,i){return att.setTime(+e),stt.setTime(+i),t(att),t(stt),Math.floor(n(att,stt))},r.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?r.filter(i?function(e){return i(e)%t==0}:function(e){return r.count(0,e)%t==0}):r:null}),r}var ctt=864e5,utt=6048e5,htt=ltt((function(t){t.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+e)}),(function(t,e){return(e-t-6e4*(e.getTimezoneOffset()-t.getTimezoneOffset()))/ctt}),(function(t){return t.getDate()-1}));function dtt(t){return ltt((function(e){e.setDate(e.getDate()-(e.getDay()+7-t)%7),e.setHours(0,0,0,0)}),(function(t,e){t.setDate(t.getDate()+7*e)}),(function(t,e){return(e-t-6e4*(e.getTimezoneOffset()-t.getTimezoneOffset()))/utt}))}var ptt=dtt(0),ftt=dtt(1);dtt(2),dtt(3);var mtt=dtt(4);dtt(5),dtt(6);var gtt=ltt((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,e){t.setFullYear(t.getFullYear()+e)}),(function(t,e){return e.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));gtt.every=function(t){return isFinite(t=Math.floor(t))&&t>0?ltt((function(e){e.setFullYear(Math.floor(e.getFullYear()/t)*t),e.setMonth(0,1),e.setHours(0,0,0,0)}),(function(e,n){e.setFullYear(e.getFullYear()+n*t)})):null};var _tt=ltt((function(t){t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+e)}),(function(t,e){return(e-t)/ctt}),(function(t){return t.getUTCDate()-1}));function ytt(t){return ltt((function(e){e.setUTCDate(e.getUTCDate()-(e.getUTCDay()+7-t)%7),e.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCDate(t.getUTCDate()+7*e)}),(function(t,e){return(e-t)/utt}))}var vtt=ytt(0),btt=ytt(1);ytt(2),ytt(3);var xtt=ytt(4);ytt(5),ytt(6);var wtt=ltt((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,e){t.setUTCFullYear(t.getUTCFullYear()+e)}),(function(t,e){return e.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));function Stt(t){if(0<=t.y&&t.y<100){var e=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return e.setFullYear(t.y),e}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function Mtt(t){if(0<=t.y&&t.y<100){var e=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return e.setUTCFullYear(t.y),e}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function Ett(t){return{y:t,m:0,d:1,H:0,M:0,S:0,L:0}}function Ttt(t){var e=t.dateTime,n=t.date,i=t.time,r=t.periods,o=t.days,a=t.shortDays,s=t.months,l=t.shortMonths,c=Btt(r),u=Htt(r),h=Btt(o),d=Htt(o),p=Btt(a),f=Htt(a),m=Btt(s),g=Htt(s),_=Btt(l),y=Htt(l),v={a:function b(t){return a[t.getDay()]},A:function x(t){return o[t.getDay()]},b:function w(t){return l[t.getMonth()]},B:function S(t){return s[t.getMonth()]},c:null,d:oet,e:oet,f:het,H:aet,I:set,j:cet,L:uet,m:det,M:pet,p:function M(t){return r[+(t.getHours()>=12)]},Q:jet,s:Uet,S:fet,u:met,U:get,V:_et,w:yet,W:vet,x:null,X:null,y:bet,Y:xet,Z:wet,"%":Vet},E={a:function T(t){return a[t.getUTCDay()]},A:function A(t){return o[t.getUTCDay()]},b:function C(t){return l[t.getUTCMonth()]},B:function k(t){return s[t.getUTCMonth()]},c:null,d:Met,e:Met,f:ket,H:Eet,I:Tet,j:Aet,L:Cet,m:Let,M:Pet,p:function L(t){return r[+(t.getUTCHours()>=12)]},Q:jet,s:Uet,S:Iet,u:Net,U:Oet,V:Ret,w:zet,W:Det,x:null,X:null,y:Bet,Y:Het,Z:Fet,"%":Vet},P={a:function I(t,e,n){var i=p.exec(e.slice(n));return i?(t.w=f[i[0].toLowerCase()],n+i[0].length):-1},A:function N(t,e,n){var i=h.exec(e.slice(n));return i?(t.w=d[i[0].toLowerCase()],n+i[0].length):-1},b:function O(t,e,n){var i=_.exec(e.slice(n));return i?(t.m=y[i[0].toLowerCase()],n+i[0].length):-1},B:function R(t,e,n){var i=m.exec(e.slice(n));return i?(t.m=g[i[0].toLowerCase()],n+i[0].length):-1},c:function z(t,n,i){return j(t,e,n,i)},d:$tt,e:$tt,f:eet,H:Ztt,I:Ztt,j:Ktt,L:tet,m:Xtt,M:Jtt,p:function D(t,e,n){var i=c.exec(e.slice(n));return i?(t.p=u[i[0].toLowerCase()],n+i[0].length):-1},Q:iet,s:ret,S:Qtt,u:Vtt,U:jtt,V:Utt,w:Ftt,W:Gtt,x:function B(t,e,i){return j(t,n,e,i)},X:function H(t,e,n){return j(t,i,e,n)},y:qtt,Y:Wtt,Z:Ytt,"%":net};function F(t,e){return function(n){var i,r,o,a=[],s=-1,l=0,c=t.length;for(n instanceof Date||(n=new Date(+n));++s<c;)37===t.charCodeAt(s)&&(a.push(t.slice(l,s)),null!=(r=Itt[i=t.charAt(++s)])?i=t.charAt(++s):r="e"===i?" ":"0",(o=e[i])&&(i=o(n,r)),a.push(i),l=s+1);return a.push(t.slice(l,s)),a.join("")}}function V(t,e){return function(n){var i,r,o=Ett(1900);if(j(o,t,n+="",0)!=n.length)return null;if("Q"in o)return new Date(o.Q);if("p"in o&&(o.H=o.H%12+12*o.p),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(r=(i=Mtt(Ett(o.y))).getUTCDay(),i=r>4||0===r?btt.ceil(i):btt(i),i=_tt.offset(i,7*(o.V-1)),o.y=i.getUTCFullYear(),o.m=i.getUTCMonth(),o.d=i.getUTCDate()+(o.w+6)%7):(r=(i=e(Ett(o.y))).getDay(),i=r>4||0===r?ftt.ceil(i):ftt(i),i=htt.offset(i,7*(o.V-1)),o.y=i.getFullYear(),o.m=i.getMonth(),o.d=i.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),r="Z"in o?Mtt(Ett(o.y)).getUTCDay():e(Ett(o.y)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(r+5)%7:o.w+7*o.U-(r+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,Mtt(o)):e(o)}}function j(t,e,n,i){for(var r,o,a=0,s=e.length,l=n.length;a<s;){if(i>=l)return-1;if(37===(r=e.charCodeAt(a++))){if(r=e.charAt(a++),!(o=P[r in Itt?e.charAt(a++):r])||(i=o(t,n,i))<0)return-1}else if(r!=n.charCodeAt(i++))return-1}return i}return v.x=F(n,v),v.X=F(i,v),v.c=F(e,v),E.x=F(n,E),E.X=F(i,E),E.c=F(e,E),{format:function(t){var e=F(t+="",v);return e.toString=function(){return t},e},parse:function(t){var e=V(t+="",Stt);return e.toString=function(){return t},e},utcFormat:function(t){var e=F(t+="",E);return e.toString=function(){return t},e},utcParse:function(t){var e=V(t,Mtt);return e.toString=function(){return t},e}}}wtt.every=function(t){return isFinite(t=Math.floor(t))&&t>0?ltt((function(e){e.setUTCFullYear(Math.floor(e.getUTCFullYear()/t)*t),e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0)}),(function(e,n){e.setUTCFullYear(e.getUTCFullYear()+n*t)})):null};var Att,Ctt,ktt,Ltt,Ptt,Itt={"-":"",_:" ",0:"0"},Ntt=/^\s*\d+/,Ott=/^%/,Rtt=/[\\^$*+?|[\]().{}]/g;function ztt(t,e,n){var i=t<0?"-":"",r=(i?-t:t)+"",o=r.length;return i+(o<n?new Array(n-o+1).join(e)+r:r)}function Dtt(t){return t.replace(Rtt,"\\$&")}function Btt(t){return new RegExp("^(?:"+t.map(Dtt).join("|")+")","i")}function Htt(t){for(var e={},n=-1,i=t.length;++n<i;)e[t[n].toLowerCase()]=n;return e}function Ftt(t,e,n){var i=Ntt.exec(e.slice(n,n+1));return i?(t.w=+i[0],n+i[0].length):-1}function Vtt(t,e,n){var i=Ntt.exec(e.slice(n,n+1));return i?(t.u=+i[0],n+i[0].length):-1}function jtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.U=+i[0],n+i[0].length):-1}function Utt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.V=+i[0],n+i[0].length):-1}function Gtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.W=+i[0],n+i[0].length):-1}function Wtt(t,e,n){var i=Ntt.exec(e.slice(n,n+4));return i?(t.y=+i[0],n+i[0].length):-1}function qtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.y=+i[0]+(+i[0]>68?1900:2e3),n+i[0].length):-1}function Ytt(t,e,n){var i=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n,n+6));return i?(t.Z=i[1]?0:-(i[2]+(i[3]||"00")),n+i[0].length):-1}function Xtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.m=i[0]-1,n+i[0].length):-1}function $tt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.d=+i[0],n+i[0].length):-1}function Ktt(t,e,n){var i=Ntt.exec(e.slice(n,n+3));return i?(t.m=0,t.d=+i[0],n+i[0].length):-1}function Ztt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.H=+i[0],n+i[0].length):-1}function Jtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.M=+i[0],n+i[0].length):-1}function Qtt(t,e,n){var i=Ntt.exec(e.slice(n,n+2));return i?(t.S=+i[0],n+i[0].length):-1}function tet(t,e,n){var i=Ntt.exec(e.slice(n,n+3));return i?(t.L=+i[0],n+i[0].length):-1}function eet(t,e,n){var i=Ntt.exec(e.slice(n,n+6));return i?(t.L=Math.floor(i[0]/1e3),n+i[0].length):-1}function net(t,e,n){var i=Ott.exec(e.slice(n,n+1));return i?n+i[0].length:-1}function iet(t,e,n){var i=Ntt.exec(e.slice(n));return i?(t.Q=+i[0],n+i[0].length):-1}function ret(t,e,n){var i=Ntt.exec(e.slice(n));return i?(t.Q=1e3*+i[0],n+i[0].length):-1}function oet(t,e){return ztt(t.getDate(),e,2)}function aet(t,e){return ztt(t.getHours(),e,2)}function set(t,e){return ztt(t.getHours()%12||12,e,2)}function cet(t,e){return ztt(1+htt.count(gtt(t),t),e,3)}function uet(t,e){return ztt(t.getMilliseconds(),e,3)}function het(t,e){return uet(t,e)+"000"}function det(t,e){return ztt(t.getMonth()+1,e,2)}function pet(t,e){return ztt(t.getMinutes(),e,2)}function fet(t,e){return ztt(t.getSeconds(),e,2)}function met(t){var e=t.getDay();return 0===e?7:e}function get(t,e){return ztt(ptt.count(gtt(t),t),e,2)}function _et(t,e){var n=t.getDay();return t=n>=4||0===n?mtt(t):mtt.ceil(t),ztt(mtt.count(gtt(t),t)+(4===gtt(t).getDay()),e,2)}function yet(t){return t.getDay()}function vet(t,e){return ztt(ftt.count(gtt(t),t),e,2)}function bet(t,e){return ztt(t.getFullYear()%100,e,2)}function xet(t,e){return ztt(t.getFullYear()%1e4,e,4)}function wet(t){var e=t.getTimezoneOffset();return(e>0?"-":(e*=-1,"+"))+ztt(e/60|0,"0",2)+ztt(e%60,"0",2)}function Met(t,e){return ztt(t.getUTCDate(),e,2)}function Eet(t,e){return ztt(t.getUTCHours(),e,2)}function Tet(t,e){return ztt(t.getUTCHours()%12||12,e,2)}function Aet(t,e){return ztt(1+_tt.count(wtt(t),t),e,3)}function Cet(t,e){return ztt(t.getUTCMilliseconds(),e,3)}function ket(t,e){return Cet(t,e)+"000"}function Let(t,e){return ztt(t.getUTCMonth()+1,e,2)}function Pet(t,e){return ztt(t.getUTCMinutes(),e,2)}function Iet(t,e){return ztt(t.getUTCSeconds(),e,2)}function Net(t){var e=t.getUTCDay();return 0===e?7:e}function Oet(t,e){return ztt(vtt.count(wtt(t),t),e,2)}function Ret(t,e){var n=t.getUTCDay();return t=n>=4||0===n?xtt(t):xtt.ceil(t),ztt(xtt.count(wtt(t),t)+(4===wtt(t).getUTCDay()),e,2)}function zet(t){return t.getUTCDay()}function Det(t,e){return ztt(btt.count(wtt(t),t),e,2)}function Bet(t,e){return ztt(t.getUTCFullYear()%100,e,2)}function Het(t,e){return ztt(t.getUTCFullYear()%1e4,e,4)}function Fet(){return"+0000"}function Vet(){return"%"}function jet(t){return+t}function Uet(t){return Math.floor(+t/1e3)}function Get(t){return Att=Ttt(t),Ctt=Att.format,ktt=Att.parse,Ltt=Att.utcFormat,Ptt=Att.utcParse,Att}Get({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var Wet,qet,Yet="%Y-%m-%dT%H:%M:%S.%LZ",Xet=Date.prototype.toISOString?function $et(t){return t.toISOString()}:Ltt(Yet),Ket=+new Date("2000-01-01T00:00:00.000Z")?function Zet(t){var e=new Date(t);return isNaN(e)?null:e}:Ptt(Yet),Jet=0,Qet=0,tnt=0,ent=0,nnt=0,int=0,rnt="object"==typeof performance&&performance.now?performance:Date,ont="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function ant(){return nnt||(ont(snt),nnt=rnt.now()+int)}function snt(){nnt=0}function lnt(){this._call=this._time=this._next=null}function cnt(t,e,n){var i=new lnt;return i.restart(t,e,n),i}function unt(){ant(),++Jet;for(var t,e=Wet;e;)(t=nnt-e._time)>=0&&e._call.call(null,t),e=e._next;--Jet}function hnt(){nnt=(ent=rnt.now())+int,Jet=Qet=0;try{unt()}finally{Jet=0,(function t(){for(var t,e,n=Wet,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:Wet=e);qet=t,pnt(i)})(),nnt=0}}function dnt(){var t=rnt.now(),e=t-ent;e>1e3&&(int-=e,ent=t)}function pnt(t){Jet||(Qet&&(Qet=clearTimeout(Qet)),t-nnt>24?(t<1/0&&(Qet=setTimeout(hnt,t-rnt.now()-int)),tnt&&(tnt=clearInterval(tnt))):(tnt||(ent=rnt.now(),tnt=setInterval(dnt,1e3)),Jet=1,ont(hnt)))}lnt.prototype=cnt.prototype={constructor:lnt,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?ant():+n)+(null==e?0:+e),this._next||qet===this||(qet?qet._next=this:Wet=this,qet=this),this._call=t,this._time=n,pnt()},stop:function(){this._call&&(this._call=null,this._time=1/0,pnt())}};var fnt="http://www.w3.org/1999/xhtml",mnt={svg:"http://www.w3.org/2000/svg",xhtml:fnt,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function gnt(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),mnt.hasOwnProperty(e)?{space:mnt[e],local:t}:t}function _nt(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===fnt&&e.documentElement.namespaceURI===fnt?e.createElement(t):e.createElementNS(n,t)}}function ynt(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function vnt(t){var e=gnt(t);return(e.local?ynt:_nt)(e)}function bnt(){}function xnt(t){return null==t?bnt:function(){return this.querySelector(t)}}function wnt(){return[]}function Snt(t){return null==t?wnt:function(){return this.querySelectorAll(t)}}function Mnt(t){return function(){return this.matches(t)}}function Ent(t){return new Array(t.length)}function Tnt(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function Ant(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new Tnt(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function Cnt(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new Tnt(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function knt(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function Lnt(t){return function(){this.removeAttribute(t)}}function Pnt(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Int(t,e){return function(){this.setAttribute(t,e)}}function Nnt(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function Ont(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function Rnt(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function znt(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function Dnt(t){return function(){this.style.removeProperty(t)}}function Bnt(t,e,n){return function(){this.style.setProperty(t,e,n)}}function Hnt(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function Fnt(t,e){return t.style.getPropertyValue(e)||znt(t).getComputedStyle(t,null).getPropertyValue(e)}function Vnt(t){return function(){delete this[t]}}function jnt(t,e){return function(){this[t]=e}}function Unt(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function Gnt(t){return t.trim().split(/^|\s+/)}function Wnt(t){return t.classList||new qnt(t)}function qnt(t){this._node=t,this._names=Gnt(t.getAttribute("class")||"")}function Ynt(t,e){for(var n=Wnt(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function Xnt(t,e){for(var n=Wnt(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function $nt(t){return function(){Ynt(this,t)}}function Knt(t){return function(){Xnt(this,t)}}function Znt(t,e){return function(){(e.apply(this,arguments)?Ynt:Xnt)(this,t)}}function Jnt(){this.textContent=""}function Qnt(t){return function(){this.textContent=t}}function tit(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function eit(){this.innerHTML=""}function nit(t){return function(){this.innerHTML=t}}function iit(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function rit(){this.nextSibling&&this.parentNode.appendChild(this)}function oit(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function ait(){return null}function sit(){var t=this.parentNode;t&&t.removeChild(this)}function lit(){var t=this.cloneNode(!1),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}function cit(){var t=this.cloneNode(!0),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}Tnt.prototype={constructor:Tnt,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},qnt.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var uit={};function hit(t,e,n){return t=dit(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function dit(t,e,n){return function(i){try{t.call(this,this.__data__,e,n)}finally{}}}function pit(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function fit(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function mit(t,e,n){var i=uit.hasOwnProperty(t.type)?hit:dit;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function git(t,e,n){var i=znt(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function _it(t,e){return function(){return git(this,t,e)}}function yit(t,e){return function(){return git(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(uit={mouseenter:"mouseover",mouseleave:"mouseout"}));var vit=[null];function bit(t,e){this._groups=t,this._parents=e}function xit(){return new bit([[document.documentElement]],vit)}bit.prototype=xit.prototype={constructor:bit,select:function wit(t){"function"!=typeof t&&(t=xnt(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new bit(i,this._parents)},selectAll:function Sit(t){"function"!=typeof t&&(t=Snt(t));for(var e=this._groups,n=e.length,i=[],r=[],o=0;o<n;++o)for(var a,s=e[o],l=s.length,c=0;c<l;++c)(a=s[c])&&(i.push(t.call(a,a.__data__,c,s)),r.push(a));return new bit(i,r)},filter:function Mit(t){"function"!=typeof t&&(t=Mnt(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new bit(i,this._parents)},data:function Eit(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?Cnt:Ant,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new bit(s,i))._enter=l,s._exit=c,s},enter:function Tit(){return new bit(this._enter||this._groups.map(Ent),this._parents)},exit:function Ait(){return new bit(this._exit||this._groups.map(Ent),this._parents)},join:function Cit(t,e,n){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof t?t(i):i.append(t+""),null!=e&&(r=e(r)),null==n?o.remove():n(o),i&&r?i.merge(r).order():r},merge:function kit(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new bit(o,this._parents)},order:function Lit(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&4^i.compareDocumentPosition(a)&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function Pit(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=knt);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new bit(r,this._parents).order()},call:function Iit(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function Nit(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function Oit(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function Rit(){var t=0;return this.each((function(){++t})),t},empty:function zit(){return!this.node()},each:function Dit(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function Bit(t,e){var n=gnt(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?Pnt:Lnt:"function"==typeof e?n.local?Rnt:Ont:n.local?Nnt:Int)(n,e))},style:function Hit(t,e,n){return arguments.length>1?this.each((null==e?Dnt:"function"==typeof e?Hnt:Bnt)(t,e,null==n?"":n)):Fnt(this.node(),t)},property:function Fit(t,e){return arguments.length>1?this.each((null==e?Vnt:"function"==typeof e?Unt:jnt)(t,e)):this.node()[t]},classed:function Vit(t,e){var n=Gnt(t+"");if(arguments.length<2){for(var i=Wnt(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?Znt:e?$nt:Knt)(n,e))},text:function jit(t){return arguments.length?this.each(null==t?Jnt:("function"==typeof t?tit:Qnt)(t)):this.node().textContent},html:function Uit(t){return arguments.length?this.each(null==t?eit:("function"==typeof t?iit:nit)(t)):this.node().innerHTML},raise:function Git(){return this.each(rit)},lower:function Wit(){return this.each(oit)},append:function qit(t){var e="function"==typeof t?t:vnt(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function Yit(t,e){var n="function"==typeof t?t:vnt(t),i=null==e?ait:"function"==typeof e?e:xnt(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function Xit(){return this.each(sit)},clone:function $it(t){return this.select(t?cit:lit)},datum:function Kit(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function Zit(t,e,n){var i,r,o=pit(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?mit:fit,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function Jit(t,e){return this.each(("function"==typeof e?yit:_it)(t,e))}};var Qit={value:function(){}};function trt(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new ert(i)}function ert(t){this._=t}function nrt(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function irt(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function rrt(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=Qit,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}ert.prototype=trt.prototype={constructor:ert,on:function(t,e){var n,i=this._,r=nrt(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=rrt(i[n],t.name,e);else if(null==e)for(n in i)i[n]=rrt(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=irt(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new ert(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var ort,art,srt=0,lrt=0,crt=0,urt=0,hrt=0,drt=0,prt="object"==typeof performance&&performance.now?performance:Date,frt="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function mrt(){return hrt||(frt(grt),hrt=prt.now()+drt)}function grt(){hrt=0}function _rt(){this._call=this._time=this._next=null}function yrt(t,e,n){var i=new _rt;return i.restart(t,e,n),i}function vrt(){hrt=(urt=prt.now())+drt,srt=lrt=0;try{!(function t(){mrt(),++srt;for(var t,e=ort;e;)(t=hrt-e._time)>=0&&e._call.call(null,t),e=e._next;--srt})()}finally{srt=0,(function e(){for(var t,e,n=ort,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:ort=e);art=t,xrt(i)})(),hrt=0}}function brt(){var t=prt.now(),e=t-urt;e>1e3&&(drt-=e,urt=t)}function xrt(t){srt||(lrt&&(lrt=clearTimeout(lrt)),t-hrt>24?(t<1/0&&(lrt=setTimeout(vrt,t-prt.now()-drt)),crt&&(crt=clearInterval(crt))):(crt||(urt=prt.now(),crt=setInterval(brt,1e3)),srt=1,frt(vrt)))}function wrt(t,e,n){var i=new _rt;return i.restart((function(n){i.stop(),t(n+e)}),e=null==e?0:+e,n),i}_rt.prototype=yrt.prototype={constructor:_rt,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?mrt():+n)+(null==e?0:+e),this._next||art===this||(art?art._next=this:ort=this,art=this),this._call=t,this._time=n,xrt()},stop:function(){this._call&&(this._call=null,this._time=1/0,xrt())}};var Srt=trt("start","end","interrupt"),Mrt=[];function Ert(t,e,n,i,r,o){var a=t.__transition;if(a){if(n in a)return}else t.__transition={};!(function s(t,e,n){var i,r=t.__transition;function o(l){var c,u,h,d;if(1!==n.state)return s();for(c in r)if((d=r[c]).name===n.name){if(3===d.state)return wrt(o);4===d.state?(d.state=6,d.timer.stop(),d.on.call("interrupt",t,t.__data__,d.index,d.group),delete r[c]):+c<e&&(d.state=6,d.timer.stop(),delete r[c])}if(wrt((function(){3===n.state&&(n.state=4,n.timer.restart(a,n.delay,n.time),a(l))})),n.state=2,n.on.call("start",t,t.__data__,n.index,n.group),2===n.state){for(n.state=3,i=new Array(h=n.tween.length),c=0,u=-1;c<h;++c)(d=n.tween[c].value.call(t,t.__data__,n.index,n.group))&&(i[++u]=d);i.length=u+1}}function a(e){for(var r=e<n.duration?n.ease.call(null,e/n.duration):(n.timer.restart(s),n.state=5,1),o=-1,a=i.length;++o<a;)i[o].call(null,r);5===n.state&&(n.on.call("end",t,t.__data__,n.index,n.group),s())}function s(){for(var i in n.state=6,n.timer.stop(),delete r[e],r)return;delete t.__transition}r[e]=n,n.timer=yrt((function l(t){n.state=1,n.timer.restart(o,n.delay,n.time),n.delay<=t&&o(t-n.delay)}),0,n.time)})(t,n,{name:e,index:i,group:r,on:Srt,tween:Mrt,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:0})}function Trt(t,e){var n=Crt(t,e);if(n.state>0)throw new Error("too late; already scheduled");return n}function Art(t,e){var n=Crt(t,e);if(n.state>2)throw new Error("too late; already started");return n}function Crt(t,e){var n=t.__transition;if(!n||!(n=n[e]))throw new Error("transition not found");return n}function krt(t,e){var n,i,r,o=t.__transition,a=!0;if(o){for(r in e=null==e?null:e+"",o)(n=o[r]).name===e?(i=n.state>2&&n.state<5,n.state=6,n.timer.stop(),i&&n.on.call("interrupt",t,t.__data__,n.index,n.group),delete o[r]):a=!1;a&&delete t.__transition}}function Lrt(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function Prt(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function Irt(){}var Nrt=.7,Ort=1/Nrt,Rrt="\\s*([+-]?\\d+)\\s*",zrt="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",Drt="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Brt=/^#([0-9a-f]{3,8})$/,Hrt=new RegExp("^rgb\\("+[Rrt,Rrt,Rrt]+"\\)$"),Frt=new RegExp("^rgb\\("+[Drt,Drt,Drt]+"\\)$"),Vrt=new RegExp("^rgba\\("+[Rrt,Rrt,Rrt,zrt]+"\\)$"),jrt=new RegExp("^rgba\\("+[Drt,Drt,Drt,zrt]+"\\)$"),Urt=new RegExp("^hsl\\("+[zrt,Drt,Drt]+"\\)$"),Grt=new RegExp("^hsla\\("+[zrt,Drt,Drt,zrt]+"\\)$"),Wrt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function qrt(){return this.rgb().formatHex()}function Yrt(){return this.rgb().formatRgb()}function Xrt(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=Brt.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?$rt(e):3===n?new Qrt(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?Krt(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?Krt(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=Hrt.exec(t))?new Qrt(e[1],e[2],e[3],1):(e=Frt.exec(t))?new Qrt(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=Vrt.exec(t))?Krt(e[1],e[2],e[3],e[4]):(e=jrt.exec(t))?Krt(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=Urt.exec(t))?iot(e[1],e[2]/100,e[3]/100,1):(e=Grt.exec(t))?iot(e[1],e[2]/100,e[3]/100,e[4]):Wrt.hasOwnProperty(t)?$rt(Wrt[t]):"transparent"===t?new Qrt(NaN,NaN,NaN,0):null}function $rt(t){return new Qrt(t>>16&255,t>>8&255,255&t,1)}function Krt(t,e,n,i){return i<=0&&(t=e=n=NaN),new Qrt(t,e,n,i)}function Zrt(t){return t instanceof Irt||(t=Xrt(t)),t?new Qrt((t=t.rgb()).r,t.g,t.b,t.opacity):new Qrt}function Jrt(t,e,n,i){return 1===arguments.length?Zrt(t):new Qrt(t,e,n,null==i?1:i)}function Qrt(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function tot(){return"#"+not(this.r)+not(this.g)+not(this.b)}function eot(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function not(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function iot(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new oot(t,e,n,i)}function rot(t){if(t instanceof oot)return new oot(t.h,t.s,t.l,t.opacity);if(t instanceof Irt||(t=Xrt(t)),!t)return new oot;if(t instanceof oot)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new oot(a,s,l,t.opacity)}function oot(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function aot(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}function sot(t){return function(){return t}}function lot(t,e){var n=e-t;return n?(function i(t,e){return function(n){return t+n*e}})(t,n):sot(isNaN(t)?e:t)}Lrt(Irt,Xrt,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:qrt,formatHex:qrt,formatHsl:function cot(){return rot(this).formatHsl()},formatRgb:Yrt,toString:Yrt}),Lrt(Qrt,Jrt,Prt(Irt,{brighter:function(t){return t=null==t?Ort:Math.pow(Ort,t),new Qrt(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?Nrt:Math.pow(Nrt,t),new Qrt(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:tot,formatHex:tot,formatRgb:eot,toString:eot})),Lrt(oot,(function uot(t,e,n,i){return 1===arguments.length?rot(t):new oot(t,e,n,null==i?1:i)}),Prt(Irt,{brighter:function(t){return t=null==t?Ort:Math.pow(Ort,t),new oot(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?Nrt:Math.pow(Nrt,t),new oot(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new Qrt(aot(t>=240?t-240:t+120,r,i),aot(t,r,i),aot(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var hot=(function t(e){var n=(function i(t){return 1==(t=+t)?lot:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):sot(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=Jrt(t)).r,(e=Jrt(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=lot(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function dot(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}var pot=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,fot=new RegExp(pot.source,"g");function mot(t,e){var n,i,r,o=pot.lastIndex=fot.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=pot.exec(t))&&(i=fot.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:dot(n,i)})),o=fot.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}var got,_ot,yot,vot,bot=180/Math.PI,xot={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function wot(t,e,n,i,r,o){var a,s,l;return(a=Math.sqrt(t*t+e*e))&&(t/=a,e/=a),(l=t*n+e*i)&&(n-=t*l,i-=e*l),(s=Math.sqrt(n*n+i*i))&&(n/=s,i/=s,l/=s),t*i<e*n&&(t=-t,e=-e,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(e,t)*bot,skewX:Math.atan(l)*bot,scaleX:a,scaleY:s}}function Sot(t,e,n,i){function r(t){return t.length?t.pop()+" ":""}return function(o,a){var s=[],l=[];return o=t(o),a=t(a),(function c(t,i,r,o,a,s){if(t!==r||i!==o){var l=a.push("translate(",null,e,null,n);s.push({i:l-4,x:dot(t,r)},{i:l-2,x:dot(i,o)})}else(r||o)&&a.push("translate("+r+e+o+n)})(o.translateX,o.translateY,a.translateX,a.translateY,s,l),(function u(t,e,n,o){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),o.push({i:n.push(r(n)+"rotate(",null,i)-2,x:dot(t,e)})):e&&n.push(r(n)+"rotate("+e+i)})(o.rotate,a.rotate,s,l),(function h(t,e,n,o){t!==e?o.push({i:n.push(r(n)+"skewX(",null,i)-2,x:dot(t,e)}):e&&n.push(r(n)+"skewX("+e+i)})(o.skewX,a.skewX,s,l),(function d(t,e,n,i,o,a){if(t!==n||e!==i){var s=o.push(r(o)+"scale(",null,",",null,")");a.push({i:s-4,x:dot(t,n)},{i:s-2,x:dot(e,i)})}else 1===n&&1===i||o.push(r(o)+"scale("+n+","+i+")")})(o.scaleX,o.scaleY,a.scaleX,a.scaleY,s,l),o=a=null,function(t){for(var e,n=-1,i=l.length;++n<i;)s[(e=l[n]).i]=e.x(t);return s.join("")}}}var Mot=Sot((function Eot(t){return"none"===t?xot:(got||(got=document.createElement("DIV"),_ot=document.documentElement,yot=document.defaultView),got.style.transform=t,t=yot.getComputedStyle(_ot.appendChild(got),null).getPropertyValue("transform"),_ot.removeChild(got),wot(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),Tot=Sot((function Aot(t){return null==t?xot:(vot||(vot=document.createElementNS("http://www.w3.org/2000/svg","g")),vot.setAttribute("transform",t),(t=vot.transform.baseVal.consolidate())?wot((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):xot)}),", ",")",")");function Cot(t,e){var n,i;return function(){var r=Art(this,t),o=r.tween;if(o!==n)for(var a=0,s=(i=n=o).length;a<s;++a)if(i[a].name===e){(i=i.slice()).splice(a,1);break}r.tween=i}}function kot(t,e,n){var i,r;if("function"!=typeof n)throw new Error;return function(){var o=Art(this,t),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:e,value:n},l=0,c=r.length;l<c;++l)if(r[l].name===e){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function Lot(t,e,n){var i=t._id;return t.each((function(){var t=Art(this,i);(t.value||(t.value={}))[e]=n.apply(this,arguments)})),function(t){return Crt(t,i).value[e]}}function Pot(t,e){var n;return("number"==typeof e?dot:e instanceof Xrt?hot:(n=Xrt(e))?(e=n,hot):mot)(t,e)}function Iot(t){return function(){this.removeAttribute(t)}}function Not(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Oot(t,e,n){var i,r;return function(){var o=this.getAttribute(t);return o===n?null:o===i?r:r=e(i=o,n)}}function Rot(t,e,n){var i,r;return function(){var o=this.getAttributeNS(t.space,t.local);return o===n?null:o===i?r:r=e(i=o,n)}}function zot(t,e,n){var i,r,o;return function(){var a,s=n(this);if(null!=s)return(a=this.getAttribute(t))===s?null:a===i&&s===r?o:o=e(i=a,r=s);this.removeAttribute(t)}}function Dot(t,e,n){var i,r,o;return function(){var a,s=n(this);if(null!=s)return(a=this.getAttributeNS(t.space,t.local))===s?null:a===i&&s===r?o:o=e(i=a,r=s);this.removeAttributeNS(t.space,t.local)}}function Bot(t,e){function n(){var n=this,i=e.apply(n,arguments);return i&&function(e){n.setAttributeNS(t.space,t.local,i(e))}}return n._value=e,n}function Hot(t,e){function n(){var n=this,i=e.apply(n,arguments);return i&&function(e){n.setAttribute(t,i(e))}}return n._value=e,n}function Fot(t,e){return function(){Trt(this,t).delay=+e.apply(this,arguments)}}function Vot(t,e){return e=+e,function(){Trt(this,t).delay=e}}function jot(t,e){return function(){Art(this,t).duration=+e.apply(this,arguments)}}function Uot(t,e){return e=+e,function(){Art(this,t).duration=e}}function Got(t,e){if("function"!=typeof e)throw new Error;return function(){Art(this,t).ease=e}}function Wot(t,e,n){var i,r,o=(function a(t){return(t+"").trim().split(/^|\s+/).every((function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t}))})(e)?Trt:Art;return function(){var a=o(this,t),s=a.on;s!==i&&(r=(i=s).copy()).on(e,n),a.on=r}}var qot=xit.prototype.constructor;function Yot(t,e,n){function i(){var i=this,r=e.apply(i,arguments);return r&&function(e){i.style.setProperty(t,r(e),n)}}return i._value=e,i}var Xot=0;function $ot(t,e,n,i){this._groups=t,this._parents=e,this._name=n,this._id=i}function Kot(t){return xit().transition(t)}function Zot(){return++Xot}var Jot=xit.prototype;$ot.prototype=Kot.prototype={constructor:$ot,select:function Qot(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=xnt(t));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var s,l,c=i[a],u=c.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=c[d])&&(l=t.call(s,s.__data__,d,c))&&("__data__"in s&&(l.__data__=s.__data__),h[d]=l,Ert(h[d],e,n,d,h,Crt(s,n)));return new $ot(o,this._parents,e,n)},selectAll:function tat(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=Snt(t));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var l,c=i[s],u=c.length,h=0;h<u;++h)if(l=c[h]){for(var d,p=t.call(l,l.__data__,h,c),f=Crt(l,n),m=0,g=p.length;m<g;++m)(d=p[m])&&Ert(d,e,n,m,p,f);o.push(p),a.push(l)}return new $ot(o,a,e,n)},filter:function eat(t){"function"!=typeof t&&(t=Mnt(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new $ot(i,this._parents,this._name,this._id)},merge:function nat(t){if(t._id!==this._id)throw new Error;for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new $ot(o,this._parents,this._name,this._id)},selection:function iat(){return new qot(this._groups,this._parents)},transition:function rat(){for(var t=this._name,e=this._id,n=Zot(),i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)if(a=s[c]){var u=Crt(a,e);Ert(a,t,n,c,s,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new $ot(i,this._parents,t,n)},call:Jot.call,nodes:Jot.nodes,node:Jot.node,size:Jot.size,empty:Jot.empty,each:Jot.each,on:function oat(t,e){var n=this._id;return arguments.length<2?Crt(this.node(),n).on.on(t):this.each(Wot(n,t,e))},attr:function aat(t,e){var n=gnt(t),i="transform"===n?Tot:Pot;return this.attrTween(t,"function"==typeof e?(n.local?Dot:zot)(n,i,Lot(this,"attr."+t,e)):null==e?(n.local?Not:Iot)(n):(n.local?Rot:Oot)(n,i,e+""))},attrTween:function sat(t,e){var n="attr."+t;if(arguments.length<2)return(n=this.tween(n))&&n._value;if(null==e)return this.tween(n,null);if("function"!=typeof e)throw new Error;var i=gnt(t);return this.tween(n,(i.local?Bot:Hot)(i,e))},style:function lat(t,e,n){var i="transform"==(t+="")?Mot:Pot;return null==e?this.styleTween(t,(function o(t,e){var n,i,r;return function(){var o=Fnt(this,t),a=(this.style.removeProperty(t),Fnt(this,t));return o===a?null:o===n&&a===i?r:r=e(n=o,i=a)}})(t,i)).on("end.style."+t,(function r(t){return function(){this.style.removeProperty(t)}})(t)):this.styleTween(t,"function"==typeof e?(function a(t,e,n){var i,r,o;return function(){var a=Fnt(this,t),s=n(this);return null==s&&(this.style.removeProperty(t),s=Fnt(this,t)),a===s?null:a===i&&s===r?o:o=e(i=a,r=s)}})(t,i,Lot(this,"style."+t,e)):(function s(t,e,n){var i,r;return function(){var o=Fnt(this,t);return o===n?null:o===i?r:r=e(i=o,n)}})(t,i,e+""),n)},styleTween:function cat(t,e,n){var i="style."+(t+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==e)return this.tween(i,null);if("function"!=typeof e)throw new Error;return this.tween(i,Yot(t,e,null==n?"":n))},text:function uat(t){return this.tween("text","function"==typeof t?(function e(t){return function(){var e=t(this);this.textContent=null==e?"":e}})(Lot(this,"text",t)):(function n(t){return function(){this.textContent=t}})(null==t?"":t+""))},remove:function hat(){return this.on("end.remove",(function t(e){return function(){var t=this.parentNode;for(var n in this.__transition)if(+n!==e)return;t&&t.removeChild(this)}})(this._id))},tween:function dat(t,e){var n=this._id;if(t+="",arguments.length<2){for(var i,r=Crt(this.node(),n).tween,o=0,a=r.length;o<a;++o)if((i=r[o]).name===t)return i.value;return null}return this.each((null==e?Cot:kot)(n,t,e))},delay:function pat(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?Fot:Vot)(e,t)):Crt(this.node(),e).delay},duration:function fat(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?jot:Uot)(e,t)):Crt(this.node(),e).duration},ease:function mat(t){var e=this._id;return arguments.length?this.each(Got(e,t)):Crt(this.node(),e).ease}};var gat={time:null,delay:0,duration:250,ease:Tf};function _at(t,e){for(var n;!(n=t.__transition)||!(n=n[e]);)if(!(t=t.parentNode))return gat.time=mrt(),gat;return n}xit.prototype.interrupt=function yat(t){return this.each((function(){krt(this,t)}))},xit.prototype.transition=function vat(t){var e,n;t instanceof $ot?(e=t._id,t=t._name):(e=Zot(),(n=gat).time=mrt(),t=null==t?null:t+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)(a=s[c])&&Ert(a,t,e,c,s,n||_at(a,e));return new $ot(i,this._parents,t,e)};var bat=[null];function xat(t){return function(){return t}}function wat(t){return t[0]}function Sat(t){return t[1]}function Mat(){this._=null}function Eat(t){t.U=t.C=t.L=t.R=t.P=t.N=null}function Tat(t,e){var n=e,i=e.R,r=n.U;r?r.L===n?r.L=i:r.R=i:t._=i,i.U=r,n.U=i,n.R=i.L,n.R&&(n.R.U=n),i.L=n}function Aat(t,e){var n=e,i=e.L,r=n.U;r?r.L===n?r.L=i:r.R=i:t._=i,i.U=r,n.U=i,n.L=i.R,n.L&&(n.L.U=n),i.R=n}function Cat(t){for(;t.L;)t=t.L;return t}function kat(t,e,n,i){var r=[null,null],o=Qat.push(r)-1;return r.left=t,r.right=e,n&&Pat(r,t,e,n),i&&Pat(r,e,t,i),Zat[t.index].halfedges.push(o),Zat[e.index].halfedges.push(o),r}function Lat(t,e,n){var i=[e,n];return i.left=t,i}function Pat(t,e,n,i){t[0]||t[1]?t.left===n?t[1]=i:t[0]=i:(t[0]=i,t.left=e,t.right=n)}function Iat(t,e,n,i,r){var o,a=t[0],s=t[1],l=a[0],c=a[1],u=0,h=1,d=s[0]-l,p=s[1]-c;if(o=e-l,d||!(o>0)){if(o/=d,d<0){if(o<u)return;o<h&&(h=o)}else if(d>0){if(o>h)return;o>u&&(u=o)}if(o=i-l,d||!(o<0)){if(o/=d,d<0){if(o>h)return;o>u&&(u=o)}else if(d>0){if(o<u)return;o<h&&(h=o)}if(o=n-c,p||!(o>0)){if(o/=p,p<0){if(o<u)return;o<h&&(h=o)}else if(p>0){if(o>h)return;o>u&&(u=o)}if(o=r-c,p||!(o<0)){if(o/=p,p<0){if(o>h)return;o>u&&(u=o)}else if(p>0){if(o<u)return;o<h&&(h=o)}return!(u>0||h<1)||(u>0&&(t[0]=[l+u*d,c+u*p]),h<1&&(t[1]=[l+h*d,c+h*p]),!0)}}}}}function Nat(t,e,n,i,r){var o=t[1];if(o)return!0;var a,s,l=t[0],c=t.left,u=t.right,h=c[0],d=c[1],p=u[0],f=u[1],m=(h+p)/2;if(f===d){if(m<e||m>=i)return;if(h>p){if(l){if(l[1]>=r)return}else l=[m,n];o=[m,r]}else{if(l){if(l[1]<n)return}else l=[m,r];o=[m,n]}}else if(s=(d+f)/2-(a=(h-p)/(f-d))*m,a<-1||a>1)if(h>p){if(l){if(l[1]>=r)return}else l=[(n-s)/a,n];o=[(r-s)/a,r]}else{if(l){if(l[1]<n)return}else l=[(r-s)/a,r];o=[(n-s)/a,n]}else if(d<f){if(l){if(l[0]>=i)return}else l=[e,a*e+s];o=[i,a*i+s]}else{if(l){if(l[0]<e)return}else l=[i,a*i+s];o=[e,a*e+s]}return t[0]=l,t[1]=o,!0}function Oat(t,e){var n=t.site,i=e.left,r=e.right;return n===r&&(r=i,i=n),r?Math.atan2(r[1]-i[1],r[0]-i[0]):(n===i?(i=e[1],r=e[0]):(i=e[0],r=e[1]),Math.atan2(i[0]-r[0],r[1]-i[1]))}function Rat(t,e){return e[+(e.left!==t.site)]}function zat(t,e){return e[+(e.left===t.site)]}Mat.prototype={constructor:Mat,insert:function(t,e){var n,i,r;if(t){if(e.P=t,e.N=t.N,t.N&&(t.N.P=e),t.N=e,t.R){for(t=t.R;t.L;)t=t.L;t.L=e}else t.R=e;n=t}else this._?(t=Cat(this._),e.P=null,e.N=t,t.P=t.L=e,n=t):(e.P=e.N=null,this._=e,n=null);for(e.L=e.R=null,e.U=n,e.C=!0,t=e;n&&n.C;)n===(i=n.U).L?(r=i.R)&&r.C?(n.C=r.C=!1,i.C=!0,t=i):(t===n.R&&(Tat(this,n),n=(t=n).U),n.C=!1,i.C=!0,Aat(this,i)):(r=i.L)&&r.C?(n.C=r.C=!1,i.C=!0,t=i):(t===n.L&&(Aat(this,n),n=(t=n).U),n.C=!1,i.C=!0,Tat(this,i)),n=t.U;this._.C=!1},remove:function(t){t.N&&(t.N.P=t.P),t.P&&(t.P.N=t.N),t.N=t.P=null;var e,n,i,r=t.U,o=t.L,a=t.R;if(n=o?a?Cat(a):o:a,r?r.L===t?r.L=n:r.R=n:this._=n,o&&a?(i=n.C,n.C=t.C,n.L=o,o.U=n,n!==a?(r=n.U,n.U=t.U,r.L=t=n.R,n.R=a,a.U=n):(n.U=r,r=n,t=n.R)):(i=t.C,t=n),t&&(t.U=r),!i)if(t&&t.C)t.C=!1;else{do{if(t===this._)break;if(t===r.L){if((e=r.R).C&&(e.C=!1,r.C=!0,Tat(this,r),e=r.R),e.L&&e.L.C||e.R&&e.R.C){e.R&&e.R.C||(e.L.C=!1,e.C=!0,Aat(this,e),e=r.R),e.C=r.C,r.C=e.R.C=!1,Tat(this,r),t=this._;break}}else if((e=r.L).C&&(e.C=!1,r.C=!0,Aat(this,r),e=r.L),e.L&&e.L.C||e.R&&e.R.C){e.L&&e.L.C||(e.R.C=!1,e.C=!0,Tat(this,e),e=r.L),e.C=r.C,r.C=e.L.C=!1,Aat(this,r),t=this._;break}e.C=!0,t=r,r=r.U}while(!t.C);t&&(t.C=!1)}}};var Dat,Bat=[];function Hat(){Eat(this),this.x=this.y=this.arc=this.site=this.cy=null}function Fat(t){var e=t.P,n=t.N;if(e&&n){var i=e.site,r=t.site,o=n.site;if(i!==o){var a=r[0],s=r[1],l=i[0]-a,c=i[1]-s,u=o[0]-a,h=o[1]-s,d=2*(l*h-c*u);if(!(d>=-est)){var p=l*l+c*c,f=u*u+h*h,m=(h*p-c*f)/d,g=(l*f-u*p)/d,_=Bat.pop()||new Hat;_.arc=t,_.site=r,_.x=m+a,_.y=(_.cy=g+s)+Math.sqrt(m*m+g*g),t.circle=_;for(var y=null,v=Jat._;v;)if(_.y<v.y||_.y===v.y&&_.x<=v.x){if(!v.L){y=v.P;break}v=v.L}else{if(!v.R){y=v;break}v=v.R}Jat.insert(y,_),y||(Dat=_)}}}}function Vat(t){var e=t.circle;e&&(e.P||(Dat=e.N),Jat.remove(e),Bat.push(e),Eat(e),t.circle=null)}var jat=[];function Uat(){Eat(this),this.edge=this.site=this.circle=null}function Gat(t){var e=jat.pop()||new Uat;return e.site=t,e}function Wat(t){Vat(t),Kat.remove(t),jat.push(t),Eat(t)}function qat(t){var e=t.circle,n=e.x,i=e.cy,r=[n,i],o=t.P,a=t.N,s=[t];Wat(t);for(var l=o;l.circle&&Math.abs(n-l.circle.x)<tst&&Math.abs(i-l.circle.cy)<tst;)o=l.P,s.unshift(l),Wat(l),l=o;s.unshift(l),Vat(l);for(var c=a;c.circle&&Math.abs(n-c.circle.x)<tst&&Math.abs(i-c.circle.cy)<tst;)a=c.N,s.push(c),Wat(c),c=a;s.push(c),Vat(c);var u,h=s.length;for(u=1;u<h;++u)Pat((c=s[u]).edge,(l=s[u-1]).site,c.site,r);(c=s[h-1]).edge=kat((l=s[0]).site,c.site,null,r),Fat(l),Fat(c)}function Yat(t){for(var e,n,i,r,o=t[0],a=t[1],s=Kat._;s;)if((i=Xat(s,a)-o)>tst)s=s.L;else{if(!((r=o-$at(s,a))>tst)){i>-tst?(e=s.P,n=s):r>-tst?(e=s,n=s.N):e=n=s;break}if(!s.R){e=s;break}s=s.R}!(function l(t){Zat[t.index]={site:t,halfedges:[]}})(t);var c=Gat(t);if(Kat.insert(e,c),e||n){if(e===n)return Vat(e),n=Gat(e.site),Kat.insert(c,n),c.edge=n.edge=kat(e.site,c.site),Fat(e),void Fat(n);if(n){Vat(e),Vat(n);var u=e.site,h=u[0],d=u[1],p=t[0]-h,f=t[1]-d,m=n.site,g=m[0]-h,_=m[1]-d,y=2*(p*_-f*g),v=p*p+f*f,b=g*g+_*_,x=[(_*v-f*b)/y+h,(p*b-g*v)/y+d];Pat(n.edge,u,m,x),c.edge=kat(u,t,null,x),n.edge=kat(t,m,null,x),Fat(e),Fat(n)}else c.edge=kat(e.site,c.site)}}function Xat(t,e){var n=t.site,i=n[0],r=n[1],o=r-e;if(!o)return i;var a=t.P;if(!a)return-1/0;var s=(n=a.site)[0],l=n[1],c=l-e;if(!c)return s;var u=s-i,h=1/o-1/c,d=u/c;return h?(-d+Math.sqrt(d*d-2*h*(u*u/(-2*c)-l+c/2+r-o/2)))/h+i:(i+s)/2}function $at(t,e){var n=t.N;if(n)return Xat(n,e);var i=t.site;return i[1]===e?i[0]:1/0}var Kat,Zat,Jat,Qat,tst=1e-6,est=1e-12;function nst(t,e,n){return(t[0]-n[0])*(e[1]-t[1])-(t[0]-e[0])*(n[1]-t[1])}function ist(t,e){return e[1]-t[1]||e[0]-t[0]}function rst(t,e){var n,i,r,o=t.sort(ist).pop();for(Qat=[],Zat=new Array(t.length),Kat=new Mat,Jat=new Mat;;)if(r=Dat,o&&(!r||o[1]<r.y||o[1]===r.y&&o[0]<r.x))o[0]===n&&o[1]===i||(Yat(o),n=o[0],i=o[1]),o=t.pop();else{if(!r)break;qat(r.arc)}if((function a(){for(var t,e,n,i,r=0,o=Zat.length;r<o;++r)if((t=Zat[r])&&(i=(e=t.halfedges).length)){var a=new Array(i),s=new Array(i);for(n=0;n<i;++n)a[n]=n,s[n]=Oat(t,Qat[e[n]]);for(a.sort((function(t,e){return s[e]-s[t]})),n=0;n<i;++n)s[n]=e[a[n]];for(n=0;n<i;++n)e[n]=s[n]}})(),e){var s=+e[0][0],l=+e[0][1],c=+e[1][0],u=+e[1][1];!(function h(t,e,n,i){for(var r,o=Qat.length;o--;)Nat(r=Qat[o],t,e,n,i)&&Iat(r,t,e,n,i)&&(Math.abs(r[0][0]-r[1][0])>tst||Math.abs(r[0][1]-r[1][1])>tst)||delete Qat[o]})(s,l,c,u),(function d(t,e,n,i){var r,o,a,s,l,c,u,h,d,p,f,m,g=Zat.length,_=!0;for(r=0;r<g;++r)if(o=Zat[r]){for(a=o.site,s=(l=o.halfedges).length;s--;)Qat[l[s]]||l.splice(s,1);for(s=0,c=l.length;s<c;)f=(p=zat(o,Qat[l[s]]))[0],m=p[1],h=(u=Rat(o,Qat[l[++s%c]]))[0],d=u[1],(Math.abs(f-h)>tst||Math.abs(m-d)>tst)&&(l.splice(s,0,Qat.push(Lat(a,p,Math.abs(f-t)<tst&&i-m>tst?[t,Math.abs(h-t)<tst?d:i]:Math.abs(m-i)<tst&&n-f>tst?[Math.abs(d-i)<tst?h:n,i]:Math.abs(f-n)<tst&&m-e>tst?[n,Math.abs(h-n)<tst?d:e]:Math.abs(m-e)<tst&&f-t>tst?[Math.abs(d-e)<tst?h:t,e]:null))-1),++c);c&&(_=!1)}if(_){var y,v,b,x=1/0;for(r=0,_=null;r<g;++r)(o=Zat[r])&&(b=(y=(a=o.site)[0]-t)*y+(v=a[1]-e)*v)<x&&(x=b,_=o);if(_){var w=[t,e],S=[t,i],M=[n,i],E=[n,e];_.halfedges.push(Qat.push(Lat(a=_.site,w,S))-1,Qat.push(Lat(a,S,M))-1,Qat.push(Lat(a,M,E))-1,Qat.push(Lat(a,E,w))-1)}}for(r=0;r<g;++r)(o=Zat[r])&&(o.halfedges.length||delete Zat[r])})(s,l,c,u)}this.edges=Qat,this.cells=Zat,Kat=Jat=Qat=Zat=null}rst.prototype={constructor:rst,polygons:function(){var t=this.edges;return this.cells.map((function(e){var n=e.halfedges.map((function(n){return Rat(e,t[n])}));return n.data=e.site.data,n}))},triangles:function(){var t=[],e=this.edges;return this.cells.forEach((function(n,i){if(o=(r=n.halfedges).length)for(var r,o,a,s=n.site,l=-1,c=e[r[o-1]],u=c.left===s?c.right:c.left;++l<o;)a=u,u=(c=e[r[l]]).left===s?c.right:c.left,a&&u&&i<a.index&&i<u.index&&nst(s,a,u)<0&&t.push([s.data,a.data,u.data])})),t},links:function(){return this.edges.filter((function(t){return t.right})).map((function(t){return{source:t.left.data,target:t.right.data}}))},find:function(t,e,n){for(var i,r,o=this,a=o._found||0,s=o.cells.length;!(r=o.cells[a]);)if(++a>=s)return null;var l=t-r.site[0],c=e-r.site[1],u=l*l+c*c;do{r=o.cells[i=a],a=null,r.halfedges.forEach((function(n){var i=o.edges[n],s=i.left;if(s!==r.site&&s||(s=i.right)){var l=t-s[0],c=e-s[1],h=l*l+c*c;h<u&&(u=h,a=s.index)}}))}while(null!==a);return o._found=i,null==n||u<=n*n?r.site:null}};var ost={value:function(){}};function ast(){for(var t,e=0,n=arguments.length,i={};e<n;++e){if(!(t=arguments[e]+"")||t in i||/[\s.]/.test(t))throw new Error("illegal type: "+t);i[t]=[]}return new sst(i)}function sst(t){this._=t}function lst(t,e){return t.trim().split(/^|\s+/).map((function(t){var n="",i=t.indexOf(".");if(i>=0&&(n=t.slice(i+1),t=t.slice(0,i)),t&&!e.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))}function cst(t,e){for(var n,i=0,r=t.length;i<r;++i)if((n=t[i]).name===e)return n.value}function ust(t,e,n){for(var i=0,r=t.length;i<r;++i)if(t[i].name===e){t[i]=ost,t=t.slice(0,i).concat(t.slice(i+1));break}return null!=n&&t.push({name:e,value:n}),t}sst.prototype=ast.prototype={constructor:sst,on:function(t,e){var n,i=this._,r=lst(t+"",i),o=-1,a=r.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++o<a;)if(n=(t=r[o]).type)i[n]=ust(i[n],t.name,e);else if(null==e)for(n in i)i[n]=ust(i[n],t.name,null);return this}for(;++o<a;)if((n=(t=r[o]).type)&&(n=cst(i[n],t.name)))return n},copy:function(){var t={},e=this._;for(var n in e)t[n]=e[n].slice();return new sst(t)},call:function(t,e){if((n=arguments.length-2)>0)for(var n,i,r=new Array(n),o=0;o<n;++o)r[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,n=(i=this._[t]).length;o<n;++o)i[o].value.apply(e,r)},apply:function(t,e,n){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var i=this._[t],r=0,o=i.length;r<o;++r)i[r].value.apply(e,n)}};var hst="http://www.w3.org/1999/xhtml",dst={svg:"http://www.w3.org/2000/svg",xhtml:hst,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function pst(t){var e=t+="",n=e.indexOf(":");return n>=0&&"xmlns"!==(e=t.slice(0,n))&&(t=t.slice(n+1)),dst.hasOwnProperty(e)?{space:dst[e],local:t}:t}function fst(t){return function(){var e=this.ownerDocument,n=this.namespaceURI;return n===hst&&e.documentElement.namespaceURI===hst?e.createElement(t):e.createElementNS(n,t)}}function mst(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function gst(t){var e=pst(t);return(e.local?mst:fst)(e)}function _st(){}function yst(t){return null==t?_st:function(){return this.querySelector(t)}}function vst(){return[]}function bst(t){return null==t?vst:function(){return this.querySelectorAll(t)}}function xst(t){return function(){return this.matches(t)}}function wst(t){return new Array(t.length)}function Sst(t,e){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=e}function Mst(t,e,n,i,r,o){for(var a,s=0,l=e.length,c=o.length;s<c;++s)(a=e[s])?(a.__data__=o[s],i[s]=a):n[s]=new Sst(t,o[s]);for(;s<l;++s)(a=e[s])&&(r[s]=a)}function Est(t,e,n,i,r,o,a){var s,l,c,u={},h=e.length,d=o.length,p=new Array(h);for(s=0;s<h;++s)(l=e[s])&&(p[s]=c="$"+a.call(l,l.__data__,s,e),c in u?r[s]=l:u[c]=l);for(s=0;s<d;++s)(l=u[c="$"+a.call(t,o[s],s,o)])?(i[s]=l,l.__data__=o[s],u[c]=null):n[s]=new Sst(t,o[s]);for(s=0;s<h;++s)(l=e[s])&&u[p[s]]===l&&(r[s]=l)}function Tst(t,e){return t<e?-1:t>e?1:t>=e?0:NaN}function Ast(t){return function(){this.removeAttribute(t)}}function Cst(t){return function(){this.removeAttributeNS(t.space,t.local)}}function kst(t,e){return function(){this.setAttribute(t,e)}}function Lst(t,e){return function(){this.setAttributeNS(t.space,t.local,e)}}function Pst(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttribute(t):this.setAttribute(t,n)}}function Ist(t,e){return function(){var n=e.apply(this,arguments);null==n?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,n)}}function Nst(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function Ost(t){return function(){this.style.removeProperty(t)}}function Rst(t,e,n){return function(){this.style.setProperty(t,e,n)}}function zst(t,e,n){return function(){var i=e.apply(this,arguments);null==i?this.style.removeProperty(t):this.style.setProperty(t,i,n)}}function Dst(t,e){return t.style.getPropertyValue(e)||Nst(t).getComputedStyle(t,null).getPropertyValue(e)}function Bst(t){return function(){delete this[t]}}function Hst(t,e){return function(){this[t]=e}}function Fst(t,e){return function(){var n=e.apply(this,arguments);null==n?delete this[t]:this[t]=n}}function Vst(t){return t.trim().split(/^|\s+/)}function jst(t){return t.classList||new Ust(t)}function Ust(t){this._node=t,this._names=Vst(t.getAttribute("class")||"")}function Gst(t,e){for(var n=jst(t),i=-1,r=e.length;++i<r;)n.add(e[i])}function Wst(t,e){for(var n=jst(t),i=-1,r=e.length;++i<r;)n.remove(e[i])}function qst(t){return function(){Gst(this,t)}}function Yst(t){return function(){Wst(this,t)}}function Xst(t,e){return function(){(e.apply(this,arguments)?Gst:Wst)(this,t)}}function $st(){this.textContent=""}function Kst(t){return function(){this.textContent=t}}function Zst(t){return function(){var e=t.apply(this,arguments);this.textContent=null==e?"":e}}function Jst(){this.innerHTML=""}function Qst(t){return function(){this.innerHTML=t}}function tlt(t){return function(){var e=t.apply(this,arguments);this.innerHTML=null==e?"":e}}function elt(){this.nextSibling&&this.parentNode.appendChild(this)}function nlt(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function ilt(){return null}function rlt(){var t=this.parentNode;t&&t.removeChild(this)}function olt(){var t=this.cloneNode(!1),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}function alt(){var t=this.cloneNode(!0),e=this.parentNode;return e?e.insertBefore(t,this.nextSibling):t}Sst.prototype={constructor:Sst,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,e){return this._parent.insertBefore(t,e)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},Ust.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var e=this._names.indexOf(t);e>=0&&(this._names.splice(e,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var slt={},llt=null;function clt(t,e,n){return t=ult(t,e,n),function(e){var n=e.relatedTarget;n&&(n===this||8&n.compareDocumentPosition(this))||t.call(this,e)}}function ult(t,e,n){return function(i){var r=llt;llt=i;try{t.call(this,this.__data__,e,n)}finally{llt=r}}}function hlt(t){return t.trim().split(/^|\s+/).map((function(t){var e="",n=t.indexOf(".");return n>=0&&(e=t.slice(n+1),t=t.slice(0,n)),{type:t,name:e}}))}function dlt(t){return function(){var e=this.__on;if(e){for(var n,i=0,r=-1,o=e.length;i<o;++i)n=e[i],t.type&&n.type!==t.type||n.name!==t.name?e[++r]=n:this.removeEventListener(n.type,n.listener,n.capture);++r?e.length=r:delete this.__on}}}function plt(t,e,n){var i=slt.hasOwnProperty(t.type)?clt:ult;return function(r,o,a){var s,l=this.__on,c=i(e,o,a);if(l)for(var u=0,h=l.length;u<h;++u)if((s=l[u]).type===t.type&&s.name===t.name)return this.removeEventListener(s.type,s.listener,s.capture),this.addEventListener(s.type,s.listener=c,s.capture=n),void(s.value=e);this.addEventListener(t.type,c,n),s={type:t.type,name:t.name,value:e,listener:c,capture:n},l?l.push(s):this.__on=[s]}}function flt(t,e,n){var i=Nst(t),r=i.CustomEvent;"function"==typeof r?r=new r(e,n):(r=i.document.createEvent("Event"),n?(r.initEvent(e,n.bubbles,n.cancelable),r.detail=n.detail):r.initEvent(e,!1,!1)),t.dispatchEvent(r)}function mlt(t,e){return function(){return flt(this,t,e)}}function glt(t,e){return function(){return flt(this,t,e.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(slt={mouseenter:"mouseover",mouseleave:"mouseout"}));var _lt=[null];function ylt(t,e){this._groups=t,this._parents=e}function vlt(){return new ylt([[document.documentElement]],_lt)}function blt(t){return"string"==typeof t?new ylt([[document.querySelector(t)]],[document.documentElement]):new ylt([[t]],_lt)}function xlt(){for(var t,e=llt;t=e.sourceEvent;)e=t;return e}function wlt(t,e){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var i=n.createSVGPoint();return i.x=e.clientX,i.y=e.clientY,[(i=i.matrixTransform(t.getScreenCTM().inverse())).x,i.y]}var r=t.getBoundingClientRect();return[e.clientX-r.left-t.clientLeft,e.clientY-r.top-t.clientTop]}function Slt(t){var e=xlt();return e.changedTouches&&(e=e.changedTouches[0]),wlt(t,e)}function Mlt(t,e,n){arguments.length<3&&(n=e,e=xlt().changedTouches);for(var i,r=0,o=e?e.length:0;r<o;++r)if((i=e[r]).identifier===n)return wlt(t,i);return null}function Elt(){llt.preventDefault(),llt.stopImmediatePropagation()}function Tlt(t){var e=t.document.documentElement,n=blt(t).on("dragstart.drag",Elt,!0);"onselectstart"in e?n.on("selectstart.drag",Elt,!0):(e.__noselect=e.style.MozUserSelect,e.style.MozUserSelect="none")}function Alt(t,e){var n=t.document.documentElement,i=blt(t).on("dragstart.drag",null);e&&(i.on("click.drag",Elt,!0),setTimeout((function(){i.on("click.drag",null)}),0)),"onselectstart"in n?i.on("selectstart.drag",null):(n.style.MozUserSelect=n.__noselect,delete n.__noselect)}function Clt(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function klt(t,e){var n=Object.create(t.prototype);for(var i in e)n[i]=e[i];return n}function Llt(){}ylt.prototype=vlt.prototype={constructor:ylt,select:function Plt(t){"function"!=typeof t&&(t=yst(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a,s=e[r],l=s.length,c=i[r]=new Array(l),u=0;u<l;++u)(o=s[u])&&(a=t.call(o,o.__data__,u,s))&&("__data__"in o&&(a.__data__=o.__data__),c[u]=a);return new ylt(i,this._parents)},selectAll:function Ilt(t){"function"!=typeof t&&(t=bst(t));for(var e=this._groups,n=e.length,i=[],r=[],o=0;o<n;++o)for(var a,s=e[o],l=s.length,c=0;c<l;++c)(a=s[c])&&(i.push(t.call(a,a.__data__,c,s)),r.push(a));return new ylt(i,r)},filter:function Nlt(t){"function"!=typeof t&&(t=xst(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new ylt(i,this._parents)},data:function Olt(t,e){if(!t)return f=new Array(this.size()),u=-1,this.each((function(t){f[++u]=t})),f;var n=e?Est:Mst,i=this._parents,r=this._groups;"function"!=typeof t&&(t=(function o(t){return function(){return t}})(t));for(var a=r.length,s=new Array(a),l=new Array(a),c=new Array(a),u=0;u<a;++u){var h=i[u],d=r[u],p=d.length,f=t.call(h,h&&h.__data__,u,i),m=f.length,g=l[u]=new Array(m),_=s[u]=new Array(m);n(h,d,g,_,c[u]=new Array(p),f,e);for(var y,v,b=0,x=0;b<m;++b)if(y=g[b]){for(b>=x&&(x=b+1);!(v=_[x])&&++x<m;);y._next=v||null}}return(s=new ylt(s,i))._enter=l,s._exit=c,s},enter:function Rlt(){return new ylt(this._enter||this._groups.map(wst),this._parents)},exit:function zlt(){return new ylt(this._exit||this._groups.map(wst),this._parents)},join:function Dlt(t,e,n){var i=this.enter(),r=this,o=this.exit();return i="function"==typeof t?t(i):i.append(t+""),null!=e&&(r=e(r)),null==n?o.remove():n(o),i&&r?i.merge(r).order():r},merge:function Blt(t){for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new ylt(o,this._parents)},order:function Hlt(){for(var t=this._groups,e=-1,n=t.length;++e<n;)for(var i,r=t[e],o=r.length-1,a=r[o];--o>=0;)(i=r[o])&&(a&&4^i.compareDocumentPosition(a)&&a.parentNode.insertBefore(i,a),a=i);return this},sort:function Flt(t){function e(e,n){return e&&n?t(e.__data__,n.__data__):!e-!n}t||(t=Tst);for(var n=this._groups,i=n.length,r=new Array(i),o=0;o<i;++o){for(var a,s=n[o],l=s.length,c=r[o]=new Array(l),u=0;u<l;++u)(a=s[u])&&(c[u]=a);c.sort(e)}return new ylt(r,this._parents).order()},call:function Vlt(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function jlt(){var t=new Array(this.size()),e=-1;return this.each((function(){t[++e]=this})),t},node:function Ult(){for(var t=this._groups,e=0,n=t.length;e<n;++e)for(var i=t[e],r=0,o=i.length;r<o;++r){var a=i[r];if(a)return a}return null},size:function Glt(){var t=0;return this.each((function(){++t})),t},empty:function Wlt(){return!this.node()},each:function qlt(t){for(var e=this._groups,n=0,i=e.length;n<i;++n)for(var r,o=e[n],a=0,s=o.length;a<s;++a)(r=o[a])&&t.call(r,r.__data__,a,o);return this},attr:function Ylt(t,e){var n=pst(t);if(arguments.length<2){var i=this.node();return n.local?i.getAttributeNS(n.space,n.local):i.getAttribute(n)}return this.each((null==e?n.local?Cst:Ast:"function"==typeof e?n.local?Ist:Pst:n.local?Lst:kst)(n,e))},style:function Xlt(t,e,n){return arguments.length>1?this.each((null==e?Ost:"function"==typeof e?zst:Rst)(t,e,null==n?"":n)):Dst(this.node(),t)},property:function $lt(t,e){return arguments.length>1?this.each((null==e?Bst:"function"==typeof e?Fst:Hst)(t,e)):this.node()[t]},classed:function Klt(t,e){var n=Vst(t+"");if(arguments.length<2){for(var i=jst(this.node()),r=-1,o=n.length;++r<o;)if(!i.contains(n[r]))return!1;return!0}return this.each(("function"==typeof e?Xst:e?qst:Yst)(n,e))},text:function Zlt(t){return arguments.length?this.each(null==t?$st:("function"==typeof t?Zst:Kst)(t)):this.node().textContent},html:function Jlt(t){return arguments.length?this.each(null==t?Jst:("function"==typeof t?tlt:Qst)(t)):this.node().innerHTML},raise:function Qlt(){return this.each(elt)},lower:function tct(){return this.each(nlt)},append:function ect(t){var e="function"==typeof t?t:gst(t);return this.select((function(){return this.appendChild(e.apply(this,arguments))}))},insert:function nct(t,e){var n="function"==typeof t?t:gst(t),i=null==e?ilt:"function"==typeof e?e:yst(e);return this.select((function(){return this.insertBefore(n.apply(this,arguments),i.apply(this,arguments)||null)}))},remove:function ict(){return this.each(rlt)},clone:function rct(t){return this.select(t?alt:olt)},datum:function oct(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function act(t,e,n){var i,r,o=hlt(t+""),a=o.length;if(!(arguments.length<2)){for(s=e?plt:dlt,null==n&&(n=!1),i=0;i<a;++i)this.each(s(o[i],e,n));return this}var s=this.node().__on;if(s)for(var l,c=0,u=s.length;c<u;++c)for(i=0,l=s[c];i<a;++i)if((r=o[i]).type===l.type&&r.name===l.name)return l.value},dispatch:function sct(t,e){return this.each(("function"==typeof e?glt:mlt)(t,e))}};var lct=.7,cct=1/lct,uct="\\s*([+-]?\\d+)\\s*",hct="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",dct="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",pct=/^#([0-9a-f]{3,8})$/,fct=new RegExp("^rgb\\("+[uct,uct,uct]+"\\)$"),mct=new RegExp("^rgb\\("+[dct,dct,dct]+"\\)$"),gct=new RegExp("^rgba\\("+[uct,uct,uct,hct]+"\\)$"),_ct=new RegExp("^rgba\\("+[dct,dct,dct,hct]+"\\)$"),yct=new RegExp("^hsl\\("+[hct,dct,dct]+"\\)$"),vct=new RegExp("^hsla\\("+[hct,dct,dct,hct]+"\\)$"),bct={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function xct(){return this.rgb().formatHex()}function wct(){return this.rgb().formatRgb()}function Sct(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=pct.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?Mct(e):3===n?new Cct(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?Ect(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?Ect(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=fct.exec(t))?new Cct(e[1],e[2],e[3],1):(e=mct.exec(t))?new Cct(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=gct.exec(t))?Ect(e[1],e[2],e[3],e[4]):(e=_ct.exec(t))?Ect(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=yct.exec(t))?Ict(e[1],e[2]/100,e[3]/100,1):(e=vct.exec(t))?Ict(e[1],e[2]/100,e[3]/100,e[4]):bct.hasOwnProperty(t)?Mct(bct[t]):"transparent"===t?new Cct(NaN,NaN,NaN,0):null}function Mct(t){return new Cct(t>>16&255,t>>8&255,255&t,1)}function Ect(t,e,n,i){return i<=0&&(t=e=n=NaN),new Cct(t,e,n,i)}function Tct(t){return t instanceof Llt||(t=Sct(t)),t?new Cct((t=t.rgb()).r,t.g,t.b,t.opacity):new Cct}function Act(t,e,n,i){return 1===arguments.length?Tct(t):new Cct(t,e,n,null==i?1:i)}function Cct(t,e,n,i){this.r=+t,this.g=+e,this.b=+n,this.opacity=+i}function kct(){return"#"+Pct(this.r)+Pct(this.g)+Pct(this.b)}function Lct(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function Pct(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function Ict(t,e,n,i){return i<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new Oct(t,e,n,i)}function Nct(t){if(t instanceof Oct)return new Oct(t.h,t.s,t.l,t.opacity);if(t instanceof Llt||(t=Sct(t)),!t)return new Oct;if(t instanceof Oct)return t;var e=(t=t.rgb()).r/255,n=t.g/255,i=t.b/255,r=Math.min(e,n,i),o=Math.max(e,n,i),a=NaN,s=o-r,l=(o+r)/2;return s?(a=e===o?(n-i)/s+6*(n<i):n===o?(i-e)/s+2:(e-n)/s+4,s/=l<.5?o+r:2-o-r,a*=60):s=l>0&&l<1?0:a,new Oct(a,s,l,t.opacity)}function Oct(t,e,n,i){this.h=+t,this.s=+e,this.l=+n,this.opacity=+i}function Rct(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}function zct(t){return function(){return t}}function Dct(t,e){var n=e-t;return n?(function i(t,e){return function(n){return t+n*e}})(t,n):zct(isNaN(t)?e:t)}Clt(Llt,Sct,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:xct,formatHex:xct,formatHsl:function Bct(){return Nct(this).formatHsl()},formatRgb:wct,toString:wct}),Clt(Cct,Act,klt(Llt,{brighter:function(t){return t=null==t?cct:Math.pow(cct,t),new Cct(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?lct:Math.pow(lct,t),new Cct(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:kct,formatHex:kct,formatRgb:Lct,toString:Lct})),Clt(Oct,(function Hct(t,e,n,i){return 1===arguments.length?Nct(t):new Oct(t,e,n,null==i?1:i)}),klt(Llt,{brighter:function(t){return t=null==t?cct:Math.pow(cct,t),new Oct(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?lct:Math.pow(lct,t),new Oct(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,i=n+(n<.5?n:1-n)*e,r=2*n-i;return new Cct(Rct(t>=240?t-240:t+120,r,i),Rct(t,r,i),Rct(t<120?t+240:t-120,r,i),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var Fct=(function t(e){var n=(function i(t){return 1==(t=+t)?Dct:function(e,n){return n-e?(function i(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(i){return Math.pow(t+i*e,n)}})(e,n,t):zct(isNaN(e)?n:e)}})(e);function r(t,e){var i=n((t=Act(t)).r,(e=Act(e)).r),r=n(t.g,e.g),o=n(t.b,e.b),a=Dct(t.opacity,e.opacity);return function(e){return t.r=i(e),t.g=r(e),t.b=o(e),t.opacity=a(e),t+""}}return r.gamma=t,r})(1);function Vct(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}var jct=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Uct=new RegExp(jct.source,"g");function Gct(t,e){var n,i,r,o=jct.lastIndex=Uct.lastIndex=0,a=-1,s=[],l=[];for(t+="",e+="";(n=jct.exec(t))&&(i=Uct.exec(e));)(r=i.index)>o&&(r=e.slice(o,r),s[a]?s[a]+=r:s[++a]=r),(n=n[0])===(i=i[0])?s[a]?s[a]+=i:s[++a]=i:(s[++a]=null,l.push({i:a,x:Vct(n,i)})),o=Uct.lastIndex;return o<e.length&&(r=e.slice(o),s[a]?s[a]+=r:s[++a]=r),s.length<2?l[0]?(function c(t){return function(e){return t(e)+""}})(l[0].x):(function u(t){return function(){return t}})(e):(e=l.length,function(t){for(var n,i=0;i<e;++i)s[(n=l[i]).i]=n.x(t);return s.join("")})}var Wct,qct,Yct,Xct,$ct=180/Math.PI,Kct={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Zct(t,e,n,i,r,o){var a,s,l;return(a=Math.sqrt(t*t+e*e))&&(t/=a,e/=a),(l=t*n+e*i)&&(n-=t*l,i-=e*l),(s=Math.sqrt(n*n+i*i))&&(n/=s,i/=s,l/=s),t*i<e*n&&(t=-t,e=-e,l=-l,a=-a),{translateX:r,translateY:o,rotate:Math.atan2(e,t)*$ct,skewX:Math.atan(l)*$ct,scaleX:a,scaleY:s}}function Jct(t,e,n,i){function r(t){return t.length?t.pop()+" ":""}return function(o,a){var s=[],l=[];return o=t(o),a=t(a),(function c(t,i,r,o,a,s){if(t!==r||i!==o){var l=a.push("translate(",null,e,null,n);s.push({i:l-4,x:Vct(t,r)},{i:l-2,x:Vct(i,o)})}else(r||o)&&a.push("translate("+r+e+o+n)})(o.translateX,o.translateY,a.translateX,a.translateY,s,l),(function u(t,e,n,o){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),o.push({i:n.push(r(n)+"rotate(",null,i)-2,x:Vct(t,e)})):e&&n.push(r(n)+"rotate("+e+i)})(o.rotate,a.rotate,s,l),(function h(t,e,n,o){t!==e?o.push({i:n.push(r(n)+"skewX(",null,i)-2,x:Vct(t,e)}):e&&n.push(r(n)+"skewX("+e+i)})(o.skewX,a.skewX,s,l),(function d(t,e,n,i,o,a){if(t!==n||e!==i){var s=o.push(r(o)+"scale(",null,",",null,")");a.push({i:s-4,x:Vct(t,n)},{i:s-2,x:Vct(e,i)})}else 1===n&&1===i||o.push(r(o)+"scale("+n+","+i+")")})(o.scaleX,o.scaleY,a.scaleX,a.scaleY,s,l),o=a=null,function(t){for(var e,n=-1,i=l.length;++n<i;)s[(e=l[n]).i]=e.x(t);return s.join("")}}}var Qct=Jct((function tut(t){return"none"===t?Kct:(Wct||(Wct=document.createElement("DIV"),qct=document.documentElement,Yct=document.defaultView),Wct.style.transform=t,t=Yct.getComputedStyle(qct.appendChild(Wct),null).getPropertyValue("transform"),qct.removeChild(Wct),Zct(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),eut=Jct((function nut(t){return null==t?Kct:(Xct||(Xct=document.createElementNS("http://www.w3.org/2000/svg","g")),Xct.setAttribute("transform",t),(t=Xct.transform.baseVal.consolidate())?Zct((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):Kct)}),", ",")",")"),iut=Math.SQRT2;function rut(t){return((t=Math.exp(t))+1/t)/2}function out(t,e){var n,i,r=t[0],o=t[1],a=t[2],s=e[2],l=e[0]-r,c=e[1]-o,u=l*l+c*c;if(u<1e-12)i=Math.log(s/a)/iut,n=function(t){return[r+t*l,o+t*c,a*Math.exp(iut*t*i)]};else{var h=Math.sqrt(u),d=(s*s-a*a+4*u)/(2*a*2*h),p=(s*s-a*a-4*u)/(2*s*2*h),f=Math.log(Math.sqrt(d*d+1)-d),m=Math.log(Math.sqrt(p*p+1)-p);i=(m-f)/iut,n=function(t){var e=t*i,n=rut(f),s=a/(2*h)*(n*(function u(t){return((t=Math.exp(2*t))-1)/(t+1)})(iut*e+f)-(function d(t){return((t=Math.exp(t))-1/t)/2})(f));return[r+s*l,o+s*c,a*n/rut(iut*e+f)]}}return n.duration=1e3*i,n}var aut,sut,lut=0,cut=0,uut=0,hut=0,dut=0,put=0,fut="object"==typeof performance&&performance.now?performance:Date,mut="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function gut(){return dut||(mut(_ut),dut=fut.now()+put)}function _ut(){dut=0}function yut(){this._call=this._time=this._next=null}function vut(t,e,n){var i=new yut;return i.restart(t,e,n),i}function but(){dut=(hut=fut.now())+put,lut=cut=0;try{!(function t(){gut(),++lut;for(var t,e=aut;e;)(t=dut-e._time)>=0&&e._call.call(null,t),e=e._next;--lut})()}finally{lut=0,(function e(){for(var t,e,n=aut,i=1/0;n;)n._call?(i>n._time&&(i=n._time),t=n,n=n._next):(e=n._next,n._next=null,n=t?t._next=e:aut=e);sut=t,wut(i)})(),dut=0}}function xut(){var t=fut.now(),e=t-hut;e>1e3&&(put-=e,hut=t)}function wut(t){lut||(cut&&(cut=clearTimeout(cut)),t-dut>24?(t<1/0&&(cut=setTimeout(but,t-fut.now()-put)),uut&&(uut=clearInterval(uut))):(uut||(hut=fut.now(),uut=setInterval(xut,1e3)),lut=1,mut(but)))}function Sut(t,e,n){var i=new yut;return i.restart((function(n){i.stop(),t(n+e)}),e=null==e?0:+e,n),i}yut.prototype=vut.prototype={constructor:yut,restart:function(t,e,n){if("function"!=typeof t)throw new TypeError("callback is not a function");n=(null==n?gut():+n)+(null==e?0:+e),this._next||sut===this||(sut?sut._next=this:aut=this,sut=this),this._call=t,this._time=n,wut()},stop:function(){this._call&&(this._call=null,this._time=1/0,wut())}};var Mut=ast("start","end","cancel","interrupt"),Eut=[];function Tut(t,e,n,i,r,o){var a=t.__transition;if(a){if(n in a)return}else t.__transition={};!(function s(t,e,n){var i,r=t.__transition;function o(l){var c,u,h,d;if(1!==n.state)return s();for(c in r)if((d=r[c]).name===n.name){if(3===d.state)return Sut(o);4===d.state?(d.state=6,d.timer.stop(),d.on.call("interrupt",t,t.__data__,d.index,d.group),delete r[c]):+c<e&&(d.state=6,d.timer.stop(),d.on.call("cancel",t,t.__data__,d.index,d.group),delete r[c])}if(Sut((function(){3===n.state&&(n.state=4,n.timer.restart(a,n.delay,n.time),a(l))})),n.state=2,n.on.call("start",t,t.__data__,n.index,n.group),2===n.state){for(n.state=3,i=new Array(h=n.tween.length),c=0,u=-1;c<h;++c)(d=n.tween[c].value.call(t,t.__data__,n.index,n.group))&&(i[++u]=d);i.length=u+1}}function a(e){for(var r=e<n.duration?n.ease.call(null,e/n.duration):(n.timer.restart(s),n.state=5,1),o=-1,a=i.length;++o<a;)i[o].call(t,r);5===n.state&&(n.on.call("end",t,t.__data__,n.index,n.group),s())}function s(){for(var i in n.state=6,n.timer.stop(),delete r[e],r)return;delete t.__transition}r[e]=n,n.timer=vut((function l(t){n.state=1,n.timer.restart(o,n.delay,n.time),n.delay<=t&&o(t-n.delay)}),0,n.time)})(t,n,{name:e,index:i,group:r,on:Mut,tween:Eut,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:0})}function Aut(t,e){var n=kut(t,e);if(n.state>0)throw new Error("too late; already scheduled");return n}function Cut(t,e){var n=kut(t,e);if(n.state>3)throw new Error("too late; already running");return n}function kut(t,e){var n=t.__transition;if(!n||!(n=n[e]))throw new Error("transition not found");return n}function Lut(t,e){var n,i,r,o=t.__transition,a=!0;if(o){for(r in e=null==e?null:e+"",o)(n=o[r]).name===e?(i=n.state>2&&n.state<5,n.state=6,n.timer.stop(),n.on.call(i?"interrupt":"cancel",t,t.__data__,n.index,n.group),delete o[r]):a=!1;a&&delete t.__transition}}function Put(t,e){var n,i;return function(){var r=Cut(this,t),o=r.tween;if(o!==n)for(var a=0,s=(i=n=o).length;a<s;++a)if(i[a].name===e){(i=i.slice()).splice(a,1);break}r.tween=i}}function Iut(t,e,n){var i,r;if("function"!=typeof n)throw new Error;return function(){var o=Cut(this,t),a=o.tween;if(a!==i){r=(i=a).slice();for(var s={name:e,value:n},l=0,c=r.length;l<c;++l)if(r[l].name===e){r[l]=s;break}l===c&&r.push(s)}o.tween=r}}function Nut(t,e,n){var i=t._id;return t.each((function(){var t=Cut(this,i);(t.value||(t.value={}))[e]=n.apply(this,arguments)})),function(t){return kut(t,i).value[e]}}function Out(t,e){var n;return("number"==typeof e?Vct:e instanceof Sct?Fct:(n=Sct(e))?(e=n,Fct):Gct)(t,e)}function Rut(t){return function(){this.removeAttribute(t)}}function zut(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Dut(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttribute(t);return a===o?null:a===i?r:r=e(i=a,n)}}function But(t,e,n){var i,r,o=n+"";return function(){var a=this.getAttributeNS(t.space,t.local);return a===o?null:a===i?r:r=e(i=a,n)}}function Hut(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttribute(t))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttribute(t)}}function Fut(t,e,n){var i,r,o;return function(){var a,s,l=n(this);if(null!=l)return(a=this.getAttributeNS(t.space,t.local))===(s=l+"")?null:a===i&&s===r?o:(r=s,o=e(i=a,l));this.removeAttributeNS(t.space,t.local)}}function Vut(t,e){return function(n){this.setAttribute(t,e.call(this,n))}}function jut(t,e){return function(n){this.setAttributeNS(t.space,t.local,e.call(this,n))}}function Uut(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&jut(t,r)),n}return r._value=e,r}function Gut(t,e){var n,i;function r(){var r=e.apply(this,arguments);return r!==i&&(n=(i=r)&&Vut(t,r)),n}return r._value=e,r}function Wut(t,e){return function(){Aut(this,t).delay=+e.apply(this,arguments)}}function qut(t,e){return e=+e,function(){Aut(this,t).delay=e}}function Yut(t,e){return function(){Cut(this,t).duration=+e.apply(this,arguments)}}function Xut(t,e){return e=+e,function(){Cut(this,t).duration=e}}function $ut(t,e){if("function"!=typeof e)throw new Error;return function(){Cut(this,t).ease=e}}function Kut(t,e,n){var i,r,o=(function a(t){return(t+"").trim().split(/^|\s+/).every((function(t){var e=t.indexOf(".");return e>=0&&(t=t.slice(0,e)),!t||"start"===t}))})(e)?Aut:Cut;return function(){var a=o(this,t),s=a.on;s!==i&&(r=(i=s).copy()).on(e,n),a.on=r}}var Zut=vlt.prototype.constructor;function Jut(t){return function(){this.style.removeProperty(t)}}function Qut(t,e,n){return function(i){this.style.setProperty(t,e.call(this,i),n)}}function tht(t,e,n){var i,r;function o(){var o=e.apply(this,arguments);return o!==r&&(i=(r=o)&&Qut(t,o,n)),i}return o._value=e,o}function eht(t){return function(e){this.textContent=t.call(this,e)}}function nht(t){var e,n;function i(){var i=t.apply(this,arguments);return i!==n&&(e=(n=i)&&eht(i)),e}return i._value=t,i}var iht=0;function rht(t,e,n,i){this._groups=t,this._parents=e,this._name=n,this._id=i}function oht(){return++iht}var aht=vlt.prototype;rht.prototype={constructor:rht,select:function sht(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=yst(t));for(var i=this._groups,r=i.length,o=new Array(r),a=0;a<r;++a)for(var s,l,c=i[a],u=c.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=c[d])&&(l=t.call(s,s.__data__,d,c))&&("__data__"in s&&(l.__data__=s.__data__),h[d]=l,Tut(h[d],e,n,d,h,kut(s,n)));return new rht(o,this._parents,e,n)},selectAll:function lht(t){var e=this._name,n=this._id;"function"!=typeof t&&(t=bst(t));for(var i=this._groups,r=i.length,o=[],a=[],s=0;s<r;++s)for(var l,c=i[s],u=c.length,h=0;h<u;++h)if(l=c[h]){for(var d,p=t.call(l,l.__data__,h,c),f=kut(l,n),m=0,g=p.length;m<g;++m)(d=p[m])&&Tut(d,e,n,m,p,f);o.push(p),a.push(l)}return new rht(o,a,e,n)},filter:function cht(t){"function"!=typeof t&&(t=xst(t));for(var e=this._groups,n=e.length,i=new Array(n),r=0;r<n;++r)for(var o,a=e[r],s=a.length,l=i[r]=[],c=0;c<s;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&l.push(o);return new rht(i,this._parents,this._name,this._id)},merge:function uht(t){if(t._id!==this._id)throw new Error;for(var e=this._groups,n=t._groups,i=e.length,r=Math.min(i,n.length),o=new Array(i),a=0;a<r;++a)for(var s,l=e[a],c=n[a],u=l.length,h=o[a]=new Array(u),d=0;d<u;++d)(s=l[d]||c[d])&&(h[d]=s);for(;a<i;++a)o[a]=e[a];return new rht(o,this._parents,this._name,this._id)},selection:function hht(){return new Zut(this._groups,this._parents)},transition:function dht(){for(var t=this._name,e=this._id,n=oht(),i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)if(a=s[c]){var u=kut(a,e);Tut(a,t,n,c,s,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new rht(i,this._parents,t,n)},call:aht.call,nodes:aht.nodes,node:aht.node,size:aht.size,empty:aht.empty,each:aht.each,on:function pht(t,e){var n=this._id;return arguments.length<2?kut(this.node(),n).on.on(t):this.each(Kut(n,t,e))},attr:function fht(t,e){var n=pst(t),i="transform"===n?eut:Out;return this.attrTween(t,"function"==typeof e?(n.local?Fut:Hut)(n,i,Nut(this,"attr."+t,e)):null==e?(n.local?zut:Rut)(n):(n.local?But:Dut)(n,i,e))},attrTween:function mht(t,e){var n="attr."+t;if(arguments.length<2)return(n=this.tween(n))&&n._value;if(null==e)return this.tween(n,null);if("function"!=typeof e)throw new Error;var i=pst(t);return this.tween(n,(i.local?Uut:Gut)(i,e))},style:function ght(t,e,n){var i="transform"==(t+="")?Qct:Out;return null==e?this.styleTween(t,(function r(t,e){var n,i,r;return function(){var o=Dst(this,t),a=(this.style.removeProperty(t),Dst(this,t));return o===a?null:o===n&&a===i?r:r=e(n=o,i=a)}})(t,i)).on("end.style."+t,Jut(t)):"function"==typeof e?this.styleTween(t,(function a(t,e,n){var i,r,o;return function(){var a=Dst(this,t),s=n(this),l=s+"";return null==s&&(this.style.removeProperty(t),l=s=Dst(this,t)),a===l?null:a===i&&l===r?o:(r=l,o=e(i=a,s))}})(t,i,Nut(this,"style."+t,e))).each((function o(t,e){var n,i,r,o,a="style."+e,s="end."+a;return function(){var l=Cut(this,t),c=l.on,u=null==l.value[a]?o||(o=Jut(e)):void 0;c===n&&r===u||(i=(n=c).copy()).on(s,r=u),l.on=i}})(this._id,t)):this.styleTween(t,(function s(t,e,n){var i,r,o=n+"";return function(){var a=Dst(this,t);return a===o?null:a===i?r:r=e(i=a,n)}})(t,i,e),n).on("end.style."+t,null)},styleTween:function _ht(t,e,n){var i="style."+(t+="");if(arguments.length<2)return(i=this.tween(i))&&i._value;if(null==e)return this.tween(i,null);if("function"!=typeof e)throw new Error;return this.tween(i,tht(t,e,null==n?"":n))},text:function yht(t){return this.tween("text","function"==typeof t?(function e(t){return function(){var e=t(this);this.textContent=null==e?"":e}})(Nut(this,"text",t)):(function n(t){return function(){this.textContent=t}})(null==t?"":t+""))},textTween:function vht(t){var e="text";if(arguments.length<1)return(e=this.tween(e))&&e._value;if(null==t)return this.tween(e,null);if("function"!=typeof t)throw new Error;return this.tween(e,nht(t))},remove:function bht(){return this.on("end.remove",(function t(e){return function(){var t=this.parentNode;for(var n in this.__transition)if(+n!==e)return;t&&t.removeChild(this)}})(this._id))},tween:function xht(t,e){var n=this._id;if(t+="",arguments.length<2){for(var i,r=kut(this.node(),n).tween,o=0,a=r.length;o<a;++o)if((i=r[o]).name===t)return i.value;return null}return this.each((null==e?Put:Iut)(n,t,e))},delay:function wht(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?Wut:qut)(e,t)):kut(this.node(),e).delay},duration:function Sht(t){var e=this._id;return arguments.length?this.each(("function"==typeof t?Yut:Xut)(e,t)):kut(this.node(),e).duration},ease:function Mht(t){var e=this._id;return arguments.length?this.each($ut(e,t)):kut(this.node(),e).ease},end:function Eht(){var t,e,n=this,i=n._id,r=n.size();return new Promise((function(o,a){var s={value:a},l={value:function(){0==--r&&o()}};n.each((function(){var n=Cut(this,i),r=n.on;r!==t&&((e=(t=r).copy())._.cancel.push(s),e._.interrupt.push(s),e._.end.push(l)),n.on=e}))}))}};var Tht={time:null,delay:0,duration:250,ease:Tf};function Aht(t,e){for(var n;!(n=t.__transition)||!(n=n[e]);)if(!(t=t.parentNode))return Tht.time=gut(),Tht;return n}function Cht(t){return function(){return t}}function kht(t,e,n){this.target=t,this.type=e,this.transform=n}function Lht(t,e,n){this.k=t,this.x=e,this.y=n}vlt.prototype.interrupt=function Pht(t){return this.each((function(){Lut(this,t)}))},vlt.prototype.transition=function Iht(t){var e,n;t instanceof rht?(e=t._id,t=t._name):(e=oht(),(n=Tht).time=gut(),t=null==t?null:t+"");for(var i=this._groups,r=i.length,o=0;o<r;++o)for(var a,s=i[o],l=s.length,c=0;c<l;++c)(a=s[c])&&Tut(a,t,e,c,s,n||Aht(a,e));return new rht(i,this._parents,t,e)},Lht.prototype={constructor:Lht,scale:function(t){return 1===t?this:new Lht(this.k*t,this.x,this.y)},translate:function(t,e){return 0===t&0===e?this:new Lht(this.k,this.x+this.k*t,this.y+this.k*e)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Nht=new Lht(1,0,0);function Oht(t){return t.__zoom||Nht}function Rht(){llt.stopImmediatePropagation()}function zht(){llt.preventDefault(),llt.stopImmediatePropagation()}function Dht(){return!llt.button}function Bht(){var t,e,n=this;return n instanceof SVGElement?(t=(n=n.ownerSVGElement||n).width.baseVal.value,e=n.height.baseVal.value):(t=n.clientWidth,e=n.clientHeight),[[0,0],[t,e]]}function Hht(){return this.__zoom||Nht}function Fht(){return-llt.deltaY*(llt.deltaMode?120:1)/500}function Vht(){return"ontouchstart"in this}function jht(t,e,n){var i=t.invertX(e[0][0])-n[0][0],r=t.invertX(e[1][0])-n[1][0],o=t.invertY(e[0][1])-n[0][1],a=t.invertY(e[1][1])-n[1][1];return t.translate(r>i?(i+r)/2:Math.min(0,i)||Math.max(0,r),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}Oht.prototype=Lht.prototype;var Uht=xe(Object.freeze({__proto__:null,version:"4.13.0",bisect:iR,bisectRight:iR,bisectLeft:rR,ascending:tR,bisector:eR,cross:function Ght(t,e,n){var i,r,o,a,s=t.length,l=e.length,c=new Array(s*l);for(null==n&&(n=oR),i=o=0;i<s;++i)for(a=t[i],r=0;r<l;++r,++o)c[o]=n(a,e[r]);return c},descending:function Wht(t,e){return e<t?-1:e>t?1:e>=t?0:NaN},deviation:lR,extent:cR,histogram:function qht(){var t=fR,e=cR,n=xR;function i(i){var r,o,a=i.length,s=new Array(a);for(r=0;r<a;++r)s[r]=t(i[r],r,i);var l=e(s),c=l[0],u=l[1],h=n(s,c,u);Array.isArray(h)||(h=bR(c,u,h),h=mR(Math.ceil(c/h)*h,Math.floor(u/h)*h,h));for(var d=h.length;h[0]<=c;)h.shift(),--d;for(;h[d-1]>u;)h.pop(),--d;var p,f=new Array(d+1);for(r=0;r<=d;++r)(p=f[r]=[]).x0=r>0?h[r-1]:c,p.x1=r<d?h[r]:u;for(r=0;r<a;++r)c<=(o=s[r])&&o<=u&&f[iR(h,o,0,d)].push(i[r]);return f}return i.value=function(e){return arguments.length?(t="function"==typeof e?e:pR(e),i):t},i.domain=function(t){return arguments.length?(e="function"==typeof t?t:pR([t[0],t[1]]),i):e},i.thresholds=function(t){return arguments.length?(n="function"==typeof t?t:Array.isArray(t)?pR(hR.call(t)):pR(t),i):n},i},thresholdFreedmanDiaconis:function Yht(t,e,n){return t=dR.call(t,aR).sort(tR),Math.ceil((n-e)/(2*(wR(t,.75)-wR(t,.25))*Math.pow(t.length,-1/3)))},thresholdScott:function Xht(t,e,n){return Math.ceil((n-e)/(3.5*lR(t)*Math.pow(t.length,-1/3)))},thresholdSturges:xR,max:function $ht(t,e){var n,i,r=t.length,o=-1;if(null==e){for(;++o<r;)if(null!=(n=t[o])&&n>=n)for(i=n;++o<r;)null!=(n=t[o])&&n>i&&(i=n)}else for(;++o<r;)if(null!=(n=e(t[o],o,t))&&n>=n)for(i=n;++o<r;)null!=(n=e(t[o],o,t))&&n>i&&(i=n);return i},mean:function Kht(t,e){var n,i=t.length,r=i,o=-1,a=0;if(null==e)for(;++o<i;)isNaN(n=aR(t[o]))?--r:a+=n;else for(;++o<i;)isNaN(n=aR(e(t[o],o,t)))?--r:a+=n;if(r)return a/r},median:function Zht(t,e){var n,i=t.length,r=-1,o=[];if(null==e)for(;++r<i;)isNaN(n=aR(t[r]))||o.push(n);else for(;++r<i;)isNaN(n=aR(e(t[r],r,t)))||o.push(n);return wR(o.sort(tR),.5)},merge:function Jht(t){for(var e,n,i,r=t.length,o=-1,a=0;++o<r;)a+=t[o].length;for(n=new Array(a);--r>=0;)for(e=(i=t[r]).length;--e>=0;)n[--a]=i[e];return n},min:SR,pairs:function Qht(t,e){null==e&&(e=oR);for(var n=0,i=t.length-1,r=t[0],o=new Array(i<0?0:i);n<i;)o[n]=e(r,r=t[++n]);return o},permute:function tdt(t,e){for(var n=e.length,i=new Array(n);n--;)i[n]=t[e[n]];return i},quantile:wR,range:mR,scan:function edt(t,e){if(n=t.length){var n,i,r=0,o=0,a=t[o];for(null==e&&(e=tR);++r<n;)(e(i=t[r],a)<0||0!==e(a,a))&&(a=i,o=r);return 0===e(a,a)?o:void 0}},shuffle:function ndt(t,e,n){for(var i,r,o=(null==n?t.length:n)-(e=null==e?0:+e);o;)r=Math.random()*o--|0,i=t[o+e],t[o+e]=t[r+e],t[r+e]=i;return t},sum:function idt(t,e){var n,i=t.length,r=-1,o=0;if(null==e)for(;++r<i;)(n=+t[r])&&(o+=n);else for(;++r<i;)(n=+e(t[r],r,t))&&(o+=n);return o},ticks:function rdt(t,e,n){var i,r,o,a,s=-1;if(n=+n,(t=+t)==(e=+e)&&n>0)return[t];if((i=e<t)&&(r=t,t=e,e=r),0===(a=vR(t,e,n))||!isFinite(a))return[];if(a>0)for(t=Math.ceil(t/a),e=Math.floor(e/a),o=new Array(r=Math.ceil(e-t+1));++s<r;)o[s]=(t+s)*a;else for(t=Math.floor(t*a),e=Math.ceil(e*a),o=new Array(r=Math.ceil(t-e+1));++s<r;)o[s]=(t-s)/a;return i&&o.reverse(),o},tickIncrement:vR,tickStep:bR,transpose:MR,variance:sR,zip:function odt(){return MR(arguments)},axisTop:function adt(t){return OR(1,t)},axisRight:function sdt(t){return OR(2,t)},axisBottom:function ldt(t){return OR(3,t)},axisLeft:function cdt(t){return OR(4,t)},brush:function udt(){return TF(mF)},brushX:function hdt(){return TF(pF)},brushY:function ddt(){return TF(fF)},brushSelection:function pdt(t){var e=t.__brush;return e?e.dim.output(e.selection):null},chord:function fdt(){var t=0,e=null,n=null,i=null;function r(r){var o,a,s,l,c,u,h=r.length,d=[],p=CF(h),f=[],m=[],g=m.groups=new Array(h),_=new Array(h*h);for(o=0,c=-1;++c<h;){for(a=0,u=-1;++u<h;)a+=r[c][u];d.push(a),f.push(CF(h)),o+=a}for(e&&p.sort((function(t,n){return e(d[t],d[n])})),n&&f.forEach((function(t,e){t.sort((function(t,i){return n(r[e][t],r[e][i])}))})),l=(o=RF(0,OF-t*h)/o)?t:OF/h,a=0,c=-1;++c<h;){for(s=a,u=-1;++u<h;){var y=p[c],v=f[y][u],b=r[y][v],x=a,w=a+=b*o;_[v*h+y]={index:y,subindex:v,startAngle:x,endAngle:w,value:b}}g[y]={index:y,startAngle:s,endAngle:a,value:d[y]},a+=l}for(c=-1;++c<h;)for(u=c-1;++u<h;){var S=_[u*h+c],M=_[c*h+u];(S.value||M.value)&&m.push(S.value<M.value?{source:M,target:S}:{source:S,target:M})}return i?m.sort(i):m}return r.padAngle=function(e){return arguments.length?(t=RF(0,e),r):t},r.sortGroups=function(t){return arguments.length?(e=t,r):e},r.sortSubgroups=function(t){return arguments.length?(n=t,r):n},r.sortChords=function(t){return arguments.length?(null==t?i=null:(i=zF(t))._=t,r):i&&i._},r},ribbon:function mdt(){var t=WF,e=qF,n=YF,i=XF,r=$F,o=null;function a(){var a,s=DF.call(arguments),l=t.apply(this,s),c=e.apply(this,s),u=+n.apply(this,(s[0]=l,s)),h=i.apply(this,s)-NF,d=r.apply(this,s)-NF,p=u*LF(h),f=u*PF(h),m=+n.apply(this,(s[0]=c,s)),g=i.apply(this,s)-NF,_=r.apply(this,s)-NF;if(o||(o=a=GF()),o.moveTo(p,f),o.arc(0,0,u,h,d),h===g&&d===_||(o.quadraticCurveTo(0,0,m*LF(g),m*PF(g)),o.arc(0,0,m,g,_)),o.quadraticCurveTo(0,0,p,f),o.closePath(),a)return o=null,a+""||null}return a.radius=function(t){return arguments.length?(n="function"==typeof t?t:BF(+t),a):n},a.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:BF(+t),a):i},a.endAngle=function(t){return arguments.length?(r="function"==typeof t?t:BF(+t),a):r},a.source=function(e){return arguments.length?(t=e,a):t},a.target=function(t){return arguments.length?(e=t,a):e},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a},nest:function gdt(){var t,e,n,i=[],r=[];function o(n,r,a,s){if(r>=i.length)return null!=t&&n.sort(t),null!=e?e(n):n;for(var l,c,u,h=-1,d=n.length,p=i[r++],f=JF(),m=a();++h<d;)(u=f.get(l=p(c=n[h])+""))?u.push(c):f.set(l,[c]);return f.each((function(t,e){s(m,e,o(t,r,a,s))})),m}function a(t,n){if(++n>i.length)return t;var o,s=r[n-1];return null!=e&&n>=i.length?o=t.entries():(o=[],t.each((function(t,e){o.push({key:e,values:a(t,n)})}))),null!=s?o.sort((function(t,e){return s(t.key,e.key)})):o}return n={object:function(t){return o(t,0,QF,tV)},map:function(t){return o(t,0,eV,nV)},entries:function(t){return a(o(t,0,eV,nV),0)},key:function(t){return i.push(t),n},sortKeys:function(t){return r[i.length-1]=t,n},sortValues:function(e){return t=e,n},rollup:function(t){return e=t,n}}},set:oV,map:JF,keys:function _dt(t){var e=[];for(var n in t)e.push(n);return e},values:function ydt(t){var e=[];for(var n in t)e.push(t[n]);return e},entries:function vdt(t){var e=[];for(var n in t)e.push({key:n,value:t[n]});return e},color:SV,rgb:AV,hsl:PV,lab:jV,hcl:$V,cubehelix:ej,dispatch:rj,drag:function bdt(){var t,e,n,i,r=NU,o=OU,a=RU,s=zU,l={},c=uj("start","drag","end"),u=0,h=0;function d(t){t.on("mousedown.drag",p).filter(s).on("touchstart.drag",g).on("touchmove.drag",_).on("touchend.drag touchcancel.drag",y).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!i&&r.apply(this,arguments)){var a=v("mouse",o.apply(this,arguments),EU,this,arguments);a&&(wU(uU.view).on("mousemove.drag",f,!0).on("mouseup.drag",m,!0),kU(uU.view),AU(),n=!1,t=uU.clientX,e=uU.clientY,a("start"))}}function f(){if(CU(),!n){var i=uU.clientX-t,r=uU.clientY-e;n=i*i+r*r>h}l.mouse("drag")}function m(){wU(uU.view).on("mousemove.drag mouseup.drag",null),LU(uU.view,n),CU(),l.mouse("end")}function g(){if(r.apply(this,arguments)){var t,e,n=uU.changedTouches,i=o.apply(this,arguments),a=n.length;for(t=0;t<a;++t)(e=v(n[t].identifier,i,TU,this,arguments))&&(AU(),e("start"))}}function _(){var t,e,n=uU.changedTouches,i=n.length;for(t=0;t<i;++t)(e=l[n[t].identifier])&&(CU(),e("drag"))}function y(){var t,e,n=uU.changedTouches,r=n.length;for(i&&clearTimeout(i),i=setTimeout((function(){i=null}),500),t=0;t<r;++t)(e=l[n[t].identifier])&&(AU(),e("end"))}function v(t,e,n,i,r){var o,s,h,p=n(e,t),f=c.copy();if(gU(new IU(d,"beforestart",o,t,u,p[0],p[1],0,0,f),(function(){return null!=(uU.subject=o=a.apply(i,r))&&(s=o.x-p[0]||0,h=o.y-p[1]||0,!0)})))return function a(c){var m,g=p;switch(c){case"start":l[t]=a,m=u++;break;case"end":delete l[t],--u;case"drag":p=n(e,t),m=u}gU(new IU(d,c,o,t,m,p[0]+s,p[1]+h,p[0]-g[0],p[1]-g[1],f),f.apply,f,[c,i,r])}}return d.filter=function(t){return arguments.length?(r="function"==typeof t?t:PU(!!t),d):r},d.container=function(t){return arguments.length?(o="function"==typeof t?t:PU(t),d):o},d.subject=function(t){return arguments.length?(a="function"==typeof t?t:PU(t),d):a},d.touchable=function(t){return arguments.length?(s="function"==typeof t?t:PU(!!t),d):s},d.on=function(){var t=c.on.apply(c,arguments);return t===c?d:t},d.clickDistance=function(t){return arguments.length?(h=(t=+t)*t,d):Math.sqrt(h)},d},dragDisable:kU,dragEnable:LU,dsvFormat:_G,csvParse:vG,csvParseRows:bG,csvFormat:xG,csvFormatRows:wG,tsvParse:MG,tsvParseRows:EG,tsvFormat:TG,tsvFormatRows:AG,easeLinear:function xdt(t){return+t},easeQuad:CG,easeQuadIn:function wdt(t){return t*t},easeQuadOut:function Sdt(t){return t*(2-t)},easeQuadInOut:CG,easeCubic:kG,easeCubicIn:function Mdt(t){return t*t*t},easeCubicOut:function Edt(t){return--t*t*t+1},easeCubicInOut:kG,easePoly:IG,easePolyIn:LG,easePolyOut:PG,easePolyInOut:IG,easeSin:RG,easeSinIn:function Tdt(t){return 1-Math.cos(t*OG)},easeSinOut:function Adt(t){return Math.sin(t*OG)},easeSinInOut:RG,easeExp:zG,easeExpIn:function Cdt(t){return Math.pow(2,10*t-10)},easeExpOut:function kdt(t){return 1-Math.pow(2,-10*t)},easeExpInOut:zG,easeCircle:DG,easeCircleIn:function Ldt(t){return 1-Math.sqrt(1-t*t)},easeCircleOut:function Pdt(t){return Math.sqrt(1- --t*t)},easeCircleInOut:DG,easeBounce:HG,easeBounceIn:function Idt(t){return 1-HG(1-t)},easeBounceOut:HG,easeBounceInOut:function Ndt(t){return((t*=2)<=1?1-HG(1-t):HG(t-1)+1)/2},easeBack:UG,easeBackIn:VG,easeBackOut:jG,easeBackInOut:UG,easeElastic:qG,easeElasticIn:WG,easeElasticOut:qG,easeElasticInOut:YG,forceCenter:function Odt(t,e){var n;function i(){var i,r,o=n.length,a=0,s=0;for(i=0;i<o;++i)a+=(r=n[i]).x,s+=r.y;for(a=a/o-t,s=s/o-e,i=0;i<o;++i)(r=n[i]).x-=a,r.y-=s}return null==t&&(t=0),null==e&&(e=0),i.initialize=function(t){n=t},i.x=function(e){return arguments.length?(t=+e,i):t},i.y=function(t){return arguments.length?(e=+t,i):e},i},forceCollide:function Rdt(t){var e,n,i=1,r=1;function o(){for(var t,o,s,l,c,u,h,d=e.length,p=0;p<r;++p)for(o=tW(e,rW,oW).visitAfter(a),t=0;t<d;++t)h=(u=n[(s=e[t]).index])*u,l=s.x+s.vx,c=s.y+s.vy,o.visit(f);function f(t,e,n,r,o){var a=t.data,d=t.r,p=u+d;if(!a)return e>l+p||r<l-p||n>c+p||o<c-p;if(a.index>s.index){var f=l-a.x-a.vx,m=c-a.y-a.vy,g=f*f+m*m;g<p*p&&(0===f&&(g+=(f=$G())*f),0===m&&(g+=(m=$G())*m),g=(p-(g=Math.sqrt(g)))/g*i,s.vx+=(f*=g)*(p=(d*=d)/(h+d)),s.vy+=(m*=g)*p,a.vx-=f*(p=1-p),a.vy-=m*p)}}}function a(t){if(t.data)return t.r=n[t.data.index];for(var e=t.r=0;e<4;++e)t[e]&&t[e].r>t.r&&(t.r=t[e].r)}function s(){if(e){var i,r,o=e.length;for(n=new Array(o),i=0;i<o;++i)n[(r=e[i]).index]=+t(r,i,e)}}return"function"!=typeof t&&(t=XG(null==t?1:+t)),o.initialize=function(t){e=t,s()},o.iterations=function(t){return arguments.length?(r=+t,o):r},o.strength=function(t){return arguments.length?(i=+t,o):i},o.radius=function(e){return arguments.length?(t="function"==typeof e?e:XG(+e),s(),o):t},o},forceLink:function zdt(t){var e,n,i,r,o,a=EW,s=function l(t){return 1/Math.min(r[t.source.index],r[t.target.index])},c=XG(30),u=1;function h(i){for(var r=0,a=t.length;r<u;++r)for(var s,l,c,h,d,p,f,m=0;m<a;++m)h=(c=(s=t[m]).target).x+c.vx-(l=s.source).x-l.vx||$G(),d=c.y+c.vy-l.y-l.vy||$G(),d*=p=((p=Math.sqrt(h*h+d*d))-n[m])/p*i*e[m],c.vx-=(h*=p)*(f=o[m]),c.vy-=d*f,l.vx+=h*(f=1-f),l.vy+=d*f}function d(){if(i){var s,l,c=i.length,u=t.length,h=wW(i,a);for(s=0,r=new Array(c);s<u;++s)(l=t[s]).index=s,"object"!=typeof l.source&&(l.source=TW(h,l.source)),"object"!=typeof l.target&&(l.target=TW(h,l.target)),r[l.source.index]=(r[l.source.index]||0)+1,r[l.target.index]=(r[l.target.index]||0)+1;for(s=0,o=new Array(u);s<u;++s)o[s]=r[(l=t[s]).source.index]/(r[l.source.index]+r[l.target.index]);e=new Array(u),p(),n=new Array(u),f()}}function p(){if(i)for(var n=0,r=t.length;n<r;++n)e[n]=+s(t[n],n,t)}function f(){if(i)for(var e=0,r=t.length;e<r;++e)n[e]=+c(t[e],e,t)}return null==t&&(t=[]),h.initialize=function(t){i=t,d()},h.links=function(e){return arguments.length?(t=e,d(),h):t},h.id=function(t){return arguments.length?(a=t,h):a},h.iterations=function(t){return arguments.length?(u=+t,h):u},h.strength=function(t){return arguments.length?(s="function"==typeof t?t:XG(+t),p(),h):s},h.distance=function(t){return arguments.length?(c="function"==typeof t?t:XG(+t),f(),h):c},h},forceManyBody:function Ddt(){var t,e,n,i,r=XG(-30),o=1,a=1/0,s=.81;function l(i){var r,o=t.length,a=tW(t,KW,ZW).visitAfter(u);for(n=i,r=0;r<o;++r)e=t[r],a.visit(h)}function c(){if(t){var e,n,o=t.length;for(i=new Array(o),e=0;e<o;++e)i[(n=t[e]).index]=+r(n,e,t)}}function u(t){var e,n,r,o,a,s=0,l=0;if(t.length){for(r=o=a=0;a<4;++a)(e=t[a])&&(n=Math.abs(e.value))&&(s+=e.value,l+=n,r+=n*e.x,o+=n*e.y);t.x=r/l,t.y=o/l}else{(e=t).x=e.data.x,e.y=e.data.y;do{s+=i[e.data.index]}while(e=e.next)}t.value=s}function h(t,r,l,c){if(!t.value)return!0;var u=t.x-e.x,h=t.y-e.y,d=c-r,p=u*u+h*h;if(d*d/s<p)return p<a&&(0===u&&(p+=(u=$G())*u),0===h&&(p+=(h=$G())*h),p<o&&(p=Math.sqrt(o*p)),e.vx+=u*t.value*n/p,e.vy+=h*t.value*n/p),!0;if(!(t.length||p>=a)){(t.data!==e||t.next)&&(0===u&&(p+=(u=$G())*u),0===h&&(p+=(h=$G())*h),p<o&&(p=Math.sqrt(o*p)));do{t.data!==e&&(e.vx+=u*(d=i[t.data.index]*n/p),e.vy+=h*d)}while(t=t.next)}}return l.initialize=function(e){t=e,c()},l.strength=function(t){return arguments.length?(r="function"==typeof t?t:XG(+t),c(),l):r},l.distanceMin=function(t){return arguments.length?(o=t*t,l):Math.sqrt(o)},l.distanceMax=function(t){return arguments.length?(a=t*t,l):Math.sqrt(a)},l.theta=function(t){return arguments.length?(s=t*t,l):Math.sqrt(s)},l},forceRadial:function Bdt(t,e,n){var i,r,o,a=XG(.1);function s(t){for(var a=0,s=i.length;a<s;++a){var l=i[a],c=l.x-e||1e-6,u=l.y-n||1e-6,h=Math.sqrt(c*c+u*u),d=(o[a]-h)*r[a]*t/h;l.vx+=c*d,l.vy+=u*d}}function l(){if(i){var e,n=i.length;for(r=new Array(n),o=new Array(n),e=0;e<n;++e)o[e]=+t(i[e],e,i),r[e]=isNaN(o[e])?0:+a(i[e],e,i)}}return"function"!=typeof t&&(t=XG(+t)),null==e&&(e=0),null==n&&(n=0),s.initialize=function(t){i=t,l()},s.strength=function(t){return arguments.length?(a="function"==typeof t?t:XG(+t),l(),s):a},s.radius=function(e){return arguments.length?(t="function"==typeof e?e:XG(+e),l(),s):t},s.x=function(t){return arguments.length?(e=+t,s):e},s.y=function(t){return arguments.length?(n=+t,s):n},s},forceSimulation:function Hdt(t){var e,n=1,i=.001,r=1-Math.pow(i,1/300),o=0,a=.6,s=wW(),l=qW(u),c=CW("tick","end");function u(){h(),c.call("tick",e),n<i&&(l.stop(),c.call("end",e))}function h(){var e,i,l=t.length;for(n+=(o-n)*r,s.each((function(t){t(n)})),e=0;e<l;++e)null==(i=t[e]).fx?i.x+=i.vx*=a:(i.x=i.fx,i.vx=0),null==i.fy?i.y+=i.vy*=a:(i.y=i.fy,i.vy=0)}function d(){for(var e,n=0,i=t.length;n<i;++n){if((e=t[n]).index=n,isNaN(e.x)||isNaN(e.y)){var r=10*Math.sqrt(n),o=n*QW;e.x=r*Math.cos(o),e.y=r*Math.sin(o)}(isNaN(e.vx)||isNaN(e.vy))&&(e.vx=e.vy=0)}}function p(e){return e.initialize&&e.initialize(t),e}return null==t&&(t=[]),d(),e={tick:h,restart:function(){return l.restart(u),e},stop:function(){return l.stop(),e},nodes:function(n){return arguments.length?(t=n,d(),s.each(p),e):t},alpha:function(t){return arguments.length?(n=+t,e):n},alphaMin:function(t){return arguments.length?(i=+t,e):i},alphaDecay:function(t){return arguments.length?(r=+t,e):+r},alphaTarget:function(t){return arguments.length?(o=+t,e):o},velocityDecay:function(t){return arguments.length?(a=1-t,e):1-a},force:function(t,n){return arguments.length>1?(null==n?s.remove(t):s.set(t,p(n)),e):s.get(t)},find:function(e,n,i){var r,o,a,s,l,c=0,u=t.length;for(null==i?i=1/0:i*=i,c=0;c<u;++c)(a=(r=e-(s=t[c]).x)*r+(o=n-s.y)*o)<i&&(l=s,i=a);return l},on:function(t,n){return arguments.length>1?(c.on(t,n),e):c.on(t)}}},forceX:function Fdt(t){var e,n,i,r=XG(.1);function o(t){for(var r,o=0,a=e.length;o<a;++o)(r=e[o]).vx+=(i[o]-r.x)*n[o]*t}function a(){if(e){var o,a=e.length;for(n=new Array(a),i=new Array(a),o=0;o<a;++o)n[o]=isNaN(i[o]=+t(e[o],o,e))?0:+r(e[o],o,e)}}return"function"!=typeof t&&(t=XG(null==t?0:+t)),o.initialize=function(t){e=t,a()},o.strength=function(t){return arguments.length?(r="function"==typeof t?t:XG(+t),a(),o):r},o.x=function(e){return arguments.length?(t="function"==typeof e?e:XG(+e),a(),o):t},o},forceY:function Vdt(t){var e,n,i,r=XG(.1);function o(t){for(var r,o=0,a=e.length;o<a;++o)(r=e[o]).vy+=(i[o]-r.y)*n[o]*t}function a(){if(e){var o,a=e.length;for(n=new Array(a),i=new Array(a),o=0;o<a;++o)n[o]=isNaN(i[o]=+t(e[o],o,e))?0:+r(e[o],o,e)}}return"function"!=typeof t&&(t=XG(null==t?0:+t)),o.initialize=function(t){e=t,a()},o.strength=function(t){return arguments.length?(r="function"==typeof t?t:XG(+t),a(),o):r},o.y=function(e){return arguments.length?(t="function"==typeof e?e:XG(+e),a(),o):t},o},formatDefaultLocale:mq,get format(){return hq},get formatPrefix(){return dq},formatLocale:fq,formatSpecifier:sq,precisionFixed:function jdt(t){return Math.max(0,-eq(Math.abs(t)))},precisionPrefix:function Udt(t,e){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(eq(e)/3)))-eq(Math.abs(t)))},precisionRound:function Gdt(t,e){return t=Math.abs(t),e=Math.abs(e)-t,Math.max(0,eq(e)-eq(t))+1},geoArea:function Wdt(t){return eY.reset(),Xq(t,nY),2*eY},geoBounds:function qdt(t){var e,n,i,r,o,a,s;if(_Y=gY=-(fY=mY=1/0),wY=[],Xq(t,VY),n=wY.length){for(wY.sort(KY),e=1,o=[i=wY[0]];e<n;++e)ZY(i,(r=wY[e])[0])||ZY(i,r[1])?($Y(i[0],r[1])>$Y(i[0],i[1])&&(i[1]=r[1]),$Y(r[0],i[1])>$Y(i[0],i[1])&&(i[0]=r[0])):o.push(i=r);for(a=-1/0,e=0,i=o[n=o.length-1];e<=n;i=r,++e)(s=$Y(i[1],(r=o[e])[0]))>a&&(a=s,fY=r[0],gY=i[1])}return wY=SY=null,fY===1/0||mY===1/0?[[NaN,NaN],[NaN,NaN]]:[[fY,mY],[gY,_Y]]},geoCentroid:function Ydt(t){MY=EY=TY=AY=CY=kY=LY=PY=IY=NY=OY=0,Xq(t,JY);var e=IY,n=NY,i=OY,r=e*e+n*n+i*i;return r<1e-12&&(e=kY,n=LY,i=PY,EY<bq&&(e=TY,n=AY,i=CY),(r=e*e+n*n+i*i)<1e-12)?[NaN,NaN]:[kq(n,e)*Eq,Fq(i/Dq(r))*Eq]},geoCircle:function Xdt(){var t,e,n=cX([0,0]),i=cX(90),r=cX(6),o={point:function a(n,i){t.push(n=e(n,i)),n[0]*=Eq,n[1]*=Eq}};function s(){var a=n.apply(this,arguments),s=i.apply(this,arguments)*Tq,l=r.apply(this,arguments)*Tq;return t=[],e=dX(-a[0]*Tq,-a[1]*Tq,0).invert,_X(o,s,l,1),a={type:"Polygon",coordinates:[t]},t=e=null,a}return s.center=function(t){return arguments.length?(n="function"==typeof t?t:cX([+t[0],+t[1]]),s):n},s.radius=function(t){return arguments.length?(i="function"==typeof t?t:cX(+t),s):i},s.precision=function(t){return arguments.length?(r="function"==typeof t?t:cX(+t),s):r},s},geoClipAntimeridian:NX,geoClipCircle:zX,geoClipExtent:function $dt(){var t,e,n,i=0,r=0,o=960,a=500;return n={stream:function(n){return t&&e===n?t:t=HX(i,r,o,a)(e=n)},extent:function(s){return arguments.length?(i=+s[0][0],r=+s[0][1],o=+s[1][0],a=+s[1][1],t=e=null,n):[[i,r],[o,a]]}}},geoClipRectangle:HX,geoContains:function Kdt(t,e){return(t&&QX.hasOwnProperty(t.type)?QX[t.type]:e$)(t,e)},geoDistance:JX,geoGraticule:c$,geoGraticule10:function Zdt(){return c$()()},geoInterpolate:function Jdt(t,e){var n=t[0]*Tq,i=t[1]*Tq,r=e[0]*Tq,o=e[1]*Tq,a=Lq(i),s=Rq(i),l=Lq(o),c=Rq(o),u=a*Lq(n),h=a*Rq(n),d=l*Lq(r),p=l*Rq(r),f=2*Fq(Dq(Vq(o-i)+a*l*Vq(r-n))),m=Rq(f),g=f?function(t){var e=Rq(t*=f)/m,n=Rq(f-t)/m,i=n*u+e*d,r=n*h+e*p,o=n*s+e*c;return[kq(r,i)*Eq,kq(o,Dq(i*i+r*r))*Eq]}:function(){return[n*Eq,i*Eq]};return g.distance=f,g},geoLength:$X,geoPath:function Qdt(t,e){var n,i,r=4.5;function o(t){return t&&("function"==typeof r&&i.pointRadius(+r.apply(this,arguments)),Xq(t,n(i))),i.result()}return o.area=function(t){return Xq(t,n(_$)),_$.result()},o.measure=function(t){return Xq(t,n(rK)),rK.result()},o.bounds=function(t){return Xq(t,n(L$)),L$.result()},o.centroid=function(t){return Xq(t,n(V$)),V$.result()},o.projection=function(e){return arguments.length?(n=null==e?(t=null,u$):(t=e).stream,o):t},o.context=function(t){return arguments.length?(i=null==t?(e=null,new sK):new Z$(e=t),"function"!=typeof r&&i.pointRadius(r),o):e},o.pointRadius=function(t){return arguments.length?(r="function"==typeof t?t:(i.pointRadius(+t),+t),o):r},o.projection(t).context(e)},geoAlbers:MK,geoAlbersUsa:function tpt(){var t,e,n,i,r,o,a=MK(),s=SK().rotate([154,0]).center([-2,58.5]).parallels([55,65]),l=SK().rotate([157,0]).center([-3,19.9]).parallels([8,18]),c={point:function(t,e){o=[t,e]}};function u(t){var e=t[0],a=t[1];return o=null,n.point(e,a),o||(i.point(e,a),o)||(r.point(e,a),o)}function h(){return t=e=null,u}return u.invert=function(t){var e=a.scale(),n=a.translate(),i=(t[0]-n[0])/e,r=(t[1]-n[1])/e;return(r>=.12&&r<.234&&i>=-.425&&i<-.214?s:r>=.166&&r<.234&&i>=-.214&&i<-.115?l:a).invert(t)},u.stream=function(n){return t&&e===n?t:t=(function i(t){var e=t.length;return{point:function(n,i){for(var r=-1;++r<e;)t[r].point(n,i)},sphere:function(){for(var n=-1;++n<e;)t[n].sphere()},lineStart:function(){for(var n=-1;++n<e;)t[n].lineStart()},lineEnd:function(){for(var n=-1;++n<e;)t[n].lineEnd()},polygonStart:function(){for(var n=-1;++n<e;)t[n].polygonStart()},polygonEnd:function(){for(var n=-1;++n<e;)t[n].polygonEnd()}}})([a.stream(e=n),s.stream(n),l.stream(n)])},u.precision=function(t){return arguments.length?(a.precision(t),s.precision(t),l.precision(t),h()):a.precision()},u.scale=function(t){return arguments.length?(a.scale(t),s.scale(.35*t),l.scale(t),u.translate(a.translate())):a.scale()},u.translate=function(t){if(!arguments.length)return a.translate();var e=a.scale(),o=+t[0],u=+t[1];return n=a.translate(t).clipExtent([[o-.455*e,u-.238*e],[o+.455*e,u+.238*e]]).stream(c),i=s.translate([o-.307*e,u+.201*e]).clipExtent([[o-.425*e+bq,u+.12*e+bq],[o-.214*e-bq,u+.234*e-bq]]).stream(c),r=l.translate([o-.205*e,u+.212*e]).clipExtent([[o-.214*e+bq,u+.166*e+bq],[o-.115*e-bq,u+.234*e-bq]]).stream(c),h()},u.fitExtent=function(t,e){return dK(u,t,e)},u.fitSize=function(t,e){return pK(u,t,e)},u.fitWidth=function(t,e){return fK(u,t,e)},u.fitHeight=function(t,e){return mK(u,t,e)},u.scale(1070)},geoAzimuthalEqualArea:function ept(){return vK(AK).scale(124.75).clipAngle(179.999)},geoAzimuthalEqualAreaRaw:AK,geoAzimuthalEquidistant:function npt(){return vK(CK).scale(79.4188).clipAngle(179.999)},geoAzimuthalEquidistantRaw:CK,geoConicConformal:function ipt(){return xK(IK).scale(109.5).parallels([30,30])},geoConicConformalRaw:IK,geoConicEqualArea:SK,geoConicEqualAreaRaw:wK,geoConicEquidistant:function rpt(){return xK(OK).scale(131.154).center([0,13.9389])},geoConicEquidistantRaw:OK,geoEquirectangular:function opt(){return vK(NK).scale(152.63)},geoEquirectangularRaw:NK,geoGnomonic:function apt(){return vK(RK).scale(144.049).clipAngle(60)},geoGnomonicRaw:RK,geoIdentity:function spt(){var t,e,n,i,r,o,a=1,s=0,l=0,c=1,u=1,h=u$,d=null,p=u$;function f(){return i=r=null,o}return o={stream:function(t){return i&&r===t?i:i=h(p(r=t))},postclip:function(i){return arguments.length?(p=i,d=t=e=n=null,f()):p},clipExtent:function(i){return arguments.length?(p=null==i?(d=t=e=n=null,u$):HX(d=+i[0][0],t=+i[0][1],e=+i[1][0],n=+i[1][1]),f()):null==d?null:[[d,t],[e,n]]},scale:function(t){return arguments.length?(h=zK((a=+t)*c,a*u,s,l),f()):a},translate:function(t){return arguments.length?(h=zK(a*c,a*u,s=+t[0],l=+t[1]),f()):[s,l]},reflectX:function(t){return arguments.length?(h=zK(a*(c=t?-1:1),a*u,s,l),f()):c<0},reflectY:function(t){return arguments.length?(h=zK(a*c,a*(u=t?-1:1),s,l),f()):u<0},fitExtent:function(t,e){return dK(o,t,e)},fitSize:function(t,e){return pK(o,t,e)},fitWidth:function(t,e){return fK(o,t,e)},fitHeight:function(t,e){return mK(o,t,e)}}},geoProjection:vK,geoProjectionMutator:bK,geoMercator:function lpt(){return LK(kK).scale(961/Mq)},geoMercatorRaw:kK,geoNaturalEarth1:function cpt(){return vK(DK).scale(175.295)},geoNaturalEarth1Raw:DK,geoOrthographic:function upt(){return vK(BK).scale(249.5).clipAngle(90.000001)},geoOrthographicRaw:BK,geoStereographic:function hpt(){return vK(HK).scale(250).clipAngle(142)},geoStereographicRaw:HK,geoTransverseMercator:function dpt(){var t=LK(FK),e=t.center,n=t.rotate;return t.center=function(t){return arguments.length?e([-t[1],t[0]]):[(t=e())[1],-t[0]]},t.rotate=function(t){return arguments.length?n([t[0],t[1],t.length>2?t[2]+90:90]):[(t=n())[0],t[1],t[2]-90]},n([0,0,90]).scale(159.155)},geoTransverseMercatorRaw:FK,geoRotation:gX,geoStream:Xq,geoTransform:function ppt(t){return{stream:cK(t)}},cluster:function fpt(){var t=VK,e=1,n=1,i=!1;function r(r){var o,a=0;r.eachAfter((function(e){var n=e.children;n?(e.x=(function i(t){return t.reduce(jK,0)/t.length})(n),e.y=(function r(t){return 1+t.reduce(UK,0)})(n)):(e.x=o?a+=t(e,o):0,e.y=0,o=e)}));var s=(function l(t){for(var e;e=t.children;)t=e[0];return t})(r),c=(function u(t){for(var e;e=t.children;)t=e[e.length-1];return t})(r),h=s.x-t(s,c)/2,d=c.x+t(c,s)/2;return r.eachAfter(i?function(t){t.x=(t.x-r.x)*e,t.y=(r.y-t.y)*n}:function(t){t.x=(t.x-h)/(d-h)*e,t.y=(1-(r.y?t.y/r.y:1))*n})}return r.separation=function(e){return arguments.length?(t=e,r):t},r.size=function(t){return arguments.length?(i=!1,e=+t[0],n=+t[1],r):i?null:[e,n]},r.nodeSize=function(t){return arguments.length?(i=!0,e=+t[0],n=+t[1],r):i?[e,n]:null},r},hierarchy:WK,pack:function mpt(){var t=null,e=1,n=1,i=MZ;function r(r){return r.x=e/2,r.y=n/2,t?r.eachBefore(AZ(t)).eachAfter(CZ(i,.5)).eachBefore(kZ(1)):r.eachBefore(AZ(TZ)).eachAfter(CZ(MZ,1)).eachAfter(CZ(i,r.r/Math.min(e,n))).eachBefore(kZ(Math.min(e,n)/(2*r.r))),r}return r.radius=function(e){return arguments.length?(t=wZ(e),r):t},r.size=function(t){return arguments.length?(e=+t[0],n=+t[1],r):[e,n]},r.padding=function(t){return arguments.length?(i="function"==typeof t?t:EZ(+t),r):i},r},packSiblings:function gpt(t){return xZ(t),t},packEnclose:cZ,partition:function _pt(){var t=1,e=1,n=0,i=!1;function r(r){var o=r.height+1;return r.x0=r.y0=n,r.x1=t,r.y1=e/o,r.eachBefore((function a(t,e){return function(i){i.children&&PZ(i,i.x0,t*(i.depth+1)/e,i.x1,t*(i.depth+2)/e);var r=i.x0,o=i.y0,a=i.x1-n,s=i.y1-n;a<r&&(r=a=(r+a)/2),s<o&&(o=s=(o+s)/2),i.x0=r,i.y0=o,i.x1=a,i.y1=s}})(e,o)),i&&r.eachBefore(LZ),r}return r.round=function(t){return arguments.length?(i=!!t,r):i},r.size=function(n){return arguments.length?(t=+n[0],e=+n[1],r):[t,e]},r.padding=function(t){return arguments.length?(n=+t,r):n},r},stratify:function ypt(){var t=OZ,e=RZ;function n(n){var i,r,o,a,s,l,c,u=n.length,h=new Array(u),d={};for(r=0;r<u;++r)s=h[r]=new $K(i=n[r]),null!=(l=t(i,r,n))&&(l+="")&&(d[c="$"+(s.id=l)]=c in d?NZ:s);for(r=0;r<u;++r)if(s=h[r],null!=(l=e(n[r],r,n))&&(l+="")){if(!(a=d["$"+l]))throw new Error("missing: "+l);if(a===NZ)throw new Error("ambiguous: "+l);a.children?a.children.push(s):a.children=[s],s.parent=a}else{if(o)throw new Error("multiple roots");o=s}if(!o)throw new Error("no root");if(o.parent=IZ,o.eachBefore((function(t){t.depth=t.parent.depth+1,--u})).eachBefore(XK),o.parent=null,u>0)throw new Error("cycle");return o}return n.id=function(e){return arguments.length?(t=SZ(e),n):t},n.parentId=function(t){return arguments.length?(e=SZ(t),n):e},n},tree:function vpt(){var t=zZ,e=1,n=1,i=null;function r(r){var l=(function c(t){for(var e,n,i,r,o,a=new VZ(t,0),s=[a];e=s.pop();)if(i=e._.children)for(e.children=new Array(o=i.length),r=o-1;r>=0;--r)s.push(n=e.children[r]=new VZ(i[r],r)),n.parent=e;return(a.parent=new VZ(null,0)).children=[a],a})(r);if(l.eachAfter(o),l.parent.m=-l.z,l.eachBefore(a),i)r.eachBefore(s);else{var u=r,h=r,d=r;r.eachBefore((function(t){t.x<u.x&&(u=t),t.x>h.x&&(h=t),t.depth>d.depth&&(d=t)}));var p=u===h?1:t(u,h)/2,f=p-u.x,m=e/(h.x+p+f),g=n/(d.depth||1);r.eachBefore((function(t){t.x=(t.x+f)*m,t.y=t.depth*g}))}return r}function o(e){var n=e.children,i=e.parent.children,r=e.i?i[e.i-1]:null;if(n){!(function o(t){for(var e,n=0,i=0,r=t.children,o=r.length;--o>=0;)(e=r[o]).z+=n,e.m+=n,n+=e.s+(i+=e.c)})(e);var a=(n[0].z+n[n.length-1].z)/2;r?(e.z=r.z+t(e._,r._),e.m=e.z-a):e.z=a}else r&&(e.z=r.z+t(e._,r._));e.parent.A=(function s(e,n,i){if(n){for(var r,o=e,a=e,s=n,l=o.parent.children[0],c=o.m,u=a.m,h=s.m,d=l.m;s=BZ(s),o=DZ(o),s&&o;)l=DZ(l),(a=BZ(a)).a=e,(r=s.z+h-o.z-c+t(s._,o._))>0&&(HZ(FZ(s,e,i),e,r),c+=r,u+=r),h+=s.m,c+=o.m,d+=l.m,u+=a.m;s&&!BZ(a)&&(a.t=s,a.m+=h-u),o&&!DZ(l)&&(l.t=o,l.m+=c-d,i=e)}return i})(e,r,e.parent.A||i[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function s(t){t.x*=e,t.y=t.depth*n}return r.separation=function(e){return arguments.length?(t=e,r):t},r.size=function(t){return arguments.length?(i=!1,e=+t[0],n=+t[1],r):i?null:[e,n]},r.nodeSize=function(t){return arguments.length?(i=!0,e=+t[0],n=+t[1],r):i?[e,n]:null},r},treemap:function bpt(){var t=WZ,e=!1,n=1,i=1,r=[0],o=MZ,a=MZ,s=MZ,l=MZ,c=MZ;function u(t){return t.x0=t.y0=0,t.x1=n,t.y1=i,t.eachBefore(h),r=[0],e&&t.eachBefore(LZ),t}function h(e){var n=r[e.depth],i=e.x0+n,u=e.y0+n,h=e.x1-n,d=e.y1-n;h<i&&(i=h=(i+h)/2),d<u&&(u=d=(u+d)/2),e.x0=i,e.y0=u,e.x1=h,e.y1=d,e.children&&(n=r[e.depth+1]=o(e)/2,i+=c(e)-n,u+=a(e)-n,(h-=s(e)-n)<i&&(i=h=(i+h)/2),(d-=l(e)-n)<u&&(u=d=(u+d)/2),t(e,i,u,h,d))}return u.round=function(t){return arguments.length?(e=!!t,u):e},u.size=function(t){return arguments.length?(n=+t[0],i=+t[1],u):[n,i]},u.tile=function(e){return arguments.length?(t=SZ(e),u):t},u.padding=function(t){return arguments.length?u.paddingInner(t).paddingOuter(t):u.paddingInner()},u.paddingInner=function(t){return arguments.length?(o="function"==typeof t?t:EZ(+t),u):o},u.paddingOuter=function(t){return arguments.length?u.paddingTop(t).paddingRight(t).paddingBottom(t).paddingLeft(t):u.paddingTop()},u.paddingTop=function(t){return arguments.length?(a="function"==typeof t?t:EZ(+t),u):a},u.paddingRight=function(t){return arguments.length?(s="function"==typeof t?t:EZ(+t),u):s},u.paddingBottom=function(t){return arguments.length?(l="function"==typeof t?t:EZ(+t),u):l},u.paddingLeft=function(t){return arguments.length?(c="function"==typeof t?t:EZ(+t),u):c},u},treemapBinary:function xpt(t,e,n,i,r){var o,a,s=t.children,l=s.length,c=new Array(l+1);for(c[0]=a=o=0;o<l;++o)c[o+1]=a+=s[o].value;!(function t(e,n,i,r,o,a,l){if(e>=n-1){var u=s[e];return u.x0=r,u.y0=o,u.x1=a,void(u.y1=l)}for(var h=c[e],d=i/2+h,p=e+1,f=n-1;p<f;){var m=p+f>>>1;c[m]<d?p=m+1:f=m}d-c[p-1]<c[p]-d&&e+1<p&&--p;var g=c[p]-h,_=i-g;if(a-r>l-o){var y=(r*_+a*g)/i;t(e,p,g,r,o,y,l),t(p,n,_,y,o,a,l)}else{var v=(o*_+l*g)/i;t(e,p,g,r,o,a,v),t(p,n,_,r,v,a,l)}})(0,l,t.value,e,n,i,r)},treemapDice:PZ,treemapSlice:jZ,treemapSliceDice:function wpt(t,e,n,i,r){(1&t.depth?jZ:PZ)(t,e,n,i,r)},treemapSquarify:WZ,treemapResquarify:qZ,interpolate:fQ,interpolateArray:sQ,interpolateBasis:ZJ,interpolateBasisClosed:JJ,interpolateDate:lQ,interpolateNumber:cQ,interpolateObject:uQ,interpolateRound:function Spt(t,e){return e-=t=+t,function(n){return Math.round(t+e*n)}},interpolateString:pQ,interpolateTransformCss:SQ,interpolateTransformSvg:EQ,interpolateZoom:function Mpt(t,e){var n,i,r=t[0],o=t[1],a=t[2],s=e[2],l=e[0]-r,c=e[1]-o,u=l*l+c*c;if(u<1e-12)i=Math.log(s/a)/AQ,n=function(t){return[r+t*l,o+t*c,a*Math.exp(AQ*t*i)]};else{var h=Math.sqrt(u),d=(s*s-a*a+4*u)/(2*a*2*h),p=(s*s-a*a-4*u)/(2*s*2*h),f=Math.log(Math.sqrt(d*d+1)-d),m=Math.log(Math.sqrt(p*p+1)-p);i=(m-f)/AQ,n=function(t){var e=t*i,n=CQ(f),s=a/(2*h)*(n*(function u(t){return((t=Math.exp(2*t))-1)/(t+1)})(AQ*e+f)-(function d(t){return((t=Math.exp(t))-1/t)/2})(f));return[r+s*l,o+s*c,a*n/CQ(AQ*e+f)]}}return n.duration=1e3*i,n},interpolateRgb:iQ,interpolateRgbBasis:oQ,interpolateRgbBasisClosed:aQ,interpolateHsl:LQ,interpolateHslLong:PQ,interpolateLab:function Ept(t,e){var n=nQ((t=OJ(t)).l,(e=OJ(e)).l),i=nQ(t.a,e.a),r=nQ(t.b,e.b),o=nQ(t.opacity,e.opacity);return function(e){return t.l=n(e),t.a=i(e),t.b=r(e),t.opacity=o(e),t+""}},interpolateHcl:NQ,interpolateHclLong:OQ,interpolateCubehelix:zQ,interpolateCubehelixLong:DQ,quantize:function Tpt(t,e){for(var n=new Array(e),i=0;i<e;++i)n[i]=t(i/(e-1));return n},path:UQ,polygonArea:function Apt(t){for(var e,n=-1,i=t.length,r=t[i-1],o=0;++n<i;)o+=(e=r)[1]*(r=t[n])[0]-e[0]*r[1];return o/2},polygonCentroid:function Cpt(t){for(var e,n,i=-1,r=t.length,o=0,a=0,s=t[r-1],l=0;++i<r;)l+=n=(e=s)[0]*(s=t[i])[1]-s[0]*e[1],o+=(e[0]+s[0])*n,a+=(e[1]+s[1])*n;return[o/(l*=3),a/l]},polygonHull:function kpt(t){if((n=t.length)<3)return null;var e,n,i=new Array(n),r=new Array(n);for(e=0;e<n;++e)i[e]=[+t[e][0],+t[e][1],e];for(i.sort(WQ),e=0;e<n;++e)r[e]=[i[e][0],-i[e][1]];var o=qQ(i),a=qQ(r),s=a[0]===o[0],l=a[a.length-1]===o[o.length-1],c=[];for(e=o.length-1;e>=0;--e)c.push(t[i[o[e]][2]]);for(e=+s;e<a.length-l;++e)c.push(t[i[a[e]][2]]);return c},polygonContains:function Lpt(t,e){for(var n,i,r=t.length,o=t[r-1],a=e[0],s=e[1],l=o[0],c=o[1],u=!1,h=0;h<r;++h)n=(o=t[h])[0],(i=o[1])>s!=c>s&&a<(l-n)*(s-i)/(c-i)+n&&(u=!u),l=n,c=i;return u},polygonLength:function Ppt(t){for(var e,n,i=-1,r=t.length,o=t[r-1],a=o[0],s=o[1],l=0;++i<r;)e=a,n=s,e-=a=(o=t[i])[0],n-=s=o[1],l+=Math.sqrt(e*e+n*n);return l},quadtree:ZQ,queue:w1,randomUniform:M1,randomNormal:E1,randomLogNormal:T1,randomBates:C1,randomIrwinHall:A1,randomExponential:k1,request:L1,html:I1,json:N1,text:O1,xml:R1,csv:B1,tsv:H1,scaleBand:s0,scalePoint:function Ipt(){return l0(s0().paddingInner(1))},scaleIdentity:function t(){var e=[0,1];function n(t){return+t}return n.invert=n,n.domain=n.range=function(t){return arguments.length?(e=i0.call(t,v2),n):e.slice()},n.copy=function(){return t().domain(e)},V2(n)},scaleLinear:function t(){var e=E2(x2,l2);return e.copy=function(){return M2(e,t())},V2(e)},scaleLog:function t(){var e=E2(U2,G2).domain([1,10]),n=e.domain,i=10,r=Y2(10),o=q2(10);function a(){return r=Y2(i),o=q2(i),n()[0]<0&&(r=X2(r),o=X2(o)),e}return e.base=function(t){return arguments.length?(i=+t,a()):i},e.domain=function(t){return arguments.length?(n(t),a()):n()},e.ticks=function(t){var e,a=n(),s=a[0],l=a[a.length-1];(e=l<s)&&(d=s,s=l,l=d);var c,u,h,d=r(s),p=r(l),f=null==t?10:+t,m=[];if(!(i%1)&&p-d<f){if(d=Math.round(d)-1,p=Math.round(p)+1,s>0){for(;d<p;++d)for(u=1,c=o(d);u<i;++u)if(!((h=c*u)<s)){if(h>l)break;m.push(h)}}else for(;d<p;++d)for(u=i-1,c=o(d);u>=1;--u)if(!((h=c*u)<s)){if(h>l)break;m.push(h)}}else m=Y1(d,p,Math.min(p-d,f)).map(o);return e?m.reverse():m},e.tickFormat=function(t,n){if(null==n&&(n=10===i?".0e":","),"function"!=typeof n&&(n=D2(n)),t===1/0)return n;null==t&&(t=10);var a=Math.max(1,i*t/e.ticks().length);return function(t){var e=t/o(Math.round(r(t)));return e*i<i-.5&&(e*=i),e<=a?n(t):""}},e.nice=function(){return n(j2(n(),{floor:function(t){return o(Math.floor(r(t)))},ceil:function(t){return o(Math.ceil(r(t)))}}))},e.copy=function(){return M2(e,t().base(i))},e},scaleOrdinal:a0,scaleImplicit:o0,scalePow:K2,scaleSqrt:function Npt(){return K2().exponent(.5)},scaleQuantile:function t(){var e=[],n=[],i=[];function r(){var t=0,r=Math.max(1,n.length);for(i=new Array(r-1);++t<r;)i[t-1]=K1(e,t/r);return o}function o(t){if(!isNaN(t=+t))return n[j1(i,t)]}return o.invertExtent=function(t){var r=n.indexOf(t);return r<0?[NaN,NaN]:[r>0?i[r-1]:e[0],r<i.length?i[r]:e[e.length-1]]},o.domain=function(t){if(!arguments.length)return e.slice();e=[];for(var n,i=0,o=t.length;i<o;++i)null==(n=t[i])||isNaN(n=+n)||e.push(n);return e.sort(F1),r()},o.range=function(t){return arguments.length?(n=r0.call(t),r()):n.slice()},o.quantiles=function(){return i.slice()},o.copy=function(){return t().domain(e).range(n)},o},scaleQuantize:function t(){var e=0,n=1,i=1,r=[.5],o=[0,1];function a(t){if(t<=t)return o[j1(r,t,0,i)]}function s(){var t=-1;for(r=new Array(i);++t<i;)r[t]=((t+1)*n-(t-i)*e)/(i+1);return a}return a.domain=function(t){return arguments.length?(e=+t[0],n=+t[1],s()):[e,n]},a.range=function(t){return arguments.length?(i=(o=r0.call(t)).length-1,s()):o.slice()},a.invertExtent=function(t){var a=o.indexOf(t);return a<0?[NaN,NaN]:a<1?[e,r[0]]:a>=i?[r[i-1],n]:[r[a-1],r[a]]},a.copy=function(){return t().domain([e,n]).range(o)},V2(a)},scaleThreshold:function t(){var e=[.5],n=[0,1],i=1;function r(t){if(t<=t)return n[j1(e,t,0,i)]}return r.domain=function(t){return arguments.length?(e=r0.call(t),i=Math.min(e.length,n.length-1),r):e.slice()},r.range=function(t){return arguments.length?(n=r0.call(t),i=Math.min(e.length,n.length-1),r):n.slice()},r.invertExtent=function(t){var i=n.indexOf(t);return[e[i-1],e[i]]},r.copy=function(){return t().domain(e).range(n)},r},scaleTime:function Opt(){return Y3(g5,m5,d5,u5,c5,l5,s5,e5,L5).domain([new Date(2e3,0,1),new Date(2e3,0,2)])},scaleUtc:function Rpt(){return Y3(E5,M5,x5,v5,y5,_5,s5,e5,P5).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])},schemeCategory10:$3,schemeCategory20b:K3,schemeCategory20c:Z3,schemeCategory20:J3,interpolateCubehelixDefault:Q3,interpolateRainbow:function zpt(t){(t<0||t>1)&&(t-=Math.floor(t));var e=Math.abs(t-.5);return n4.h=360*t-100,n4.s=1.5-1.5*e,n4.l=.8-.9*e,n4+""},interpolateWarm:t4,interpolateCool:e4,interpolateViridis:r4,interpolateMagma:o4,interpolateInferno:a4,interpolatePlasma:s4,scaleSequential:function t(e){var n=0,i=1,r=!1;function o(t){var o=(t-n)/(i-n);return e(r?Math.max(0,Math.min(1,o)):o)}return o.domain=function(t){return arguments.length?(n=+t[0],i=+t[1],o):[n,i]},o.clamp=function(t){return arguments.length?(r=!!t,o):r},o.interpolator=function(t){return arguments.length?(e=t,o):e},o.copy=function(){return t(e).domain([n,i]).clamp(r)},V2(o)},create:function Dpt(t){return b6(p4(t).call(document.documentElement))},creator:p4,local:J6,matcher:x4,mouse:function Bpt(t){var e=t9();return e.changedTouches&&(e=e.changedTouches[0]),e9(t,e)},namespace:u4,namespaces:c4,clientPoint:e9,select:b6,selectAll:function Hpt(t){return"string"==typeof t?new y6([document.querySelectorAll(t)],[document.documentElement]):new y6([null==t?[]:t],_6)},selection:v6,selector:m4,selectorAll:_4,style:D4,touch:function Fpt(t,e,n){arguments.length<3&&(n=e,e=t9().changedTouches);for(var i,r=0,o=e?e.length:0;r<o;++r)if((i=e[r]).identifier===n)return e9(t,i);return null},touches:function Vpt(t,e){null==e&&(e=t9().touches);for(var n=0,i=e?e.length:0,r=new Array(i);n<i;++n)r[n]=e9(t,e[n]);return r},window:N4,get event(){return l6},customEvent:function jpt(t,e,n,i){var r=l6;t.sourceEvent=l6,l6=t;try{return e.apply(n,i)}finally{l6=r}},arc:function Upt(){var t=w9,e=S9,n=l9(0),i=null,r=M9,o=E9,a=T9,s=null;function l(){var l,c,u=+t.apply(this,arguments),h=+e.apply(this,arguments),d=r.apply(this,arguments)-y9,p=o.apply(this,arguments)-y9,f=c9(p-d),m=p>d;if(s||(s=l=s9()),h<u&&(c=h,h=u,u=c),h>g9)if(f>v9-g9)s.moveTo(h*h9(d),h*f9(d)),s.arc(0,0,h,d,p,!m),u>g9&&(s.moveTo(u*h9(p),u*f9(p)),s.arc(0,0,u,p,d,m));else{var g,_,y=d,v=p,b=d,x=p,w=f,S=f,M=a.apply(this,arguments)/2,E=M>g9&&(i?+i.apply(this,arguments):m9(u*u+h*h)),T=p9(c9(h-u)/2,+n.apply(this,arguments)),A=T,C=T;if(E>g9){var k=x9(E/u*f9(M)),L=x9(E/h*f9(M));(w-=2*k)>g9?(b+=k*=m?1:-1,x-=k):(w=0,b=x=(d+p)/2),(S-=2*L)>g9?(y+=L*=m?1:-1,v-=L):(S=0,y=v=(d+p)/2)}var P=h*h9(y),I=h*f9(y),N=u*h9(x),O=u*f9(x);if(T>g9){var R=h*h9(v),z=h*f9(v),D=u*h9(b),B=u*f9(b);if(f<_9){var H=w>g9?A9(P,I,D,B,R,z,N,O):[N,O],F=P-H[0],V=I-H[1],j=R-H[0],U=z-H[1],G=1/f9(b9((F*j+V*U)/(m9(F*F+V*V)*m9(j*j+U*U)))/2),W=m9(H[0]*H[0]+H[1]*H[1]);A=p9(T,(u-W)/(G-1)),C=p9(T,(h-W)/(G+1))}}S>g9?C>g9?(g=C9(D,B,P,I,h,C,m),_=C9(R,z,N,O,h,C,m),s.moveTo(g.cx+g.x01,g.cy+g.y01),C<T?s.arc(g.cx,g.cy,C,u9(g.y01,g.x01),u9(_.y01,_.x01),!m):(s.arc(g.cx,g.cy,C,u9(g.y01,g.x01),u9(g.y11,g.x11),!m),s.arc(0,0,h,u9(g.cy+g.y11,g.cx+g.x11),u9(_.cy+_.y11,_.cx+_.x11),!m),s.arc(_.cx,_.cy,C,u9(_.y11,_.x11),u9(_.y01,_.x01),!m))):(s.moveTo(P,I),s.arc(0,0,h,y,v,!m)):s.moveTo(P,I),u>g9&&w>g9?A>g9?(g=C9(N,O,R,z,u,-A,m),_=C9(P,I,D,B,u,-A,m),s.lineTo(g.cx+g.x01,g.cy+g.y01),A<T?s.arc(g.cx,g.cy,A,u9(g.y01,g.x01),u9(_.y01,_.x01),!m):(s.arc(g.cx,g.cy,A,u9(g.y01,g.x01),u9(g.y11,g.x11),!m),s.arc(0,0,u,u9(g.cy+g.y11,g.cx+g.x11),u9(_.cy+_.y11,_.cx+_.x11),m),s.arc(_.cx,_.cy,A,u9(_.y11,_.x11),u9(_.y01,_.x01),!m))):s.arc(0,0,u,x,b,m):s.lineTo(N,O)}else s.moveTo(0,0);if(s.closePath(),l)return s=null,l+""||null}return l.centroid=function(){var n=(+t.apply(this,arguments)+ +e.apply(this,arguments))/2,i=(+r.apply(this,arguments)+ +o.apply(this,arguments))/2-_9/2;return[h9(i)*n,f9(i)*n]},l.innerRadius=function(e){return arguments.length?(t="function"==typeof e?e:l9(+e),l):t},l.outerRadius=function(t){return arguments.length?(e="function"==typeof t?t:l9(+t),l):e},l.cornerRadius=function(t){return arguments.length?(n="function"==typeof t?t:l9(+t),l):n},l.padRadius=function(t){return arguments.length?(i=null==t?null:"function"==typeof t?t:l9(+t),l):i},l.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:l9(+t),l):r},l.endAngle=function(t){return arguments.length?(o="function"==typeof t?t:l9(+t),l):o},l.padAngle=function(t){return arguments.length?(a="function"==typeof t?t:l9(+t),l):a},l.context=function(t){return arguments.length?(s=null==t?null:t,l):s},l},area:O9,line:N9,pie:function Gpt(){var t=z9,e=R9,n=null,i=l9(0),r=l9(v9),o=l9(0);function a(a){var s,l,c,u,h,d=a.length,p=0,f=new Array(d),m=new Array(d),g=+i.apply(this,arguments),_=Math.min(v9,Math.max(-v9,r.apply(this,arguments)-g)),y=Math.min(Math.abs(_)/d,o.apply(this,arguments)),v=y*(_<0?-1:1);for(s=0;s<d;++s)(h=m[f[s]=s]=+t(a[s],s,a))>0&&(p+=h);for(null!=e?f.sort((function(t,n){return e(m[t],m[n])})):null!=n&&f.sort((function(t,e){return n(a[t],a[e])})),s=0,c=p?(_-d*v)/p:0;s<d;++s,g=u)m[l=f[s]]={data:a[l],index:s,value:h=m[l],startAngle:g,endAngle:u=g+(h>0?h*c:0)+v,padAngle:y};return m}return a.value=function(e){return arguments.length?(t="function"==typeof e?e:l9(+e),a):t},a.sortValues=function(t){return arguments.length?(e=t,n=null,a):e},a.sort=function(t){return arguments.length?(n=t,e=null,a):n},a.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:l9(+t),a):i},a.endAngle=function(t){return arguments.length?(r="function"==typeof t?t:l9(+t),a):r},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:l9(+t),a):o},a},areaRadial:j9,radialArea:j9,lineRadial:V9,radialLine:V9,pointRadial:U9,linkHorizontal:function Wpt(){return Y9(X9)},linkVertical:function qpt(){return Y9($9)},linkRadial:function Ypt(){var t=Y9(K9);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},symbol:function Xpt(){var t=l9(Z9),e=l9(64),n=null;function i(){var i;if(n||(n=i=s9()),t.apply(this,arguments).draw(n,+e.apply(this,arguments)),i)return n=null,i+""||null}return i.type=function(e){return arguments.length?(t="function"==typeof e?e:l9(e),i):t},i.size=function(t){return arguments.length?(e="function"==typeof t?t:l9(+t),i):e},i.context=function(t){return arguments.length?(n=null==t?null:t,i):n},i},symbols:f8,symbolCircle:Z9,symbolCross:J9,symbolDiamond:e8,symbolSquare:a8,symbolStar:o8,symbolTriangle:l8,symbolWye:p8,curveBasisClosed:function $pt(t){return new y8(t)},curveBasisOpen:function Kpt(t){return new v8(t)},curveBasis:function Zpt(t){return new _8(t)},curveBundle:x8,curveCardinalClosed:T8,curveCardinalOpen:C8,curveCardinal:M8,curveCatmullRomClosed:N8,curveCatmullRomOpen:R8,curveCatmullRom:P8,curveLinearClosed:function Jpt(t){return new z8(t)},curveLinear:L9,curveMonotoneX:function Qpt(t){return new V8(t)},curveMonotoneY:function tft(t){return new j8(t)},curveNatural:function eft(t){return new G8(t)},curveStep:function nft(t){return new q8(t,.5)},curveStepAfter:function ift(t){return new q8(t,1)},curveStepBefore:function rft(t){return new q8(t,0)},stack:function oft(){var t=l9([]),e=X8,n=Y8,i=$8;function r(r){var o,a,s=t.apply(this,arguments),l=r.length,c=s.length,u=new Array(c);for(o=0;o<c;++o){for(var h,d=s[o],p=u[o]=new Array(l),f=0;f<l;++f)p[f]=h=[0,+i(r[f],d,f,r)],h.data=r[f];p.key=d}for(o=0,a=e(u);o<c;++o)u[a[o]].index=o;return n(u,a),u}return r.keys=function(e){return arguments.length?(t="function"==typeof e?e:l9(G9.call(e)),r):t},r.value=function(t){return arguments.length?(i="function"==typeof t?t:l9(+t),r):i},r.order=function(t){return arguments.length?(e=null==t?X8:"function"==typeof t?t:l9(G9.call(t)),r):e},r.offset=function(t){return arguments.length?(n=null==t?Y8:t,r):n},r},stackOffsetExpand:function aft(t,e){if((i=t.length)>0){for(var n,i,r,o=0,a=t[0].length;o<a;++o){for(r=n=0;n<i;++n)r+=t[n][o][1]||0;if(r)for(n=0;n<i;++n)t[n][o][1]/=r}Y8(t,e)}},stackOffsetDiverging:function sft(t,e){if((s=t.length)>1)for(var n,i,r,o,a,s,l=0,c=t[e[0]].length;l<c;++l)for(o=a=0,n=0;n<s;++n)(r=(i=t[e[n]][l])[1]-i[0])>=0?(i[0]=o,i[1]=o+=r):r<0?(i[1]=a,i[0]=a+=r):i[0]=o},stackOffsetNone:Y8,stackOffsetSilhouette:function lft(t,e){if((n=t.length)>0){for(var n,i=0,r=t[e[0]],o=r.length;i<o;++i){for(var a=0,s=0;a<n;++a)s+=t[a][i][1]||0;r[i][1]+=r[i][0]=-s/2}Y8(t,e)}},stackOffsetWiggle:function cft(t,e){if((r=t.length)>0&&(i=(n=t[e[0]]).length)>0){for(var n,i,r,o=0,a=1;a<i;++a){for(var s=0,l=0,c=0;s<r;++s){for(var u=t[e[s]],h=u[a][1]||0,d=(h-(u[a-1][1]||0))/2,p=0;p<s;++p){var f=t[e[p]];d+=(f[a][1]||0)-(f[a-1][1]||0)}l+=h,c+=d*h}n[a-1][1]+=n[a-1][0]=o,l&&(o-=c/l)}n[a-1][1]+=n[a-1][0]=o,Y8(t,e)}},stackOrderAscending:K8,stackOrderDescending:function uft(t){return K8(t).reverse()},stackOrderInsideOut:function hft(t){var e,n,i=t.length,r=t.map(Z8),o=X8(t).sort((function(t,e){return r[e]-r[t]})),a=0,s=0,l=[],c=[];for(e=0;e<i;++e)n=o[e],a<s?(a+=r[n],l.push(n)):(s+=r[n],c.push(n));return c.reverse().concat(l)},stackOrderNone:X8,stackOrderReverse:function dft(t){return X8(t).reverse()},timeInterval:t7,timeMillisecond:e7,timeMilliseconds:n7,utcMillisecond:e7,utcMilliseconds:n7,timeSecond:l7,timeSeconds:c7,utcSecond:l7,utcSeconds:c7,timeMinute:u7,timeMinutes:h7,timeHour:d7,timeHours:p7,timeDay:f7,timeDays:m7,timeWeek:_7,timeWeeks:M7,timeSunday:_7,timeSundays:M7,timeMonday:y7,timeMondays:E7,timeTuesday:v7,timeTuesdays:T7,timeWednesday:b7,timeWednesdays:A7,timeThursday:x7,timeThursdays:C7,timeFriday:w7,timeFridays:k7,timeSaturday:S7,timeSaturdays:L7,timeMonth:P7,timeMonths:I7,timeYear:N7,timeYears:O7,utcMinute:R7,utcMinutes:z7,utcHour:D7,utcHours:B7,utcDay:H7,utcDays:F7,utcWeek:j7,utcWeeks:$7,utcSunday:j7,utcSundays:$7,utcMonday:U7,utcMondays:K7,utcTuesday:G7,utcTuesdays:Z7,utcWednesday:W7,utcWednesdays:J7,utcThursday:q7,utcThursdays:Q7,utcFriday:Y7,utcFridays:ttt,utcSaturday:X7,utcSaturdays:ett,utcMonth:ntt,utcMonths:itt,utcYear:rtt,utcYears:ott,timeFormatDefaultLocale:Get,get timeFormat(){return Ctt},get timeParse(){return ktt},get utcFormat(){return Ltt},get utcParse(){return Ptt},timeFormatLocale:Ttt,isoFormat:Xet,isoParse:Ket,now:ant,timer:cnt,timerFlush:unt,timeout:function pft(t,e,n){var i=new lnt;return i.restart((function(n){i.stop(),t(n+e)}),e=null==e?0:+e,n),i},interval:function fft(t,e,n){var i=new lnt,r=e;return null==e?(i.restart(t,e,n),i):(e=+e,n=null==n?ant():+n,i.restart((function o(a){a+=r,i.restart(o,r+=e,n),t(a)}),e,n),i)},transition:Kot,active:function mft(t,e){var n,i,r=t.__transition;if(r)for(i in e=null==e?null:e+"",r)if((n=r[i]).state>1&&n.name===e)return new $ot([[t]],bat,e,+i);return null},interrupt:krt,voronoi:function gft(){var t=wat,e=Sat,n=null;function i(i){return new rst(i.map((function(n,r){var o=[Math.round(t(n,r,i)/tst)*tst,Math.round(e(n,r,i)/tst)*tst];return o.index=r,o.data=n,o})),n)}return i.polygons=function(t){return i(t).polygons()},i.links=function(t){return i(t).links()},i.triangles=function(t){return i(t).triangles()},i.x=function(e){return arguments.length?(t="function"==typeof e?e:xat(+e),i):t},i.y=function(t){return arguments.length?(e="function"==typeof t?t:xat(+t),i):e},i.extent=function(t){return arguments.length?(n=null==t?null:[[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]],i):n&&[[n[0][0],n[0][1]],[n[1][0],n[1][1]]]},i.size=function(t){return arguments.length?(n=null==t?null:[[0,0],[+t[0],+t[1]]],i):n&&[n[1][0]-n[0][0],n[1][1]-n[0][1]]},i},zoom:function _ft(){var t,e,n=Dht,i=Bht,r=jht,o=Fht,a=Vht,s=[0,1/0],l=[[-1/0,-1/0],[1/0,1/0]],c=250,u=out,h=[],d=ast("start","zoom","end"),p=500,f=0;function m(t){t.property("__zoom",Hht).on("wheel.zoom",w).on("mousedown.zoom",S).on("dblclick.zoom",M).filter(a).on("touchstart.zoom",E).on("touchmove.zoom",T).on("touchend.zoom touchcancel.zoom",A).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function g(t,e){return(e=Math.max(s[0],Math.min(s[1],e)))===t.k?t:new Lht(e,t.x,t.y)}function _(t,e,n){var i=e[0]-n[0]*t.k,r=e[1]-n[1]*t.k;return i===t.x&&r===t.y?t:new Lht(t.k,i,r)}function y(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function v(t,e,n){t.on("start.zoom",(function(){b(this,arguments).start()})).on("interrupt.zoom end.zoom",(function(){b(this,arguments).end()})).tween("zoom",(function(){var t=this,r=arguments,o=b(t,r),a=i.apply(t,r),s=n||y(a),l=Math.max(a[1][0]-a[0][0],a[1][1]-a[0][1]),c=t.__zoom,h="function"==typeof e?e.apply(t,r):e,d=u(c.invert(s).concat(l/c.k),h.invert(s).concat(l/h.k));return function(t){if(1===t)t=h;else{var e=d(t),n=l/e[2];t=new Lht(n,s[0]-e[0]*n,s[1]-e[1]*n)}o.zoom(null,t)}}))}function b(t,e){for(var n,i=0,r=h.length;i<r;++i)if((n=h[i]).that===t)return n;return new x(t,e)}function x(t,e){this.that=t,this.args=e,this.index=-1,this.active=0,this.extent=i.apply(t,e)}function w(){if(n.apply(this,arguments)){var t=b(this,arguments),e=this.__zoom,i=Math.max(s[0],Math.min(s[1],e.k*Math.pow(2,o.apply(this,arguments)))),a=Slt(this);if(t.wheel)t.mouse[0][0]===a[0]&&t.mouse[0][1]===a[1]||(t.mouse[1]=e.invert(t.mouse[0]=a)),clearTimeout(t.wheel);else{if(e.k===i)return;t.mouse=[a,e.invert(a)],Lut(this),t.start()}zht(),t.wheel=setTimeout(c,150),t.zoom("mouse",r(_(g(e,i),t.mouse[0],t.mouse[1]),t.extent,l))}function c(){t.wheel=null,t.end()}}function S(){if(!e&&n.apply(this,arguments)){var t=b(this,arguments),i=blt(llt.view).on("mousemove.zoom",c,!0).on("mouseup.zoom",u,!0),o=Slt(this),a=llt.clientX,s=llt.clientY;Tlt(llt.view),Rht(),t.mouse=[o,this.__zoom.invert(o)],Lut(this),t.start()}function c(){if(zht(),!t.moved){var e=llt.clientX-a,n=llt.clientY-s;t.moved=e*e+n*n>f}t.zoom("mouse",r(_(t.that.__zoom,t.mouse[0]=Slt(t.that),t.mouse[1]),t.extent,l))}function u(){i.on("mousemove.zoom mouseup.zoom",null),Alt(llt.view,t.moved),zht(),t.end()}}function M(){if(n.apply(this,arguments)){var t=this.__zoom,e=Slt(this),o=t.invert(e),a=t.k*(llt.shiftKey?.5:2),s=r(_(g(t,a),e,o),i.apply(this,arguments),l);zht(),c>0?blt(this).transition().duration(c).call(v,s,e):blt(this).call(m.transform,s)}}function E(){if(n.apply(this,arguments)){var e,i,r,o,a=b(this,arguments),s=llt.changedTouches,l=s.length;for(Rht(),i=0;i<l;++i)o=[o=Mlt(this,s,(r=s[i]).identifier),this.__zoom.invert(o),r.identifier],a.touch0?a.touch1||(a.touch1=o):(a.touch0=o,e=!0);if(t&&(t=clearTimeout(t),!a.touch1))return a.end(),void((o=blt(this).on("dblclick.zoom"))&&o.apply(this,arguments));e&&(t=setTimeout((function(){t=null}),p),Lut(this),a.start())}}function T(){var e,n,i,o,a=b(this,arguments),s=llt.changedTouches,c=s.length;for(zht(),t&&(t=clearTimeout(t)),e=0;e<c;++e)i=Mlt(this,s,(n=s[e]).identifier),a.touch0&&a.touch0[2]===n.identifier?a.touch0[0]=i:a.touch1&&a.touch1[2]===n.identifier&&(a.touch1[0]=i);if(n=a.that.__zoom,a.touch1){var u=a.touch0[0],h=a.touch0[1],d=a.touch1[0],p=a.touch1[1],f=(f=d[0]-u[0])*f+(f=d[1]-u[1])*f,m=(m=p[0]-h[0])*m+(m=p[1]-h[1])*m;n=g(n,Math.sqrt(f/m)),i=[(u[0]+d[0])/2,(u[1]+d[1])/2],o=[(h[0]+p[0])/2,(h[1]+p[1])/2]}else{if(!a.touch0)return;i=a.touch0[0],o=a.touch0[1]}a.zoom("touch",r(_(n,i,o),a.extent,l))}function A(){var t,n,i=b(this,arguments),r=llt.changedTouches,o=r.length;for(Rht(),e&&clearTimeout(e),e=setTimeout((function(){e=null}),p),t=0;t<o;++t)n=r[t],i.touch0&&i.touch0[2]===n.identifier?delete i.touch0:i.touch1&&i.touch1[2]===n.identifier&&delete i.touch1;i.touch1&&!i.touch0&&(i.touch0=i.touch1,delete i.touch1),i.touch0?i.touch0[1]=this.__zoom.invert(i.touch0[0]):i.end()}return m.transform=function(t,e){var n=t.selection?t.selection():t;n.property("__zoom",Hht),t!==n?v(t,e):n.interrupt().each((function(){b(this,arguments).start().zoom(null,"function"==typeof e?e.apply(this,arguments):e).end()}))},m.scaleBy=function(t,e){m.scaleTo(t,(function(){var t=this.__zoom.k,n="function"==typeof e?e.apply(this,arguments):e;return t*n}))},m.scaleTo=function(t,e){m.transform(t,(function(){var t=i.apply(this,arguments),n=this.__zoom,o=y(t),a=n.invert(o),s="function"==typeof e?e.apply(this,arguments):e;return r(_(g(n,s),o,a),t,l)}))},m.translateBy=function(t,e,n){m.transform(t,(function(){return r(this.__zoom.translate("function"==typeof e?e.apply(this,arguments):e,"function"==typeof n?n.apply(this,arguments):n),i.apply(this,arguments),l)}))},m.translateTo=function(t,e,n){m.transform(t,(function(){var t=i.apply(this,arguments),o=this.__zoom,a=y(t);return r(Nht.translate(a[0],a[1]).scale(o.k).translate("function"==typeof e?-e.apply(this,arguments):-e,"function"==typeof n?-n.apply(this,arguments):-n),t,l)}))},x.prototype={start:function(){return 1==++this.active&&(this.index=h.push(this)-1,this.emit("start")),this},zoom:function(t,e){return this.mouse&&"mouse"!==t&&(this.mouse[1]=e.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=e.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=e.invert(this.touch1[0])),this.that.__zoom=e,this.emit("zoom"),this},end:function(){return 0==--this.active&&(h.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(t){!(function e(t,n,i,r){var o=llt;t.sourceEvent=llt,llt=t;try{n.apply(i,r)}finally{llt=o}})(new kht(m,t,this.that.__zoom),d.apply,d,[t,this.that,this.args])}},m.wheelDelta=function(t){return arguments.length?(o="function"==typeof t?t:Cht(+t),m):o},m.filter=function(t){return arguments.length?(n="function"==typeof t?t:Cht(!!t),m):n},m.touchable=function(t){return arguments.length?(a="function"==typeof t?t:Cht(!!t),m):a},m.extent=function(t){return arguments.length?(i="function"==typeof t?t:Cht([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),m):i},m.scaleExtent=function(t){return arguments.length?(s[0]=+t[0],s[1]=+t[1],m):[s[0],s[1]]},m.translateExtent=function(t){return arguments.length?(l[0][0]=+t[0][0],l[1][0]=+t[1][0],l[0][1]=+t[0][1],l[1][1]=+t[1][1],m):[[l[0][0],l[0][1]],[l[1][0],l[1][1]]]},m.constrain=function(t){return arguments.length?(r=t,m):r},m.duration=function(t){return arguments.length?(c=+t,m):c},m.interpolate=function(t){return arguments.length?(u=t,m):u},m.on=function(){var t=d.on.apply(d,arguments);return t===d?m:t},m.clickDistance=function(t){return arguments.length?(f=(t=+t)*t,m):Math.sqrt(f)},m},zoomTransform:Oht,zoomIdentity:Nht}));be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     *
     * @fileoverview manually add d3-selection-multi to d3 default bundle. Most of this code is
     * copied from d3-selection-multi@1.0.0.
     * See https://github.com/d3/d3-selection-multi/issues/11 for why we have to do this
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=Uht,i=Uht;function r(t,e){return t.each((function(){var t=e.apply(this,arguments),i=n.select(this);for(var r in t)i.attr(r,t[r])}))}function o(t,e){for(var n in e)t.attr(n,e[n]);return t}function a(t,e,i){return t.each((function(){var t=e.apply(this,arguments),r=n.select(this);for(var o in t)r.style(o,t[o],i)}))}function s(t,e,n){for(var i in e)t.style(i,e[i],n);return t}function l(t,e){return t.each((function(){var t=e.apply(this,arguments),i=n.select(this);for(var r in t)i.property(r,t[r])}))}function c(t,e){for(var n in e)t.property(n,e[n]);return t}function u(t,e){return t.each((function(){var i=e.apply(this,arguments),r=n.select(this).transition(t);for(var o in i)r.attr(o,i[o])}))}function h(t,e){for(var n in e)t.attr(n,e[n]);return t}function d(t,e,i){return t.each((function(){var r=e.apply(this,arguments),o=n.select(this).transition(t);for(var a in r)o.style(a,r[a],i)}))}function p(t,e,n){for(var i in e)t.style(i,e[i],n);return t}n.selection.prototype.attrs=function f(t){return("function"==typeof t?r:o)(this,t)},n.selection.prototype.styles=function m(t,e){return("function"==typeof t?a:s)(this,t,null==e?"":e)},n.selection.prototype.properties=function g(t){return("function"==typeof t?l:c)(this,t)},i.transition.prototype.attrs=function _(t){return("function"==typeof t?u:h)(this,t)},i.transition.prototype.styles=function y(t,e){return("function"==typeof t?d:p)(this,t,null==e?"":e)}}));var yft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0}),e.coerceExternalD3=function n(t){if(null==t.attrs){if(null==t.nodes){var e=[];return t.each((function(){e.push(this)})),Uht.selectAll(e)}return Uht.selectAll(t.nodes())}return t}})),vft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.makeEnum=function n(t){return t.reduce((function(t,e){return t[e]=e,t}),{})}})),bft=xe(ym),xft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n={linear:bft.easeLinear,quad:bft.easeQuad,quadIn:bft.easeQuadIn,quadOut:bft.easeQuadOut,quadInOut:bft.easeQuadInOut,cubic:bft.easeCubic,cubicIn:bft.easeCubicIn,cubicOut:bft.easeCubicOut,cubicInOut:bft.easeCubicInOut,poly:bft.easePoly,polyIn:bft.easePolyIn,polyOut:bft.easePolyOut,polyInOut:bft.easePolyInOut,sin:bft.easeSin,sinIn:bft.easeSinIn,sinOut:bft.easeSinOut,sinInOut:bft.easeSinInOut,exp:bft.easeExp,expIn:bft.easeExpIn,expOut:bft.easeExpOut,expInOut:bft.easeExpInOut,circle:bft.easeCircle,circleIn:bft.easeCircleIn,circleOut:bft.easeCircleOut,circleInOut:bft.easeCircleInOut,bounce:bft.easeBounce,bounceIn:bft.easeBounceIn,bounceOut:bft.easeBounceOut,bounceInOut:bft.easeBounceInOut,back:bft.easeBack,backIn:bft.easeBackIn,backOut:bft.easeBackOut,backInOut:bft.easeBackInOut,elastic:bft.easeElastic,elasticIn:bft.easeElasticIn,elasticOut:bft.easeElasticOut,elasticInOut:bft.easeElasticInOut};e.EaseName=vft.makeEnum(["linear","quad","quadIn","quadOut","quadInOut","cubic","cubicIn","cubicOut","cubicInOut","poly","polyIn","polyOut","polyInOut","sin","sinIn","sinOut","sinInOut","exp","expIn","expOut","expInOut","circle","circleIn","circleOut","circleInOut","bounce","bounceIn","bounceOut","bounceInOut","back","backIn","backOut","backInOut","elastic","elasticIn","elasticOut","elasticInOut"]);var i=(function(){function t(){this._startDelay=t._DEFAULT_START_DELAY_MILLISECONDS,this._stepDuration=t._DEFAULT_STEP_DURATION_MILLISECONDS,this._stepDelay=t._DEFAULT_ITERATIVE_DELAY_MILLISECONDS,this._maxTotalDuration=t._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS,this._easingMode=t._DEFAULT_EASING_MODE}return t.prototype.totalTime=function(t){var e=this._getAdjustedIterativeDelay(t);return this.startDelay()+e*Math.max(t-1,0)+this.stepDuration()},t.prototype.animate=function(t,e){var n=this,i=(t=yft.coerceExternalD3(t)).size(),r=this._getAdjustedIterativeDelay(i);return t.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay((function(t,e){return n.startDelay()+r*e})).attrs(e)},t.prototype.startDelay=function(t){return null==t?this._startDelay:(this._startDelay=t,this)},t.prototype.stepDuration=function(t){return null==t?Math.min(this._stepDuration,this._maxTotalDuration):(this._stepDuration=t,this)},t.prototype.stepDelay=function(t){return null==t?this._stepDelay:(this._stepDelay=t,this)},t.prototype.maxTotalDuration=function(t){return null==t?this._maxTotalDuration:(this._maxTotalDuration=t,this)},t.prototype.easingMode=function(t){return null==t?this._easingMode:(this._easingMode=t,this)},t.prototype._getEaseFactory=function(){var t=this.easingMode();if("string"==typeof t){var e=n[t];return null==e?n.linear:e}return t},t.prototype._getAdjustedIterativeDelay=function(t){var e=this.maxTotalDuration()-this.stepDuration(),n=(e=Math.max(e,0))/Math.max(t-1,1);return Math.min(this.stepDelay(),n)},t._DEFAULT_START_DELAY_MILLISECONDS=0,t._DEFAULT_STEP_DURATION_MILLISECONDS=300,t._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15,t._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=1/0,t._DEFAULT_EASING_MODE="expOut",t})();e.Easing=i})),wft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.prototype.totalTime=function(t){return 0},t.prototype.animate=function(t,e){return(t=yft.coerceExternalD3(t)).attrs(e)},t})();e.Null=n})),Sft=xe(FO),Mft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(xft,e),Sft.__exportStar(wft,e)})),Eft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t){this.cache={},this.compute=t}return t.prototype.get=function(t){return this.cache.hasOwnProperty(t)||(this.cache[t]=this.compute(t)),this.cache[t]},t.prototype.clear=function(){return this.cache={},this},t})();e.Cache=n})),Tft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.arrayEq=function(t,e){if(null==t||null==e)return t===e;if(t.length!==e.length)return!1;for(var n=0;n<t.length;n++)if(t[n]!==e[n])return!1;return!0},t.objEq=function(e,n){if(null==e||null==n)return e===n;var i=Object.keys(e).sort(),r=Object.keys(n).sort(),o=i.map((function(t){return e[t]})),a=r.map((function(t){return n[t]}));return t.arrayEq(i,r)&&t.arrayEq(o,a)},t.strictEq=function(t,e){return t===e},t.defaults=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];if(null==t)throw new TypeError("Cannot convert undefined or null to object");var i=Object(t);return e.forEach((function(t){if(null!=t)for(var e in t)Object.prototype.hasOwnProperty.call(t,e)&&(i[e]=t[e])})),i},t})();e.Methods=n})),Aft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.combineWhitespace=function(t){return t.replace(/[ \t]+/g," ")},t.isNotEmptyString=function(t){return t&&""!==t.trim()},t.trimStart=function(e,n){if(!e)return e;var i=e.split(""),r=n?function(e){return e.split(n).some(t.isNotEmptyString)}:t.isNotEmptyString;return i.reduce((function(t,e){return r(t+e)?t+e:t}),"")},t.trimEnd=function(e,n){if(!e)return e;var i=e.split("");return i.reverse(),(i=t.trimStart(i.join(""),n).split("")).reverse(),i.join("")},t})();e.StringMethods=n})),Cft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this.WordDividerRegExp=new RegExp("\\W"),this.WhitespaceRegExp=new RegExp("\\s")}return t.prototype.tokenize=function(t){var e=this;return t.split("").reduce((function(t,n){return t.slice(0,-1).concat(e.shouldCreateNewToken(t[t.length-1],n))}),[""])},t.prototype.shouldCreateNewToken=function(t,e){if(!t)return[e];var n=t[t.length-1];return this.WhitespaceRegExp.test(n)&&this.WhitespaceRegExp.test(e)?[t+e]:this.WhitespaceRegExp.test(n)||this.WhitespaceRegExp.test(e)?[t,e]:this.WordDividerRegExp.test(n)?n===e?[t+e]:[t,e]:[t+e]},t})();e.Tokenizer=n})),kft=be((function(t,e){function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),n(Eft),n(Tft),n(Aft),n(Cft)})),Lft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"},i=(function(){function t(t,e,n){this._measurer=t,this._penFactory=e,this._wrapper=n}return t.prototype.measurer=function(t){return this._measurer=t,this},t.prototype.wrapper=function(t){return this._wrapper=t,this},t.prototype.penFactory=function(t){return this._penFactory=t,this},t.prototype.write=function(e,i,r,o,a){if(void 0===o&&(o={}),o=kft.Methods.defaults({},n,o),-1===t.SupportedRotation.indexOf(o.textRotation))throw new Error("unsupported rotation - "+o.textRotation+". Supported rotations are "+t.SupportedRotation.join(", "));if(null!=o.textShear&&o.textShear<-80||o.textShear>80)throw new Error("unsupported shear angle - "+o.textShear+". Must be between -80 and 80");var s=Math.abs(Math.abs(o.textRotation)-90)>45,l=s?i:r,c=s?r:i,u=o.textShear,h=u*Math.PI/180,d=this._measurer.measure().height,p=d*Math.tan(h),f=l/Math.cos(h)-Math.abs(p),m=c*Math.cos(h),g=kft.StringMethods.combineWhitespace(e),_=(this._wrapper?this._wrapper.wrap(g,this._measurer,f,m).wrappedText:g).split("\n"),y=t.XOffsetFactor[o.xAlign]*f*Math.sin(h)-t.YOffsetFactor[o.yAlign]*(m-_.length*d),v=[0,0],b=o.textRotation+u;switch(o.textRotation){case 90:v=[i+y,0];break;case-90:v=[-y,r];break;case 180:v=[i,r+y];break;default:v=[0,-y]}var x=this._penFactory.createPen(e,{translate:v,rotate:b},a);this.writeLines(_,x,f,d,p,o.xAlign),null!=x.destroy&&x.destroy()},t.prototype.writeLines=function(t,e,n,i,r,o){t.forEach((function(t,a){e.write(t,n,o,r>0?(a+1)*r:a*r,(a+1)*i)}))},t})();i.XOffsetFactor={center:.5,left:0,right:1},i.YOffsetFactor={bottom:1,center:.5,top:0},i.SupportedRotation=[-90,0,180,90],e.Writer=i})),Pft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0}),(function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])})(Lft)})),Ift=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.append=function(e,n){for(var i=[],r=2;r<arguments.length;r++)i[r-2]=arguments[r];var o=t.create.apply(t,[n].concat(i));return e.appendChild(o),o},t.create=function(e){for(var n=[],i=1;i<arguments.length;i++)n[i-1]=arguments[i];var r=document.createElement(e);return t.addClasses.apply(t,[r].concat(n)),r},t.addClasses=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];e=e.filter((function(t){return null!=t})),null!=t.classList?e.forEach((function(e){t.classList.add(e)})):t.setAttribute("class",e.join(" "))},t.getDimensions=function(t){if(t.getBoundingClientRect)try{var e=t.getBoundingClientRect();return{width:e.width,height:e.height}}catch(t){}return{height:0,width:0}},t})();e.HtmlUtils=n;var i=(function(){function t(t,e,i){void 0===i&&(i=!1);var r=this;this.element=t,this.className=e,this.addTitle=i,this.createRuler=function(){return function(t){var e=n.append(r.element,"span","text-tmp",r.className);e.textContent=t;var i=n.getDimensions(e);return r.element.removeChild(e),i}},this.createPen=function(t,e,i){null==i&&(i=r.element);var o=n.append(i,"div","text-block",r.className);return o.style.position="relative",o.style.transform="translate(0, -1em) translate("+e.translate[0]+"px, "+e.translate[1]+"px) rotate("+e.rotate+"deg)",o.style.transformOrigin="0 1.2em",r.addTitle&&o.setAttribute("title",t),r.createHtmlLinePen(o)}}return t.prototype.setAddTitle=function(t){this.addTitle=t},t.prototype.createHtmlLinePen=function(t){return{write:function(e,i,r,o,a){var s=n.append(t,"div","text-line");s.textContent=e,s.style.width=i+"px",s.style.textAlign=r,s.style.position="absolute",s.style.whiteSpace="nowrap",s.style.top=a+"px",s.style.left=o+"px"}}},t})();e.HtmlContext=i})),Nft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.append=function(e,n){for(var i=[],r=2;r<arguments.length;r++)i[r-2]=arguments[r];var o=t.create.apply(t,[n].concat(i));return e.appendChild(o),o},t.create=function(e){for(var n=[],i=1;i<arguments.length;i++)n[i-1]=arguments[i];var r=document.createElementNS(t.SVG_NS,e);return Ift.HtmlUtils.addClasses.apply(Ift.HtmlUtils,[r].concat(n)),r},t.getDimensions=function(t){if(t.getBBox)try{var e=t.getBBox();return{width:e.width,height:e.height}}catch(t){}return{height:0,width:0}},t})();n.SVG_NS="http://www.w3.org/2000/svg",e.SvgUtils=n;var i=(function(){function t(t,e,i){void 0===i&&(i=!1);var r=this;this.element=t,this.className=e,this.addTitleElement=i,this.createRuler=function(){var t=r.getTextElements(r.element),e=t.parentElement,i=t.containerElement,o=t.textElement;return function(t){e.appendChild(i),o.textContent=t;var r=n.getDimensions(o);return e.removeChild(i),r}},this.createPen=function(t,e,i){null==i&&(i=r.element);var o=n.append(i,"g","text-container",r.className);r.addTitleElement&&(n.append(o,"title").textContent=t,o.setAttribute("title",t));var a=n.append(o,"g","text-area");return a.setAttribute("transform","translate("+e.translate[0]+","+e.translate[1]+")rotate("+e.rotate+")"),r.createSvgLinePen(a)}}return t.prototype.setAddTitleElement=function(t){this.addTitleElement=t},t.prototype.createSvgLinePen=function(e){return{write:function(i,r,o,a,s){a+=r*Pft.Writer.XOffsetFactor[o];var l=n.append(e,"text","text-line");l.textContent=i,l.setAttribute("text-anchor",t.AnchorMap[o]),l.setAttribute("transform","translate("+a+","+s+")"),l.setAttribute("y","-0.25em")}}},t.prototype.getTextElements=function(t){if("text"===t.tagName)return null==(e=t.parentElement)&&(e=t.parentNode),e.removeChild(t),{containerElement:t,parentElement:e,textElement:t};var e,i=t.querySelector("text");if(null!=i)return null==(e=i.parentElement)&&(e=i.parentNode),e.removeChild(i),{containerElement:i,parentElement:e,textElement:i};var r=n.create("text",this.className);return{containerElement:r,parentElement:t,textElement:r}},t})();i.AnchorMap={center:"middle",left:"start",right:"end"},e.SvgContext=i})),Oft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e,n){void 0===e&&(e=10),void 0===n&&(n={});var i=this;this.ctx=t,this.lineHeight=e,this.style=n,this.createRuler=function(){return function(t){return i.ctx.font=i.style.font,{width:i.ctx.measureText(t).width,height:i.lineHeight}}},this.createPen=function(t,e,n){return null==n&&(n=i.ctx),n.save(),n.translate(e.translate[0],e.translate[1]),n.rotate(e.rotate*Math.PI/180),i.createCanvasPen(n)},void 0===this.style.fill&&(this.style.fill="#444")}return t.prototype.createCanvasPen=function(t){var e=this;return{destroy:function(){t.restore()},write:function(n,i,r,o,a){o+=i*Pft.Writer.XOffsetFactor[r],t.textAlign=r,null!=e.style.font&&(t.font=e.style.font),null!=e.style.fill&&(t.fillStyle=e.style.fill,t.fillText(n,o,a)),null!=e.style.stroke&&(t.strokeStyle=e.style.fill,t.strokeText(n,o,a))}}},t})();e.CanvasContext=n})),Rft=be((function(t,e){function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),n(Nft),n(Oft),n(Ift)})),zft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t){this.ruler=null!=t.createRuler?t.createRuler():t}return t.prototype.measure=function(e){return void 0===e&&(e=t.HEIGHT_TEXT),this.ruler(e)},t})();n.HEIGHT_TEXT="bdpql",e.AbstractMeasurer=n})),Dft=be((function(t,e){var n=ve&&ve.__extends||(function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}})();Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(e,n){void 0===n&&(n=!1);var i=t.call(this,e)||this;return i.useGuards=n,i}return n(e,t),e.prototype._addGuards=function(t){return zft.AbstractMeasurer.HEIGHT_TEXT+t+zft.AbstractMeasurer.HEIGHT_TEXT},e.prototype._measureLine=function(e,n){void 0===n&&(n=!1);var i=this.useGuards||n||/^[\t ]$/.test(e),r=i?this._addGuards(e):e,o=t.prototype.measure.call(this,r);return o.width-=i?2*this.getGuardWidth():0,o},e.prototype.measure=function(t){var e=this;if(void 0===t&&(t=zft.AbstractMeasurer.HEIGHT_TEXT),""===t.trim())return{width:0,height:0};var n=t.trim().split("\n").map((function(t){return e._measureLine(t)}));return{height:n.reduce((function(t,e){return t+e.height}),0),width:n.reduce((function(t,e){return Math.max(t,e.width)}),0)}},e.prototype.getGuardWidth=function(){return null==this.guardWidth&&(this.guardWidth=t.prototype.measure.call(this).width),this.guardWidth},e})(zft.AbstractMeasurer);e.Measurer=i})),Bft=be((function(t,e){var n=ve&&ve.__extends||(function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}})();Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype._measureCharacter=function(e){return t.prototype._measureLine.call(this,e)},e.prototype._measureLine=function(t){var e=this,n=t.split("").map((function(t){return e._measureCharacter(t)}));return{height:n.reduce((function(t,e){return Math.max(t,e.height)}),0),width:n.reduce((function(t,e){return t+e.width}),0)}},e})(Dft.Measurer);e.CharacterMeasurer=i})),Hft=be((function(t,e){var n=ve&&ve.__extends||(function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}})();Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(e,n){var i=t.call(this,e,n)||this;return i.cache=new kft.Cache((function(t){return i._measureCharacterNotFromCache(t)})),i}return n(e,t),e.prototype._measureCharacterNotFromCache=function(e){return t.prototype._measureCharacter.call(this,e)},e.prototype._measureCharacter=function(t){return this.cache.get(t)},e.prototype.reset=function(){this.cache.clear()},e})(Bft.CharacterMeasurer);e.CacheCharacterMeasurer=i})),Fft=be((function(t,e){var n=ve&&ve.__extends||(function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}})();Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(e){var n=t.call(this,e)||this;return n.dimCache=new kft.Cache((function(t){return n._measureNotFromCache(t)})),n}return n(e,t),e.prototype._measureNotFromCache=function(e){return t.prototype.measure.call(this,e)},e.prototype.measure=function(t){return void 0===t&&(t=zft.AbstractMeasurer.HEIGHT_TEXT),this.dimCache.get(t)},e.prototype.reset=function(){this.dimCache.clear(),t.prototype.reset.call(this)},e})(Hft.CacheCharacterMeasurer);e.CacheMeasurer=i})),Vft=be((function(t,e){function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),n(zft),n(Hft),n(Fft),n(Bft),n(Dft)})),jft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this.maxLines(1/0),this.textTrimming("ellipsis"),this.allowBreakingWords(!1),this._tokenizer=new kft.Tokenizer,this._breakingCharacter="-"}return t.prototype.maxLines=function(t){return null==t?this._maxLines:(this._maxLines=t,this)},t.prototype.textTrimming=function(t){if(null==t)return this._textTrimming;if("ellipsis"!==t&&"none"!==t)throw new Error(t+" - unsupported text trimming option.");return this._textTrimming=t,this},t.prototype.allowBreakingWords=function(t){return null==t?this._allowBreakingWords:(this._allowBreakingWords=t,this)},t.prototype.wrap=function(t,e,n,i){var r=this;void 0===i&&(i=1/0);var o={noBrokeWords:0,noLines:0,originalText:t,truncatedText:"",wrappedText:""},a={availableLines:Math.min(Math.floor(i/e.measure().height),this._maxLines),availableWidth:n,canFitText:!0,currentLine:"",wrapping:o},s=t.split("\n");return s.reduce((function(t,n,i){return r.breakLineToFitWidth(t,n,i!==s.length-1,e)}),a).wrapping},t.prototype.breakLineToFitWidth=function(t,e,n,i){var r=this;t.canFitText||""===t.wrapping.truncatedText||(t.wrapping.truncatedText+="\n"),t=this._tokenizer.tokenize(e).reduce((function(t,e){return r.wrapNextToken(e,t,i)}),t);var o=kft.StringMethods.trimEnd(t.currentLine);return t.wrapping.noLines+=+(""!==o),t.wrapping.noLines===t.availableLines&&"none"!==this._textTrimming&&n?t.canFitText=!1:t.wrapping.wrappedText+=o,t.currentLine="\n",t},t.prototype.canFitToken=function(t,e,n){var i=this,r=t.split("").map((function(e,n){return n!==t.length-1?e+i._breakingCharacter:e}));return n.measure(t).width<=e||r.every((function(t){return n.measure(t).width<=e}))},t.prototype.addEllipsis=function(t,e,n){if("none"===this._textTrimming)return{remainingToken:"",wrappedToken:t};var i=t.substring(0).trim(),r=n.measure(i).width,o=n.measure("...").width,a=t.length>0&&"\n"===t[0]?"\n":"";if(e<=o){var s=Math.floor(e/(o/3));return{remainingToken:t,wrappedToken:a+"...".substr(0,s)}}for(;r+o>e;)i=kft.StringMethods.trimEnd(i.substr(0,i.length-1)),r=n.measure(i).width;return{remainingToken:kft.StringMethods.trimEnd(t.substring(i.length),"-").trim(),wrappedToken:a+i+"..."}},t.prototype.wrapNextToken=function(t,e,n){if(!e.canFitText||e.availableLines===e.wrapping.noLines||!this.canFitToken(t,e.availableWidth,n))return this.finishWrapping(t,e,n);for(var i=t;i;){var r=this.breakTokenToFitInWidth(i,e.currentLine,e.availableWidth,n);if(e.currentLine=r.line,null!=(i=r.remainingToken)){if(e.wrapping.noBrokeWords+=+r.breakWord,++e.wrapping.noLines,e.availableLines===e.wrapping.noLines){var o=this.addEllipsis(e.currentLine,e.availableWidth,n);return e.wrapping.wrappedText+=o.wrappedToken,e.wrapping.truncatedText+=o.remainingToken+i,e.currentLine="\n",e}e.wrapping.wrappedText+=kft.StringMethods.trimEnd(e.currentLine),e.currentLine="\n"}}return e},t.prototype.finishWrapping=function(t,e,n){if(e.canFitText&&e.availableLines!==e.wrapping.noLines&&"none"!==this._textTrimming){var i=this.addEllipsis(e.currentLine+t,e.availableWidth,n);e.wrapping.wrappedText+=i.wrappedToken,e.wrapping.truncatedText+=i.remainingToken,e.wrapping.noBrokeWords+=+(i.remainingToken.length<t.length),e.wrapping.noLines+=+(i.wrappedToken.length>0),e.currentLine=""}else e.wrapping.truncatedText+=t;return e.canFitText=!1,e},t.prototype.breakTokenToFitInWidth=function(t,e,n,i,r){if(void 0===r&&(r=this._breakingCharacter),i.measure(e+t).width<=n)return{breakWord:!1,line:e+t,remainingToken:null};if(""===t.trim())return{breakWord:!1,line:e,remainingToken:""};if(!this._allowBreakingWords&&""!==e.trim())return{breakWord:!1,line:e,remainingToken:t};for(var o=0;o<t.length&&i.measure(e+t.substring(0,o+1)+r).width<=n;)++o;var a="";return o>0&&(a=r),{breakWord:o>0,line:e+t.substring(0,o)+a,remainingToken:t.substring(o)}},t})();e.Wrapper=n})),Uft=be((function(t,e){var n=ve&&ve.__extends||(function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}})();Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return n(e,t),e.prototype.wrap=function(n,i,r,o){var a=this;if(void 0===o&&(o=1/0),n.split("\n").length>1)throw new Error("SingleLineWrapper is designed to work only on single line");var s=function(e){return t.prototype.wrap.call(a,n,i,e,o)},l=s(r);if(l.noLines<2)return l;for(var c=0,u=r,h=0;h<e.NO_WRAP_ITERATIONS&&u>c;++h){var d=(u+c)/2,p=s(d);this.areSameResults(l,p)?(u=d,l=p):c=d}return l},e.prototype.areSameResults=function(t,e){return t.noLines===e.noLines&&t.truncatedText===e.truncatedText},e})(jft.Wrapper);i.NO_WRAP_ITERATIONS=5,e.SingleLineWrapper=i})),Gft=be((function(t,e){function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),n(Uft),n(jft)})),Wft=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t){this.context=t,this.measurer=new Vft.CacheMeasurer(this.context),this.wrapper=new Gft.Wrapper,this.writer=new Pft.Writer(this.measurer,this.context,this.wrapper)}return t.svg=function(e,n,i){return new t(new Rft.SvgContext(e,n,i))},t.canvas=function(e,n,i){return new t(new Rft.CanvasContext(e,n,i))},t.html=function(e,n,i){return new t(new Rft.HtmlContext(e,n,i))},t.prototype.write=function(t,e,n,i,r){this.writer.write(t,e,n,i,r)},t.prototype.clearMeasurerCache=function(){this.measurer.reset()},t})();e.Typesetter=n})),qft=be((function(t,e){function n(t){for(var n in t)e.hasOwnProperty(n)||(e[n]=t[n])}Object.defineProperty(e,"__esModule",{value:!0}),n(Rft),n(Vft),n(Wft),n(kft),n(Gft),n(Pft)})),Yft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=window.Array;e.add=function i(t,e){if(t.length!==e.length)throw new Error("attempted to add arrays of unequal length");return t.map((function(n,i){return t[i]+e[i]}))},e.uniq=function r(t){var e=Uht.set(),n=[];return t.forEach((function(t){e.has(String(t))||(e.add(String(t)),n.push(t))})),n},e.flatten=function o(t){return n.prototype.concat.apply([],t)},e.createFilledArray=function a(t,e){for(var n=[],i=0;i<e;i++)n[i]="function"==typeof t?t(i):t;return n}})),Xft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=window.Math;function i(t){var e=Uht.rgb(t),i=function(t){return(t/=255)<=.03928?t/12.92:n.pow((t+.055)/1.055,2.4)};return.2126*i(e.r)+.7152*i(e.g)+.0722*i(e.b)}e.contrast=function r(t,e){var n=i(t)+.05,r=i(e)+.05;return n>r?n/r:r/n},e.lightenColor=function o(t,e){return Uht.color(t).brighter(e).rgb().toString()},e.colorTest=function a(t,e){t.classed(e,!0);var n=t.style("background-color");if("transparent"===n)return null;var i=/\((.+)\)/.exec(n);if(!i)return null;var r=i[1].split(",").map((function(t){var e=+t,n=e.toString(16);return e<16?"0"+n:n}));if(4===r.length&&"00"===r[3])return null;var o="#"+r.join("");return t.classed(e,!1),o}})),$ft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=window.Math;function i(t){var e;try{e=t.node().getBBox()}catch(t){e={x:0,y:0,width:0,height:0}}return e}e.contains=function r(t,e){for(var n=e;null!=n&&n!==t;)n=n.parentNode;return n===t},e.elementBBox=i,e.entityBounds=function o(t){if(t instanceof SVGElement)return i(Uht.select(t));if(t instanceof HTMLElement){var e=t.getBoundingClientRect();return{x:e.left,y:e.top,width:e.width,height:e.height}}return{x:0,y:0,width:0,height:0}},e.SCREEN_REFRESH_RATE_MILLISECONDS=1e3/60,e.requestAnimationFramePolyfill=function a(t){null!=window.requestAnimationFrame?window.requestAnimationFrame(t):setTimeout(t,e.SCREEN_REFRESH_RATE_MILLISECONDS)},e.elementWidth=function s(t){var e=t instanceof Uht.selection?t.node():t,n=window.getComputedStyle(e);return m(n,"width")+m(n,"padding-left")+m(n,"padding-right")+m(n,"border-left-width")+m(n,"border-right-width")},e.elementHeight=function l(t){var e=t instanceof Uht.selection?t.node():t,n=window.getComputedStyle(e);return m(n,"height")+m(n,"padding-top")+m(n,"padding-bottom")+m(n,"border-top-width")+m(n,"border-bottom-width")};var c="(?:[-+]?[0-9]*\\.?[0-9]+)",u="(?:(?:\\s+,?\\s*)|(?:,\\s*))",h=new RegExp("translate\\s*\\(\\s*("+c+")(?:"+u+"("+c+"))?\\s*\\)"),d=new RegExp("rotate\\s*\\(\\s*("+c+")\\s*\\)"),p=new RegExp("scale\\s*\\(\\s*("+c+")(?:"+u+"("+c+"))?\\s*\\)");function f(t){if("number"==typeof t)return{min:t,max:t};if(t instanceof Object&&"min"in t&&"max"in t)return t;throw new Error("input '"+t+"' can't be parsed as an Range")}function m(t,e){var n=t.getPropertyValue(e);return parseFloat(n)||0}e.getTranslateValues=function g(t){var e=h.exec(t.attr("transform"));if(null!=e){var n=e[2];return[+e[1],+(void 0===n?0:n)]}return[0,0]},e.getRotate=function _(t){var e=d.exec(t.attr("transform"));return null!=e?+e[1]:0},e.getScaleValues=function y(t){var e=p.exec(t.attr("transform"));if(null!=e){var n=e[1],i=e[2];return[+n,null==i?+n:+i]}return[0,0]},e.clientRectsOverlap=function v(t,e){return!(n.floor(t.right)<=n.ceil(e.left)||n.ceil(t.left)>=n.floor(e.right)||n.floor(t.bottom)<=n.ceil(e.top)||n.ceil(t.top)>=n.floor(e.bottom))},e.expandRect=function b(t,e){return{left:t.left-e,top:t.top-e,right:t.right+e,bottom:t.bottom+e,width:t.width+2*e,height:t.height+2*e}},e.clientRectInside=function x(t,e){return n.floor(e.left)<=n.ceil(t.left)&&n.floor(e.top)<=n.ceil(t.top)&&n.floor(t.right)<=n.ceil(e.right)&&n.floor(t.bottom)<=n.ceil(e.bottom)},e.intersectsBBox=function w(t,e,n,i){void 0===i&&(i=.5);var r=f(t),o=f(e);return n.x+n.width>=r.min-i&&n.x<=r.max+i&&n.y+n.height>=o.min-i&&n.y<=o.max+i},e.getHtmlElementAncestors=function S(t){for(var e=[];t&&t instanceof HTMLElement;)e.push(t),t=t.parentElement;return e},e.getElementTransform=function M(t){var e=window.getComputedStyle(t,null);return(function n(t){if(null==t||"none"===t)return null;var e=t.match(E);if(null==e||e.length<2)return null;var n=e[1].split(T).map((function(t){return parseFloat(t)}));return 6!=n.length?null:n})(e.getPropertyValue("-webkit-transform")||e.getPropertyValue("-moz-transform")||e.getPropertyValue("-ms-transform")||e.getPropertyValue("-o-transform")||e.getPropertyValue("transform"))};var E=/^matrix\(([^)]+)\)$/,T=/[, ]+/})),Kft=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=window.Math,i=[1,0,0,1,0,0];function r(t,e){return[t[0]*e[0]+t[2]*e[1],t[1]*e[0]+t[3]*e[1],t[0]*e[2]+t[2]*e[3],t[1]*e[2]+t[3]*e[3],t[0]*e[4]+t[2]*e[5]+t[4],t[1]*e[4]+t[3]*e[5]+t[5]]}function o(t,e){return[t[0],t[1],t[2],t[3],t[0]*e[0]+t[2]*e[1]+t[4],t[1]*e[0]+t[3]*e[1]+t[5]]}function a(t){var e=t[0]*t[3]-t[1]*t[2];if(0===e)throw new Error("singular matrix");var n=1/e;return[n*t[3],n*-t[1],n*-t[2],n*t[0],n*(-t[3]*t[4]+t[2]*t[5]),n*(t[1]*t[4]+-t[0]*t[5])]}e.inRange=function s(t,e,i){return n.min(e,i)<=t&&t<=n.max(e,i)},e.clamp=function l(t,e,i){return n.min(n.max(e,t),i)},e.max=function c(t,e,n){var i="function"==typeof e?e:null,r=null==i?e:n,o=null==i?Uht.max(t):Uht.max(t,i);return void 0!==o?o:r},e.min=function u(t,e,n){var i="function"==typeof e?e:null,r=null==i?e:n,o=null==i?Uht.min(t):Uht.min(t,i);return void 0!==o?o:r},e.isNaN=function h(t){return t!=t},e.isValidNumber=function d(t){return"number"==typeof t&&t-t<1},e.range=function p(t,e,i){if(void 0===i&&(i=1),0===i)throw new Error("step cannot be 0");for(var r=n.max(n.ceil((e-t)/i),0),o=[],a=0;a<r;++a)o[a]=t+i*a;return o},e.distanceSquared=function f(t,e){return n.pow(e.y-t.y,2)+n.pow(e.x-t.x,2)},e.degreesToRadians=function m(t){return t/360*n.PI*2},e.within=function g(t,e){return e.topLeft.x<=t.x&&e.bottomRight.x>=t.x&&e.topLeft.y<=t.y&&e.bottomRight.y>=t.y},e.boundsIntersects=function _(t,e,n,i,r,o,a,s){return t<=r+a&&r<=t+n&&e<=o+s&&o<=e+i},e.getCumulativeTransform=function y(t){for(var e=$ft.getHtmlElementAncestors(t),n=i,s=null,l=0,c=e;l<c.length;l++){var u=c[l],h=$ft.getElementTransform(u);if(null!=h){var d=u.clientWidth/2,p=u.clientHeight/2;n=o(n,[d,p]),n=o(n=r(n,a(h)),[-d,-p])}var f=u.scrollLeft,m=u.scrollTop;null!==s&&u!==s||(f-=u.offsetLeft+u.clientLeft,m-=u.offsetTop+u.clientTop,s=u.offsetParent),n=o(n,[f,m])}return n},e.multiplyMatrix=r,e.premultiplyTranslate=function v(t,e){return[e[0],e[1],e[2],e[3],e[4]+t[0],e[5]+t[1]]},e.multiplyTranslate=o,e.invertMatrix=a,e.applyTransform=function b(t,e){return{x:t[0]*e.x+t[2]*e.y+t[4],y:t[1]*e.x+t[3]*e.y+t[5]}}})),Zft=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.prototype.split=function(t,e){for(var n=Math.ceil(t.length/2),i=0;i<n;i++)e[0].insert(t[i]);for(i=n;i<t.length;i++)e[1].insert(t[i])},t})();e.SplitStrategyTrivial=n;var i=(function(){function t(){}return t.prototype.split=function(t,e){for(t=t.slice(),this.chooseFirstSplit(t,e);t.length>0;)this.addNext(t,e)},t.prototype.chooseFirstSplit=function(t,e){for(var n=0,i=0,r=t.length-1,o=t.length-1,a=1;a<t.length-1;a++){var s=t[a];s.bounds.xl>t[r].bounds.xl?r=a:s.bounds.xh<t[n].bounds.xh&&(n=a),s.bounds.yl>t[o].bounds.yl?o=a:s.bounds.yh<t[i].bounds.yh&&(i=a)}var l=Math.abs(t[n].bounds.xh-t[r].bounds.xl)>Math.abs(t[i].bounds.yh-t[o].bounds.yl)?[n,r]:[i,o],c=l[0],u=l[1];c===u&&(c=0,u=t.length-1),e[0].insert(t.splice(Math.max(c,u),1)[0]),e[1].insert(t.splice(Math.min(c,u),1)[0])},t.prototype.addNext=function(t,e){for(var n=null,i=null,r=null,o=0;o<t.length;o++){var a=t[o],s=e[0].unionAreaDifference(a.bounds),l=e[1].unionAreaDifference(a.bounds);(s<i||null==n)&&(n=o,i=s,r=e[0]),l<i&&(n=o,i=l,r=e[1])}r.insert(t.splice(n,1)[0])},t})();e.SplitStrategyLinear=i})),Jft=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n,i=new Zft.SplitStrategyLinear;function r(t,e,i){var r=1/0,o=1/0;return function(a){var s=e(a.bounds,t),l=i(a.bounds,t);return null!=a.value?s<r?(r=s,o=l,n.PASS_AND_OVERWRITE):s===r?n.PASS:n.FAIL:s>o?n.FAIL:(o=Math.max(l,o),n.PASS)}}function o(t,e){return function(n,i){return e(i.bounds,t)-e(n.bounds,t)}}!(function(t){t[t.PASS=0]="PASS",t[t.FAIL=1]="FAIL",t[t.PASS_AND_OVERWRITE=2]="PASS_AND_OVERWRITE"})(n=e.QueryPredicateResult||(e.QueryPredicateResult={})),e.createMinimizingNodePredicate=r,e.createNodeSort=o;var a=(function(){function t(t,e){void 0===t&&(t=5),void 0===e&&(e=i),this.maxNodeChildren=t,this.splitStrategy=e,this.root=new s(!0),this.size=0}return t.prototype.getRoot=function(){return this.root},t.prototype.clear=function(){this.root=new s(!0),this.size=0},t.prototype.insert=function(t,e){for(var n=this.root;!n.leaf;)n=n.subtree(t);var i=s.valueNode(t,e);for(n.insert(i),this.size+=1;n.overflow(this.maxNodeChildren);)null==(n=n.split(this.splitStrategy)).parent&&(this.root=n);return i},t.prototype.locate=function(t){return this.query((function(e){return e.contains(t)}))},t.prototype.locateNearest=function(t){var e=r(t,l.distanceSquaredToNearEdge,l.distanceSquaredToFarEdge);return this.queryNodes(e).map((function(t){return t.value}))},t.prototype.locateNearestX=function(t){var e=r(t,l.absoluteDistanceToNearEdgeX,l.absoluteDistanceToFarEdgeX),n=this.queryNodes(e);return n.sort(o(t,l.absoluteDistanceToNearEdgeY)),n.map((function(t){return t.value}))},t.prototype.locateNearestY=function(t){var e=r(t,l.absoluteDistanceToNearEdgeY,l.absoluteDistanceToFarEdgeY),n=this.queryNodes(e);return n.sort(o(t,l.absoluteDistanceToNearEdgeX)),n.map((function(t){return t.value}))},t.prototype.intersect=function(t){return this.query((function(e){return l.isBoundsOverlapBounds(e,t)}))},t.prototype.intersectX=function(t){return this.query((function(e){return l.isBoundsOverlapX(e,t)}))},t.prototype.intersectY=function(t){return this.query((function(e){return l.isBoundsOverlapY(e,t)}))},t.prototype.query=function(t){var e=[];if(null!=this.root.bounds&&!t(this.root.bounds))return e;for(var n=[this.root];n.length>0;)for(var i=n.shift(),r=0;r<i.entries.length;r++){var o=i.entries[r];t(o.bounds)&&(i.leaf?e.push(o.value):n.push(o))}return e},t.prototype.queryNodes=function(t){var e=[];if(null!=this.root.bounds&&t(this.root)===n.FAIL)return e;for(var i=[this.root];i.length>0;)for(var r=i.shift(),o=0;o<r.entries.length;o++){var a=r.entries[o],s=t(a);s===n.PASS_AND_OVERWRITE&&(e=[]),s!==n.PASS&&s!==n.PASS_AND_OVERWRITE||(r.leaf?e.push(a):i.push(a))}return e},t})();e.RTree=a;var s=(function(){function t(t){this.leaf=t,this.bounds=null,this.entries=[],this.parent=null,this.value=null}return t.valueNode=function(e,n){var i=new t(!0);return i.bounds=e,i.value=n,i},t.prototype.overflow=function(t){return this.entries.length>t},t.prototype.insert=function(t){this.entries.push(t),t.parent=this;for(var e=this;null!=e;)e.bounds=l.unionAll([e.bounds,t.bounds]),e=e.parent;return this},t.prototype.remove=function(t){var e=this.entries.indexOf(t);if(e>=0){this.entries.splice(e,1);for(var n=this;null!=n;)n.bounds=l.unionAll(n.entries.map((function(t){return t.bounds}))),n=n.parent}return this},t.prototype.subtree=function(t){for(var e=1/0,n=null,i=0;i<this.entries.length;i++){var r=this.entries[i],o=r.unionAreaDifference(t);(o<e||o===e&&null!=n&&r.entries.length<n.entries.length)&&(n=r)}return n},t.prototype.split=function(e){null!=this.parent&&this.parent.remove(this);var n=[new t(this.leaf),new t(this.leaf)];e.split(this.entries,n);var i=null!=this.parent?this.parent:new t(!1);return i.insert(n[0]),i.insert(n[1]),i.leaf=!1,i},t.prototype.unionAreaDifference=function(t){return Math.abs(l.union(this.bounds,t).area()-this.bounds.area())},t.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map((function(t){return t.maxDepth()})).reduce((function(t,e){return Math.max(t,e)}))},t})();e.RTreeNode=s;var l=(function(){function t(t,e,n,i){this.xl=t,this.yl=e,this.xh=n,this.yh=i,this.width=this.xh-this.xl,this.height=this.yh-this.yl}return t.xywh=function(e,n,i,r){return new t(e,n,e+i,n+r)},t.entityBounds=function(e){return new t(e.x,e.y,e.x+e.width,e.y+e.height)},t.bounds=function(e){return t.pointPair(e.topLeft,e.bottomRight)},t.pointPair=function(e,n){return new t(Math.min(e.x,n.x),Math.min(e.y,n.y),Math.max(e.x,n.x),Math.max(e.y,n.y))},t.points=function(e){if(e.length<2)throw new Error("need at least 2 points to create bounds");var n=e.map((function(t){return t.x})),i=e.map((function(t){return t.y}));return new t(n.reduce((function(t,e){return Math.min(t,e)})),i.reduce((function(t,e){return Math.min(t,e)})),n.reduce((function(t,e){return Math.max(t,e)})),i.reduce((function(t,e){return Math.max(t,e)})))},t.union=function(e,n){return new t(Math.min(e.xl,n.xl),Math.min(e.yl,n.yl),Math.max(e.xh,n.xh),Math.max(e.yh,n.yh))},t.unionAll=function(e){return 0===(e=e.filter((function(t){return null!=t}))).length?null:e.reduce((function(e,n){return t.union(e,n)}))},t.isBoundsOverlapBounds=function(e,n){return t.isBoundsOverlapX(e,n)&&t.isBoundsOverlapY(e,n)},t.isBoundsOverlapX=function(t,e){return!(t.xh<e.xl||t.xl>e.xh)},t.isBoundsOverlapY=function(t,e){return!(t.yh<e.yl||t.yl>e.yh)},t.absoluteDistanceToNearEdgeX=function(t,e){var n=t.width/2;return Math.max(Math.abs(e.x-(t.xl+n))-n,0)},t.absoluteDistanceToNearEdgeY=function(t,e){var n=t.height/2;return Math.max(Math.abs(e.y-(t.yl+n))-n,0)},t.absoluteDistanceToFarEdgeX=function(e,n){var i=t.absoluteDistanceToNearEdgeX(e,n);return 0===i?0:i+e.width},t.absoluteDistanceToFarEdgeY=function(e,n){var i=t.absoluteDistanceToNearEdgeY(e,n);return 0===i?0:i+e.height},t.distanceSquaredToNearEdge=function(e,n){var i=t.absoluteDistanceToNearEdgeX(e,n),r=t.absoluteDistanceToNearEdgeY(e,n);return i*i+r*r},t.distanceSquaredToFarEdge=function(e,n){var i=t.absoluteDistanceToFarEdgeX(e,n),r=t.absoluteDistanceToFarEdgeY(e,n);return i*i+r*r},t.prototype.area=function(){return null==this.areaCached&&(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl)),this.areaCached},t.prototype.contains=function(t){return this.xl<=t.x&&this.xh>=t.x&&this.yl<=t.y&&this.yh>=t.y},t})();e.RTreeBounds=l})),Qft=be((function(t,e){(function(){var n,i="Expected a function",r="__lodash_hash_undefined__",o="__lodash_placeholder__",a=32,s=128,l=1/0,c=9007199254740991,u=NaN,h=4294967295,d=[["ary",s],["bind",1],["bindKey",2],["curry",8],["curryRight",16],["flip",512],["partial",a],["partialRight",64],["rearg",256]],p="[object Arguments]",f="[object Array]",m="[object Boolean]",g="[object Date]",_="[object Error]",y="[object Function]",v="[object GeneratorFunction]",b="[object Map]",x="[object Number]",w="[object Object]",S="[object Promise]",M="[object RegExp]",E="[object Set]",T="[object String]",A="[object Symbol]",C="[object WeakMap]",k="[object ArrayBuffer]",L="[object DataView]",P="[object Float32Array]",I="[object Float64Array]",N="[object Int8Array]",O="[object Int16Array]",R="[object Int32Array]",z="[object Uint8Array]",D="[object Uint8ClampedArray]",B="[object Uint16Array]",H="[object Uint32Array]",F=/\b__p \+= '';/g,V=/\b(__p \+=) '' \+/g,j=/(__e\(.*?\)|\b__t\)) \+\n'';/g,U=/&(?:amp|lt|gt|quot|#39);/g,G=/[&<>"']/g,W=RegExp(U.source),q=RegExp(G.source),Y=/<%-([\s\S]+?)%>/g,X=/<%([\s\S]+?)%>/g,$=/<%=([\s\S]+?)%>/g,K=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,Z=/^\w*$/,J=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,Q=/[\\^$.*+?()[\]{}|]/g,tt=RegExp(Q.source),et=/^\s+|\s+$/g,nt=/^\s+/,it=/\s+$/,rt=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,ot=/\{\n\/\* \[wrapped with (.+)\] \*/,at=/,? & /,st=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,lt=/\\(\\)?/g,ct=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,ut=/\w*$/,ht=/^[-+]0x[0-9a-f]+$/i,dt=/^0b[01]+$/i,pt=/^\[object .+?Constructor\]$/,ft=/^0o[0-7]+$/i,mt=/^(?:0|[1-9]\d*)$/,gt=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,_t=/($^)/,yt=/['\n\r\u2028\u2029\\]/g,vt="\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff",bt="a-z\\xdf-\\xf6\\xf8-\\xff",xt="A-Z\\xc0-\\xd6\\xd8-\\xde",wt="\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000",St="["+wt+"]",Mt="["+vt+"]",Et="\\d+",Tt="["+bt+"]",At="[^\\ud800-\\udfff"+wt+Et+"\\u2700-\\u27bf"+bt+xt+"]",Ct="\\ud83c[\\udffb-\\udfff]",kt="[^\\ud800-\\udfff]",Lt="(?:\\ud83c[\\udde6-\\uddff]){2}",Pt="[\\ud800-\\udbff][\\udc00-\\udfff]",It="["+xt+"]",Nt="(?:"+Tt+"|"+At+")",Ot="(?:"+It+"|"+At+")",Rt="(?:['’](?:d|ll|m|re|s|t|ve))?",zt="(?:['’](?:D|LL|M|RE|S|T|VE))?",Dt="(?:"+Mt+"|"+Ct+")?",Bt="[\\ufe0e\\ufe0f]?",Ht=Bt+Dt+"(?:\\u200d(?:"+[kt,Lt,Pt].join("|")+")"+Bt+Dt+")*",Ft="(?:"+["[\\u2700-\\u27bf]",Lt,Pt].join("|")+")"+Ht,Vt="(?:"+[kt+Mt+"?",Mt,Lt,Pt,"[\\ud800-\\udfff]"].join("|")+")",jt=RegExp("['’]","g"),Ut=RegExp(Mt,"g"),Gt=RegExp(Ct+"(?="+Ct+")|"+Vt+Ht,"g"),Wt=RegExp([It+"?"+Tt+"+"+Rt+"(?="+[St,It,"$"].join("|")+")",Ot+"+"+zt+"(?="+[St,It+Nt,"$"].join("|")+")",It+"?"+Nt+"+"+Rt,It+"+"+zt,"\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])","\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])",Et,Ft].join("|"),"g"),qt=RegExp("[\\u200d\\ud800-\\udfff"+vt+"\\ufe0e\\ufe0f]"),Yt=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Xt=["Array","Buffer","DataView","Date","Error","Float32Array","Float64Array","Function","Int8Array","Int16Array","Int32Array","Map","Math","Object","Promise","RegExp","Set","String","Symbol","TypeError","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","WeakMap","_","clearTimeout","isFinite","parseInt","setTimeout"],$t=-1,Kt={};Kt[P]=Kt[I]=Kt[N]=Kt[O]=Kt[R]=Kt[z]=Kt[D]=Kt[B]=Kt[H]=!0,Kt[p]=Kt[f]=Kt[k]=Kt[m]=Kt[L]=Kt[g]=Kt[_]=Kt[y]=Kt[b]=Kt[x]=Kt[w]=Kt[M]=Kt[E]=Kt[T]=Kt[C]=!1;var Zt={};Zt[p]=Zt[f]=Zt[k]=Zt[L]=Zt[m]=Zt[g]=Zt[P]=Zt[I]=Zt[N]=Zt[O]=Zt[R]=Zt[b]=Zt[x]=Zt[w]=Zt[M]=Zt[E]=Zt[T]=Zt[A]=Zt[z]=Zt[D]=Zt[B]=Zt[H]=!0,Zt[_]=Zt[y]=Zt[C]=!1;var Jt={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Qt=parseFloat,te=parseInt,ee="object"==typeof ve&&ve&&ve.Object===Object&&ve,ne="object"==typeof self&&self&&self.Object===Object&&self,ie=ee||ne||Function("return this")(),re=e&&!e.nodeType&&e,oe=re&&t&&!t.nodeType&&t,ae=oe&&oe.exports===re,se=ae&&ee.process,le=(function(){try{return oe&&oe.require&&oe.require("util").types||se&&se.binding&&se.binding("util")}catch(t){}})(),ce=le&&le.isArrayBuffer,ue=le&&le.isDate,he=le&&le.isMap,de=le&&le.isRegExp,pe=le&&le.isSet,fe=le&&le.isTypedArray;function me(t,e,n){switch(n.length){case 0:return t.call(e);case 1:return t.call(e,n[0]);case 2:return t.call(e,n[0],n[1]);case 3:return t.call(e,n[0],n[1],n[2])}return t.apply(e,n)}function ge(t,e,n,i){for(var r=-1,o=null==t?0:t.length;++r<o;){var a=t[r];e(i,a,n(a),t)}return i}function _e(t,e){for(var n=-1,i=null==t?0:t.length;++n<i&&!1!==e(t[n],n,t););return t}function ye(t,e){for(var n=null==t?0:t.length;n--&&!1!==e(t[n],n,t););return t}function be(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(!e(t[n],n,t))return!1;return!0}function xe(t,e){for(var n=-1,i=null==t?0:t.length,r=0,o=[];++n<i;){var a=t[n];e(a,n,t)&&(o[r++]=a)}return o}function we(t,e){return!(null==t||!t.length)&&Ie(t,e,0)>-1}function Se(t,e,n){for(var i=-1,r=null==t?0:t.length;++i<r;)if(n(e,t[i]))return!0;return!1}function Me(t,e){for(var n=-1,i=null==t?0:t.length,r=Array(i);++n<i;)r[n]=e(t[n],n,t);return r}function Ee(t,e){for(var n=-1,i=e.length,r=t.length;++n<i;)t[r+n]=e[n];return t}function Te(t,e,n,i){var r=-1,o=null==t?0:t.length;for(i&&o&&(n=t[++r]);++r<o;)n=e(n,t[r],r,t);return n}function Ae(t,e,n,i){var r=null==t?0:t.length;for(i&&r&&(n=t[--r]);r--;)n=e(n,t[r],r,t);return n}function Ce(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(e(t[n],n,t))return!0;return!1}var ke=ze("length");function Le(t,e,n){var i;return n(t,(function(t,n,r){if(e(t,n,r))return i=n,!1})),i}function Pe(t,e,n,i){for(var r=t.length,o=n+(i?1:-1);i?o--:++o<r;)if(e(t[o],o,t))return o;return-1}function Ie(t,e,n){return e==e?(function i(t,e,n){for(var i=n-1,r=t.length;++i<r;)if(t[i]===e)return i;return-1})(t,e,n):Pe(t,Oe,n)}function Ne(t,e,n,i){for(var r=n-1,o=t.length;++r<o;)if(i(t[r],e))return r;return-1}function Oe(t){return t!=t}function Re(t,e){var n=null==t?0:t.length;return n?He(t,e)/n:u}function ze(t){return function(e){return null==e?n:e[t]}}function De(t){return function(e){return null==t?n:t[e]}}function Be(t,e,n,i,r){return r(t,(function(t,r,o){n=i?(i=!1,t):e(n,t,r,o)})),n}function He(t,e){for(var i,r=-1,o=t.length;++r<o;){var a=e(t[r]);a!==n&&(i=i===n?a:i+a)}return i}function Fe(t,e){for(var n=-1,i=Array(t);++n<t;)i[n]=e(n);return i}function Ve(t){return function(e){return t(e)}}function je(t,e){return Me(e,(function(e){return t[e]}))}function Ue(t,e){return t.has(e)}function Ge(t,e){for(var n=-1,i=t.length;++n<i&&Ie(e,t[n],0)>-1;);return n}function We(t,e){for(var n=t.length;n--&&Ie(e,t[n],0)>-1;);return n}function qe(t,e){for(var n=t.length,i=0;n--;)t[n]===e&&++i;return i}var Ye=De({"À":"A","Á":"A","Â":"A","Ã":"A","Ä":"A","Å":"A","à":"a","á":"a","â":"a","ã":"a","ä":"a","å":"a","Ç":"C","ç":"c","Ð":"D","ð":"d","È":"E","É":"E","Ê":"E","Ë":"E","è":"e","é":"e","ê":"e","ë":"e","Ì":"I","Í":"I","Î":"I","Ï":"I","ì":"i","í":"i","î":"i","ï":"i","Ñ":"N","ñ":"n","Ò":"O","Ó":"O","Ô":"O","Õ":"O","Ö":"O","Ø":"O","ò":"o","ó":"o","ô":"o","õ":"o","ö":"o","ø":"o","Ù":"U","Ú":"U","Û":"U","Ü":"U","ù":"u","ú":"u","û":"u","ü":"u","Ý":"Y","ý":"y","ÿ":"y","Æ":"Ae","æ":"ae","Þ":"Th","þ":"th","ß":"ss","Ā":"A","Ă":"A","Ą":"A","ā":"a","ă":"a","ą":"a","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","ć":"c","ĉ":"c","ċ":"c","č":"c","Ď":"D","Đ":"D","ď":"d","đ":"d","Ē":"E","Ĕ":"E","Ė":"E","Ę":"E","Ě":"E","ē":"e","ĕ":"e","ė":"e","ę":"e","ě":"e","Ĝ":"G","Ğ":"G","Ġ":"G","Ģ":"G","ĝ":"g","ğ":"g","ġ":"g","ģ":"g","Ĥ":"H","Ħ":"H","ĥ":"h","ħ":"h","Ĩ":"I","Ī":"I","Ĭ":"I","Į":"I","İ":"I","ĩ":"i","ī":"i","ĭ":"i","į":"i","ı":"i","Ĵ":"J","ĵ":"j","Ķ":"K","ķ":"k","ĸ":"k","Ĺ":"L","Ļ":"L","Ľ":"L","Ŀ":"L","Ł":"L","ĺ":"l","ļ":"l","ľ":"l","ŀ":"l","ł":"l","Ń":"N","Ņ":"N","Ň":"N","Ŋ":"N","ń":"n","ņ":"n","ň":"n","ŋ":"n","Ō":"O","Ŏ":"O","Ő":"O","ō":"o","ŏ":"o","ő":"o","Ŕ":"R","Ŗ":"R","Ř":"R","ŕ":"r","ŗ":"r","ř":"r","Ś":"S","Ŝ":"S","Ş":"S","Š":"S","ś":"s","ŝ":"s","ş":"s","š":"s","Ţ":"T","Ť":"T","Ŧ":"T","ţ":"t","ť":"t","ŧ":"t","Ũ":"U","Ū":"U","Ŭ":"U","Ů":"U","Ű":"U","Ų":"U","ũ":"u","ū":"u","ŭ":"u","ů":"u","ű":"u","ų":"u","Ŵ":"W","ŵ":"w","Ŷ":"Y","ŷ":"y","Ÿ":"Y","Ź":"Z","Ż":"Z","Ž":"Z","ź":"z","ż":"z","ž":"z","Ĳ":"IJ","ĳ":"ij","Œ":"Oe","œ":"oe","ŉ":"'n","ſ":"s"}),Xe=De({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"});function $e(t){return"\\"+Jt[t]}function Ke(t){return qt.test(t)}function Ze(t){var e=-1,n=Array(t.size);return t.forEach((function(t,i){n[++e]=[i,t]})),n}function Je(t,e){return function(n){return t(e(n))}}function Qe(t,e){for(var n=-1,i=t.length,r=0,a=[];++n<i;){var s=t[n];s!==e&&s!==o||(t[n]=o,a[r++]=n)}return a}function tn(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=t})),n}function en(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=[t,t]})),n}function nn(t){return Ke(t)?(function e(t){for(var e=Gt.lastIndex=0;Gt.test(t);)++e;return e})(t):ke(t)}function rn(t){return Ke(t)?(function e(t){return t.match(Gt)||[]})(t):(function n(t){return t.split("")})(t)}var on=De({"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"}),an=(function t(e){var vt,bt=(e=null==e?ie:an.defaults(ie.Object(),e,an.pick(ie,Xt))).Array,xt=e.Date,wt=e.Error,St=e.Function,Mt=e.Math,Et=e.Object,Tt=e.RegExp,At=e.String,Ct=e.TypeError,kt=bt.prototype,Lt=Et.prototype,Pt=e["__core-js_shared__"],It=St.prototype.toString,Nt=Lt.hasOwnProperty,Ot=0,Rt=(vt=/[^.]+$/.exec(Pt&&Pt.keys&&Pt.keys.IE_PROTO||""))?"Symbol(src)_1."+vt:"",zt=Lt.toString,Dt=It.call(Et),Bt=ie._,Ht=Tt("^"+It.call(Nt).replace(Q,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Ft=ae?e.Buffer:n,Vt=e.Symbol,Gt=e.Uint8Array,qt=Ft?Ft.allocUnsafe:n,Jt=Je(Et.getPrototypeOf,Et),ee=Et.create,ne=Lt.propertyIsEnumerable,re=kt.splice,oe=Vt?Vt.isConcatSpreadable:n,se=Vt?Vt.iterator:n,le=Vt?Vt.toStringTag:n,ve=(function(){try{var t=Lo(Et,"defineProperty");return t({},"",{}),t}catch(t){}})(),ke=e.clearTimeout!==ie.clearTimeout&&e.clearTimeout,De=xt&&xt.now!==ie.Date.now&&xt.now,sn=e.setTimeout!==ie.setTimeout&&e.setTimeout,ln=Mt.ceil,cn=Mt.floor,un=Et.getOwnPropertySymbols,hn=Ft?Ft.isBuffer:n,dn=e.isFinite,pn=kt.join,fn=Je(Et.keys,Et),mn=Mt.max,gn=Mt.min,_n=xt.now,yn=e.parseInt,vn=Mt.random,bn=kt.reverse,xn=Lo(e,"DataView"),wn=Lo(e,"Map"),Sn=Lo(e,"Promise"),Mn=Lo(e,"Set"),En=Lo(e,"WeakMap"),Tn=Lo(Et,"create"),An=En&&new En,Cn={},kn=ra(xn),Ln=ra(wn),Pn=ra(Sn),In=ra(Mn),Nn=ra(En),On=Vt?Vt.prototype:n,Rn=On?On.valueOf:n,zn=On?On.toString:n;function Dn(t){if(Ss(t)&&!us(t)&&!(t instanceof Vn)){if(t instanceof Fn)return t;if(Nt.call(t,"__wrapped__"))return oa(t)}return new Fn(t)}var Bn=(function(){function t(){}return function(e){if(!ws(e))return{};if(ee)return ee(e);t.prototype=e;var i=new t;return t.prototype=n,i}})();function Hn(){}function Fn(t,e){this.__wrapped__=t,this.__actions__=[],this.__chain__=!!e,this.__index__=0,this.__values__=n}function Vn(t){this.__wrapped__=t,this.__actions__=[],this.__dir__=1,this.__filtered__=!1,this.__iteratees__=[],this.__takeCount__=h,this.__views__=[]}function jn(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function Un(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function Gn(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}function Wn(t){var e=-1,n=null==t?0:t.length;for(this.__data__=new Gn;++e<n;)this.add(t[e])}function qn(t){var e=this.__data__=new Un(t);this.size=e.size}function Yn(t,e){var n=us(t),i=!n&&cs(t),r=!n&&!i&&ms(t),o=!n&&!i&&!r&&Os(t),a=n||i||r||o,s=a?Fe(t.length,At):[],l=s.length;for(var c in t)!e&&!Nt.call(t,c)||a&&("length"==c||r&&("offset"==c||"parent"==c)||o&&("buffer"==c||"byteLength"==c||"byteOffset"==c)||Do(c,l))||s.push(c);return s}function Xn(t){var e=t.length;return e?t[dr(0,e-1)]:n}function $n(t,e){return ta(Yr(t),ri(e,0,t.length))}function Kn(t){return ta(Yr(t))}function Zn(t,e,i){(i!==n&&!as(t[e],i)||i===n&&!(e in t))&&ni(t,e,i)}function Jn(t,e,i){var r=t[e];Nt.call(t,e)&&as(r,i)&&(i!==n||e in t)||ni(t,e,i)}function Qn(t,e){for(var n=t.length;n--;)if(as(t[n][0],e))return n;return-1}function ti(t,e,n,i){return Pi(t,(function(t,r,o){e(i,t,n(t),o)})),i}function ei(t,e){return t&&Xr(e,il(e),t)}function ni(t,e,n){"__proto__"==e&&ve?ve(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n}function ii(t,e){for(var i=-1,r=e.length,o=bt(r),a=null==t;++i<r;)o[i]=a?n:Js(t,e[i]);return o}function ri(t,e,i){return t==t&&(i!==n&&(t=t<=i?t:i),e!==n&&(t=t>=e?t:e)),t}function oi(t,e,i,r,o,a){var s,l=1&e,c=2&e,u=4&e;if(i&&(s=o?i(t,r,o,a):i(t)),s!==n)return s;if(!ws(t))return t;var h=us(t);if(h){if(s=(function d(t){var e=t.length,n=new t.constructor(e);return e&&"string"==typeof t[0]&&Nt.call(t,"index")&&(n.index=t.index,n.input=t.input),n})(t),!l)return Yr(t,s)}else{var f=No(t),_=f==y||f==v;if(ms(t))return Vr(t,l);if(f==w||f==p||_&&!o){if(s=c||_?{}:Ro(t),!l)return c?(function C(t,e){return Xr(t,Io(t),e)})(t,(function S(t,e){return t&&Xr(e,rl(e),t)})(s,t)):(function F(t,e){return Xr(t,Po(t),e)})(t,ei(s,t))}else{if(!Zt[f])return o?t:{};s=(function V(t,e,n){var i=t.constructor;switch(e){case k:return jr(t);case m:case g:return new i(+t);case L:return(function r(t,e){var n=e?jr(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.byteLength)})(t,n);case P:case I:case N:case O:case R:case z:case D:case B:case H:return Ur(t,n);case b:return new i;case x:case T:return new i(t);case M:return(function o(t){var e=new t.constructor(t.source,ut.exec(t));return e.lastIndex=t.lastIndex,e})(t);case E:return new i;case A:return(function a(t){return Rn?Et(Rn.call(t)):{}})(t)}})(t,f,l)}}a||(a=new qn);var j=a.get(t);if(j)return j;a.set(t,s),Ls(t)?t.forEach((function(n){s.add(oi(n,e,i,n,t,a))})):Ms(t)&&t.forEach((function(n,r){s.set(r,oi(n,e,i,r,t,a))}));var U=h?n:(u?c?So:wo:c?rl:il)(t);return _e(U||t,(function(n,r){U&&(n=t[r=n]),Jn(s,r,oi(n,e,i,r,t,a))})),s}function ai(t,e,i){var r=i.length;if(null==t)return!r;for(t=Et(t);r--;){var o=i[r],a=t[o];if(a===n&&!(o in t)||!(0,e[o])(a))return!1}return!0}function si(t,e,r){if("function"!=typeof t)throw new Ct(i);return Ko((function(){t.apply(n,r)}),e)}function li(t,e,n,i){var r=-1,o=we,a=!0,s=t.length,l=[],c=e.length;if(!s)return l;n&&(e=Me(e,Ve(n))),i?(o=Se,a=!1):e.length>=200&&(o=Ue,a=!1,e=new Wn(e));t:for(;++r<s;){var u=t[r],h=null==n?u:n(u);if(u=i||0!==u?u:0,a&&h==h){for(var d=c;d--;)if(e[d]===h)continue t;l.push(u)}else o(e,h,i)||l.push(u)}return l}Dn.templateSettings={escape:Y,evaluate:X,interpolate:$,variable:"",imports:{_:Dn}},(Dn.prototype=Hn.prototype).constructor=Dn,(Fn.prototype=Bn(Hn.prototype)).constructor=Fn,(Vn.prototype=Bn(Hn.prototype)).constructor=Vn,jn.prototype.clear=function ci(){this.__data__=Tn?Tn(null):{},this.size=0},jn.prototype.delete=function ui(t){var e=this.has(t)&&delete this.__data__[t];return this.size-=e?1:0,e},jn.prototype.get=function hi(t){var e=this.__data__;if(Tn){var i=e[t];return i===r?n:i}return Nt.call(e,t)?e[t]:n},jn.prototype.has=function di(t){var e=this.__data__;return Tn?e[t]!==n:Nt.call(e,t)},jn.prototype.set=function pi(t,e){var i=this.__data__;return this.size+=this.has(t)?0:1,i[t]=Tn&&e===n?r:e,this},Un.prototype.clear=function fi(){this.__data__=[],this.size=0},Un.prototype.delete=function mi(t){var e=this.__data__,n=Qn(e,t);return!(n<0||(n==e.length-1?e.pop():re.call(e,n,1),--this.size,0))},Un.prototype.get=function gi(t){var e=this.__data__,i=Qn(e,t);return i<0?n:e[i][1]},Un.prototype.has=function _i(t){return Qn(this.__data__,t)>-1},Un.prototype.set=function yi(t,e){var n=this.__data__,i=Qn(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this},Gn.prototype.clear=function vi(){this.size=0,this.__data__={hash:new jn,map:new(wn||Un),string:new jn}},Gn.prototype.delete=function bi(t){var e=Co(this,t).delete(t);return this.size-=e?1:0,e},Gn.prototype.get=function xi(t){return Co(this,t).get(t)},Gn.prototype.has=function wi(t){return Co(this,t).has(t)},Gn.prototype.set=function Si(t,e){var n=Co(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this},Wn.prototype.add=Wn.prototype.push=function Mi(t){return this.__data__.set(t,r),this},Wn.prototype.has=function Ei(t){return this.__data__.has(t)},qn.prototype.clear=function Ti(){this.__data__=new Un,this.size=0},qn.prototype.delete=function Ai(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n},qn.prototype.get=function Ci(t){return this.__data__.get(t)},qn.prototype.has=function ki(t){return this.__data__.has(t)},qn.prototype.set=function Li(t,e){var n=this.__data__;if(n instanceof Un){var i=n.__data__;if(!wn||i.length<199)return i.push([t,e]),this.size=++n.size,this;n=this.__data__=new Gn(i)}return n.set(t,e),this.size=n.size,this};var Pi=Zr(Hi),Ii=Zr(Fi,!0);function Ni(t,e){var n=!0;return Pi(t,(function(t,i,r){return n=!!e(t,i,r)})),n}function Oi(t,e,i){for(var r=-1,o=t.length;++r<o;){var a=t[r],s=e(a);if(null!=s&&(l===n?s==s&&!Ns(s):i(s,l)))var l=s,c=a}return c}function Ri(t,e){var n=[];return Pi(t,(function(t,i,r){e(t,i,r)&&n.push(t)})),n}function zi(t,e,n,i,r){var o=-1,a=t.length;for(n||(n=zo),r||(r=[]);++o<a;){var s=t[o];e>0&&n(s)?e>1?zi(s,e-1,n,i,r):Ee(r,s):i||(r[r.length]=s)}return r}var Di=Jr(),Bi=Jr(!0);function Hi(t,e){return t&&Di(t,e,il)}function Fi(t,e){return t&&Bi(t,e,il)}function Vi(t,e){return xe(e,(function(e){return vs(t[e])}))}function ji(t,e){for(var i=0,r=(e=Dr(e,t)).length;null!=t&&i<r;)t=t[ia(e[i++])];return i&&i==r?t:n}function Ui(t,e,n){var i=e(t);return us(t)?i:Ee(i,n(t))}function Gi(t){return null==t?t===n?"[object Undefined]":"[object Null]":le&&le in Et(t)?(function e(t){var e=Nt.call(t,le),i=t[le];try{t[le]=n;var r=!0}catch(t){}var o=zt.call(t);return r&&(e?t[le]=i:delete t[le]),o})(t):(function i(t){return zt.call(t)})(t)}function Wi(t,e){return t>e}function qi(t,e){return null!=t&&Nt.call(t,e)}function Yi(t,e){return null!=t&&e in Et(t)}function Xi(t,e,i){for(var r=i?Se:we,o=t[0].length,a=t.length,s=a,l=bt(a),c=1/0,u=[];s--;){var h=t[s];s&&e&&(h=Me(h,Ve(e))),c=gn(h.length,c),l[s]=!i&&(e||o>=120&&h.length>=120)?new Wn(s&&h):n}h=t[0];var d=-1,p=l[0];t:for(;++d<o&&u.length<c;){var f=h[d],m=e?e(f):f;if(f=i||0!==f?f:0,!(p?Ue(p,m):r(u,m,i))){for(s=a;--s;){var g=l[s];if(!(g?Ue(g,m):r(t[s],m,i)))continue t}p&&p.push(m),u.push(f)}}return u}function $i(t,e,i){var r=null==(t=qo(t,e=Dr(e,t)))?t:t[ia(ga(e))];return null==r?n:me(r,t,i)}function Ki(t){return Ss(t)&&Gi(t)==p}function Zi(t,e,i,r,o){return t===e||(null==t||null==e||!Ss(t)&&!Ss(e)?t!=t&&e!=e:(function a(t,e,i,r,o,s){var l=us(t),c=us(e),u=l?f:No(t),h=c?f:No(e),d=(u=u==p?w:u)==w,y=(h=h==p?w:h)==w,v=u==h;if(v&&ms(t)){if(!ms(e))return!1;l=!0,d=!1}if(v&&!d)return s||(s=new qn),l||Os(t)?bo(t,e,i,r,o,s):(function S(t,e,n,i,r,o,a){switch(n){case L:if(t.byteLength!=e.byteLength||t.byteOffset!=e.byteOffset)return!1;t=t.buffer,e=e.buffer;case k:return!(t.byteLength!=e.byteLength||!o(new Gt(t),new Gt(e)));case m:case g:case x:return as(+t,+e);case _:return t.name==e.name&&t.message==e.message;case M:case T:return t==e+"";case b:var s=Ze;case E:if(s||(s=tn),t.size!=e.size&&!(1&i))return!1;var l=a.get(t);if(l)return l==e;i|=2,a.set(t,e);var c=bo(s(t),s(e),i,r,o,a);return a.delete(t),c;case A:if(Rn)return Rn.call(t)==Rn.call(e)}return!1})(t,e,u,i,r,o,s);if(!(1&i)){var C=d&&Nt.call(t,"__wrapped__"),P=y&&Nt.call(e,"__wrapped__");if(C||P){var I=C?t.value():t,N=P?e.value():e;return s||(s=new qn),o(I,N,i,r,s)}}return!!v&&(s||(s=new qn),(function O(t,e,i,r,o,a){var s=1&i,l=wo(t),c=l.length;if(c!=wo(e).length&&!s)return!1;for(var u=c;u--;){var h=l[u];if(!(s?h in e:Nt.call(e,h)))return!1}var d=a.get(t),p=a.get(e);if(d&&p)return d==e&&p==t;var f=!0;a.set(t,e),a.set(e,t);for(var m=s;++u<c;){var g=t[h=l[u]],_=e[h];if(r)var y=s?r(_,g,h,e,t,a):r(g,_,h,t,e,a);if(!(y===n?g===_||o(g,_,i,r,a):y)){f=!1;break}m||(m="constructor"==h)}if(f&&!m){var v=t.constructor,b=e.constructor;v==b||!("constructor"in t)||!("constructor"in e)||"function"==typeof v&&v instanceof v&&"function"==typeof b&&b instanceof b||(f=!1)}return a.delete(t),a.delete(e),f})(t,e,i,r,o,s))})(t,e,i,r,Zi,o))}function Ji(t,e,i,r){var o=i.length,a=o,s=!r;if(null==t)return!a;for(t=Et(t);o--;){var l=i[o];if(s&&l[2]?l[1]!==t[l[0]]:!(l[0]in t))return!1}for(;++o<a;){var c=(l=i[o])[0],u=t[c],h=l[1];if(s&&l[2]){if(u===n&&!(c in t))return!1}else{var d=new qn;if(r)var p=r(u,h,c,t,e,d);if(!(p===n?Zi(h,u,3,r,d):p))return!1}}return!0}function Qi(t){return!(!ws(t)||(function e(t){return!!Rt&&Rt in t})(t))&&(vs(t)?Ht:pt).test(ra(t))}function tr(t){return"function"==typeof t?t:null==t?kl:"object"==typeof t?us(t)?or(t[0],t[1]):rr(t):Bl(t)}function er(t){if(!jo(t))return fn(t);var e=[];for(var n in Et(t))Nt.call(t,n)&&"constructor"!=n&&e.push(n);return e}function nr(t,e){return t<e}function ir(t,e){var n=-1,i=ps(t)?bt(t.length):[];return Pi(t,(function(t,r,o){i[++n]=e(t,r,o)})),i}function rr(t){var e=ko(t);return 1==e.length&&e[0][2]?Go(e[0][0],e[0][1]):function(n){return n===t||Ji(n,t,e)}}function or(t,e){return Ho(t)&&Uo(e)?Go(ia(t),e):function(i){var r=Js(i,t);return r===n&&r===e?Qs(i,t):Zi(e,r,3)}}function ar(t,e,i,r,o){t!==e&&Di(e,(function(a,s){if(o||(o=new qn),ws(a))!(function l(t,e,i,r,o,a,s){var l=Xo(t,i),c=Xo(e,i),u=s.get(c);if(u)Zn(t,i,u);else{var h=a?a(l,c,i+"",t,e,s):n,d=h===n;if(d){var p=us(c),f=!p&&ms(c),m=!p&&!f&&Os(c);h=c,p||f||m?us(l)?h=l:fs(l)?h=Yr(l):f?(d=!1,h=Vr(c,!0)):m?(d=!1,h=Ur(c,!0)):h=[]:As(c)||cs(c)?(h=l,cs(l)?h=Us(l):ws(l)&&!vs(l)||(h=Ro(c))):d=!1}d&&(s.set(c,h),o(h,c,r,a,s),s.delete(c)),Zn(t,i,h)}})(t,e,s,i,ar,r,o);else{var c=r?r(Xo(t,s),a,s+"",t,e,o):n;c===n&&(c=a),Zn(t,s,c)}}),rl)}function sr(t,e){var i=t.length;if(i)return Do(e+=e<0?i:0,i)?t[e]:n}function lr(t,e,n){e=e.length?Me(e,(function(t){return us(t)?function(e){return ji(e,1===t.length?t[0]:t)}:t})):[kl];var i=-1;return e=Me(e,Ve(Ao())),(function r(t,e){var n=t.length;for(t.sort(e);n--;)t[n]=t[n].value;return t})(ir(t,(function(t,n,r){return{criteria:Me(e,(function(e){return e(t)})),index:++i,value:t}})),(function(t,e){return(function i(t,e,n){for(var i=-1,r=t.criteria,o=e.criteria,a=r.length,s=n.length;++i<a;){var l=Gr(r[i],o[i]);if(l)return i>=s?l:l*("desc"==n[i]?-1:1)}return t.index-e.index})(t,e,n)}))}function cr(t,e,n){for(var i=-1,r=e.length,o={};++i<r;){var a=e[i],s=ji(t,a);n(s,a)&&_r(o,Dr(a,t),s)}return o}function ur(t,e,n,i){var r=i?Ne:Ie,o=-1,a=e.length,s=t;for(t===e&&(e=Yr(e)),n&&(s=Me(t,Ve(n)));++o<a;)for(var l=0,c=e[o],u=n?n(c):c;(l=r(s,u,l,i))>-1;)s!==t&&re.call(s,l,1),re.call(t,l,1);return t}function hr(t,e){for(var n=t?e.length:0,i=n-1;n--;){var r=e[n];if(n==i||r!==o){var o=r;Do(r)?re.call(t,r,1):kr(t,r)}}return t}function dr(t,e){return t+cn(vn()*(e-t+1))}function pr(t,e){var n="";if(!t||e<1||e>c)return n;do{e%2&&(n+=t),(e=cn(e/2))&&(t+=t)}while(e);return n}function fr(t,e){return Zo(Wo(t,e,kl),t+"")}function mr(t){return Xn(dl(t))}function gr(t,e){var n=dl(t);return ta(n,ri(e,0,n.length))}function _r(t,e,i,r){if(!ws(t))return t;for(var o=-1,a=(e=Dr(e,t)).length,s=a-1,l=t;null!=l&&++o<a;){var c=ia(e[o]),u=i;if("__proto__"===c||"constructor"===c||"prototype"===c)return t;if(o!=s){var h=l[c];(u=r?r(h,c,l):n)===n&&(u=ws(h)?h:Do(e[o+1])?[]:{})}Jn(l,c,u),l=l[c]}return t}var yr=An?function(t,e){return An.set(t,e),t}:kl,vr=ve?function(t,e){return ve(t,"toString",{configurable:!0,enumerable:!1,value:Tl(e),writable:!0})}:kl;function br(t){return ta(dl(t))}function xr(t,e,n){var i=-1,r=t.length;e<0&&(e=-e>r?0:r+e),(n=n>r?r:n)<0&&(n+=r),r=e>n?0:n-e>>>0,e>>>=0;for(var o=bt(r);++i<r;)o[i]=t[i+e];return o}function wr(t,e){var n;return Pi(t,(function(t,i,r){return!(n=e(t,i,r))})),!!n}function Sr(t,e,n){var i=0,r=null==t?i:t.length;if("number"==typeof e&&e==e&&r<=2147483647){for(;i<r;){var o=i+r>>>1,a=t[o];null!==a&&!Ns(a)&&(n?a<=e:a<e)?i=o+1:r=o}return r}return Mr(t,e,kl,n)}function Mr(t,e,i,r){var o=0,a=null==t?0:t.length;if(0===a)return 0;for(var s=(e=i(e))!=e,l=null===e,c=Ns(e),u=e===n;o<a;){var h=cn((o+a)/2),d=i(t[h]),p=d!==n,f=null===d,m=d==d,g=Ns(d);if(s)var _=r||m;else _=u?m&&(r||p):l?m&&p&&(r||!f):c?m&&p&&!f&&(r||!g):!f&&!g&&(r?d<=e:d<e);_?o=h+1:a=h}return gn(a,4294967294)}function Er(t,e){for(var n=-1,i=t.length,r=0,o=[];++n<i;){var a=t[n],s=e?e(a):a;if(!n||!as(s,l)){var l=s;o[r++]=0===a?0:a}}return o}function Tr(t){return"number"==typeof t?t:Ns(t)?u:+t}function Ar(t){if("string"==typeof t)return t;if(us(t))return Me(t,Ar)+"";if(Ns(t))return zn?zn.call(t):"";var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}function Cr(t,e,n){var i=-1,r=we,o=t.length,a=!0,s=[],l=s;if(n)a=!1,r=Se;else if(o>=200){var c=e?null:fo(t);if(c)return tn(c);a=!1,r=Ue,l=new Wn}else l=e?[]:s;t:for(;++i<o;){var u=t[i],h=e?e(u):u;if(u=n||0!==u?u:0,a&&h==h){for(var d=l.length;d--;)if(l[d]===h)continue t;e&&l.push(h),s.push(u)}else r(l,h,n)||(l!==s&&l.push(h),s.push(u))}return s}function kr(t,e){return null==(t=qo(t,e=Dr(e,t)))||delete t[ia(ga(e))]}function Lr(t,e,n,i){return _r(t,e,n(ji(t,e)),i)}function Pr(t,e,n,i){for(var r=t.length,o=i?r:-1;(i?o--:++o<r)&&e(t[o],o,t););return n?xr(t,i?0:o,i?o+1:r):xr(t,i?o+1:0,i?r:o)}function Ir(t,e){var n=t;return n instanceof Vn&&(n=n.value()),Te(e,(function(t,e){return e.func.apply(e.thisArg,Ee([t],e.args))}),n)}function Nr(t,e,n){var i=t.length;if(i<2)return i?Cr(t[0]):[];for(var r=-1,o=bt(i);++r<i;)for(var a=t[r],s=-1;++s<i;)s!=r&&(o[r]=li(o[r]||a,t[s],e,n));return Cr(zi(o,1),e,n)}function Or(t,e,i){for(var r=-1,o=t.length,a=e.length,s={};++r<o;)i(s,t[r],r<a?e[r]:n);return s}function Rr(t){return fs(t)?t:[]}function zr(t){return"function"==typeof t?t:kl}function Dr(t,e){return us(t)?t:Ho(t,e)?[t]:ea(Gs(t))}var Br=fr;function Hr(t,e,i){var r=t.length;return i=i===n?r:i,!e&&i>=r?t:xr(t,e,i)}var Fr=ke||function(t){return ie.clearTimeout(t)};function Vr(t,e){if(e)return t.slice();var n=t.length,i=qt?qt(n):new t.constructor(n);return t.copy(i),i}function jr(t){var e=new t.constructor(t.byteLength);return new Gt(e).set(new Gt(t)),e}function Ur(t,e){var n=e?jr(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.length)}function Gr(t,e){if(t!==e){var i=t!==n,r=null===t,o=t==t,a=Ns(t),s=e!==n,l=null===e,c=e==e,u=Ns(e);if(!l&&!u&&!a&&t>e||a&&s&&c&&!l&&!u||r&&s&&c||!i&&c||!o)return 1;if(!r&&!a&&!u&&t<e||u&&i&&o&&!r&&!a||l&&i&&o||!s&&o||!c)return-1}return 0}function Wr(t,e,n,i){for(var r=-1,o=t.length,a=n.length,s=-1,l=e.length,c=mn(o-a,0),u=bt(l+c),h=!i;++s<l;)u[s]=e[s];for(;++r<a;)(h||r<o)&&(u[n[r]]=t[r]);for(;c--;)u[s++]=t[r++];return u}function qr(t,e,n,i){for(var r=-1,o=t.length,a=-1,s=n.length,l=-1,c=e.length,u=mn(o-s,0),h=bt(u+c),d=!i;++r<u;)h[r]=t[r];for(var p=r;++l<c;)h[p+l]=e[l];for(;++a<s;)(d||r<o)&&(h[p+n[a]]=t[r++]);return h}function Yr(t,e){var n=-1,i=t.length;for(e||(e=bt(i));++n<i;)e[n]=t[n];return e}function Xr(t,e,i,r){var o=!i;i||(i={});for(var a=-1,s=e.length;++a<s;){var l=e[a],c=r?r(i[l],t[l],l,i,t):n;c===n&&(c=t[l]),o?ni(i,l,c):Jn(i,l,c)}return i}function $r(t,e){return function(n,i){var r=us(n)?ge:ti,o=e?e():{};return r(n,t,Ao(i,2),o)}}function Kr(t){return fr((function(e,i){var r=-1,o=i.length,a=o>1?i[o-1]:n,s=o>2?i[2]:n;for(a=t.length>3&&"function"==typeof a?(o--,a):n,s&&Bo(i[0],i[1],s)&&(a=o<3?n:a,o=1),e=Et(e);++r<o;){var l=i[r];l&&t(e,l,r,a)}return e}))}function Zr(t,e){return function(n,i){if(null==n)return n;if(!ps(n))return t(n,i);for(var r=n.length,o=e?r:-1,a=Et(n);(e?o--:++o<r)&&!1!==i(a[o],o,a););return n}}function Jr(t){return function(e,n,i){for(var r=-1,o=Et(e),a=i(e),s=a.length;s--;){var l=a[t?s:++r];if(!1===n(o[l],l,o))break}return e}}function Qr(t){return function(e){var i=Ke(e=Gs(e))?rn(e):n,r=i?i[0]:e.charAt(0),o=i?Hr(i,1).join(""):e.slice(1);return r[t]()+o}}function to(t){return function(e){return Te(Sl(ml(e).replace(jt,"")),t,"")}}function eo(t){return function(){var e=arguments;switch(e.length){case 0:return new t;case 1:return new t(e[0]);case 2:return new t(e[0],e[1]);case 3:return new t(e[0],e[1],e[2]);case 4:return new t(e[0],e[1],e[2],e[3]);case 5:return new t(e[0],e[1],e[2],e[3],e[4]);case 6:return new t(e[0],e[1],e[2],e[3],e[4],e[5]);case 7:return new t(e[0],e[1],e[2],e[3],e[4],e[5],e[6])}var n=Bn(t.prototype),i=t.apply(n,e);return ws(i)?i:n}}function no(t){return function(e,i,r){var o=Et(e);if(!ps(e)){var a=Ao(i,3);e=il(e),i=function(t){return a(o[t],t,o)}}var s=t(e,i,r);return s>-1?o[a?e[s]:s]:n}}function io(t){return xo((function(e){var r=e.length,o=r,a=Fn.prototype.thru;for(t&&e.reverse();o--;){var s=e[o];if("function"!=typeof s)throw new Ct(i);if(a&&!l&&"wrapper"==Eo(s))var l=new Fn([],!0)}for(o=l?o:r;++o<r;){var c=Eo(s=e[o]),u="wrapper"==c?Mo(s):n;l=u&&Fo(u[0])&&424==u[1]&&!u[4].length&&1==u[9]?l[Eo(u[0])].apply(l,u[3]):1==s.length&&Fo(s)?l[c]():l.thru(s)}return function(){var t=arguments,n=t[0];if(l&&1==t.length&&us(n))return l.plant(n).value();for(var i=0,o=r?e[i].apply(this,t):n;++i<r;)o=e[i].call(this,o);return o}}))}function ro(t,e,i,r,o,a,l,c,u,h){var d=e&s,p=1&e,f=2&e,m=24&e,g=512&e,_=f?n:eo(t);return function n(){for(var s=arguments.length,y=bt(s),v=s;v--;)y[v]=arguments[v];if(m)var b=To(n),x=qe(y,b);if(r&&(y=Wr(y,r,o,m)),a&&(y=qr(y,a,l,m)),s-=x,m&&s<h){var w=Qe(y,b);return ho(t,e,ro,n.placeholder,i,y,w,c,u,h-s)}var S=p?i:this,M=f?S[t]:t;return s=y.length,c?y=Yo(y,c):g&&s>1&&y.reverse(),d&&u<s&&(y.length=u),this&&this!==ie&&this instanceof n&&(M=_||eo(M)),M.apply(S,y)}}function oo(t,e){return function(n,i){return(function r(t,e,n,i){return Hi(t,(function(t,r,o){e(i,n(t),r,o)})),i})(n,t,e(i),{})}}function ao(t,e){return function(i,r){var o;if(i===n&&r===n)return e;if(i!==n&&(o=i),r!==n){if(o===n)return r;"string"==typeof i||"string"==typeof r?(i=Ar(i),r=Ar(r)):(i=Tr(i),r=Tr(r)),o=t(i,r)}return o}}function so(t){return xo((function(e){return e=Me(e,Ve(Ao())),fr((function(n){var i=this;return t(e,(function(t){return me(t,i,n)}))}))}))}function lo(t,e){var i=(e=e===n?" ":Ar(e)).length;if(i<2)return i?pr(e,t):e;var r=pr(e,ln(t/nn(e)));return Ke(e)?Hr(rn(r),0,t).join(""):r.slice(0,t)}function co(t){return function(e,i,r){return r&&"number"!=typeof r&&Bo(e,i,r)&&(i=r=n),e=Hs(e),i===n?(i=e,e=0):i=Hs(i),(function o(t,e,n,i){for(var r=-1,o=mn(ln((e-t)/(n||1)),0),a=bt(o);o--;)a[i?o:++r]=t,t+=n;return a})(e,i,r=r===n?e<i?1:-1:Hs(r),t)}}function uo(t){return function(e,n){return"string"==typeof e&&"string"==typeof n||(e=js(e),n=js(n)),t(e,n)}}function ho(t,e,i,r,o,s,l,c,u,h){var d=8&e;e|=d?a:64,4&(e&=~(d?64:a))||(e&=-4);var p=[t,e,o,d?s:n,d?l:n,d?n:s,d?n:l,c,u,h],f=i.apply(n,p);return Fo(t)&&$o(f,p),f.placeholder=r,Jo(f,t,e)}function po(t){var e=Mt[t];return function(t,n){if(t=js(t),(n=null==n?0:gn(Fs(n),292))&&dn(t)){var i=(Gs(t)+"e").split("e");return+((i=(Gs(e(i[0]+"e"+(+i[1]+n)))+"e").split("e"))[0]+"e"+(+i[1]-n))}return e(t)}}var fo=Mn&&1/tn(new Mn([,-0]))[1]==l?function(t){return new Mn(t)}:Ol;function mo(t){return function(e){var n=No(e);return n==b?Ze(e):n==E?en(e):(function i(t,e){return Me(e,(function(e){return[e,t[e]]}))})(e,t(e))}}function go(t,e,r,l,c,u,h,d){var p=2&e;if(!p&&"function"!=typeof t)throw new Ct(i);var f=l?l.length:0;if(f||(e&=-97,l=c=n),h=h===n?h:mn(Fs(h),0),d=d===n?d:Fs(d),f-=c?c.length:0,64&e){var m=l,g=c;l=c=n}var _=p?n:Mo(t),y=[t,e,r,l,c,m,g,u,h,d];if(_&&(function v(t,e){var n=t[1],i=e[1],r=n|i;if(!(r<131||i==s&&8==n||i==s&&256==n&&t[7].length<=e[8]||384==i&&e[7].length<=e[8]&&8==n))return t;1&i&&(t[2]=e[2],r|=1&n?0:4);var a=e[3];if(a){var l=t[3];t[3]=l?Wr(l,a,e[4]):a,t[4]=l?Qe(t[3],o):e[4]}(a=e[5])&&(t[5]=(l=t[5])?qr(l,a,e[6]):a,t[6]=l?Qe(t[5],o):e[6]),(a=e[7])&&(t[7]=a),i&s&&(t[8]=null==t[8]?e[8]:gn(t[8],e[8])),null==t[9]&&(t[9]=e[9]),t[0]=e[0],t[1]=r})(y,_),t=y[0],e=y[1],r=y[2],l=y[3],c=y[4],!(d=y[9]=y[9]===n?p?0:t.length:mn(y[9]-f,0))&&24&e&&(e&=-25),e&&1!=e)w=8==e||16==e?(function b(t,e,i){var r=eo(t);return function o(){for(var a=arguments.length,s=bt(a),l=a,c=To(o);l--;)s[l]=arguments[l];var u=a<3&&s[0]!==c&&s[a-1]!==c?[]:Qe(s,c);return(a-=u.length)<i?ho(t,e,ro,o.placeholder,n,s,u,n,n,i-a):me(this&&this!==ie&&this instanceof o?r:t,this,s)}})(t,e,d):e!=a&&33!=e||c.length?ro.apply(n,y):(function x(t,e,n,i){var r=1&e,o=eo(t);return function e(){for(var a=-1,s=arguments.length,l=-1,c=i.length,u=bt(c+s),h=this&&this!==ie&&this instanceof e?o:t;++l<c;)u[l]=i[l];for(;s--;)u[l++]=arguments[++a];return me(h,r?n:this,u)}})(t,e,r,l);else var w=(function S(t,e,n){var i=1&e,r=eo(t);return function e(){return(this&&this!==ie&&this instanceof e?r:t).apply(i?n:this,arguments)}})(t,e,r);return Jo((_?yr:$o)(w,y),t,e)}function _o(t,e,i,r){return t===n||as(t,Lt[i])&&!Nt.call(r,i)?e:t}function yo(t,e,i,r,o,a){return ws(t)&&ws(e)&&(a.set(e,t),ar(t,e,n,yo,a),a.delete(e)),t}function vo(t){return As(t)?n:t}function bo(t,e,i,r,o,a){var s=1&i,l=t.length,c=e.length;if(l!=c&&!(s&&c>l))return!1;var u=a.get(t),h=a.get(e);if(u&&h)return u==e&&h==t;var d=-1,p=!0,f=2&i?new Wn:n;for(a.set(t,e),a.set(e,t);++d<l;){var m=t[d],g=e[d];if(r)var _=s?r(g,m,d,e,t,a):r(m,g,d,t,e,a);if(_!==n){if(_)continue;p=!1;break}if(f){if(!Ce(e,(function(t,e){if(!Ue(f,e)&&(m===t||o(m,t,i,r,a)))return f.push(e)}))){p=!1;break}}else if(m!==g&&!o(m,g,i,r,a)){p=!1;break}}return a.delete(t),a.delete(e),p}function xo(t){return Zo(Wo(t,n,ha),t+"")}function wo(t){return Ui(t,il,Po)}function So(t){return Ui(t,rl,Io)}var Mo=An?function(t){return An.get(t)}:Ol;function Eo(t){for(var e=t.name+"",n=Cn[e],i=Nt.call(Cn,e)?n.length:0;i--;){var r=n[i],o=r.func;if(null==o||o==t)return r.name}return e}function To(t){return(Nt.call(Dn,"placeholder")?Dn:t).placeholder}function Ao(){var t=Dn.iteratee||Ll;return t=t===Ll?tr:t,arguments.length?t(arguments[0],arguments[1]):t}function Co(t,e){var n=t.__data__;return(function i(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t})(e)?n["string"==typeof e?"string":"hash"]:n.map}function ko(t){for(var e=il(t),n=e.length;n--;){var i=e[n],r=t[i];e[n]=[i,r,Uo(r)]}return e}function Lo(t,e){var i=(function r(t,e){return null==t?n:t[e]})(t,e);return Qi(i)?i:n}var Po=un?function(t){return null==t?[]:(t=Et(t),xe(un(t),(function(e){return ne.call(t,e)})))}:Vl,Io=un?function(t){for(var e=[];t;)Ee(e,Po(t)),t=Jt(t);return e}:Vl,No=Gi;function Oo(t,e,n){for(var i=-1,r=(e=Dr(e,t)).length,o=!1;++i<r;){var a=ia(e[i]);if(!(o=null!=t&&n(t,a)))break;t=t[a]}return o||++i!=r?o:!!(r=null==t?0:t.length)&&xs(r)&&Do(a,r)&&(us(t)||cs(t))}function Ro(t){return"function"!=typeof t.constructor||jo(t)?{}:Bn(Jt(t))}function zo(t){return us(t)||cs(t)||!!(oe&&t&&t[oe])}function Do(t,e){var n=typeof t;return!!(e=null==e?c:e)&&("number"==n||"symbol"!=n&&mt.test(t))&&t>-1&&t%1==0&&t<e}function Bo(t,e,n){if(!ws(n))return!1;var i=typeof e;return!!("number"==i?ps(n)&&Do(e,n.length):"string"==i&&e in n)&&as(n[e],t)}function Ho(t,e){if(us(t))return!1;var n=typeof t;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=t&&!Ns(t))||Z.test(t)||!K.test(t)||null!=e&&t in Et(e)}function Fo(t){var e=Eo(t),n=Dn[e];if("function"!=typeof n||!(e in Vn.prototype))return!1;if(t===n)return!0;var i=Mo(n);return!!i&&t===i[0]}(xn&&No(new xn(new ArrayBuffer(1)))!=L||wn&&No(new wn)!=b||Sn&&No(Sn.resolve())!=S||Mn&&No(new Mn)!=E||En&&No(new En)!=C)&&(No=function(t){var e=Gi(t),i=e==w?t.constructor:n,r=i?ra(i):"";if(r)switch(r){case kn:return L;case Ln:return b;case Pn:return S;case In:return E;case Nn:return C}return e});var Vo=Pt?vs:jl;function jo(t){var e=t&&t.constructor;return t===("function"==typeof e&&e.prototype||Lt)}function Uo(t){return t==t&&!ws(t)}function Go(t,e){return function(i){return null!=i&&i[t]===e&&(e!==n||t in Et(i))}}function Wo(t,e,i){return e=mn(e===n?t.length-1:e,0),function(){for(var n=arguments,r=-1,o=mn(n.length-e,0),a=bt(o);++r<o;)a[r]=n[e+r];r=-1;for(var s=bt(e+1);++r<e;)s[r]=n[r];return s[e]=i(a),me(t,this,s)}}function qo(t,e){return e.length<2?t:ji(t,xr(e,0,-1))}function Yo(t,e){for(var i=t.length,r=gn(e.length,i),o=Yr(t);r--;){var a=e[r];t[r]=Do(a,i)?o[a]:n}return t}function Xo(t,e){if(("constructor"!==e||"function"!=typeof t[e])&&"__proto__"!=e)return t[e]}var $o=Qo(yr),Ko=sn||function(t,e){return ie.setTimeout(t,e)},Zo=Qo(vr);function Jo(t,e,n){var i=e+"";return Zo(t,(function a(t,e){var n=e.length;if(!n)return t;var i=n-1;return e[i]=(n>1?"& ":"")+e[i],e=e.join(n>2?", ":" "),t.replace(rt,"{\n/* [wrapped with "+e+"] */\n")})(i,(function o(t,e){return _e(d,(function(n){var i="_."+n[0];e&n[1]&&!we(t,i)&&t.push(i)})),t.sort()})((function r(t){var e=t.match(ot);return e?e[1].split(at):[]})(i),n)))}function Qo(t){var e=0,i=0;return function(){var r=_n(),o=16-(r-i);if(i=r,o>0){if(++e>=800)return arguments[0]}else e=0;return t.apply(n,arguments)}}function ta(t,e){var i=-1,r=t.length,o=r-1;for(e=e===n?r:e;++i<e;){var a=dr(i,o),s=t[a];t[a]=t[i],t[i]=s}return t.length=e,t}var ea=(function na(t){var e=ts(t,(function(t){return 500===n.size&&n.clear(),t})),n=e.cache;return e})((function(t){var e=[];return 46===t.charCodeAt(0)&&e.push(""),t.replace(J,(function(t,n,i,r){e.push(i?r.replace(lt,"$1"):n||t)})),e}));function ia(t){if("string"==typeof t||Ns(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e}function ra(t){if(null!=t){try{return It.call(t)}catch(t){}try{return t+""}catch(t){}}return""}function oa(t){if(t instanceof Vn)return t.clone();var e=new Fn(t.__wrapped__,t.__chain__);return e.__actions__=Yr(t.__actions__),e.__index__=t.__index__,e.__values__=t.__values__,e}var aa=fr((function(t,e){return fs(t)?li(t,zi(e,1,fs,!0)):[]})),sa=fr((function(t,e){var i=ga(e);return fs(i)&&(i=n),fs(t)?li(t,zi(e,1,fs,!0),Ao(i,2)):[]})),la=fr((function(t,e){var i=ga(e);return fs(i)&&(i=n),fs(t)?li(t,zi(e,1,fs,!0),n,i):[]}));function ca(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var r=null==n?0:Fs(n);return r<0&&(r=mn(i+r,0)),Pe(t,Ao(e,3),r)}function ua(t,e,i){var r=null==t?0:t.length;if(!r)return-1;var o=r-1;return i!==n&&(o=Fs(i),o=i<0?mn(r+o,0):gn(o,r-1)),Pe(t,Ao(e,3),o,!0)}function ha(t){return null!=t&&t.length?zi(t,1):[]}function da(t){return t&&t.length?t[0]:n}var pa=fr((function(t){var e=Me(t,Rr);return e.length&&e[0]===t[0]?Xi(e):[]})),fa=fr((function(t){var e=ga(t),i=Me(t,Rr);return e===ga(i)?e=n:i.pop(),i.length&&i[0]===t[0]?Xi(i,Ao(e,2)):[]})),ma=fr((function(t){var e=ga(t),i=Me(t,Rr);return(e="function"==typeof e?e:n)&&i.pop(),i.length&&i[0]===t[0]?Xi(i,n,e):[]}));function ga(t){var e=null==t?0:t.length;return e?t[e-1]:n}var _a=fr(ya);function ya(t,e){return t&&t.length&&e&&e.length?ur(t,e):t}var va=xo((function(t,e){var n=null==t?0:t.length,i=ii(t,e);return hr(t,Me(e,(function(t){return Do(t,n)?+t:t})).sort(Gr)),i}));function ba(t){return null==t?t:bn.call(t)}var xa=fr((function(t){return Cr(zi(t,1,fs,!0))})),wa=fr((function(t){var e=ga(t);return fs(e)&&(e=n),Cr(zi(t,1,fs,!0),Ao(e,2))})),Sa=fr((function(t){var e=ga(t);return e="function"==typeof e?e:n,Cr(zi(t,1,fs,!0),n,e)}));function Ma(t){if(!t||!t.length)return[];var e=0;return t=xe(t,(function(t){if(fs(t))return e=mn(t.length,e),!0})),Fe(e,(function(e){return Me(t,ze(e))}))}function Ea(t,e){if(!t||!t.length)return[];var i=Ma(t);return null==e?i:Me(i,(function(t){return me(e,n,t)}))}var Ta=fr((function(t,e){return fs(t)?li(t,e):[]})),Aa=fr((function(t){return Nr(xe(t,fs))})),Ca=fr((function(t){var e=ga(t);return fs(e)&&(e=n),Nr(xe(t,fs),Ao(e,2))})),ka=fr((function(t){var e=ga(t);return e="function"==typeof e?e:n,Nr(xe(t,fs),n,e)})),La=fr(Ma),Pa=fr((function(t){var e=t.length,i=e>1?t[e-1]:n;return i="function"==typeof i?(t.pop(),i):n,Ea(t,i)}));function Ia(t){var e=Dn(t);return e.__chain__=!0,e}function Na(t,e){return e(t)}var Oa=xo((function(t){var e=t.length,i=e?t[0]:0,r=this.__wrapped__,o=function(e){return ii(e,t)};return!(e>1||this.__actions__.length)&&r instanceof Vn&&Do(i)?((r=r.slice(i,+i+(e?1:0))).__actions__.push({func:Na,args:[o],thisArg:n}),new Fn(r,this.__chain__).thru((function(t){return e&&!t.length&&t.push(n),t}))):this.thru(o)})),Ra=$r((function(t,e,n){Nt.call(t,n)?++t[n]:ni(t,n,1)})),za=no(ca),Da=no(ua);function Ba(t,e){return(us(t)?_e:Pi)(t,Ao(e,3))}function Ha(t,e){return(us(t)?ye:Ii)(t,Ao(e,3))}var Fa=$r((function(t,e,n){Nt.call(t,n)?t[n].push(e):ni(t,n,[e])})),Va=fr((function(t,e,n){var i=-1,r="function"==typeof e,o=ps(t)?bt(t.length):[];return Pi(t,(function(t){o[++i]=r?me(e,t,n):$i(t,e,n)})),o})),ja=$r((function(t,e,n){ni(t,n,e)}));function Ua(t,e){return(us(t)?Me:ir)(t,Ao(e,3))}var Ga=$r((function(t,e,n){t[n?0:1].push(e)}),(function(){return[[],[]]})),Wa=fr((function(t,e){if(null==t)return[];var n=e.length;return n>1&&Bo(t,e[0],e[1])?e=[]:n>2&&Bo(e[0],e[1],e[2])&&(e=[e[0]]),lr(t,zi(e,1),[])})),qa=De||function(){return ie.Date.now()};function Ya(t,e,i){return e=i?n:e,go(t,s,n,n,n,n,e=t&&null==e?t.length:e)}function Xa(t,e){var r;if("function"!=typeof e)throw new Ct(i);return t=Fs(t),function(){return--t>0&&(r=e.apply(this,arguments)),t<=1&&(e=n),r}}var $a=fr((function(t,e,n){var i=1;if(n.length){var r=Qe(n,To($a));i|=a}return go(t,i,e,n,r)})),Ka=fr((function(t,e,n){var i=3;if(n.length){var r=Qe(n,To(Ka));i|=a}return go(e,i,t,n,r)}));function Za(t,e,r){var o,a,s,l,c,u,h=0,d=!1,p=!1,f=!0;if("function"!=typeof t)throw new Ct(i);function m(e){var i=o,r=a;return o=a=n,h=e,l=t.apply(r,i)}function g(t){return h=t,c=Ko(y,e),d?m(t):l}function _(t){var i=t-u;return u===n||i>=e||i<0||p&&t-h>=s}function y(){var t=qa();if(_(t))return v(t);c=Ko(y,(function n(t){var n=e-(t-u);return p?gn(n,s-(t-h)):n})(t))}function v(t){return c=n,f&&o?m(t):(o=a=n,l)}function b(){var t=qa(),i=_(t);if(o=arguments,a=this,u=t,i){if(c===n)return g(u);if(p)return Fr(c),c=Ko(y,e),m(u)}return c===n&&(c=Ko(y,e)),l}return e=js(e)||0,ws(r)&&(d=!!r.leading,s=(p="maxWait"in r)?mn(js(r.maxWait)||0,e):s,f="trailing"in r?!!r.trailing:f),b.cancel=function x(){c!==n&&Fr(c),h=0,o=u=a=c=n},b.flush=function w(){return c===n?l:v(qa())},b}var Ja=fr((function(t,e){return si(t,1,e)})),Qa=fr((function(t,e,n){return si(t,js(e)||0,n)}));function ts(t,e){if("function"!=typeof t||null!=e&&"function"!=typeof e)throw new Ct(i);var n=function(){var i=arguments,r=e?e.apply(this,i):i[0],o=n.cache;if(o.has(r))return o.get(r);var a=t.apply(this,i);return n.cache=o.set(r,a)||o,a};return n.cache=new(ts.Cache||Gn),n}function es(t){if("function"!=typeof t)throw new Ct(i);return function(){var e=arguments;switch(e.length){case 0:return!t.call(this);case 1:return!t.call(this,e[0]);case 2:return!t.call(this,e[0],e[1]);case 3:return!t.call(this,e[0],e[1],e[2])}return!t.apply(this,e)}}ts.Cache=Gn;var ns=Br((function(t,e){var n=(e=1==e.length&&us(e[0])?Me(e[0],Ve(Ao())):Me(zi(e,1),Ve(Ao()))).length;return fr((function(i){for(var r=-1,o=gn(i.length,n);++r<o;)i[r]=e[r].call(this,i[r]);return me(t,this,i)}))})),is=fr((function(t,e){var i=Qe(e,To(is));return go(t,a,n,e,i)})),rs=fr((function(t,e){var i=Qe(e,To(rs));return go(t,64,n,e,i)})),os=xo((function(t,e){return go(t,256,n,n,n,e)}));function as(t,e){return t===e||t!=t&&e!=e}var ss=uo(Wi),ls=uo((function(t,e){return t>=e})),cs=Ki((function(){return arguments})())?Ki:function(t){return Ss(t)&&Nt.call(t,"callee")&&!ne.call(t,"callee")},us=bt.isArray,hs=ce?Ve(ce):function ds(t){return Ss(t)&&Gi(t)==k};function ps(t){return null!=t&&xs(t.length)&&!vs(t)}function fs(t){return Ss(t)&&ps(t)}var ms=hn||jl,gs=ue?Ve(ue):function _s(t){return Ss(t)&&Gi(t)==g};function ys(t){if(!Ss(t))return!1;var e=Gi(t);return e==_||"[object DOMException]"==e||"string"==typeof t.message&&"string"==typeof t.name&&!As(t)}function vs(t){if(!ws(t))return!1;var e=Gi(t);return e==y||e==v||"[object AsyncFunction]"==e||"[object Proxy]"==e}function bs(t){return"number"==typeof t&&t==Fs(t)}function xs(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=c}function ws(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}function Ss(t){return null!=t&&"object"==typeof t}var Ms=he?Ve(he):function Es(t){return Ss(t)&&No(t)==b};function Ts(t){return"number"==typeof t||Ss(t)&&Gi(t)==x}function As(t){if(!Ss(t)||Gi(t)!=w)return!1;var e=Jt(t);if(null===e)return!0;var n=Nt.call(e,"constructor")&&e.constructor;return"function"==typeof n&&n instanceof n&&It.call(n)==Dt}var Cs=de?Ve(de):function ks(t){return Ss(t)&&Gi(t)==M},Ls=pe?Ve(pe):function Ps(t){return Ss(t)&&No(t)==E};function Is(t){return"string"==typeof t||!us(t)&&Ss(t)&&Gi(t)==T}function Ns(t){return"symbol"==typeof t||Ss(t)&&Gi(t)==A}var Os=fe?Ve(fe):function Rs(t){return Ss(t)&&xs(t.length)&&!!Kt[Gi(t)]},zs=uo(nr),Ds=uo((function(t,e){return t<=e}));function Bs(t){if(!t)return[];if(ps(t))return Is(t)?rn(t):Yr(t);if(se&&t[se])return(function e(t){for(var e,n=[];!(e=t.next()).done;)n.push(e.value);return n})(t[se]());var n=No(t);return(n==b?Ze:n==E?tn:dl)(t)}function Hs(t){return t?(t=js(t))===l||t===-1/0?17976931348623157e292*(t<0?-1:1):t==t?t:0:0===t?t:0}function Fs(t){var e=Hs(t),n=e%1;return e==e?n?e-n:e:0}function Vs(t){return t?ri(Fs(t),0,h):0}function js(t){if("number"==typeof t)return t;if(Ns(t))return u;if(ws(t)){var e="function"==typeof t.valueOf?t.valueOf():t;t=ws(e)?e+"":e}if("string"!=typeof t)return 0===t?t:+t;t=t.replace(et,"");var n=dt.test(t);return n||ft.test(t)?te(t.slice(2),n?2:8):ht.test(t)?u:+t}function Us(t){return Xr(t,rl(t))}function Gs(t){return null==t?"":Ar(t)}var Ws=Kr((function(t,e){if(jo(e)||ps(e))Xr(e,il(e),t);else for(var n in e)Nt.call(e,n)&&Jn(t,n,e[n])})),qs=Kr((function(t,e){Xr(e,rl(e),t)})),Ys=Kr((function(t,e,n,i){Xr(e,rl(e),t,i)})),Xs=Kr((function(t,e,n,i){Xr(e,il(e),t,i)})),$s=xo(ii),Ks=fr((function(t,e){t=Et(t);var i=-1,r=e.length,o=r>2?e[2]:n;for(o&&Bo(e[0],e[1],o)&&(r=1);++i<r;)for(var a=e[i],s=rl(a),l=-1,c=s.length;++l<c;){var u=s[l],h=t[u];(h===n||as(h,Lt[u])&&!Nt.call(t,u))&&(t[u]=a[u])}return t})),Zs=fr((function(t){return t.push(n,yo),me(al,n,t)}));function Js(t,e,i){var r=null==t?n:ji(t,e);return r===n?i:r}function Qs(t,e){return null!=t&&Oo(t,e,Yi)}var tl=oo((function(t,e,n){null!=e&&"function"!=typeof e.toString&&(e=zt.call(e)),t[e]=n}),Tl(kl)),el=oo((function(t,e,n){null!=e&&"function"!=typeof e.toString&&(e=zt.call(e)),Nt.call(t,e)?t[e].push(n):t[e]=[n]}),Ao),nl=fr($i);function il(t){return ps(t)?Yn(t):er(t)}function rl(t){return ps(t)?Yn(t,!0):(function e(t){if(!ws(t))return(function e(t){var e=[];if(null!=t)for(var n in Et(t))e.push(n);return e})(t);var n=jo(t),i=[];for(var r in t)("constructor"!=r||!n&&Nt.call(t,r))&&i.push(r);return i})(t)}var ol=Kr((function(t,e,n){ar(t,e,n)})),al=Kr((function(t,e,n,i){ar(t,e,n,i)})),sl=xo((function(t,e){var n={};if(null==t)return n;var i=!1;e=Me(e,(function(e){return e=Dr(e,t),i||(i=e.length>1),e})),Xr(t,So(t),n),i&&(n=oi(n,7,vo));for(var r=e.length;r--;)kr(n,e[r]);return n})),ll=xo((function(t,e){return null==t?{}:(function n(t,e){return cr(t,e,(function(e,n){return Qs(t,n)}))})(t,e)}));function cl(t,e){if(null==t)return{};var n=Me(So(t),(function(t){return[t]}));return e=Ao(e),cr(t,n,(function(t,n){return e(t,n[0])}))}var ul=mo(il),hl=mo(rl);function dl(t){return null==t?[]:je(t,il(t))}var pl=to((function(t,e,n){return e=e.toLowerCase(),t+(n?fl(e):e)}));function fl(t){return wl(Gs(t).toLowerCase())}function ml(t){return(t=Gs(t))&&t.replace(gt,Ye).replace(Ut,"")}var gl=to((function(t,e,n){return t+(n?"-":"")+e.toLowerCase()})),_l=to((function(t,e,n){return t+(n?" ":"")+e.toLowerCase()})),yl=Qr("toLowerCase"),vl=to((function(t,e,n){return t+(n?"_":"")+e.toLowerCase()})),bl=to((function(t,e,n){return t+(n?" ":"")+wl(e)})),xl=to((function(t,e,n){return t+(n?" ":"")+e.toUpperCase()})),wl=Qr("toUpperCase");function Sl(t,e,i){return t=Gs(t),(e=i?n:e)===n?(function r(t){return Yt.test(t)})(t)?(function o(t){return t.match(Wt)||[]})(t):(function a(t){return t.match(st)||[]})(t):t.match(e)||[]}var Ml=fr((function(t,e){try{return me(t,n,e)}catch(t){return ys(t)?t:new wt(t)}})),El=xo((function(t,e){return _e(e,(function(e){e=ia(e),ni(t,e,$a(t[e],t))})),t}));function Tl(t){return function(){return t}}var Al=io(),Cl=io(!0);function kl(t){return t}function Ll(t){return tr("function"==typeof t?t:oi(t,1))}var Pl=fr((function(t,e){return function(n){return $i(n,t,e)}})),Il=fr((function(t,e){return function(n){return $i(t,n,e)}}));function Nl(t,e,n){var i=il(e),r=Vi(e,i);null!=n||ws(e)&&(r.length||!i.length)||(n=e,e=t,t=this,r=Vi(e,il(e)));var o=!(ws(n)&&"chain"in n&&!n.chain),a=vs(t);return _e(r,(function(n){var i=e[n];t[n]=i,a&&(t.prototype[n]=function(){var e=this.__chain__;if(o||e){var n=t(this.__wrapped__),r=n.__actions__=Yr(this.__actions__);return r.push({func:i,args:arguments,thisArg:t}),n.__chain__=e,n}return i.apply(t,Ee([this.value()],arguments))})})),t}function Ol(){}var Rl=so(Me),zl=so(be),Dl=so(Ce);function Bl(t){return Ho(t)?ze(ia(t)):(function e(t){return function(e){return ji(e,t)}})(t)}var Hl=co(),Fl=co(!0);function Vl(){return[]}function jl(){return!1}var Ul,Gl=ao((function(t,e){return t+e}),0),Wl=po("ceil"),ql=ao((function(t,e){return t/e}),1),Yl=po("floor"),Xl=ao((function(t,e){return t*e}),1),$l=po("round"),Kl=ao((function(t,e){return t-e}),0);return Dn.after=function Zl(t,e){if("function"!=typeof e)throw new Ct(i);return t=Fs(t),function(){if(--t<1)return e.apply(this,arguments)}},Dn.ary=Ya,Dn.assign=Ws,Dn.assignIn=qs,Dn.assignInWith=Ys,Dn.assignWith=Xs,Dn.at=$s,Dn.before=Xa,Dn.bind=$a,Dn.bindAll=El,Dn.bindKey=Ka,Dn.castArray=function Jl(){if(!arguments.length)return[];var t=arguments[0];return us(t)?t:[t]},Dn.chain=Ia,Dn.chunk=function Ql(t,e,i){e=(i?Bo(t,e,i):e===n)?1:mn(Fs(e),0);var r=null==t?0:t.length;if(!r||e<1)return[];for(var o=0,a=0,s=bt(ln(r/e));o<r;)s[a++]=xr(t,o,o+=e);return s},Dn.compact=function tc(t){for(var e=-1,n=null==t?0:t.length,i=0,r=[];++e<n;){var o=t[e];o&&(r[i++]=o)}return r},Dn.concat=function ec(){var t=arguments.length;if(!t)return[];for(var e=bt(t-1),n=arguments[0],i=t;i--;)e[i-1]=arguments[i];return Ee(us(n)?Yr(n):[n],zi(e,1))},Dn.cond=function nc(t){var e=null==t?0:t.length,n=Ao();return t=e?Me(t,(function(t){if("function"!=typeof t[1])throw new Ct(i);return[n(t[0]),t[1]]})):[],fr((function(n){for(var i=-1;++i<e;){var r=t[i];if(me(r[0],this,n))return me(r[1],this,n)}}))},Dn.conforms=function ic(t){return(function e(t){var e=il(t);return function(n){return ai(n,t,e)}})(oi(t,1))},Dn.constant=Tl,Dn.countBy=Ra,Dn.create=function rc(t,e){var n=Bn(t);return null==e?n:ei(n,e)},Dn.curry=function t(e,i,r){var o=go(e,8,n,n,n,n,n,i=r?n:i);return o.placeholder=t.placeholder,o},Dn.curryRight=function t(e,i,r){var o=go(e,16,n,n,n,n,n,i=r?n:i);return o.placeholder=t.placeholder,o},Dn.debounce=Za,Dn.defaults=Ks,Dn.defaultsDeep=Zs,Dn.defer=Ja,Dn.delay=Qa,Dn.difference=aa,Dn.differenceBy=sa,Dn.differenceWith=la,Dn.drop=function oc(t,e,i){var r=null==t?0:t.length;return r?xr(t,(e=i||e===n?1:Fs(e))<0?0:e,r):[]},Dn.dropRight=function ac(t,e,i){var r=null==t?0:t.length;return r?xr(t,0,(e=r-(e=i||e===n?1:Fs(e)))<0?0:e):[]},Dn.dropRightWhile=function sc(t,e){return t&&t.length?Pr(t,Ao(e,3),!0,!0):[]},Dn.dropWhile=function lc(t,e){return t&&t.length?Pr(t,Ao(e,3),!0):[]},Dn.fill=function cc(t,e,i,r){var o=null==t?0:t.length;return o?(i&&"number"!=typeof i&&Bo(t,e,i)&&(i=0,r=o),(function a(t,e,i,r){var o=t.length;for((i=Fs(i))<0&&(i=-i>o?0:o+i),(r=r===n||r>o?o:Fs(r))<0&&(r+=o),r=i>r?0:Vs(r);i<r;)t[i++]=e;return t})(t,e,i,r)):[]},Dn.filter=function uc(t,e){return(us(t)?xe:Ri)(t,Ao(e,3))},Dn.flatMap=function hc(t,e){return zi(Ua(t,e),1)},Dn.flatMapDeep=function dc(t,e){return zi(Ua(t,e),l)},Dn.flatMapDepth=function pc(t,e,i){return i=i===n?1:Fs(i),zi(Ua(t,e),i)},Dn.flatten=ha,Dn.flattenDeep=function fc(t){return null!=t&&t.length?zi(t,l):[]},Dn.flattenDepth=function mc(t,e){return null!=t&&t.length?zi(t,e=e===n?1:Fs(e)):[]},Dn.flip=function gc(t){return go(t,512)},Dn.flow=Al,Dn.flowRight=Cl,Dn.fromPairs=function _c(t){for(var e=-1,n=null==t?0:t.length,i={};++e<n;){var r=t[e];i[r[0]]=r[1]}return i},Dn.functions=function yc(t){return null==t?[]:Vi(t,il(t))},Dn.functionsIn=function vc(t){return null==t?[]:Vi(t,rl(t))},Dn.groupBy=Fa,Dn.initial=function bc(t){return null!=t&&t.length?xr(t,0,-1):[]},Dn.intersection=pa,Dn.intersectionBy=fa,Dn.intersectionWith=ma,Dn.invert=tl,Dn.invertBy=el,Dn.invokeMap=Va,Dn.iteratee=Ll,Dn.keyBy=ja,Dn.keys=il,Dn.keysIn=rl,Dn.map=Ua,Dn.mapKeys=function xc(t,e){var n={};return e=Ao(e,3),Hi(t,(function(t,i,r){ni(n,e(t,i,r),t)})),n},Dn.mapValues=function wc(t,e){var n={};return e=Ao(e,3),Hi(t,(function(t,i,r){ni(n,i,e(t,i,r))})),n},Dn.matches=function Sc(t){return rr(oi(t,1))},Dn.matchesProperty=function Mc(t,e){return or(t,oi(e,1))},Dn.memoize=ts,Dn.merge=ol,Dn.mergeWith=al,Dn.method=Pl,Dn.methodOf=Il,Dn.mixin=Nl,Dn.negate=es,Dn.nthArg=function Ec(t){return t=Fs(t),fr((function(e){return sr(e,t)}))},Dn.omit=sl,Dn.omitBy=function Tc(t,e){return cl(t,es(Ao(e)))},Dn.once=function Ac(t){return Xa(2,t)},Dn.orderBy=function Cc(t,e,i,r){return null==t?[]:(us(e)||(e=null==e?[]:[e]),us(i=r?n:i)||(i=null==i?[]:[i]),lr(t,e,i))},Dn.over=Rl,Dn.overArgs=ns,Dn.overEvery=zl,Dn.overSome=Dl,Dn.partial=is,Dn.partialRight=rs,Dn.partition=Ga,Dn.pick=ll,Dn.pickBy=cl,Dn.property=Bl,Dn.propertyOf=function kc(t){return function(e){return null==t?n:ji(t,e)}},Dn.pull=_a,Dn.pullAll=ya,Dn.pullAllBy=function Lc(t,e,n){return t&&t.length&&e&&e.length?ur(t,e,Ao(n,2)):t},Dn.pullAllWith=function Pc(t,e,i){return t&&t.length&&e&&e.length?ur(t,e,n,i):t},Dn.pullAt=va,Dn.range=Hl,Dn.rangeRight=Fl,Dn.rearg=os,Dn.reject=function Ic(t,e){return(us(t)?xe:Ri)(t,es(Ao(e,3)))},Dn.remove=function Nc(t,e){var n=[];if(!t||!t.length)return n;var i=-1,r=[],o=t.length;for(e=Ao(e,3);++i<o;){var a=t[i];e(a,i,t)&&(n.push(a),r.push(i))}return hr(t,r),n},Dn.rest=function Oc(t,e){if("function"!=typeof t)throw new Ct(i);return fr(t,e=e===n?e:Fs(e))},Dn.reverse=ba,Dn.sampleSize=function Rc(t,e,i){return e=(i?Bo(t,e,i):e===n)?1:Fs(e),(us(t)?$n:gr)(t,e)},Dn.set=function zc(t,e,n){return null==t?t:_r(t,e,n)},Dn.setWith=function Dc(t,e,i,r){return r="function"==typeof r?r:n,null==t?t:_r(t,e,i,r)},Dn.shuffle=function Bc(t){return(us(t)?Kn:br)(t)},Dn.slice=function Hc(t,e,i){var r=null==t?0:t.length;return r?(i&&"number"!=typeof i&&Bo(t,e,i)?(e=0,i=r):(e=null==e?0:Fs(e),i=i===n?r:Fs(i)),xr(t,e,i)):[]},Dn.sortBy=Wa,Dn.sortedUniq=function Fc(t){return t&&t.length?Er(t):[]},Dn.sortedUniqBy=function Vc(t,e){return t&&t.length?Er(t,Ao(e,2)):[]},Dn.split=function jc(t,e,i){return i&&"number"!=typeof i&&Bo(t,e,i)&&(e=i=n),(i=i===n?h:i>>>0)?(t=Gs(t))&&("string"==typeof e||null!=e&&!Cs(e))&&!(e=Ar(e))&&Ke(t)?Hr(rn(t),0,i):t.split(e,i):[]},Dn.spread=function Uc(t,e){if("function"!=typeof t)throw new Ct(i);return e=null==e?0:mn(Fs(e),0),fr((function(n){var i=n[e],r=Hr(n,0,e);return i&&Ee(r,i),me(t,this,r)}))},Dn.tail=function Gc(t){var e=null==t?0:t.length;return e?xr(t,1,e):[]},Dn.take=function Wc(t,e,i){return t&&t.length?xr(t,0,(e=i||e===n?1:Fs(e))<0?0:e):[]},Dn.takeRight=function qc(t,e,i){var r=null==t?0:t.length;return r?xr(t,(e=r-(e=i||e===n?1:Fs(e)))<0?0:e,r):[]},Dn.takeRightWhile=function Yc(t,e){return t&&t.length?Pr(t,Ao(e,3),!1,!0):[]},Dn.takeWhile=function Xc(t,e){return t&&t.length?Pr(t,Ao(e,3)):[]},Dn.tap=function $c(t,e){return e(t),t},Dn.throttle=function Kc(t,e,n){var r=!0,o=!0;if("function"!=typeof t)throw new Ct(i);return ws(n)&&(r="leading"in n?!!n.leading:r,o="trailing"in n?!!n.trailing:o),Za(t,e,{leading:r,maxWait:e,trailing:o})},Dn.thru=Na,Dn.toArray=Bs,Dn.toPairs=ul,Dn.toPairsIn=hl,Dn.toPath=function Zc(t){return us(t)?Me(t,ia):Ns(t)?[t]:Yr(ea(Gs(t)))},Dn.toPlainObject=Us,Dn.transform=function Jc(t,e,n){var i=us(t),r=i||ms(t)||Os(t);if(e=Ao(e,4),null==n){var o=t&&t.constructor;n=r?i?new o:[]:ws(t)&&vs(o)?Bn(Jt(t)):{}}return(r?_e:Hi)(t,(function(t,i,r){return e(n,t,i,r)})),n},Dn.unary=function Qc(t){return Ya(t,1)},Dn.union=xa,Dn.unionBy=wa,Dn.unionWith=Sa,Dn.uniq=function tu(t){return t&&t.length?Cr(t):[]},Dn.uniqBy=function eu(t,e){return t&&t.length?Cr(t,Ao(e,2)):[]},Dn.uniqWith=function nu(t,e){return e="function"==typeof e?e:n,t&&t.length?Cr(t,n,e):[]},Dn.unset=function iu(t,e){return null==t||kr(t,e)},Dn.unzip=Ma,Dn.unzipWith=Ea,Dn.update=function ru(t,e,n){return null==t?t:Lr(t,e,zr(n))},Dn.updateWith=function ou(t,e,i,r){return r="function"==typeof r?r:n,null==t?t:Lr(t,e,zr(i),r)},Dn.values=dl,Dn.valuesIn=function au(t){return null==t?[]:je(t,rl(t))},Dn.without=Ta,Dn.words=Sl,Dn.wrap=function su(t,e){return is(zr(e),t)},Dn.xor=Aa,Dn.xorBy=Ca,Dn.xorWith=ka,Dn.zip=La,Dn.zipObject=function lu(t,e){return Or(t||[],e||[],Jn)},Dn.zipObjectDeep=function cu(t,e){return Or(t||[],e||[],_r)},Dn.zipWith=Pa,Dn.entries=ul,Dn.entriesIn=hl,Dn.extend=qs,Dn.extendWith=Ys,Nl(Dn,Dn),Dn.add=Gl,Dn.attempt=Ml,Dn.camelCase=pl,Dn.capitalize=fl,Dn.ceil=Wl,Dn.clamp=function uu(t,e,i){return i===n&&(i=e,e=n),i!==n&&(i=(i=js(i))==i?i:0),e!==n&&(e=(e=js(e))==e?e:0),ri(js(t),e,i)},Dn.clone=function hu(t){return oi(t,4)},Dn.cloneDeep=function du(t){return oi(t,5)},Dn.cloneDeepWith=function pu(t,e){return oi(t,5,e="function"==typeof e?e:n)},Dn.cloneWith=function fu(t,e){return oi(t,4,e="function"==typeof e?e:n)},Dn.conformsTo=function mu(t,e){return null==e||ai(t,e,il(e))},Dn.deburr=ml,Dn.defaultTo=function gu(t,e){return null==t||t!=t?e:t},Dn.divide=ql,Dn.endsWith=function _u(t,e,i){t=Gs(t),e=Ar(e);var r=t.length,o=i=i===n?r:ri(Fs(i),0,r);return(i-=e.length)>=0&&t.slice(i,o)==e},Dn.eq=as,Dn.escape=function yu(t){return(t=Gs(t))&&q.test(t)?t.replace(G,Xe):t},Dn.escapeRegExp=function vu(t){return(t=Gs(t))&&tt.test(t)?t.replace(Q,"\\$&"):t},Dn.every=function bu(t,e,i){var r=us(t)?be:Ni;return i&&Bo(t,e,i)&&(e=n),r(t,Ao(e,3))},Dn.find=za,Dn.findIndex=ca,Dn.findKey=function xu(t,e){return Le(t,Ao(e,3),Hi)},Dn.findLast=Da,Dn.findLastIndex=ua,Dn.findLastKey=function wu(t,e){return Le(t,Ao(e,3),Fi)},Dn.floor=Yl,Dn.forEach=Ba,Dn.forEachRight=Ha,Dn.forIn=function Su(t,e){return null==t?t:Di(t,Ao(e,3),rl)},Dn.forInRight=function Mu(t,e){return null==t?t:Bi(t,Ao(e,3),rl)},Dn.forOwn=function Eu(t,e){return t&&Hi(t,Ao(e,3))},Dn.forOwnRight=function Tu(t,e){return t&&Fi(t,Ao(e,3))},Dn.get=Js,Dn.gt=ss,Dn.gte=ls,Dn.has=function Au(t,e){return null!=t&&Oo(t,e,qi)},Dn.hasIn=Qs,Dn.head=da,Dn.identity=kl,Dn.includes=function Cu(t,e,n,i){t=ps(t)?t:dl(t),n=n&&!i?Fs(n):0;var r=t.length;return n<0&&(n=mn(r+n,0)),Is(t)?n<=r&&t.indexOf(e,n)>-1:!!r&&Ie(t,e,n)>-1},Dn.indexOf=function ku(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var r=null==n?0:Fs(n);return r<0&&(r=mn(i+r,0)),Ie(t,e,r)},Dn.inRange=function Lu(t,e,i){return e=Hs(e),i===n?(i=e,e=0):i=Hs(i),(function r(t,e,n){return t>=gn(e,n)&&t<mn(e,n)})(t=js(t),e,i)},Dn.invoke=nl,Dn.isArguments=cs,Dn.isArray=us,Dn.isArrayBuffer=hs,Dn.isArrayLike=ps,Dn.isArrayLikeObject=fs,Dn.isBoolean=function Pu(t){return!0===t||!1===t||Ss(t)&&Gi(t)==m},Dn.isBuffer=ms,Dn.isDate=gs,Dn.isElement=function Iu(t){return Ss(t)&&1===t.nodeType&&!As(t)},Dn.isEmpty=function Nu(t){if(null==t)return!0;if(ps(t)&&(us(t)||"string"==typeof t||"function"==typeof t.splice||ms(t)||Os(t)||cs(t)))return!t.length;var e=No(t);if(e==b||e==E)return!t.size;if(jo(t))return!er(t).length;for(var n in t)if(Nt.call(t,n))return!1;return!0},Dn.isEqual=function Ou(t,e){return Zi(t,e)},Dn.isEqualWith=function Ru(t,e,i){var r=(i="function"==typeof i?i:n)?i(t,e):n;return r===n?Zi(t,e,n,i):!!r},Dn.isError=ys,Dn.isFinite=function zu(t){return"number"==typeof t&&dn(t)},Dn.isFunction=vs,Dn.isInteger=bs,Dn.isLength=xs,Dn.isMap=Ms,Dn.isMatch=function Du(t,e){return t===e||Ji(t,e,ko(e))},Dn.isMatchWith=function Bu(t,e,i){return i="function"==typeof i?i:n,Ji(t,e,ko(e),i)},Dn.isNaN=function Hu(t){return Ts(t)&&t!=+t},Dn.isNative=function Fu(t){if(Vo(t))throw new wt("Unsupported core-js use. Try https://npms.io/search?q=ponyfill.");return Qi(t)},Dn.isNil=function Vu(t){return null==t},Dn.isNull=function ju(t){return null===t},Dn.isNumber=Ts,Dn.isObject=ws,Dn.isObjectLike=Ss,Dn.isPlainObject=As,Dn.isRegExp=Cs,Dn.isSafeInteger=function Uu(t){return bs(t)&&t>=-9007199254740991&&t<=c},Dn.isSet=Ls,Dn.isString=Is,Dn.isSymbol=Ns,Dn.isTypedArray=Os,Dn.isUndefined=function Gu(t){return t===n},Dn.isWeakMap=function Wu(t){return Ss(t)&&No(t)==C},Dn.isWeakSet=function qu(t){return Ss(t)&&"[object WeakSet]"==Gi(t)},Dn.join=function Yu(t,e){return null==t?"":pn.call(t,e)},Dn.kebabCase=gl,Dn.last=ga,Dn.lastIndexOf=function Xu(t,e,i){var r=null==t?0:t.length;if(!r)return-1;var o=r;return i!==n&&(o=(o=Fs(i))<0?mn(r+o,0):gn(o,r-1)),e==e?(function a(t,e,n){for(var i=n+1;i--;)if(t[i]===e)return i;return i})(t,e,o):Pe(t,Oe,o,!0)},Dn.lowerCase=_l,Dn.lowerFirst=yl,Dn.lt=zs,Dn.lte=Ds,Dn.max=function $u(t){return t&&t.length?Oi(t,kl,Wi):n},Dn.maxBy=function Ku(t,e){return t&&t.length?Oi(t,Ao(e,2),Wi):n},Dn.mean=function Zu(t){return Re(t,kl)},Dn.meanBy=function Ju(t,e){return Re(t,Ao(e,2))},Dn.min=function Qu(t){return t&&t.length?Oi(t,kl,nr):n},Dn.minBy=function th(t,e){return t&&t.length?Oi(t,Ao(e,2),nr):n},Dn.stubArray=Vl,Dn.stubFalse=jl,Dn.stubObject=function eh(){return{}},Dn.stubString=function nh(){return""},Dn.stubTrue=function ih(){return!0},Dn.multiply=Xl,Dn.nth=function rh(t,e){return t&&t.length?sr(t,Fs(e)):n},Dn.noConflict=function oh(){return ie._===this&&(ie._=Bt),this},Dn.noop=Ol,Dn.now=qa,Dn.pad=function ah(t,e,n){t=Gs(t);var i=(e=Fs(e))?nn(t):0;if(!e||i>=e)return t;var r=(e-i)/2;return lo(cn(r),n)+t+lo(ln(r),n)},Dn.padEnd=function sh(t,e,n){t=Gs(t);var i=(e=Fs(e))?nn(t):0;return e&&i<e?t+lo(e-i,n):t},Dn.padStart=function lh(t,e,n){t=Gs(t);var i=(e=Fs(e))?nn(t):0;return e&&i<e?lo(e-i,n)+t:t},Dn.parseInt=function ch(t,e,n){return n||null==e?e=0:e&&(e=+e),yn(Gs(t).replace(nt,""),e||0)},Dn.random=function uh(t,e,i){if(i&&"boolean"!=typeof i&&Bo(t,e,i)&&(e=i=n),i===n&&("boolean"==typeof e?(i=e,e=n):"boolean"==typeof t&&(i=t,t=n)),t===n&&e===n?(t=0,e=1):(t=Hs(t),e===n?(e=t,t=0):e=Hs(e)),t>e){var r=t;t=e,e=r}if(i||t%1||e%1){var o=vn();return gn(t+o*(e-t+Qt("1e-"+((o+"").length-1))),e)}return dr(t,e)},Dn.reduce=function hh(t,e,n){var i=us(t)?Te:Be,r=arguments.length<3;return i(t,Ao(e,4),n,r,Pi)},Dn.reduceRight=function dh(t,e,n){var i=us(t)?Ae:Be,r=arguments.length<3;return i(t,Ao(e,4),n,r,Ii)},Dn.repeat=function ph(t,e,i){return e=(i?Bo(t,e,i):e===n)?1:Fs(e),pr(Gs(t),e)},Dn.replace=function fh(){var t=arguments,e=Gs(t[0]);return t.length<3?e:e.replace(t[1],t[2])},Dn.result=function mh(t,e,i){var r=-1,o=(e=Dr(e,t)).length;for(o||(o=1,t=n);++r<o;){var a=null==t?n:t[ia(e[r])];a===n&&(r=o,a=i),t=vs(a)?a.call(t):a}return t},Dn.round=$l,Dn.runInContext=t,Dn.sample=function gh(t){return(us(t)?Xn:mr)(t)},Dn.size=function _h(t){if(null==t)return 0;if(ps(t))return Is(t)?nn(t):t.length;var e=No(t);return e==b||e==E?t.size:er(t).length},Dn.snakeCase=vl,Dn.some=function yh(t,e,i){var r=us(t)?Ce:wr;return i&&Bo(t,e,i)&&(e=n),r(t,Ao(e,3))},Dn.sortedIndex=function vh(t,e){return Sr(t,e)},Dn.sortedIndexBy=function bh(t,e,n){return Mr(t,e,Ao(n,2))},Dn.sortedIndexOf=function xh(t,e){var n=null==t?0:t.length;if(n){var i=Sr(t,e);if(i<n&&as(t[i],e))return i}return-1},Dn.sortedLastIndex=function wh(t,e){return Sr(t,e,!0)},Dn.sortedLastIndexBy=function Sh(t,e,n){return Mr(t,e,Ao(n,2),!0)},Dn.sortedLastIndexOf=function Mh(t,e){if(null!=t&&t.length){var n=Sr(t,e,!0)-1;if(as(t[n],e))return n}return-1},Dn.startCase=bl,Dn.startsWith=function Eh(t,e,n){return t=Gs(t),n=null==n?0:ri(Fs(n),0,t.length),e=Ar(e),t.slice(n,n+e.length)==e},Dn.subtract=Kl,Dn.sum=function Th(t){return t&&t.length?He(t,kl):0},Dn.sumBy=function Ah(t,e){return t&&t.length?He(t,Ao(e,2)):0},Dn.template=function Ch(t,e,i){var r=Dn.templateSettings;i&&Bo(t,e,i)&&(e=n),t=Gs(t),e=Ys({},e,r,_o);var o,a,s=Ys({},e.imports,r.imports,_o),l=il(s),c=je(s,l),u=0,h=e.interpolate||_t,d="__p += '",p=Tt((e.escape||_t).source+"|"+h.source+"|"+(h===$?ct:_t).source+"|"+(e.evaluate||_t).source+"|$","g"),f="//# sourceURL="+(Nt.call(e,"sourceURL")?(e.sourceURL+"").replace(/\s/g," "):"lodash.templateSources["+ ++$t+"]")+"\n";t.replace(p,(function(e,n,i,r,s,l){return i||(i=r),d+=t.slice(u,l).replace(yt,$e),n&&(o=!0,d+="' +\n__e("+n+") +\n'"),s&&(a=!0,d+="';\n"+s+";\n__p += '"),i&&(d+="' +\n((__t = ("+i+")) == null ? '' : __t) +\n'"),u=l+e.length,e})),d+="';\n";var m=Nt.call(e,"variable")&&e.variable;m||(d="with (obj) {\n"+d+"\n}\n"),d=(a?d.replace(F,""):d).replace(V,"$1").replace(j,"$1;"),d="function("+(m||"obj")+") {\n"+(m?"":"obj || (obj = {});\n")+"var __t, __p = ''"+(o?", __e = _.escape":"")+(a?", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n":";\n")+d+"return __p\n}";var g=Ml((function(){return St(l,f+"return "+d).apply(n,c)}));if(g.source=d,ys(g))throw g;return g},Dn.times=function kh(t,e){if((t=Fs(t))<1||t>c)return[];var n=h,i=gn(t,h);e=Ao(e),t-=h;for(var r=Fe(i,e);++n<t;)e(n);return r},Dn.toFinite=Hs,Dn.toInteger=Fs,Dn.toLength=Vs,Dn.toLower=function Lh(t){return Gs(t).toLowerCase()},Dn.toNumber=js,Dn.toSafeInteger=function Ph(t){return t?ri(Fs(t),-9007199254740991,c):0===t?t:0},Dn.toString=Gs,Dn.toUpper=function Ih(t){return Gs(t).toUpperCase()},Dn.trim=function Nh(t,e,i){if((t=Gs(t))&&(i||e===n))return t.replace(et,"");if(!t||!(e=Ar(e)))return t;var r=rn(t),o=rn(e);return Hr(r,Ge(r,o),We(r,o)+1).join("")},Dn.trimEnd=function Oh(t,e,i){if((t=Gs(t))&&(i||e===n))return t.replace(it,"");if(!t||!(e=Ar(e)))return t;var r=rn(t);return Hr(r,0,We(r,rn(e))+1).join("")},Dn.trimStart=function Rh(t,e,i){if((t=Gs(t))&&(i||e===n))return t.replace(nt,"");if(!t||!(e=Ar(e)))return t;var r=rn(t);return Hr(r,Ge(r,rn(e))).join("")},Dn.truncate=function zh(t,e){var i=30,r="...";if(ws(e)){var o="separator"in e?e.separator:o;i="length"in e?Fs(e.length):i,r="omission"in e?Ar(e.omission):r}var a=(t=Gs(t)).length;if(Ke(t)){var s=rn(t);a=s.length}if(i>=a)return t;var l=i-nn(r);if(l<1)return r;var c=s?Hr(s,0,l).join(""):t.slice(0,l);if(o===n)return c+r;if(s&&(l+=c.length-l),Cs(o)){if(t.slice(l).search(o)){var u,h=c;for(o.global||(o=Tt(o.source,Gs(ut.exec(o))+"g")),o.lastIndex=0;u=o.exec(h);)var d=u.index;c=c.slice(0,d===n?l:d)}}else if(t.indexOf(Ar(o),l)!=l){var p=c.lastIndexOf(o);p>-1&&(c=c.slice(0,p))}return c+r},Dn.unescape=function Dh(t){return(t=Gs(t))&&W.test(t)?t.replace(U,on):t},Dn.uniqueId=function Bh(t){var e=++Ot;return Gs(t)+e},Dn.upperCase=xl,Dn.upperFirst=wl,Dn.each=Ba,Dn.eachRight=Ha,Dn.first=da,Nl(Dn,(Ul={},Hi(Dn,(function(t,e){Nt.call(Dn.prototype,e)||(Ul[e]=t)})),Ul),{chain:!1}),Dn.VERSION="4.17.19",_e(["bind","bindKey","curry","curryRight","partial","partialRight"],(function(t){Dn[t].placeholder=Dn})),_e(["drop","take"],(function(t,e){Vn.prototype[t]=function(i){i=i===n?1:mn(Fs(i),0);var r=this.__filtered__&&!e?new Vn(this):this.clone();return r.__filtered__?r.__takeCount__=gn(i,r.__takeCount__):r.__views__.push({size:gn(i,h),type:t+(r.__dir__<0?"Right":"")}),r},Vn.prototype[t+"Right"]=function(e){return this.reverse()[t](e).reverse()}})),_e(["filter","map","takeWhile"],(function(t,e){var n=e+1,i=1==n||3==n;Vn.prototype[t]=function(t){var e=this.clone();return e.__iteratees__.push({iteratee:Ao(t,3),type:n}),e.__filtered__=e.__filtered__||i,e}})),_e(["head","last"],(function(t,e){var n="take"+(e?"Right":"");Vn.prototype[t]=function(){return this[n](1).value()[0]}})),_e(["initial","tail"],(function(t,e){var n="drop"+(e?"":"Right");Vn.prototype[t]=function(){return this.__filtered__?new Vn(this):this[n](1)}})),Vn.prototype.compact=function(){return this.filter(kl)},Vn.prototype.find=function(t){return this.filter(t).head()},Vn.prototype.findLast=function(t){return this.reverse().find(t)},Vn.prototype.invokeMap=fr((function(t,e){return"function"==typeof t?new Vn(this):this.map((function(n){return $i(n,t,e)}))})),Vn.prototype.reject=function(t){return this.filter(es(Ao(t)))},Vn.prototype.slice=function(t,e){t=Fs(t);var i=this;return i.__filtered__&&(t>0||e<0)?new Vn(i):(t<0?i=i.takeRight(-t):t&&(i=i.drop(t)),e!==n&&(i=(e=Fs(e))<0?i.dropRight(-e):i.take(e-t)),i)},Vn.prototype.takeRightWhile=function(t){return this.reverse().takeWhile(t).reverse()},Vn.prototype.toArray=function(){return this.take(h)},Hi(Vn.prototype,(function(t,e){var i=/^(?:filter|find|map|reject)|While$/.test(e),r=/^(?:head|last)$/.test(e),o=Dn[r?"take"+("last"==e?"Right":""):e],a=r||/^find/.test(e);o&&(Dn.prototype[e]=function(){var e=this.__wrapped__,s=r?[1]:arguments,l=e instanceof Vn,c=s[0],u=l||us(e),h=function(t){var e=o.apply(Dn,Ee([t],s));return r&&d?e[0]:e};u&&i&&"function"==typeof c&&1!=c.length&&(l=u=!1);var d=this.__chain__,p=!!this.__actions__.length,f=a&&!d,m=l&&!p;if(!a&&u){e=m?e:new Vn(this);var g=t.apply(e,s);return g.__actions__.push({func:Na,args:[h],thisArg:n}),new Fn(g,d)}return f&&m?t.apply(this,s):(g=this.thru(h),f?r?g.value()[0]:g.value():g)})})),_e(["pop","push","shift","sort","splice","unshift"],(function(t){var e=kt[t],n=/^(?:push|sort|unshift)$/.test(t)?"tap":"thru",i=/^(?:pop|shift)$/.test(t);Dn.prototype[t]=function(){var t=arguments;if(i&&!this.__chain__){var r=this.value();return e.apply(us(r)?r:[],t)}return this[n]((function(n){return e.apply(us(n)?n:[],t)}))}})),Hi(Vn.prototype,(function(t,e){var n=Dn[e];if(n){var i=n.name+"";Nt.call(Cn,i)||(Cn[i]=[]),Cn[i].push({name:e,func:n})}})),Cn[ro(n,2).name]=[{name:"wrapper",func:n}],Vn.prototype.clone=function Hh(){var t=new Vn(this.__wrapped__);return t.__actions__=Yr(this.__actions__),t.__dir__=this.__dir__,t.__filtered__=this.__filtered__,t.__iteratees__=Yr(this.__iteratees__),t.__takeCount__=this.__takeCount__,t.__views__=Yr(this.__views__),t},Vn.prototype.reverse=function Fh(){if(this.__filtered__){var t=new Vn(this);t.__dir__=-1,t.__filtered__=!0}else(t=this.clone()).__dir__*=-1;return t},Vn.prototype.value=function Vh(){var t=this.__wrapped__.value(),e=this.__dir__,n=us(t),i=e<0,r=n?t.length:0,o=(function a(t,e,n){for(var i=-1,r=n.length;++i<r;){var o=n[i],a=o.size;switch(o.type){case"drop":t+=a;break;case"dropRight":e-=a;break;case"take":e=gn(e,t+a);break;case"takeRight":t=mn(t,e-a)}}return{start:t,end:e}})(0,r,this.__views__),s=o.start,l=o.end,c=l-s,u=i?l:s-1,h=this.__iteratees__,d=h.length,p=0,f=gn(c,this.__takeCount__);if(!n||!i&&r==c&&f==c)return Ir(t,this.__actions__);var m=[];t:for(;c--&&p<f;){for(var g=-1,_=t[u+=e];++g<d;){var y=h[g],v=y.type,b=(0,y.iteratee)(_);if(2==v)_=b;else if(!b){if(1==v)continue t;break t}}m[p++]=_}return m},Dn.prototype.at=Oa,Dn.prototype.chain=function jh(){return Ia(this)},Dn.prototype.commit=function Uh(){return new Fn(this.value(),this.__chain__)},Dn.prototype.next=function Gh(){this.__values__===n&&(this.__values__=Bs(this.value()));var t=this.__index__>=this.__values__.length;return{done:t,value:t?n:this.__values__[this.__index__++]}},Dn.prototype.plant=function Wh(t){for(var e,i=this;i instanceof Hn;){var r=oa(i);r.__index__=0,r.__values__=n,e?o.__wrapped__=r:e=r;var o=r;i=i.__wrapped__}return o.__wrapped__=t,e},Dn.prototype.reverse=function qh(){var t=this.__wrapped__;if(t instanceof Vn){var e=t;return this.__actions__.length&&(e=new Vn(this)),(e=e.reverse()).__actions__.push({func:Na,args:[ba],thisArg:n}),new Fn(e,this.__chain__)}return this.thru(ba)},Dn.prototype.toJSON=Dn.prototype.valueOf=Dn.prototype.value=function Yh(){return Ir(this.__wrapped__,this.__actions__)},Dn.prototype.first=Dn.prototype.head,se&&(Dn.prototype[se]=function Xh(){return this}),Dn})();oe?((oe.exports=an)._=an,re._=an):ie._=an}).call(ve)})),tmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.IStackingOrder=vft.makeEnum(["topdown","bottomup"]);var n=window.Math;e.stack=function i(t,n,r,o){void 0===o&&(o="bottomup");var a=Uht.map(),s=Uht.map(),l=new umt.Map;"topdown"===o&&(t=t.slice()).reverse();for(var c=0,u=t;c<u.length;c++){for(var h=u[c],d=new umt.Map,p=h.data(),f=p.length,m=0;m<f;m++){var g=p[m],_=n(g,m,h),y=e.normalizeKey(_),v=+r(g,m,h),b=void 0,x=v>=0?a:s;x.has(y)?(b=x.get(y),x.set(y,b+v)):(b=0,x.set(y,v)),d.set(y,{offset:b,value:v,axisValue:_,originalDatum:g,originalDataset:h,originalIndex:m})}l.set(h,d)}return l},e.stackedExtents=function r(t){var e=new umt.Map,n=new umt.Map;return t.forEach((function(t){t.forEach((function(t,i){var r=t.offset+t.value,o=umt.Math.max([r,t.offset],t.offset),a=umt.Math.min([r,t.offset],t.offset),s=t.axisValue;e.has(i)?e.get(i).extent<o&&e.set(i,{extent:o,axisValue:s,stackedDatum:t}):e.set(i,{extent:o,axisValue:s,stackedDatum:t}),n.has(i)?n.get(i).extent>a&&n.set(i,{extent:a,axisValue:s,stackedDatum:t}):n.set(i,{extent:a,axisValue:s,stackedDatum:t})}))})),{maximumExtents:e,minimumExtents:n}},e.stackedExtent=function o(t,i,r){var o=[];t.forEach((function(t,n){for(var a=n.data(),s=a.length,l=0;l<s;l++){var c=a[l];if(null==r||r(c,l,n)){var u=t.get(e.normalizeKey(i(c,l,n)));o.push(u.value+u.offset)}}}));var a=umt.Math.max(o,0),s=umt.Math.min(o,0);return[n.min(s,0),n.max(0,a)]},e.normalizeKey=Qft.memoize((function(t){return String(t)}))})),emt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.SHOW_WARNINGS=!0,e.ADD_TITLE_ELEMENTS=!0})),nmt=be((function(t,e){function n(t){emt.SHOW_WARNINGS&&console.warn(t)}function i(t,e){for(var n=[],i=2;i<arguments.length;i++)n[i-2]=arguments[i];return 0===e?(t(n),-1):window.setTimeout(t,e,n)}
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.warn=n,e.setTimeout=i,e.debounce=function r(t,e,n){var r=null,o=[],a=function(){e.apply(n,o)};return function(){o=Array.prototype.slice.call(arguments),clearTimeout(r),r=i(a,t)}},e.deprecated=function o(t,e,i){void 0===i&&(i=""),n("Method "+t+" has been deprecated in version "+e+". Please refer to the release notes. "+i)}})),imt=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e,n){this.entryIndex=t,this.exitIndex=t,this.minIndex=t,this.maxIndex=t,this.bucketValue=e,this.minValue=n,this.maxValue=n}return t.prototype.isInBucket=function(t){return t==this.bucketValue},t.prototype.addToBucket=function(t,e){t<this.minValue&&(this.minValue=t,this.minIndex=e),t>this.maxValue&&(this.maxValue=t,this.maxIndex=e),this.exitIndex=e},t.prototype.getUniqueIndices=function(){var t=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return t.filter((function(e,n){return 0==n||e!=t[n-1]}))},t})();e.Bucket=n})),rmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){"function"==typeof window.Set?this._es6Set=new window.Set:this._values=[],this.size=0}return t.prototype.add=function(t){return null!=this._es6Set?(this._es6Set.add(t),this.size=this._es6Set.size,this):(this.has(t)||(this._values.push(t),this.size=this._values.length),this)},t.prototype.delete=function(t){if(null!=this._es6Set){var e=this._es6Set.delete(t);return this.size=this._es6Set.size,e}var n=this._values.indexOf(t);return-1!==n&&(this._values.splice(n,1),this.size=this._values.length,!0)},t.prototype.has=function(t){return null!=this._es6Set?this._es6Set.has(t):-1!==this._values.indexOf(t)},t.prototype.forEach=function(t,e){var n=this;null==this._es6Set?this._values.forEach((function(i){t.call(e,i,i,n)})):this._es6Set.forEach((function(i,r){return t.call(e,i,r,n)}),e)},t})();e.Set=n})),omt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return Sft.__extends(e,t),e.prototype.callCallbacks=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return this.forEach((function(n){n.apply(t,e)})),this},e})(rmt.Set);e.CallbackSet=n})),amt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this._entities=[],this._rtree=new Jft.RTree}return t.prototype.addAll=function(t,e,n){if(this._entities=this._entities.concat(t),void 0!==n)for(var i=Jft.RTreeBounds.bounds(n),r=0;r<t.length;r++){var o=Jft.RTreeBounds.entityBounds(e(a=t[r]));Jft.RTreeBounds.isBoundsOverlapBounds(i,o)&&this._rtree.insert(o,a)}else for(r=0;r<t.length;r++){var a;o=Jft.RTreeBounds.entityBounds(e(a=t[r])),this._rtree.insert(o,a)}},t.prototype.entityNearest=function(t){return this._rtree.locateNearest(t).pop()},t.prototype.entityNearestX=function(t){return this._rtree.locateNearestX(t).pop()},t.prototype.entityNearestY=function(t){return this._rtree.locateNearestY(t).pop()},t.prototype.entitiesInBounds=function(t){return this._rtree.intersect(Jft.RTreeBounds.entityBounds(t))},t.prototype.entitiesInXBounds=function(t){return this._rtree.intersectX(Jft.RTreeBounds.entityBounds(t))},t.prototype.entitiesInYBounds=function(t){return this._rtree.intersectY(Jft.RTreeBounds.entityBounds(t))},t.prototype.entities=function(){return this._entities},t})();e.EntityStore=n})),smt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){"function"==typeof window.Map?this._es6Map=new window.Map:this._keyValuePairs=[]}return t.prototype.set=function(t,e){if(Kft.isNaN(t))throw new Error("NaN may not be used as a key to the Map");if(null!=this._es6Map)return this._es6Map.set(t,e),this;for(var n=0;n<this._keyValuePairs.length;n++)if(this._keyValuePairs[n].key===t)return this._keyValuePairs[n].value=e,this;return this._keyValuePairs.push({key:t,value:e}),this},t.prototype.get=function(t){if(null!=this._es6Map)return this._es6Map.get(t);for(var e=0;e<this._keyValuePairs.length;e++)if(this._keyValuePairs[e].key===t)return this._keyValuePairs[e].value},t.prototype.has=function(t){if(null!=this._es6Map)return this._es6Map.has(t);for(var e=0;e<this._keyValuePairs.length;e++)if(this._keyValuePairs[e].key===t)return!0;return!1},t.prototype.forEach=function(t,e){var n=this;null==this._es6Map?this._keyValuePairs.forEach((function(i){t.call(e,i.value,i.key,n)})):this._es6Map.forEach((function(i,r){return t.call(e,i,r,n)}),e)},t.prototype.delete=function(t){if(null!=this._es6Map)return this._es6Map.delete(t);for(var e=0;e<this._keyValuePairs.length;e++)if(this._keyValuePairs[e].key===t)return this._keyValuePairs.splice(e,1),!0;return!1},t})();e.Map=n})),lmt=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.assign=function n(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];for(var n={},i=0,r=t;i<r.length;i++)for(var o=r[i],a=Object.keys(o),s=0,l=a;s<l.length;s++){var c=l[s];n[c]=o[c]}return n}})),cmt=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n="__Plottable_ClientTranslator";e.getTranslator=function i(t){var e=t.root().rootElement().node(),i=e[n];return null==i&&(i=new r(e),e[n]=i),i};var r=(function(){function t(t){this._rootElement=t}return t.prototype.computePosition=function(t,e){var n={x:t,y:e},i=umt.Math.getCumulativeTransform(this._rootElement);return null==i?n:umt.Math.applyTransform(i,n)},t.isEventInside=function(t,e){return umt.DOM.contains(t.root().rootElement().node(),e.target)},t})();e.Translator=r})),umt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.Array=Yft,e.Color=Xft,e.DOM=$ft,e.Math=Kft,e.RTree=Jft,e.Stacking=tmt,e.Window=nmt,Sft.__exportStar(imt,e),Sft.__exportStar(omt,e),Sft.__exportStar(yft,e),Sft.__exportStar(amt,e),Sft.__exportStar(smt,e),Sft.__exportStar(lmt,e),Sft.__exportStar(rmt,e),Sft.__exportStar(cmt,e)})),hmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){}return t.prototype.render=function(){dmt.flush()},t})();e.Immediate=n;var i=(function(){function t(){}return t.prototype.render=function(){umt.DOM.requestAnimationFramePolyfill(dmt.flush)},t})();e.AnimationFrame=i;var r=(function(){function t(){this._timeoutMsec=umt.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}return t.prototype.render=function(){setTimeout(dmt.flush,this._timeoutMsec)},t})();e.Timeout=r})),dmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=new umt.Set,i=new umt.Set,r=!1,o=!1;e.Policy=vft.makeEnum(["immediate","animationFrame","timeout"]);var a=new hmt.AnimationFrame;function s(t){i.add(t),n.add(t),l()}function l(){r||(r=!0,a.render())}e.renderPolicy=function c(t){if(null==t)return a;switch(t){case e.Policy.immediate:a=new hmt.Immediate;break;case e.Policy.animationFrame:a=new hmt.AnimationFrame;break;case e.Policy.timeout:a=new hmt.Timeout;break;default:umt.Window.warn("Unrecognized renderPolicy: "+t)}},e.registerToRender=function u(t){o&&umt.Window.warn("Registered to render while other components are flushing: request may be ignored"),n.add(t),l()},e.registerToComputeLayoutAndRender=s,e.registerToComputeLayout=function h(t){s(t)},e.flush=function d(){if(r){i.forEach((function(t){return t.computeLayout()})),n.forEach((function(t){return t.render()})),o=!0;var t=new umt.Set;n.forEach((function(e){try{e.renderImmediately()}catch(n){window.setTimeout((function(){throw n}),0),t.add(e)}})),i=new umt.Set,n=t,r=!1,o=!1}}})),pmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.XAlignment=vft.makeEnum(["left","center","right"]),e.YAlignment=vft.makeEnum(["top","center","bottom"]);var n=(function(){function t(){this._overflowHidden=!1,this._origin={x:0,y:0},this._xAlignment="left",this._yAlignment="top",this._isSetup=!1,this._isAnchored=!1,this._cssClasses=new umt.Set,this._destroyed=!1,this._onAnchorCallbacks=new umt.CallbackSet,this._onDetachCallbacks=new umt.CallbackSet,this._cssClasses.add("component")}return t.prototype.anchor=function(t){if(t=yft.coerceExternalD3(t),this._destroyed)throw new Error("Can't reuse destroy()-ed Components!");return this.isRoot()&&(this._rootElement=t,this._rootElement.classed("plottable",!0)),null!=this._element?t.node().appendChild(this._element.node()):(this._element=t.append("div"),this._setup()),this._isAnchored=!0,this._onAnchorCallbacks.callCallbacks(this),this},t.prototype.onAnchor=function(t){return this._isAnchored&&t(this),this._onAnchorCallbacks.add(t),this},t.prototype.offAnchor=function(t){return this._onAnchorCallbacks.delete(t),this},t.prototype._setup=function(){var t=this;this._isSetup||(this._cssClasses.forEach((function(e){t._element.classed(e,!0)})),this._cssClasses=new umt.Set,this._backgroundContainer=this._element.append("svg").classed("background-container",!0),this._content=this._element.append("svg").classed("content",!0),this._foregroundContainer=this._element.append("svg").classed("foreground-container",!0),this._content.classed(this._overflowHidden?"component-overflow-hidden":"component-overflow-visible",!0),this._isSetup=!0)},t.prototype.requestedSpace=function(t,e){return{minWidth:0,minHeight:0}},t.prototype.computeLayout=function(e,n,i){if(null==e||null==n||null==i){if(null==this._element)throw new Error("anchor() must be called before computeLayout()");if(null==this._rootElement)throw new Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node");e={x:0,y:0};var r=this._rootElement.node();n=umt.DOM.elementWidth(r),i=umt.DOM.elementHeight(r)}var o=this._sizeFromOffer(n,i),a=o.height,s=o.width;return this.setBounds(s,a,e.x+(n-s)*t._xAlignToProportion[this._xAlignment],e.y+(i-a)*t._yAlignToProportion[this._yAlignment]),this},t.prototype.setBounds=function(t,e,n,i){return void 0===n&&(n=0),void 0===i&&(i=0),this._width=t,this._height=e,this._origin={x:n,y:i},null!=this._element&&this._element.styles({left:n+"px",height:e+"px",top:i+"px",width:t+"px"}),null!=this._resizeHandler&&this._resizeHandler({width:t,height:e}),this},t.prototype._sizeFromOffer=function(t,e){var n=this.requestedSpace(t,e);return{width:this.fixedWidth()?Math.min(t,n.minWidth):t,height:this.fixedHeight()?Math.min(e,n.minHeight):e}},t.prototype.render=function(){return this._isAnchored&&this._isSetup&&this.width()>=0&&this.height()>=0&&dmt.registerToRender(this),this},t.prototype.renderLowPriority=function(){return this.render()},t.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&dmt.registerToComputeLayoutAndRender(this)},t.prototype.onResize=function(t){return this._resizeHandler=t,this},t.prototype.renderImmediately=function(){return this},t.prototype.redraw=function(){return this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():this.parent().redraw()),this},t.prototype.invalidateCache=function(){},t.prototype.renderTo=function(t){if(this.detach(),null!=t){var e=void 0;if(!(e="string"==typeof t||Qft.isElement(t)?Uht.select(t):yft.coerceExternalD3(t)).node()||null==e.node().nodeName)throw new Error("Plottable requires a valid Element to renderTo");if("svg"===e.node().nodeName)throw new Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(e)}if(null==this._element)throw new Error("If a Component has never been rendered before, then renderTo must be given a node to render to, or a d3.Selection, or a selector string");return dmt.registerToComputeLayoutAndRender(this),dmt.flush(),this},t.prototype.xAlignment=function(e){if(null==e)return this._xAlignment;if(e=e.toLowerCase(),null==t._xAlignToProportion[e])throw new Error("Unsupported alignment: "+e);return this._xAlignment=e,this.redraw(),this},t.prototype.yAlignment=function(e){if(null==e)return this._yAlignment;if(e=e.toLowerCase(),null==t._yAlignToProportion[e])throw new Error("Unsupported alignment: "+e);return this._yAlignment=e,this.redraw(),this},t.prototype.hasClass=function(t){return null!=t&&(null==this._element?this._cssClasses.has(t):this._element.classed(t))},t.prototype.addClass=function(t){return null==t||(null==this._element?this._cssClasses.add(t):this._element.classed(t,!0)),this},t.prototype.removeClass=function(t){return null==t||(null==this._element?this._cssClasses.delete(t):this._element.classed(t,!1)),this},t.prototype.fixedWidth=function(){return!1},t.prototype.fixedHeight=function(){return!1},t.prototype.detach=function(){return this.parent(null),this._isAnchored&&this._element.remove(),this._isAnchored=!1,this._onDetachCallbacks.callCallbacks(this),this},t.prototype.onDetach=function(t){return this._onDetachCallbacks.add(t),this},t.prototype.offDetach=function(t){return this._onDetachCallbacks.delete(t),this},t.prototype.parent=function(t){if(void 0===t)return this._parent;if(null!==t&&!t.has(this))throw new Error("Passed invalid parent");return this._parent=t,this},t.prototype.bounds=function(){var t=this.origin();return{topLeft:t,bottomRight:{x:t.x+this.width(),y:t.y+this.height()}}},t.prototype.destroy=function(){this._destroyed=!0,this.detach()},t.prototype.width=function(){return this._width},t.prototype.height=function(){return this._height},t.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}},t.prototype.originToRoot=function(){for(var t=this.origin(),e=this.parent();null!=e;){var n=e.origin();t.x+=n.x,t.y+=n.y,e=e.parent()}return t},t.prototype.root=function(){for(var t=this;!t.isRoot();)t=t.parent();return t},t.prototype.isRoot=function(){return null==this.parent()},t.prototype.foreground=function(){return this._foregroundContainer},t.prototype.content=function(){return this._content},t.prototype.element=function(){return this._element},t.prototype.rootElement=function(){return this.root()._rootElement},t.prototype.background=function(){return this._backgroundContainer},t._xAlignToProportion={left:0,center:.5,right:1},t._yAlignToProportion={top:0,center:.5,bottom:1},t})();e.Component=n})),fmt=be((function(t,e){function n(t){return void 0===t&&(t=3),i(t),function(e){return e.toFixed(t)}}function i(t){if(t<0||t>20)throw new RangeError("Formatter precision must be between 0 and 20");if(t!==Math.floor(t))throw new RangeError("Formatter precision must be an integer")}
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.currency=function r(t,e,i){void 0===t&&(t=2),void 0===e&&(e="$"),void 0===i&&(i=!0);var r=n(t);return function(t){var n=r(Math.abs(t));return""!==n&&(i?n=e+n:n+=e,t<0&&(n="-"+n)),n}},e.fixed=n,e.general=function o(t){return void 0===t&&(t=3),i(t),function(e){if("number"==typeof e){var n=Math.pow(10,t);return String(Math.round(e*n)/n)}return String(e)}},e.identity=function a(){return function(t){return String(t)}},e.percentage=function s(t){void 0===t&&(t=0);var e=n(t);return function(t){var n=100*t,i=t.toString(),r=Math.pow(10,i.length-(i.indexOf(".")+1));return n=parseInt((n*r).toString(),10)/r,e(n)+"%"}},e.siSuffix=function l(t){return void 0===t&&(t=3),i(t),function(e){return Uht.format("."+t+"s")(e)}},e.shortScale=function c(t){void 0===t&&(t=3),i(t);var e="KMBTQ",n=Uht.format("."+t+"e"),r=Uht.format("."+t+"f"),o=Math.pow(10,3*(e.length+1)),a=Math.pow(10,-t);return function(t){var i=Math.abs(t);if((i<a||i>=o)&&0!==i)return n(t);for(var s=-1;i>=Math.pow(1e3,s+2)&&s<e.length-1;)s++;var l="";return l=-1===s?r(t):r(t/Math.pow(1e3,s+1))+e[s],(t>0&&"1000"===l.substr(0,4)||t<0&&"-1000"===l.substr(0,5))&&(s<e.length-1?(s++,l=r(t/Math.pow(1e3,s+1))+e[s]):l=n(t)),l}},e.multiTime=function u(){var t=[{specifier:".%L",predicate:function(t){return 0!==t.getMilliseconds()}},{specifier:":%S",predicate:function(t){return 0!==t.getSeconds()}},{specifier:"%I:%M",predicate:function(t){return 0!==t.getMinutes()}},{specifier:"%I %p",predicate:function(t){return 0!==t.getHours()}},{specifier:"%a %d",predicate:function(t){return 0!==t.getDay()&&1!==t.getDate()}},{specifier:"%b %d",predicate:function(t){return 1!==t.getDate()}},{specifier:"%b",predicate:function(t){return 0!==t.getMonth()}}];return function(e){var n=t.filter((function(t){return t.predicate(e)}));return Uht.timeFormat(n.length>0?n[0].specifier:"%Y")(e)}},e.time=function h(t,e){return void 0===e&&(e=!1),e?Uht.utcFormat(t):Uht.timeFormat(t)}})),mmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.AxisOrientation=vft.makeEnum(["bottom","left","right","top"]);var n=(function(t){function e(e,n){var i=t.call(this)||this;if(i._endTickLength=5,i._innerTickLength=5,i._tickLabelPadding=10,i._margin=15,i._showEndTickLabels=!1,i._annotationsEnabled=!1,i._annotationTierCount=1,null==e||null==n)throw new Error("Axis requires a scale and orientation");return i._scale=e,i.orientation(n),i._setDefaultAlignment(),i.addClass("axis"),i.isHorizontal()?i.addClass("x-axis"):i.addClass("y-axis"),i.formatter(fmt.identity()),i._rescaleCallback=function(t){return i._rescale()},i._scale.onUpdate(i._rescaleCallback),i._annotatedTicks=[],i._annotationFormatter=fmt.identity(),i}return Sft.__extends(e,t),e.prototype.destroy=function(){t.prototype.destroy.call(this),this._scale.offUpdate(this._rescaleCallback)},e.prototype.tickLabelDataOnElement=function(t){if(null!=t){for(var n;null!=t&&t.classList&&void 0===n;)t.classList.contains(e.TICK_LABEL_CLASS)?n=t:t=t.parentNode;return void 0===t?void 0:Uht.select(t).datum()}},e.prototype._computeWidth=function(){return this._maxLabelTickLength()},e.prototype._computeHeight=function(){return this._maxLabelTickLength()},e.prototype.requestedSpace=function(t,n){var i=0,r=0;return this.isHorizontal()?(r=this._computeHeight()+this._margin,this.annotationsEnabled()&&(r+=(this._annotationMeasurer.measure().height+2*e._ANNOTATION_LABEL_PADDING)*this.annotationTierCount())):(i=this._computeWidth()+this._margin,this.annotationsEnabled()&&(i+=(this._annotationMeasurer.measure().height+2*e._ANNOTATION_LABEL_PADDING)*this.annotationTierCount())),{minWidth:i,minHeight:r}},e.prototype.fixedHeight=function(){return this.isHorizontal()},e.prototype.fixedWidth=function(){return!this.isHorizontal()},e.prototype._rescale=function(){this.render()},e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]),this},e.prototype._sizeFromOffer=function(t,e){var n=this.requestedSpace(t,e);return this.isHorizontal()?{width:t,height:n.minHeight}:{height:e,width:n.minWidth}},e.prototype._setup=function(){t.prototype._setup.call(this),this._tickMarkContainer=this.content().append("g").classed(e.TICK_MARK_CLASS+"-container",!0),this._tickLabelContainer=this.content().append("g").classed(e.TICK_LABEL_CLASS+"-container",!0),this._baseline=this.content().append("line").classed("baseline",!0),this._annotationContainer=this.content().append("g").classed("annotation-container",!0),this._annotationContainer.append("g").classed("annotation-line-container",!0),this._annotationContainer.append("g").classed("annotation-circle-container",!0),this._annotationContainer.append("g").classed("annotation-rect-container",!0);var n=this._annotationContainer.append("g").classed("annotation-label-container",!0),i=new qft.SvgContext(n.node());this._annotationMeasurer=new qft.CacheMeasurer(i),this._annotationWriter=new qft.Writer(this._annotationMeasurer,i)},e.prototype._getTickValues=function(){return[]},e.prototype.renderImmediately=function(){var t=this._getTickValues(),n=this._tickMarkContainer.selectAll("."+e.TICK_MARK_CLASS).data(t),i=n.enter().append("line").classed(e.TICK_MARK_CLASS,!0).merge(n);return i.attrs(this._generateTickMarkAttrHash()),Uht.select(i.nodes()[0]).classed(e.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),Uht.select(i.nodes()[t.length-1]).classed(e.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0)),n.exit().remove(),this._baseline.attrs(this._generateBaselineAttrHash()),this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},e.prototype.annotatedTicks=function(t){return null==t?this._annotatedTicks:(this._annotatedTicks=t,this.render(),this)},e.prototype.annotationFormatter=function(t){return null==t?this._annotationFormatter:(this._annotationFormatter=t,this.render(),this)},e.prototype.annotationsEnabled=function(t){return null==t?this._annotationsEnabled:(this._annotationsEnabled=t,this.redraw(),this)},e.prototype.annotationTierCount=function(t){if(null==t)return this._annotationTierCount;if(t<0)throw new Error("annotationTierCount cannot be negative");return this._annotationTierCount=t,this.redraw(),this},e.prototype._drawAnnotations=function(){var t=this,n=e._ANNOTATION_LABEL_PADDING,i=new umt.Map,r=this._annotatedTicksToRender();r.forEach((function(e){var r=t._annotationMeasurer.measure(t.annotationFormatter()(e));i.set(e,{width:r.width+2*n,height:r.height+2*n})}));var o=this._annotationMeasurer.measure().height+2*n,a=this._annotationToTier(i),s=new umt.Set,l=this.isHorizontal()?this.height():this.width(),c=this._coreSize(),u=Math.min(this.annotationTierCount(),Math.floor((l-c)/o));a.forEach((function(t,e){(-1===t||t>=u)&&s.add(e)}));var h,d=function(t,e,n){var i=t.selectAll("."+n).data(r),o=i.enter().append(e).classed(n,!0).merge(i);return i.exit().remove(),o},p=function(e){switch(t.orientation()){case"bottom":case"right":return a.get(e)*o+c;case"top":case"left":return l-c-a.get(e)*o}},f=function(e){return t._scale.scale(e)},m=function(t){return s.has(t)?"hidden":"visible"};switch(this.orientation()){case"bottom":case"right":h=0;break;case"top":h=this.height();break;case"left":h=this.width()}var g=this.isHorizontal();d(this._annotationContainer.select(".annotation-line-container"),"line",e.ANNOTATION_LINE_CLASS).attrs({x1:g?f:h,x2:g?f:p,y1:g?h:f,y2:g?p:f,visibility:m}),d(this._annotationContainer.select(".annotation-circle-container"),"circle",e.ANNOTATION_CIRCLE_CLASS).attrs({cx:g?f:h,cy:g?h:f,r:3});var _=function(e){switch(t.orientation()){case"bottom":case"right":return p(e);case"top":case"left":return p(e)-i.get(e).height}};d(this._annotationContainer.select(".annotation-rect-container"),"rect",e.ANNOTATION_RECT_CLASS).attrs({x:g?f:_,y:g?_:f,width:g?function(t){return i.get(t).width}:function(t){return i.get(t).height},height:g?function(t){return i.get(t).height}:function(t){return i.get(t).width},visibility:m});var y=this._annotationWriter,v=this.annotationFormatter(),b=d(this._annotationContainer.select(".annotation-label-container"),"g",e.ANNOTATION_LABEL_CLASS);b.selectAll(".text-container").remove(),b.attrs({transform:function(t){return"translate("+(g?f(t):_(t))+","+(g?_(t):f(t))+")"},visibility:m}).each((function(t){y.write(v(t),g?i.get(t).width:i.get(t).height,g?i.get(t).height:i.get(t).width,{xAlign:"center",yAlign:"center",textRotation:g?0:90},Uht.select(this).node())}))},e.prototype._annotatedTicksToRender=function(){var t=this,e=this._scale.range();return umt.Array.uniq(this.annotatedTicks().filter((function(n){return null!=n&&umt.Math.inRange(t._scale.scale(n),e[0],e[1])})))},e.prototype._coreSize=function(){var t=this.isHorizontal()?this.height():this.width(),e=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(e,t)},e.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*e._ANNOTATION_LABEL_PADDING},e.prototype._annotationToTier=function(t){var e=this,n=[[]],i=new umt.Map,r=this.isHorizontal()?this.width():this.height();return this._annotatedTicksToRender().forEach((function(o){var a=e._scale.scale(o),s=t.get(o).width;if(a<0||a+s>r)i.set(o,-1);else{for(var l=0;n[l].some((function(n){var i=e._scale.scale(n),r=t.get(n).width;return a+s>=i&&a<=i+r}));)l++,n.length===l&&n.push([]);n[l].push(o),i.set(o,l)}})),i},e.prototype._removeAnnotations=function(){this._annotationContainer.selectAll(".annotation-line").remove(),this._annotationContainer.selectAll(".annotation-circle").remove(),this._annotationContainer.selectAll(".annotation-rect").remove(),this._annotationContainer.selectAll(".annotation-label").remove()},e.prototype._generateBaselineAttrHash=function(){var t={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case"bottom":t.x2=this.width();break;case"top":t.x2=this.width(),t.y1=this.height(),t.y2=this.height();break;case"left":t.x1=this.width(),t.x2=this.width(),t.y2=this.height();break;case"right":t.y2=this.height()}return t},e.prototype._generateTickMarkAttrHash=function(t){var e=this;void 0===t&&(t=!1);var n={x1:0,y1:0,x2:0,y2:0},i=function(t){return e._scale.scale(t)};this.isHorizontal()?(n.x1=i,n.x2=i):(n.y1=i,n.y2=i);var r=t?this._endTickLength:this._innerTickLength;switch(this._orientation){case"bottom":n.y2=r;break;case"top":n.y1=this.height(),n.y2=this.height()-r;break;case"left":n.x1=this.width(),n.x2=this.width()-r;break;case"right":n.x2=r}return n},e.prototype._setDefaultAlignment=function(){switch(this._orientation){case"bottom":this.yAlignment("top");break;case"top":this.yAlignment("bottom");break;case"left":this.xAlignment("right");break;case"right":this.xAlignment("left")}},e.prototype.isHorizontal=function(){return"top"===this._orientation||"bottom"===this._orientation},e.prototype.getScale=function(){return this._scale},e.prototype.formatter=function(t){return null==t?this._formatter:(this._formatter=t,this.redraw(),this)},e.prototype.innerTickLength=function(t){if(null==t)return this._innerTickLength;if(t<0)throw new Error("inner tick length must be positive");return this._innerTickLength=t,this.redraw(),this},e.prototype.endTickLength=function(t){if(null==t)return this._endTickLength;if(t<0)throw new Error("end tick length must be positive");return this._endTickLength=t,this.redraw(),this},e.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),this.endTickLength()):this.innerTickLength()},e.prototype.tickLabelPadding=function(t){if(null==t)return this._tickLabelPadding;if(t<0)throw new Error("tick label padding must be positive");return this._tickLabelPadding=t,this.redraw(),this},e.prototype.margin=function(t){if(null==t)return this._margin;if(t<0)throw new Error("margin size must be positive");return this._margin=t,this.redraw(),this},e.prototype.orientation=function(t){if(null==t)return this._orientation;var e=t.toLowerCase();if("top"!==e&&"bottom"!==e&&"left"!==e&&"right"!==e)throw new Error("unsupported orientation");return this._orientation=e,this.redraw(),this},e.prototype.showEndTickLabels=function(t){return null==t?this._showEndTickLabels:(this._showEndTickLabels=t,this.render(),this)},e.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+e.TICK_MARK_CLASS).each((function(){Uht.select(this).style("visibility","inherit")}))},e.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+e.TICK_LABEL_CLASS).each((function(){Uht.select(this).style("visibility","inherit")}))},e.prototype._hideOverflowingTickLabels=function(){var t=this.element().node().getBoundingClientRect(),n=this._tickLabelContainer.selectAll("."+e.TICK_LABEL_CLASS);n.empty()||n.each((function(e,n){umt.DOM.clientRectInside(this.getBoundingClientRect(),t)||Uht.select(this).style("visibility","hidden")}))},e.prototype._hideTickMarksWithoutLabel=function(){var t=this._tickMarkContainer.selectAll("."+e.TICK_MARK_CLASS),n=this._tickLabelContainer.selectAll("."+e.TICK_LABEL_CLASS).filter((function(t,e){var n=Uht.select(this).style("visibility");return"inherit"===n||"visible"===n})).data();t.each((function(t,e){-1===n.indexOf(t)&&Uht.select(this).style("visibility","hidden")}))},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._annotationMeasurer.reset()},e.END_TICK_MARK_CLASS="end-tick-mark",e.TICK_MARK_CLASS="tick-mark",e.TICK_LABEL_CLASS="tick-label",e.ANNOTATION_LINE_CLASS="annotation-line",e.ANNOTATION_RECT_CLASS="annotation-rect",e.ANNOTATION_CIRCLE_CLASS="annotation-circle",e.ANNOTATION_LABEL_CLASS="annotation-label",e._ANNOTATION_LABEL_PADDING=4,e})(pmt.Component);e.Axis=n})),gmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e,n){void 0===n&&(n="bottom");var i=t.call(this,e,n)||this;return i._tickLabelAngle=0,i._tickLabelShearAngle=0,i.addClass("category-axis"),i}return Sft.__extends(e,t),Object.defineProperty(e.prototype,"_wrapper",{get:function(){var t=new qft.Wrapper;return null!=this._tickLabelMaxLines&&t.maxLines(this._tickLabelMaxLines),t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"_writer",{get:function(){return new qft.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0}),e.prototype._setup=function(){t.prototype._setup.call(this),this._typesetterContext=new qft.SvgContext(this._tickLabelContainer.node()),this._measurer=new qft.CacheMeasurer(this._typesetterContext)},e.prototype._rescale=function(){return this.redraw()},e.prototype.requestedSpace=function(t,e){var n=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),i=this.isHorizontal()?this._tickSpaceRequired()+this.margin():0;if(0===this._scale.domain().length)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var r=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?i+=r:n+=r}var o=this._measureTickLabels(t,e);return{minWidth:o.usedWidth+n,minHeight:o.usedHeight+i}},e.prototype._coreSize=function(){var t=this.isHorizontal()?this.height():this.width(),e=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),this.height()).minWidth,n=this.margin()+this._annotationTierHeight();return Math.min(e-n,t)},e.prototype._getTickValues=function(){return this.getDownsampleInfo().domain},e.prototype._sizeFromOffer=function(t,e){return pmt.Component.prototype._sizeFromOffer.call(this,t,e)},e.prototype.getDownsampleInfo=function(t,n){void 0===t&&(t=this._scale),void 0===n&&(n=t.invertRange());var i=0===this._tickLabelAngle?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI),r=Math.ceil(e._MINIMUM_WIDTH_PER_LABEL_PX*i/t.stepWidth());return{domain:n.filter((function(t,e){return e%r==0})),stepWidth:r*t.stepWidth()}},e.prototype.tickLabelAngle=function(t){if(null==t)return this._tickLabelAngle;if(0!==t&&90!==t&&-90!==t)throw new Error("Angle "+t+" not supported; only 0, 90, and -90 are valid values");return this._tickLabelAngle=t,this.redraw(),this},e.prototype.tickLabelShearAngle=function(t){if(null==t)return this._tickLabelShearAngle;if(t<-80||t>80)throw new Error("Angle "+t+" not supported; Must be between [-80, 80]");return this._tickLabelShearAngle=t,this.redraw(),this},e.prototype.tickLabelMaxWidth=function(t){return 0===arguments.length?this._tickLabelMaxWidth:(this._tickLabelMaxWidth=t,this.redraw(),this)},e.prototype.tickLabelMaxLines=function(t){return 0===arguments.length?this._tickLabelMaxLines:(this._tickLabelMaxLines=t,this.redraw(),this)},e.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()},e.prototype._drawTicks=function(t,e){var n,i,r=this;switch(this.tickLabelAngle()){case 0:n={left:"right",right:"left",top:"center",bottom:"center"},i={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:n={left:"center",right:"center",top:"right",bottom:"left"},i={left:"top",right:"bottom",top:"center",bottom:"center"};break;case-90:n={left:"center",right:"center",top:"left",bottom:"right"},i={left:"bottom",right:"top",top:"center",bottom:"center"}}e.each((function(e){var o=Uht.select(this),a=r.isHorizontal()?t:r.width()-r._tickSpaceRequired(),s=r.isHorizontal()?r.height()-r._tickSpaceRequired():t,l={xAlign:n[r.orientation()],yAlign:i[r.orientation()],textRotation:r.tickLabelAngle(),textShear:r.tickLabelShearAngle()};if(null!=r._tickLabelMaxWidth){if("left"===r.orientation()&&a>r._tickLabelMaxWidth){var c=a-r._tickLabelMaxWidth,u=o.attr("transform")+" translate("+c+", 0)";o.attr("transform",u)}a=Math.min(a,r._tickLabelMaxWidth)}r._writer.write(r.formatter()(e),a,s,l,o.node())}))},e.prototype._measureTickLabels=function(t,e){var n=this,i=this._scale.cloneWithoutProviders().range([0,this.isHorizontal()?t:e]),r=this.getDownsampleInfo(i),o=r.domain,a=r.stepWidth,s=t-this._tickSpaceRequired();this.isHorizontal()&&(s=a,0!==this._tickLabelAngle&&(s=e-this._tickSpaceRequired()),s=Math.max(s,0));var l=a;this.isHorizontal()&&(l=e-this._tickSpaceRequired(),0!==this._tickLabelAngle&&(l=t-this._tickSpaceRequired()),l=Math.max(l,0)),null!=this._tickLabelMaxWidth&&(s=Math.min(s,this._tickLabelMaxWidth));var c,u=o.map((function(t){return n._wrapper.wrap(n.formatter()(t),n._measurer,s,l)})),h=this.isHorizontal()&&0===this._tickLabelAngle?Uht.sum:umt.Math.max,d=this.isHorizontal()&&0===this._tickLabelAngle?umt.Math.max:Uht.sum,p=h(u,(function(t){return n._measurer.measure(t.wrappedText).width}),0),f=d(u,(function(t){return n._measurer.measure(t.wrappedText).height}),0);return 0!==this._tickLabelAngle&&(p=(c=[f,p])[0],f=c[1]),{usedWidth:p,usedHeight:f}},e.prototype.renderImmediately=function(){var e=this;t.prototype.renderImmediately.call(this);var n=this._scale,i=this.getDownsampleInfo(n),r=i.domain,o=i.stepWidth,a=o;this.isHorizontal()&&null!=this._tickLabelMaxWidth&&(a=Math.min(a,this._tickLabelMaxWidth));var s=this._tickLabelContainer.selectAll("."+mmt.Axis.TICK_LABEL_CLASS).data(r),l=s.enter().append("g").classed(mmt.Axis.TICK_LABEL_CLASS,!0).merge(s);s.exit().remove(),l.attr("transform",(function(t,i){var r=n.scale(t)-a/2;return"translate("+(e.isHorizontal()?r:0)+","+(e.isHorizontal()?0:r)+")"})),l.text(""),this._drawTicks(o,l);var c="right"===this.orientation()?this._tickSpaceRequired():0,u="bottom"===this.orientation()?this._tickSpaceRequired():0;return this._tickLabelContainer.attr("transform","translate("+c+","+u+")"),this._showAllTickMarks(),this._showAllTickLabels(),this._hideTickMarksWithoutLabel(),this},e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),this.isHorizontal()||this._scale.range([0,this.height()]),this},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},e._MINIMUM_WIDTH_PER_LABEL_PX=15,e})(mmt.Axis);e.Category=n})),_mt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e,n){var i=t.call(this,e,n)||this;return i._tickLabelPositioning="center",i._usesTextWidthApproximation=!1,i.formatter(fmt.general()),i}return Sft.__extends(e,t),e.prototype._setup=function(){t.prototype._setup.call(this);var e=new qft.SvgContext(this._tickLabelContainer.node(),mmt.Axis.TICK_LABEL_CLASS);this._measurer=new qft.CacheMeasurer(e),this._wrapper=(new qft.Wrapper).maxLines(1)},e.prototype._computeWidth=function(){var t=this._usesTextWidthApproximation?this._computeApproximateTextWidth():this._computeExactTextWidth();return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+t:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+t)},e.prototype._computeExactTextWidth=function(){var t=this,e=this._getTickValues().map((function(e){var n=t.formatter()(e);return t._measurer.measure(n).width}));return umt.Math.max(e,0)},e.prototype._computeApproximateTextWidth=function(){var t=this,e=this._getTickValues(),n=this._measurer.measure("M").width,i=e.map((function(e){return t.formatter()(e).length*n}));return umt.Math.max(i,0)},e.prototype._computeHeight=function(){var t=this._measurer.measure().height;return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+t:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+t)},e.prototype._getTickValues=function(){var t=this._scale,e=t.domain(),n=e[0]<=e[1]?e[0]:e[1],i=e[0]>=e[1]?e[0]:e[1];return t.ticks().filter((function(t){return t>=n&&t<=i}))},e.prototype._rescale=function(){if(this._isSetup){if(!this.isHorizontal()){var t=this._computeWidth();if(t>this.width()||t<this.width()-this.margin())return void this.redraw()}this.render()}},e.prototype.renderImmediately=function(){var e=this;t.prototype.renderImmediately.call(this);var n={x:0,y:0,dx:"0em",dy:"0.3em"},i=this._maxLabelTickLength(),r=this.tickLabelPadding(),o="middle",a=0,s=0,l=0,c=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case"left":o="end",a=-r,c=r;break;case"center":c=i+r;break;case"right":o="start",a=r,c=r}else switch(this._tickLabelPositioning){case"top":n.dy="-0.3em",l=r,s=-r;break;case"center":l=i+r;break;case"bottom":n.dy="1em",l=r,s=r}var u=this._generateTickMarkAttrHash();switch(this.orientation()){case"bottom":n.x=u.x1,n.dy="0.95em",s=u.y1+c;break;case"top":n.x=u.x1,n.dy="-.25em",s=u.y1-c;break;case"left":o="end",a=u.x1-l,n.y=u.y1;break;case"right":o="start",a=u.x1+l,n.y=u.y1}var h=this._getTickValues(),d=this._tickLabelContainer.selectAll("."+mmt.Axis.TICK_LABEL_CLASS).data(h);return d.exit().remove(),d.enter().append("text").classed(mmt.Axis.TICK_LABEL_CLASS,!0).merge(d).style("text-anchor",o).style("visibility","inherit").attrs(n).text((function(t){return e.formatter()(t)})),this._tickLabelContainer.attr("transform","translate("+a+", "+s+")"),this._showAllTickMarks(),this.showEndTickLabels()||this._hideEndTickLabels(),this._hideOverflowingTickLabels(),this._hideOverlappingTickLabels(),"center"!==this._tickLabelPositioning&&this._hideTickMarksWithoutLabel(),this},e.prototype.tickLabelPosition=function(t){if(null==t)return this._tickLabelPositioning;var e=t.toLowerCase();if(this.isHorizontal()){if("left"!==e&&"center"!==e&&"right"!==e)throw new Error(e+" is not a valid tick label position for a horizontal NumericAxis")}else if("top"!==e&&"center"!==e&&"bottom"!==e)throw new Error(e+" is not a valid tick label position for a vertical NumericAxis");return this._tickLabelPositioning=e,this.redraw(),this},e.prototype.usesTextWidthApproximation=function(t){return null==t?this._usesTextWidthApproximation:(this._usesTextWidthApproximation=t,this)},e.prototype._hideEndTickLabels=function(){var t=this.element().node().getBoundingClientRect(),e=this._tickLabelContainer.selectAll("."+mmt.Axis.TICK_LABEL_CLASS);if(0!==e.size()){var n=e.nodes()[0];umt.DOM.clientRectInside(n.getBoundingClientRect(),t)||Uht.select(n).style("visibility","hidden");var i=e.nodes()[e.size()-1];umt.DOM.clientRectInside(i.getBoundingClientRect(),t)||Uht.select(i).style("visibility","hidden")}},e.prototype._hideOverlappingTickLabels=function(){for(var t=this._tickLabelContainer.selectAll("."+mmt.Axis.TICK_LABEL_CLASS).filter((function(t,e){var n=Uht.select(this).style("visibility");return"inherit"===n||"visible"===n})),e=t.nodes().map((function(t){return t.getBoundingClientRect()})),n=1;!this._hasOverlapWithInterval(n,e)&&n<e.length;)n+=1;t.each((function(t,e){var i=Uht.select(this);e%n!=0&&i.style("visibility","hidden")}))},e.prototype._hasOverlapWithInterval=function(t,e){for(var n="center"===this._tickLabelPositioning?this.tickLabelPadding():3*this.tickLabelPadding(),i=e.map((function(t){return umt.DOM.expandRect(t,n)})),r=0;r<i.length-t;r+=t)if(umt.DOM.clientRectsOverlap(i[r],i[r+t]))return!1;return!0},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},e})(mmt.Axis);e.Numeric=n})),ymt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.intervalTickGenerator=function n(t){if(t<=0)throw new Error("interval must be positive number");return function(e){var n=e.domain(),i=Math.min(n[0],n[1]),r=Math.max(n[0],n[1]),o=Math.ceil(i/t)*t,a=Math.floor((r-o)/t)+1,s=i%t==0?[]:[i],l=umt.Math.range(0,a).map((function(e){return o+e*t})),c=r%t==0?[]:[r];return s.concat(l).concat(c)}},e.integerTickGenerator=function i(){return function(t){var e=t.defaultTicks();return e.filter((function(t,n){return t%1==0||0===n||n===e.length-1}))}}})),vmt=be((function(t,e){function n(t,e,n){return n-(n-t)*e}function i(t,e,n){return(t*e-n)/(e-1)}function r(t,e,n,i){var r=e>1,o=r?i:n;if(null==o)return e;var a=t.getTransformationDomain(),s=Math.abs(a[1]-a[0]);return(r?Math.min:Math.max)(e,o/s)}function o(t,e,r,o,s){if(e<=1)return{centerPoint:r,zoomAmount:e};if(null==o&&null==s)return{centerPoint:r,zoomAmount:e};var l=a(t),c=(function u(t){var e=t.getTransformationDomain();return e[1]<e[0]})(t);o=null==o?c?1/0:-1/0:o,s=null==s?c?-1/0:1/0:s;var h=t.getTransformationDomain(),d=h[0],p=h[1],f=t.scaleTransformation(s),m=t.scaleTransformation(p),g=n(m,e,r),_=t.scaleTransformation(o),y=t.scaleTransformation(d),v=n(y,e,r),b=Math.abs(f-_);if(Math.abs(g-v)>b){var x=(f-_)/(m-y);return 1!==x?{centerPoint:i(m,x,f),zoomAmount:x}:{centerPoint:r,zoomAmount:x}}return g>f!=l?{centerPoint:i(m,e,f),zoomAmount:e}:v<_!=l?{centerPoint:i(y,e,_),zoomAmount:e}:{centerPoint:r,zoomAmount:e}}function a(t){var e=t.range();return e[1]<e[0]}
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.zoomOut=n,e.constrainedZoom=function s(t,e,n,i,a,l,c){return o(t,e=r(t,e,i,a),n,l,c)},e.constrainZoomExtents=r,e.constrainZoomValues=o,e.constrainedTranslation=function l(t,e,n,i){var r,o=t.getTransformationDomain(),s=o[0],l=o[1],c=a(t);if(e>0!==c){if(null!=(r=i)){var u=t.scaleTransformation(l),h=t.scaleTransformation(r);e=(c?Math.max:Math.min)(u+e,h)-u}}else if(null!=(r=n)){var d=t.scaleTransformation(s),p=t.scaleTransformation(r);e=(c?Math.min:Math.max)(d+e,p)-d}return e}})),bmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this._autoDomainAutomatically=!0,this._domainModificationInProgress=!1,this._updateId=0,this._callbacks=new umt.CallbackSet,this._includedValuesProviders=new umt.Set}return t.prototype.extentOfValues=function(t){return[]},t.prototype._getAllIncludedValues=function(t){var e=this;void 0===t&&(t=!1);var n=[];return this._includedValuesProviders.forEach((function(i){var r=i(e,t);n=n.concat(r)})),n},t.prototype._getExtent=function(){return[]},t.prototype.onUpdate=function(t){return this._callbacks.add(t),this},t.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},t.prototype._dispatchUpdate=function(){this._updateId++,this._callbacks.callCallbacks(this)},t.prototype.autoDomain=function(){return this._autoDomainAutomatically=!0,this._setDomain(this._getExtent()),this},t.prototype.autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()},t.prototype.scale=function(t){throw new Error("Subclasses should override scale")},t.prototype.ticks=function(){return this.domain()},t.prototype.domain=function(t){return null==t?this._getDomain():(this._autoDomainAutomatically=!1,this._setDomain(t),this)},t.prototype._getDomain=function(){throw new Error("Subclasses should override _getDomain")},t.prototype._setDomain=function(t){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(t),this._dispatchUpdate(),this._domainModificationInProgress=!1)},t.prototype._backingScaleDomain=function(t){throw new Error("Subclasses should override _backingDomain")},t.prototype.range=function(t){return null==t?this._getRange():(this._setRange(t),this)},t.prototype._getRange=function(){throw new Error("Subclasses should override _getRange")},t.prototype._setRange=function(t){throw new Error("Subclasses should override _setRange")},t.prototype.addIncludedValuesProvider=function(t){return this._includedValuesProviders.add(t),this.autoDomainIfAutomaticMode(),this},t.prototype.removeIncludedValuesProvider=function(t){return this._includedValuesProviders.delete(t),this.autoDomainIfAutomaticMode(),this},t.prototype.updateId=function(){return this._updateId},t})();e.Scale=n})),xmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=[0,1],i=(function(t){function e(){var i=t.call(this)||this;return i._range=[0,1],i._d3Scale=Uht.scaleBand(),i._d3Scale.range(n),i._d3TransformationScale=Uht.scaleLinear(),i._d3TransformationScale.domain(n),i._innerPadding=e._convertToPlottableInnerPadding(.3),i._outerPadding=e._convertToPlottableOuterPadding(.5,.3),i}return Sft.__extends(e,t),e.prototype.cloneWithoutProviders=function(){var t=(new e).domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());return t._d3TransformationScale.domain(this._d3TransformationScale.domain()),t},e.prototype.extentOfValues=function(t){return umt.Array.uniq(t)},e.prototype._getExtent=function(){return umt.Array.uniq(this._getAllIncludedValues())},e.prototype.domain=function(e){return t.prototype.domain.call(this,e)},e.prototype.invertRange=function(t){var e=this;void 0===t&&(t=this.range());var n=this._d3Scale.bandwidth(),i=this.invertedTransformation(t[0]),r=this.invertedTransformation(t[1]),o=this._d3Scale.domain(),a=o.map((function(t){return e._d3Scale(t)+n/2})),s=Uht.bisect(a,i),l=Uht.bisect(a,r);return o.slice(s,l)},e.prototype.range=function(e){return t.prototype.range.call(this,e)},e._convertToPlottableInnerPadding=function(t){return 1/(1-t)-1},e._convertToPlottableOuterPadding=function(t,e){return t/(1-e)},e.prototype._setBands=function(){var t=1-1/(1+this.innerPadding()),e=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(t),this._d3Scale.paddingOuter(e)},e.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())},e.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))},e.prototype.ticks=function(){return this.domain()},e.prototype.innerPadding=function(t){return null==t?this._innerPadding:(this._innerPadding=t,this.range(this.range()),this._dispatchUpdate(),this)},e.prototype.outerPadding=function(t){return null==t?this._outerPadding:(this._outerPadding=t,this.range(this.range()),this._dispatchUpdate(),this)},e.prototype.scale=function(t){var e=this._d3Scale(t)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(e)},e.prototype.zoom=function(t,e){var n=this;this._d3TransformationScale.domain(this._d3TransformationScale.range().map((function(i){return n._d3TransformationScale.invert(vmt.zoomOut(i,t,e))}))),this._dispatchUpdate()},e.prototype.pan=function(t){var e=this;this._d3TransformationScale.domain(this._d3TransformationScale.range().map((function(n){return e._d3TransformationScale.invert(n+t)}))),this._dispatchUpdate()},e.prototype.scaleTransformation=function(t){return this._d3TransformationScale(t)},e.prototype.invertedTransformation=function(t){return this._d3TransformationScale.invert(t)},e.prototype.getTransformationExtent=function(){return n},e.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()},e.prototype.setTransformationDomain=function(t){this._d3TransformationScale.domain(t),this._dispatchUpdate()},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this._setBands(),this)},e.prototype._getRange=function(){return this._range},e.prototype._setRange=function(t){this._range=t,this._d3TransformationScale.range(t),this._setBands()},e.prototype._rescaleBand=function(t){return Math.abs(this._d3TransformationScale(t)-this._d3TransformationScale(0))},e})(bmt.Scale);e.Category=i})),wmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this.count=0,this.tracker={}}return t.prototype.getIndex=function(t){if(null!=this.tracker[t])return this.tracker[t];var e=this.count;return this.tracker[t]=e,this.count+=1,e},t.prototype.clear=function(){this.count=0,this.tracker={}},t})(),i=(function(t){function e(i){var r,o=t.call(this)||this;switch(o._rangeLength=1,o._tracker=new n,i){case null:case void 0:null==e._plottableColorCache&&(e._plottableColorCache=e._getPlottableColors()),r=Uht.scaleOrdinal().range(e._plottableColorCache);break;case"Category10":case"category10":case"10":r=Uht.scaleOrdinal(Uht.schemeCategory10);break;case"Category20":case"category20":case"20":r=Uht.scaleOrdinal(Uht.schemeCategory20);break;case"Category20b":case"category20b":case"20b":r=Uht.scaleOrdinal(Uht.schemeCategory20b);break;case"Category20c":case"category20c":case"20c":r=Uht.scaleOrdinal(Uht.schemeCategory20c);break;default:throw new Error("Unsupported ColorScale type")}return o._d3Scale=r,o._rangeLength=o._d3Scale.range().length,o}return Sft.__extends(e,t),e.prototype.extentOfValues=function(t){return umt.Array.uniq(t)},e.prototype._getExtent=function(){return umt.Array.uniq(this._getAllIncludedValues())},e.invalidateColorCache=function(){e._plottableColorCache=null},e._getPlottableColors=function(){for(var t=[],e=Uht.select("body").append("plottable-color-tester"),n=umt.Color.colorTest(e,""),i=0,r=umt.Color.colorTest(e,"plottable-colors-0");null!=r&&i<this._MAXIMUM_COLORS_FROM_CSS&&(r!==n||r!==t[t.length-1]);)t.push(r),i++,r=umt.Color.colorTest(e,"plottable-colors-"+i);return e.remove(),t},e.prototype.scale=function(t){var n=this._d3Scale(t),i=this._tracker.getIndex(t),r=Math.floor(i/this._rangeLength);if(0===r)return n;var o=Math.log(r*e._LOOP_LIGHTEN_FACTOR+1);return umt.Color.lightenColor(n,o)},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this._tracker.clear(),this)},e.prototype._getRange=function(){return this._d3Scale.range()},e.prototype._setRange=function(t){this._d3Scale.range(t),this._rangeLength=t.length},e._LOOP_LIGHTEN_FACTOR=1.6,e._MAXIMUM_COLORS_FROM_CSS=256,e})(bmt.Scale);e.Color=i})),Smt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(n){void 0===n&&(n="linear");var i=t.call(this)||this;switch(n){case"linear":i._colorScale=Uht.scaleLinear();break;case"log":i._colorScale=Uht.scaleLog();break;case"sqrt":i._colorScale=Uht.scaleSqrt();break;case"pow":i._colorScale=Uht.scalePow()}if(null==i._colorScale)throw new Error("unknown QuantitativeScale scale type "+n);return i.range(e.REDS),i}return Sft.__extends(e,t),e.prototype.extentOfValues=function(t){var e=Uht.extent(t);return null==e[0]||null==e[1]?[]:e},e.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())},e.prototype._interpolateColors=function(){var t=this._colorRange;if(t.length<2)throw new Error("Color scale arrays must have at least two elements.");return function(e,n){return function(e){var n=(e=Math.max(0,Math.min(1,e)))*(t.length-1),i=Math.floor(n),r=Math.ceil(n),o=n-i;return Uht.interpolateLab(t[i],t[r])(o)}}},e.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale(),this.autoDomainIfAutomaticMode(),this._dispatchUpdate()},e.prototype.autoDomain=function(){var t=this._getAllIncludedValues();return t.length>0&&this._setDomain([umt.Math.min(t,0),umt.Math.max(t,0)]),this},e.prototype.scale=function(t){return this._d3Scale(t)},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this)},e.prototype._getRange=function(){return this._colorRange},e.prototype._setRange=function(t){this._colorRange=t,this._resetScale()},e.REDS=["#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],e.BLUES=["#FFFFFF","#CCFFFF","#A5FFFD","#85F7FB","#6ED3EF","#55A7E0","#417FD0","#2545D3","#0B02E1"],e.POSNEG=["#0B02E1","#2545D3","#417FD0","#55A7E0","#6ED3EF","#85F7FB","#A5FFFD","#CCFFFF","#FFFFFF","#FFF6E1","#FEF4C0","#FED976","#FEB24C","#FD8D3C","#FC4E2A","#E31A1C","#B10026"],e})(bmt.Scale);e.InterpolatedColor=n})),Mmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._tickGenerator=function(t){return t.defaultTicks()},e._padProportion=.05,e._snappingDomainEnabled=!0,e._paddingExceptionsProviders=new umt.Set,e}return Sft.__extends(e,t),e.prototype.autoDomain=function(){return this._domainMin=null,this._domainMax=null,t.prototype.autoDomain.call(this),this},e.prototype.autoDomainIfAutomaticMode=function(){if(null==this._domainMin||null==this._domainMax){var e=this._getExtent();if(null!=this._domainMin){var n=e[1];return this._domainMin>=n&&(n=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),void this._setDomain([this._domainMin,n])}if(null!=this._domainMax){var i=e[0];return this._domainMax<=i&&(i=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),void this._setDomain([i,this._domainMax])}t.prototype.autoDomainIfAutomaticMode.call(this)}else this._setDomain([this._domainMin,this._domainMax])},e.prototype._getUnboundedExtent=function(t){void 0===t&&(t=!1);var e=this._getAllIncludedValues(t),n=this._defaultExtent();if(0!==e.length){var i=[umt.Math.min(e,n[0]),umt.Math.max(e,n[1])];n=this._padDomain(i)}return n},e.prototype._getExtent=function(){var t=this._getUnboundedExtent();return null!=this._domainMin&&(t[0]=this._domainMin),null!=this._domainMax&&(t[1]=this._domainMax),t},e.prototype.addPaddingExceptionsProvider=function(t){return this._paddingExceptionsProviders.add(t),this.autoDomainIfAutomaticMode(),this},e.prototype.removePaddingExceptionsProvider=function(t){return this._paddingExceptionsProviders.delete(t),this.autoDomainIfAutomaticMode(),this},e.prototype.padProportion=function(t){if(null==t)return this._padProportion;if(t<0)throw new Error("padProportion must be non-negative");return this._padProportion=t,this.autoDomainIfAutomaticMode(),this},e.prototype._padDomain=function(t){var e=this;if(t[0].valueOf()===t[1].valueOf())return this._expandSingleValueDomain(t);if(0===this._padProportion)return t;var n=this._padProportion/2,i=t[0],r=t[1],o=!1,a=!1;this._paddingExceptionsProviders.forEach((function(t){t(e).forEach((function(t){t.valueOf()===i.valueOf()&&(o=!0),t.valueOf()===r.valueOf()&&(a=!0)}))}));var s=this._backingScaleDomain();this._backingScaleDomain(t);var l=o?i:this.invert(this.scale(i)-(this.scale(r)-this.scale(i))*n),c=a?r:this.invert(this.scale(r)+(this.scale(r)-this.scale(i))*n);return this._backingScaleDomain(s),this._snappingDomainEnabled?this._niceDomain([l,c]):[l,c]},e.prototype.snappingDomainEnabled=function(t){return null==t?this._snappingDomainEnabled:(this._snappingDomainEnabled=t,this.autoDomainIfAutomaticMode(),this)},e.prototype._expandSingleValueDomain=function(t){return t},e.prototype.invert=function(t){throw new Error("Subclasses should override invert")},e.prototype.domain=function(e){return null!=e&&(this._domainMin=e[0],this._domainMax=e[1]),t.prototype.domain.call(this,e)},e.prototype.domainMin=function(t){return null==t?this.domain()[0]:(this._domainMin=t,this.autoDomainIfAutomaticMode(),this)},e.prototype.domainMax=function(t){return null==t?this.domain()[1]:(this._domainMax=t,this.autoDomainIfAutomaticMode(),this)},e.prototype.extentOfValues=function(t){var e=Uht.extent(t.filter((function(t){return umt.Math.isValidNumber(+t)})));return null==e[0]||null==e[1]?[]:e},e.prototype.zoom=function(t,e){var n=this;this.domain(this.range().map((function(i){return n.invert(vmt.zoomOut(i,t,e))})))},e.prototype.pan=function(t){var e=this;this.domain(this.range().map((function(n){return e.invert(n+t)})))},e.prototype.scaleTransformation=function(t){throw new Error("Subclasses should override scaleTransformation")},e.prototype.invertedTransformation=function(t){throw new Error("Subclasses should override invertedTransformation")},e.prototype.getTransformationExtent=function(){throw new Error("Subclasses should override getTransformationExtent")},e.prototype.getTransformationDomain=function(){throw new Error("Subclasses should override getTransformationDomain")},e.prototype.setTransformationDomain=function(t){throw new Error("Subclasses should override setTransformationDomain")},e.prototype._setDomain=function(e){var n=function(t){return umt.Math.isNaN(t)||t===1/0||t===-1/0};n(e[0])||n(e[1])?umt.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring."):t.prototype._setDomain.call(this,e)},e.prototype.defaultTicks=function(){throw new Error("Subclasses should override _getDefaultTicks")},e.prototype.ticks=function(){return this._tickGenerator(this)},e.prototype._niceDomain=function(t,e){throw new Error("Subclasses should override _niceDomain")},e.prototype._defaultExtent=function(){throw new Error("Subclasses should override _defaultExtent")},e.prototype.tickGenerator=function(t){return null==t?this._tickGenerator:(this._tickGenerator=t,this)},e._DEFAULT_NUM_TICKS=10,e})(bmt.Scale);e.QuantitativeScale=n})),Emt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._d3Scale=Uht.scaleLinear(),e}return Sft.__extends(e,t),e.prototype._defaultExtent=function(){return[0,1]},e.prototype._expandSingleValueDomain=function(t){return t[0]===t[1]?[t[0]-1,t[1]+1]:t},e.prototype.scale=function(t){return this._d3Scale(t)},e.prototype.scaleTransformation=function(t){return this.scale(t)},e.prototype.invertedTransformation=function(t){return this.invert(t)},e.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},e.prototype.getTransformationDomain=function(){return this.domain()},e.prototype.setTransformationDomain=function(t){this.domain(t)},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this)},e.prototype._getRange=function(){return this._d3Scale.range()},e.prototype._setRange=function(t){this._d3Scale.range(t)},e.prototype.invert=function(t){return this._d3Scale.invert(t)},e.prototype.defaultTicks=function(){return this._d3Scale.ticks(e._DEFAULT_NUM_TICKS)},e.prototype._niceDomain=function(t,e){return this._d3Scale.copy().domain(t).nice(e).domain()},e})(Mmt.QuantitativeScale);e.Linear=n})),Tmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e=10);var n=t.call(this)||this;return n._d3Scale=Uht.scaleLog().base(e),n._setDomain(n._defaultExtent()),n}return Sft.__extends(e,t),e.prototype._defaultExtent=function(){return[1,this._d3Scale.base()]},e.prototype._expandSingleValueDomain=function(t){return t[0]===t[1]?[t[0]/this._d3Scale.base(),t[1]*this._d3Scale.base()]:t},e.prototype.scale=function(t){return this._d3Scale(t)},e.prototype.scaleTransformation=function(t){return this.scale(t)},e.prototype.invertedTransformation=function(t){return this.invert(t)},e.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},e.prototype.getTransformationDomain=function(){return this.domain()},e.prototype.setTransformationDomain=function(t){this.domain(t)},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this)},e.prototype._getRange=function(){return this._d3Scale.range()},e.prototype._setRange=function(t){this._d3Scale.range(t)},e.prototype.invert=function(t){return this._d3Scale.invert(t)},e.prototype.defaultTicks=function(){return this._d3Scale.ticks(e._DEFAULT_NUM_TICKS)},e.prototype._niceDomain=function(t,e){return this._d3Scale.copy().domain(t).nice().domain()},e})(Mmt.QuantitativeScale);e.Log=n})),Amt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e=10);var n=t.call(this)||this;if(n._logTickGenerator=function(t){var e=function(t,e,n){return[t,e,n].sort((function(t,e){return t-e}))[1]},i=umt.Math.min(n._untransformedDomain,0),r=umt.Math.max(n._untransformedDomain,0),o=i,a=e(i,r,-n._pivot),s=e(i,r,n._pivot),l=r,c=n._logTicks(-a,-o).map((function(t){return-t})).reverse(),u=n._logTicks(s,l),h=Math.max(i,-n._pivot),d=Math.min(r,n._pivot),p=Uht.scaleLinear().domain([h,d]).ticks(n._howManyTicks(h,d)),f=c.concat(p).concat(u);return f.length<=1&&(f=Uht.scaleLinear().domain([i,r]).ticks(kmt.ModifiedLog._DEFAULT_NUM_TICKS)),f},n._d3Scale=Uht.scaleLinear(),n._base=e,n._pivot=n._base,n._setDomain(n._defaultExtent()),n.tickGenerator(n._logTickGenerator),e<=1)throw new Error("ModifiedLogScale: The base must be > 1");return n}return Sft.__extends(e,t),e.prototype._adjustedLog=function(t){var e=t<0?-1:1;return(t*=e)<this._pivot&&(t+=(this._pivot-t)/this._pivot),(t=Math.log(t)/Math.log(this._base))*e},e.prototype._invertedAdjustedLog=function(t){var e=t<0?-1:1;return t*=e,(t=Math.pow(this._base,t))<this._pivot&&(t=this._pivot*(t-1)/(this._pivot-1)),t*e},e.prototype.scale=function(t){return this._d3Scale(this._adjustedLog(t))},e.prototype.invert=function(t){return this._invertedAdjustedLog(this._d3Scale.invert(t))},e.prototype.scaleTransformation=function(t){return this.scale(t)},e.prototype.invertedTransformation=function(t){return this.invert(t)},e.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)},e.prototype.getTransformationDomain=function(){return this.domain()},e.prototype.setTransformationDomain=function(t){this.domain(t)},e.prototype._getDomain=function(){return this._untransformedDomain},e.prototype._setDomain=function(e){this._untransformedDomain=e;var n=[this._adjustedLog(e[0]),this._adjustedLog(e[1])];t.prototype._setDomain.call(this,n)},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this)},e.prototype._logTicks=function(t,e){var n=this,i=this._howManyTicks(t,e);if(0===i)return[];var r=Math.floor(Math.log(t)/Math.log(this._base)),o=Math.ceil(Math.log(e)/Math.log(this._base)),a=Uht.range(o,r,-Math.ceil((o-r)/i)),s=Uht.range(this._base,1,-(this._base-1)).map(Math.floor),l=umt.Array.uniq(s),c=a.map((function(t){return l.map((function(e){return Math.pow(n._base,t-1)*e}))}));return umt.Array.flatten(c).filter((function(n){return t<=n&&n<=e})).sort((function(t,e){return t-e}))},e.prototype._howManyTicks=function(t,e){var n=this._adjustedLog(umt.Math.min(this._untransformedDomain,0)),i=this._adjustedLog(umt.Math.max(this._untransformedDomain,0)),r=this._adjustedLog(t),o=this._adjustedLog(e);return Math.ceil((o-r)/(i-n)*kmt.ModifiedLog._DEFAULT_NUM_TICKS)},e.prototype._niceDomain=function(t,e){return t},e.prototype._defaultExtent=function(){return[0,this._base]},e.prototype._expandSingleValueDomain=function(t){if(t[0]===t[1]){var e=t[0];return e>0?[e/this._base,e*this._base]:0===e?[-this._base,this._base]:[e*this._base,e/this._base]}return t},e.prototype._getRange=function(){return this._d3Scale.range()},e.prototype._setRange=function(t){this._d3Scale.range(t)},e.prototype.defaultTicks=function(){return this._d3Scale.ticks(kmt.ModifiedLog._DEFAULT_NUM_TICKS)},e})(Mmt.QuantitativeScale);e.ModifiedLog=n})),Cmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._d3Scale=Uht.scaleTime(),e.autoDomain(),e}return Sft.__extends(e,t),e.prototype.tickInterval=function(t,n,i){void 0===n&&(n=1),void 0===i&&(i=!1);var r=Uht.scaleTime(),o=e.timeIntervalToD3Time(t,i).every(n);return r.domain(this.domain()),r.range(this.range()),r.ticks(o)},e.prototype._setDomain=function(e){if(e[1]<e[0])throw new Error("Scale.Time domain values must be in chronological order");return t.prototype._setDomain.call(this,e)},e.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]},e.prototype._expandSingleValueDomain=function(t){var e=t[0].getTime(),n=t[1].getTime();if(e===n){var i=new Date(e);i.setDate(i.getDate()-1);var r=new Date(n);return r.setDate(r.getDate()+1),[i,r]}return t},e.prototype.scale=function(t){return this._d3Scale(t)},e.prototype.scaleTransformation=function(t){return this.scale(new Date(t))},e.prototype.invertedTransformation=function(t){return this.invert(t).getTime()},e.prototype.getTransformationExtent=function(){var t=this._getUnboundedExtent(!0);return[t[0].valueOf(),t[1].valueOf()]},e.prototype.getTransformationDomain=function(){var t=this.domain();return[t[0].valueOf(),t[1].valueOf()]},e.prototype.setTransformationDomain=function(t){var e=t[1];this.domain([new Date(t[0]),new Date(e)])},e.prototype._getDomain=function(){return this._backingScaleDomain()},e.prototype._backingScaleDomain=function(t){return null==t?this._d3Scale.domain():(this._d3Scale.domain(t),this)},e.prototype._getRange=function(){return this._d3Scale.range()},e.prototype._setRange=function(t){this._d3Scale.range(t)},e.prototype.invert=function(t){return this._d3Scale.invert(t)},e.prototype.defaultTicks=function(){return this._d3Scale.ticks(e._DEFAULT_NUM_TICKS)},e.prototype._niceDomain=function(t){return this._d3Scale.copy().domain(t).nice().domain()},e.timeIntervalToD3Time=function(t,e){switch(t){case Lmt.TimeInterval.second:return e?Uht.utcSecond:Uht.timeSecond;case Lmt.TimeInterval.minute:return e?Uht.utcMinute:Uht.timeMinute;case Lmt.TimeInterval.hour:return e?Uht.utcHour:Uht.timeHour;case Lmt.TimeInterval.day:return e?Uht.utcDay:Uht.timeDay;case Lmt.TimeInterval.week:return e?Uht.utcWeek:Uht.timeWeek;case Lmt.TimeInterval.month:return e?Uht.utcMonth:Uht.timeMonth;case Lmt.TimeInterval.year:return e?Uht.utcYear:Uht.timeYear;default:throw Error("TimeInterval specified does not exist: "+t)}},e})(Mmt.QuantitativeScale);e.Time=n})),kmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.TickGenerators=ymt,Sft.__exportStar(xmt,e),Sft.__exportStar(wmt,e),Sft.__exportStar(Smt,e),Sft.__exportStar(Emt,e),Sft.__exportStar(Tmt,e),Sft.__exportStar(Amt,e),Sft.__exportStar(Cmt,e);var n=xmt;e.isTransformable=function i(t){return t instanceof Mmt.QuantitativeScale||t instanceof n.Category}})),Lmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.TimeInterval=vft.makeEnum(["second","minute","hour","day","week","month","year"]),e.TimeAxisOrientation=vft.makeEnum(["top","bottom"]),e.TierLabelPosition=vft.makeEnum(["between","center"]);var n,i=(function(t){function i(e,n,r){var o=t.call(this,e,n)||this;return o._maxTimeIntervalPrecision=null,o._tierLabelPositions=[],o._useUTC=r,o.addClass("time-axis"),o.tickLabelPadding(5),o.axisConfigurations(i._DEFAULT_TIME_AXIS_CONFIGURATIONS(o._useUTC)),o.annotationFormatter(fmt.time("%a %b %d, %Y",o._useUTC)),o}return Sft.__extends(i,t),i.prototype.tierLabelPositions=function(t){if(null==t)return this._tierLabelPositions;if(!t.every((function(t){return"between"===t.toLowerCase()||"center"===t.toLowerCase()})))throw new Error("Unsupported position for tier labels");return this._tierLabelPositions=t,this.redraw(),this},i.prototype.maxTimeIntervalPrecision=function(t){return null==t?this._maxTimeIntervalPrecision:(this._maxTimeIntervalPrecision=t,this.redraw(),this)},i.prototype.currentAxisConfiguration=function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]},i.prototype.axisConfigurations=function(t){if(null==t)return this._possibleTimeAxisConfigurations;this._possibleTimeAxisConfigurations=t,this._numTiers=umt.Math.max(this._possibleTimeAxisConfigurations.map((function(t){return t.length})),0),this._isAnchored&&this._setupDomElements();for(var e=this.tierLabelPositions(),n=[],i=0;i<this._numTiers;i++)n.push(e[i]||"between");return this.tierLabelPositions(n),this.redraw(),this},i.prototype._getMostPreciseConfigurationIndex=function(){var t=this,e=this._possibleTimeAxisConfigurations.length;return this._possibleTimeAxisConfigurations.forEach((function(n,i){i<e&&n.every((function(e){return t._checkTimeAxisTierConfiguration(e)}))&&(e=i)})),e===this._possibleTimeAxisConfigurations.length&&(umt.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--e),e},i.prototype.orientation=function(e){if(e&&("right"===e.toLowerCase()||"left"===e.toLowerCase()))throw new Error(e+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");return t.prototype.orientation.call(this,e)},i.prototype._computeHeight=function(){var t=this._measurer.measure().height;this._tierHeights=[];for(var e=0;e<this._numTiers;e++)this._tierHeights.push(t+this.tickLabelPadding()+("between"===this._tierLabelPositions[e]?0:this._maxLabelTickLength()));return Uht.sum(this._tierHeights)},i.prototype._getIntervalLength=function(t){var e=this._scale.domain()[0],n=kmt.Time.timeIntervalToD3Time(t.interval,this._useUTC).offset(e,t.step);return n>this._scale.domain()[1]?this.width():Math.abs(this._scale.scale(n)-this._scale.scale(e))},i.prototype._maxWidthForInterval=function(t){return this._measurer.measure(t.formatter(i._LONG_DATE)).width},i.prototype._checkTimeAxisTierConfiguration=function(t){if(null!=this._maxTimeIntervalPrecision){var e=i._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],n=i._SORTED_TIME_INTERVAL_INDEX[t.interval];if(null!=e&&null!=n&&n<e)return!1}var r=this._maxWidthForInterval(t)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(t),this.width())>=r},i.prototype._sizeFromOffer=function(e,n){var i=t.prototype._sizeFromOffer.call(this,e,n),r=this._tierHeights.reduce((function(t,e,n,r){return t+e>i.height?t:t+e})),o=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);return i.height=Math.min(i.height,r+o),i},i.prototype._setup=function(){t.prototype._setup.call(this),this._setupDomElements()},i.prototype._setupDomElements=function(){this.content().selectAll("."+i.TIME_AXIS_TIER_CLASS).remove(),this._tierLabelContainers=[],this._tierMarkContainers=[],this._tierBaselines=[],this._tickLabelContainer.remove(),this._baseline.remove();for(var t=0;t<this._numTiers;++t){var e=this.content().append("g").classed(i.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(e.append("g").classed(mmt.Axis.TICK_LABEL_CLASS+"-container",!0)),this._tierMarkContainers.push(e.append("g").classed(mmt.Axis.TICK_MARK_CLASS+"-container",!0)),this._tierBaselines.push(e.append("line").classed("baseline",!0))}var n=new qft.SvgContext(this._tierLabelContainers[0].node());this._measurer=new qft.CacheMeasurer(n)},i.prototype._getTickIntervalValues=function(t){return this._scale.tickInterval(t.interval,t.step,this._useUTC)},i.prototype._getTickValues=function(){var t=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce((function(e,n){return e.concat(t._getTickIntervalValues(n))}),[])},i.prototype._cleanTiers=function(){for(var t=0;t<this._tierLabelContainers.length;t++)this._tierLabelContainers[t].selectAll("."+mmt.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[t].selectAll("."+mmt.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[t].style("visibility","hidden")},i.prototype._getTickValuesForConfiguration=function(t){var e=this._scale.tickInterval(t.interval,t.step,this._useUTC),n=this._scale.domain(),i=e.map((function(t){return t.valueOf()}));return-1===i.indexOf(n[0].valueOf())&&e.unshift(n[0]),-1===i.indexOf(n[1].valueOf())&&e.push(n[1]),e},i.prototype._renderTierLabels=function(t,e,n){var i=this,r=this._getTickValuesForConfiguration(e),o=[];"between"===this._tierLabelPositions[n]&&1===e.step?r.map((function(t,e){e+1>=r.length||o.push(new Date((r[e+1].valueOf()-r[e].valueOf())/2+r[e].valueOf()))})):o=r;var a=t.selectAll("."+mmt.Axis.TICK_LABEL_CLASS).data(o,(function(t){return String(t.valueOf())})),s=a.enter().append("g").classed(mmt.Axis.TICK_LABEL_CLASS,!0);s.append("text");var l,c="center"===this._tierLabelPositions[n]||1===e.step?0:this.tickLabelPadding();l="bottom"===this.orientation()?Uht.sum(this._tierHeights.slice(0,n+1))-this.tickLabelPadding():"center"===this._tierLabelPositions[n]?this.height()-Uht.sum(this._tierHeights.slice(0,n))-this.tickLabelPadding()-this._maxLabelTickLength():this.height()-Uht.sum(this._tierHeights.slice(0,n))-this.tickLabelPadding();var u=a.merge(s),h=u.selectAll("text");h.size()>0&&h.attr("transform","translate("+c+","+l+")"),a.exit().remove(),u.attr("transform",(function(t){return"translate("+i._scale.scale(t)+",0)"}));var d="center"===this._tierLabelPositions[n]||1===e.step?"middle":"start";u.selectAll("text").text(e.formatter).style("text-anchor",d)},i.prototype._renderTickMarks=function(t,e){var n=this._tierMarkContainers[e].selectAll("."+mmt.Axis.TICK_MARK_CLASS).data(t),i=n.enter().append("line").classed(mmt.Axis.TICK_MARK_CLASS,!0).merge(n),r=this._generateTickMarkAttrHash(),o=this._tierHeights.slice(0,e).reduce((function(t,e){return t+e}),0);"bottom"===this.orientation()?(r.y1=o,r.y2=o+("center"===this._tierLabelPositions[e]?this.innerTickLength():this._tierHeights[e])):(r.y1=this.height()-o,r.y2=this.height()-(o+("center"===this._tierLabelPositions[e]?this.innerTickLength():this._tierHeights[e]))),i.attrs(r),"bottom"===this.orientation()?(r.y1=o,r.y2=o+("center"===this._tierLabelPositions[e]?this.endTickLength():this._tierHeights[e])):(r.y1=this.height()-o,r.y2=this.height()-(o+("center"===this._tierLabelPositions[e]?this.endTickLength():this._tierHeights[e]))),Uht.select(i.nodes()[0]).attrs(r),Uht.select(i.nodes()[i.size()-1]).attrs(r),Uht.select(i.nodes()[0]).classed(mmt.Axis.END_TICK_MARK_CLASS,!0),Uht.select(i.nodes()[i.size()-1]).classed(mmt.Axis.END_TICK_MARK_CLASS,!0),n.exit().remove()},i.prototype._renderLabellessTickMarks=function(t){var e=this._tickMarkContainer.selectAll("."+mmt.Axis.TICK_MARK_CLASS).data(t),n=e.enter().append("line").classed(mmt.Axis.TICK_MARK_CLASS,!0).merge(e),i=this._generateTickMarkAttrHash();i.y2="bottom"===this.orientation()?this.tickLabelPadding():this.height()-this.tickLabelPadding(),n.attrs(i),e.exit().remove()},i.prototype._generateLabellessTicks=function(){return this._mostPreciseConfigIndex<1?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-1][0])},i.prototype.renderImmediately=function(){var t=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var e=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers(),e.forEach((function(e,n){return t._renderTierLabels(t._tierLabelContainers[n],e,n)}));for(var n=e.map((function(e,n){return t._getTickValuesForConfiguration(e)})),i=0,r=0;r<Math.max(e.length,1);++r){var o=this._generateBaselineAttrHash();o.y1+="bottom"===this.orientation()?i:-i,o.y2=o.y1,this._tierBaselines[r].attrs(o).style("visibility","inherit"),i+=this._tierHeights[r]}var a=[],s=this._scale.domain(),l=this._scale.scale(s[1])-this._scale.scale(s[0]);for(1.5*this._getIntervalLength(e[0])>=l&&(a=this._generateLabellessTicks()),this._renderLabellessTickMarks(a),this._hideOverflowingTiers(),r=0;r<e.length;++r)this._renderTickMarks(n[r],r),this._hideOverlappingAndCutOffLabels(r);return this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations(),this},i.prototype._hideOverflowingTiers=function(){var t=this,e=this.height(),n=0;this.content().selectAll("."+i.TIME_AXIS_TIER_CLASS).attr("visibility",(function(i,r){return(n+=t._tierHeights[r])<=e?"inherit":"hidden"}))},i.prototype._hideOverlappingAndCutOffLabels=function(t){var e,n=this,i=this.element().node().getBoundingClientRect(),r=this._tierMarkContainers[t].selectAll("."+mmt.Axis.TICK_MARK_CLASS).filter((function(t,e){var n=Uht.select(this).style("visibility");return"visible"===n||"inherit"===n})).nodes().map((function(t){return t.getBoundingClientRect()}));this._tierLabelContainers[t].selectAll("."+mmt.Axis.TICK_LABEL_CLASS).filter((function(t,e){var n=Uht.select(this).style("visibility");return"visible"===n||"inherit"===n})).each((function(t,o){var a,s=this.getBoundingClientRect(),l=Uht.select(this),c=r[o],u=r[o+1],h=null!=e&&umt.DOM.clientRectsOverlap(s,e),d=null!=c&&umt.DOM.clientRectsOverlap(s,c),p=null!=u&&umt.DOM.clientRectsOverlap(s,u);a=s,!(Math.floor(i.left)<=Math.ceil(a.left)&&Math.floor(i.top)<=Math.ceil(a.top)&&Math.floor(a.right)<=Math.ceil(i.left+n.width())&&Math.floor(a.bottom)<=Math.ceil(i.top+n.height()))||h||d||p?l.style("visibility","hidden"):(e=s,l.style("visibility","inherit"))}))},i.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},i.TIME_AXIS_TIER_CLASS="time-axis-tier",i._SORTED_TIME_INTERVAL_INDEX=((n={})[e.TimeInterval.second]=0,n[e.TimeInterval.minute]=1,n[e.TimeInterval.hour]=2,n[e.TimeInterval.day]=3,n[e.TimeInterval.week]=4,n[e.TimeInterval.month]=5,n[e.TimeInterval.year]=6,n),i._DEFAULT_TIME_AXIS_CONFIGURATIONS=function(t){var n=function(e){return fmt.time(e,t)};return[[{interval:e.TimeInterval.second,step:1,formatter:n("%I:%M:%S %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.second,step:5,formatter:n("%I:%M:%S %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.second,step:10,formatter:n("%I:%M:%S %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.second,step:15,formatter:n("%I:%M:%S %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.second,step:30,formatter:n("%I:%M:%S %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.minute,step:1,formatter:n("%I:%M %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.minute,step:5,formatter:n("%I:%M %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.minute,step:10,formatter:n("%I:%M %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.minute,step:15,formatter:n("%I:%M %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.minute,step:30,formatter:n("%I:%M %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.hour,step:1,formatter:n("%I %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.hour,step:3,formatter:n("%I %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.hour,step:6,formatter:n("%I %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.hour,step:12,formatter:n("%I %p")},{interval:e.TimeInterval.day,step:1,formatter:n("%B %e, %Y")}],[{interval:e.TimeInterval.day,step:1,formatter:n("%a %e")},{interval:e.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:e.TimeInterval.day,step:1,formatter:n("%e")},{interval:e.TimeInterval.month,step:1,formatter:n("%B %Y")}],[{interval:e.TimeInterval.month,step:1,formatter:n("%B")},{interval:e.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:e.TimeInterval.month,step:1,formatter:n("%b")},{interval:e.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:e.TimeInterval.month,step:3,formatter:n("%b")},{interval:e.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:e.TimeInterval.month,step:6,formatter:n("%b")},{interval:e.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:1,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:1,formatter:n("%y")}],[{interval:e.TimeInterval.year,step:5,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:25,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:50,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:100,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:200,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:500,formatter:n("%Y")}],[{interval:e.TimeInterval.year,step:1e3,formatter:n("%Y")}]]},i._LONG_DATE=new Date(9999,8,29,12,59,9999),i})(mmt.Axis);e.Time=i})),Pmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(gmt,e),Sft.__exportStar(_mt,e),Sft.__exportStar(Lmt,e)})),Imt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this._eventToProcessingFunction={},this._eventTarget=document,this._eventNameToCallbackSet={},this._connected=!1}return t.prototype._hasNoCallbacks=function(){for(var t=Object.keys(this._eventNameToCallbackSet),e=0;e<t.length;e++)if(0!==this._eventNameToCallbackSet[t[e]].size)return!1;return!0},t.prototype._connect=function(){var t=this;this._connected||(Object.keys(this._eventToProcessingFunction).forEach((function(e){t._eventTarget.addEventListener(e,t._eventToProcessingFunction[e],"wheel"===e?{passive:!1}:void 0)})),this._connected=!0)},t.prototype._disconnect=function(){var t=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach((function(e){t._eventTarget.removeEventListener(e,t._eventToProcessingFunction[e])})),this._connected=!1)},t.prototype._addCallbackForEvent=function(t,e){null==this._eventNameToCallbackSet[t]&&(this._eventNameToCallbackSet[t]=new umt.CallbackSet),this._eventNameToCallbackSet[t].add(e),this._connect()},t.prototype._removeCallbackForEvent=function(t,e){null!=this._eventNameToCallbackSet[t]&&this._eventNameToCallbackSet[t].delete(e),this._disconnect()},t.prototype._callCallbacksForEvent=function(t){for(var e=[],n=1;n<arguments.length;n++)e[n-1]=arguments[n];var i=this._eventNameToCallbackSet[t];null!=i&&i.callCallbacks.apply(i,e)},t})();e.Dispatcher=n})),Nmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var n=t.call(this)||this;return n._eventToProcessingFunction[e._KEYDOWN_EVENT_NAME]=function(t){return n._processKeydown(t)},n._eventToProcessingFunction[e._KEYUP_EVENT_NAME]=function(t){return n._processKeyup(t)},n}return Sft.__extends(e,t),e.getDispatcher=function(){var t=document[e._DISPATCHER_KEY];return null==t&&(t=new e,document[e._DISPATCHER_KEY]=t),t},e.prototype._processKeydown=function(t){this._callCallbacksForEvent(e._KEYDOWN_EVENT_NAME,t.keyCode,t)},e.prototype._processKeyup=function(t){this._callCallbacksForEvent(e._KEYUP_EVENT_NAME,t.keyCode,t)},e.prototype.onKeyDown=function(t){return this._addCallbackForEvent(e._KEYDOWN_EVENT_NAME,t),this},e.prototype.offKeyDown=function(t){return this._removeCallbackForEvent(e._KEYDOWN_EVENT_NAME,t),this},e.prototype.onKeyUp=function(t){return this._addCallbackForEvent(e._KEYUP_EVENT_NAME,t),this},e.prototype.offKeyUp=function(t){return this._removeCallbackForEvent(e._KEYUP_EVENT_NAME,t),this},e._DISPATCHER_KEY="__Plottable_Dispatcher_Key",e._KEYDOWN_EVENT_NAME="keydown",e._KEYUP_EVENT_NAME="keyup",e})(Imt.Dispatcher);e.Key=n})),Omt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(n){var i=t.call(this)||this;i._lastMousePosition={x:-1,y:-1},i._translator=umt.getTranslator(n);var r=function(t){return i._measureAndDispatch(n,t,e._MOUSEMOVE_EVENT_NAME,"page")};return i._eventToProcessingFunction[e._MOUSEOVER_EVENT_NAME]=r,i._eventToProcessingFunction[e._MOUSEMOVE_EVENT_NAME]=r,i._eventToProcessingFunction[e._MOUSEOUT_EVENT_NAME]=r,i._eventToProcessingFunction[e._MOUSEDOWN_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._MOUSEDOWN_EVENT_NAME)},i._eventToProcessingFunction[e._MOUSEUP_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._MOUSEUP_EVENT_NAME,"page")},i._eventToProcessingFunction[e._WHEEL_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._WHEEL_EVENT_NAME)},i._eventToProcessingFunction[e._DBLCLICK_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._DBLCLICK_EVENT_NAME)},i}return Sft.__extends(e,t),e.getDispatcher=function(t){var n=t.root().rootElement(),i=n[e._DISPATCHER_KEY];return null==i&&(i=new e(t),n[e._DISPATCHER_KEY]=i),i},e.prototype.onMouseMove=function(t){return this._addCallbackForEvent(e._MOUSEMOVE_EVENT_NAME,t),this},e.prototype.offMouseMove=function(t){return this._removeCallbackForEvent(e._MOUSEMOVE_EVENT_NAME,t),this},e.prototype.onMouseDown=function(t){return this._addCallbackForEvent(e._MOUSEDOWN_EVENT_NAME,t),this},e.prototype.offMouseDown=function(t){return this._removeCallbackForEvent(e._MOUSEDOWN_EVENT_NAME,t),this},e.prototype.onMouseUp=function(t){return this._addCallbackForEvent(e._MOUSEUP_EVENT_NAME,t),this},e.prototype.offMouseUp=function(t){return this._removeCallbackForEvent(e._MOUSEUP_EVENT_NAME,t),this},e.prototype.onWheel=function(t){return this._addCallbackForEvent(e._WHEEL_EVENT_NAME,t),this},e.prototype.offWheel=function(t){return this._removeCallbackForEvent(e._WHEEL_EVENT_NAME,t),this},e.prototype.onDblClick=function(t){return this._addCallbackForEvent(e._DBLCLICK_EVENT_NAME,t),this},e.prototype.offDblClick=function(t){return this._removeCallbackForEvent(e._DBLCLICK_EVENT_NAME,t),this},e.prototype._measureAndDispatch=function(t,e,n,i){if(void 0===i&&(i="element"),"page"!==i&&"element"!==i)throw new Error("Invalid scope '"+i+"', must be 'element' or 'page'");if("page"===i||this.eventInside(t,e)){var r=this._translator.computePosition(e.clientX,e.clientY);this._lastMousePosition=r,this._callCallbacksForEvent(n,this.lastMousePosition(),e)}},e.prototype.eventInside=function(t,e){return umt.Translator.isEventInside(t,e)},e.prototype.lastMousePosition=function(){return this._lastMousePosition},e._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse",e._MOUSEOVER_EVENT_NAME="mouseover",e._MOUSEMOVE_EVENT_NAME="mousemove",e._MOUSEOUT_EVENT_NAME="mouseout",e._MOUSEDOWN_EVENT_NAME="mousedown",e._MOUSEUP_EVENT_NAME="mouseup",e._WHEEL_EVENT_NAME="wheel",e._DBLCLICK_EVENT_NAME="dblclick",e})(Imt.Dispatcher);e.Mouse=n})),Rmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(n){var i=t.call(this)||this;return i._translator=umt.getTranslator(n),i._eventToProcessingFunction[e._TOUCHSTART_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._TOUCHSTART_EVENT_NAME,"page")},i._eventToProcessingFunction[e._TOUCHMOVE_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._TOUCHMOVE_EVENT_NAME,"page")},i._eventToProcessingFunction[e._TOUCHEND_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._TOUCHEND_EVENT_NAME,"page")},i._eventToProcessingFunction[e._TOUCHCANCEL_EVENT_NAME]=function(t){return i._measureAndDispatch(n,t,e._TOUCHCANCEL_EVENT_NAME,"page")},i}return Sft.__extends(e,t),e.getDispatcher=function(t){var n=t.root().rootElement(),i=n[e._DISPATCHER_KEY];return null==i&&(i=new e(t),n[e._DISPATCHER_KEY]=i),i},e.prototype.onTouchStart=function(t){return this._addCallbackForEvent(e._TOUCHSTART_EVENT_NAME,t),this},e.prototype.offTouchStart=function(t){return this._removeCallbackForEvent(e._TOUCHSTART_EVENT_NAME,t),this},e.prototype.onTouchMove=function(t){return this._addCallbackForEvent(e._TOUCHMOVE_EVENT_NAME,t),this},e.prototype.offTouchMove=function(t){return this._removeCallbackForEvent(e._TOUCHMOVE_EVENT_NAME,t),this},e.prototype.onTouchEnd=function(t){return this._addCallbackForEvent(e._TOUCHEND_EVENT_NAME,t),this},e.prototype.offTouchEnd=function(t){return this._removeCallbackForEvent(e._TOUCHEND_EVENT_NAME,t),this},e.prototype.onTouchCancel=function(t){return this._addCallbackForEvent(e._TOUCHCANCEL_EVENT_NAME,t),this},e.prototype.offTouchCancel=function(t){return this._removeCallbackForEvent(e._TOUCHCANCEL_EVENT_NAME,t),this},e.prototype._measureAndDispatch=function(t,e,n,i){if(void 0===i&&(i="element"),"page"!==i&&"element"!==i)throw new Error("Invalid scope '"+i+"', must be 'element' or 'page'");if("element"!==i||this.eventInside(t,e)){for(var r=e.changedTouches,o={},a=[],s=0;s<r.length;s++){var l=r[s],c=l.identifier,u=this._translator.computePosition(l.clientX,l.clientY);null!=u&&(o[c]=u,a.push(c))}a.length>0&&this._callCallbacksForEvent(n,a,o,e)}},e.prototype.eventInside=function(t,e){return umt.Translator.isEventInside(t,e)},e._DISPATCHER_KEY="__Plottable_Dispatcher_Touch",e._TOUCHSTART_EVENT_NAME="touchstart",e._TOUCHMOVE_EVENT_NAME="touchmove",e._TOUCHEND_EVENT_NAME="touchend",e._TOUCHCANCEL_EVENT_NAME="touchcancel",e})(Imt.Dispatcher);e.Touch=n})),zmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(Nmt,e),Sft.__exportStar(Omt,e),Sft.__exportStar(Rmt,e)})),Dmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){var t=this;this._anchorCallback=function(e){return t._anchor(e)},this._enabled=!0}return t.prototype.attachTo=function(t){return this._disconnect(),this._componentAttachedTo=t,this._connect(),this},t.prototype.detachFrom=function(t){return this.detach()},t.prototype.detach=function(){return this._disconnect(),this._componentAttachedTo=null,this},t.prototype.enabled=function(t){return null==t?this._enabled:(this._enabled=t,this._enabled?this._connect():this._disconnect(),this)},t.prototype._anchor=function(t){this._isAnchored=!0},t.prototype._unanchor=function(){this._isAnchored=!1},t.prototype._translateToComponentSpace=function(t){var e=this._componentAttachedTo.originToRoot();return{x:t.x-e.x,y:t.y-e.y}},t.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<=this._componentAttachedTo.width()&&t.y<=this._componentAttachedTo.height()},t.prototype._connect=function(){this.enabled()&&null!=this._componentAttachedTo&&!this._isAnchored&&this._componentAttachedTo.onAnchor(this._anchorCallback)},t.prototype._disconnect=function(){this._isAnchored&&this._unanchor(),null!=this._componentAttachedTo&&this._componentAttachedTo.offAnchor(this._anchorCallback)},t})();e.Interaction=n})),Bmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._clickedDown=!1,e._doubleClicking=!1,e._onClickCallbacks=new umt.CallbackSet,e._onDoubleClickCallbacks=new umt.CallbackSet,e._mouseDownCallback=function(t,n){return e._handleClickDown(t,n)},e._mouseUpCallback=function(t,n){return e._handleClickUp(t,n)},e._dblClickCallback=function(t,n){return e._handleDblClick(t,n)},e._touchStartCallback=function(t,n,i){return e._handleClickDown(n[t[0]],i)},e._touchEndCallback=function(t,n,i){return e._handleClickUp(n[t[0]],i)},e._touchCancelCallback=function(t,n){return e._clickedDown=!1},e}return Sft.__extends(e,t),e.prototype._anchor=function(e){t.prototype._anchor.call(this,e),this._mouseDispatcher=zmt.Mouse.getDispatcher(e),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._mouseDispatcher.onDblClick(this._dblClickCallback),this._touchDispatcher=zmt.Touch.getDispatcher(e),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},e.prototype._unanchor=function(){t.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher.offDblClick(this._dblClickCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null},e.prototype._handleClickDown=function(t,e){var n=this._translateToComponentSpace(t);this._isInsideComponent(n)&&(this._clickedDown=!0,this._clickedPoint=n)},e.prototype._handleClickUp=function(t,n){var i=this,r=this._translateToComponentSpace(t);this._clickedDown&&e._pointsEqual(r,this._clickedPoint)&&setTimeout((function(){i._doubleClicking||i._onClickCallbacks.callCallbacks(r,n)}),0),this._clickedDown=!1},e.prototype._handleDblClick=function(t,e){var n=this,i=this._translateToComponentSpace(t);this._doubleClicking=!0,this._onDoubleClickCallbacks.callCallbacks(i,e),setTimeout((function(){return n._doubleClicking=!1}),0)},e._pointsEqual=function(t,e){return t.x===e.x&&t.y===e.y},e.prototype.onClick=function(t){return this._onClickCallbacks.add(t),this},e.prototype.offClick=function(t){return this._onClickCallbacks.delete(t),this},e.prototype.onDoubleClick=function(t){return this._onDoubleClickCallbacks.add(t),this},e.prototype.offDoubleClick=function(t){return this._onDoubleClickCallbacks.delete(t),this},e})(Dmt.Interaction);e.Click=n})),Hmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(n){var i=t.call(this)||this;return i._dragging=!1,i._constrainedToComponent=!0,i._mouseFilter=e._DEFAULT_MOUSE_FILTER,i._dragStartCallbacks=new umt.CallbackSet,i._dragCallbacks=new umt.CallbackSet,i._dragEndCallbacks=new umt.CallbackSet,i._mouseDownCallback=function(t,e){return i._startDrag(t,e)},i._mouseMoveCallback=function(t,e){return i._doDrag(t,e)},i._mouseUpCallback=function(t,e){return i._endDrag(t,e)},i._touchStartCallback=function(t,e,n){return i._startDrag(e[t[0]],n)},i._touchMoveCallback=function(t,e,n){return i._doDrag(e[t[0]],n)},i._touchEndCallback=function(t,e,n){return i._endDrag(e[t[0]],n)},i._mouseButton=void 0!==n?n:0,i}return Sft.__extends(e,t),e.prototype._anchor=function(e){t.prototype._anchor.call(this,e),this._mouseDispatcher=zmt.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseDown(this._mouseDownCallback),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._mouseDispatcher.onMouseUp(this._mouseUpCallback),this._touchDispatcher=zmt.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback)},e.prototype._unanchor=function(){t.prototype._unanchor.call(this),this._mouseDispatcher.offMouseDown(this._mouseDownCallback),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher.offMouseUp(this._mouseUpCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher=null},e.prototype._translateAndConstrain=function(t){var e=this._translateToComponentSpace(t);return this._constrainedToComponent?{x:umt.Math.clamp(e.x,0,this._componentAttachedTo.width()),y:umt.Math.clamp(e.y,0,this._componentAttachedTo.height())}:e},e.prototype._startDrag=function(t,e){if(!(e instanceof MouseEvent)||this._mouseFilter(e)){var n=this._translateToComponentSpace(t);this._isInsideComponent(n)&&(e.preventDefault(),this._dragging=!0,this._dragOrigin=n,this._dragStartCallbacks.callCallbacks(this._dragOrigin))}},e.prototype._doDrag=function(t,e){this._dragging&&this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(t))},e.prototype._endDrag=function(t,e){e instanceof MouseEvent&&e.button!==this._mouseButton||this._dragging&&(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(t)))},e.prototype.constrainedToComponent=function(t){return null==t?this._constrainedToComponent:(this._constrainedToComponent=t,this)},e.prototype.mouseFilter=function(t){return 0===arguments.length?this._mouseFilter:(this._mouseFilter=t,this)},e.prototype.onDragStart=function(t){return this._dragStartCallbacks.add(t),this},e.prototype.offDragStart=function(t){return this._dragStartCallbacks.delete(t),this},e.prototype.onDrag=function(t){return this._dragCallbacks.add(t),this},e.prototype.offDrag=function(t){return this._dragCallbacks.delete(t),this},e.prototype.onDragEnd=function(t){return this._dragEndCallbacks.add(t),this},e.prototype.offDragEnd=function(t){return this._dragEndCallbacks.delete(t),this},e._DEFAULT_MOUSE_FILTER=function(t){return 0===t.button},e})(Dmt.Interaction);e.Drag=n})),Fmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._keyPressCallbacks={},e._keyReleaseCallbacks={},e._mouseMoveCallback=function(t){return!1},e._downedKeys=new umt.Set,e._keyDownCallback=function(t,n){return e._handleKeyDownEvent(t,n)},e._keyUpCallback=function(t){return e._handleKeyUpEvent(t)},e}return Sft.__extends(e,t),e.prototype._anchor=function(e){t.prototype._anchor.call(this,e),this._positionDispatcher=zmt.Mouse.getDispatcher(this._componentAttachedTo),this._positionDispatcher.onMouseMove(this._mouseMoveCallback),this._keyDispatcher=zmt.Key.getDispatcher(),this._keyDispatcher.onKeyDown(this._keyDownCallback),this._keyDispatcher.onKeyUp(this._keyUpCallback)},e.prototype._unanchor=function(){t.prototype._unanchor.call(this),this._positionDispatcher.offMouseMove(this._mouseMoveCallback),this._positionDispatcher=null,this._keyDispatcher.offKeyDown(this._keyDownCallback),this._keyDispatcher.offKeyUp(this._keyUpCallback),this._keyDispatcher=null},e.prototype._handleKeyDownEvent=function(t,e){var n=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(n)&&!e.repeat&&(this._keyPressCallbacks[t]&&this._keyPressCallbacks[t].callCallbacks(t),this._downedKeys.add(t))},e.prototype._handleKeyUpEvent=function(t){this._downedKeys.has(t)&&this._keyReleaseCallbacks[t]&&this._keyReleaseCallbacks[t].callCallbacks(t),this._downedKeys.delete(t)},e.prototype.onKeyPress=function(t,e){return this._keyPressCallbacks[t]||(this._keyPressCallbacks[t]=new umt.CallbackSet),this._keyPressCallbacks[t].add(e),this},e.prototype.offKeyPress=function(t,e){return this._keyPressCallbacks[t].delete(e),0===this._keyPressCallbacks[t].size&&delete this._keyPressCallbacks[t],this},e.prototype.onKeyRelease=function(t,e){return this._keyReleaseCallbacks[t]||(this._keyReleaseCallbacks[t]=new umt.CallbackSet),this._keyReleaseCallbacks[t].add(e),this},e.prototype.offKeyRelease=function(t,e){return this._keyReleaseCallbacks[t].delete(e),0===this._keyReleaseCallbacks[t].size&&delete this._keyReleaseCallbacks[t],this},e})(Dmt.Interaction);e.Key=n})),Vmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e,n){var i=t.call(this)||this;return i._wheelFilter=function(t){return!0},i._wheelCallback=function(t,e){return i._handleWheelEvent(t,e)},i._touchStartCallback=function(t,e,n){return i._handleTouchStart(t,e,n)},i._touchMoveCallback=function(t,e,n){return i._handlePinch(t,e,n)},i._touchEndCallback=function(t,e,n){return i._handleTouchEnd(t,e,n)},i._touchCancelCallback=function(t,e,n){return i._handleTouchEnd(t,e,n)},i._panEndCallbacks=new umt.CallbackSet,i._zoomEndCallbacks=new umt.CallbackSet,i._panZoomUpdateCallbacks=new umt.CallbackSet,i._xScales=new umt.Set,i._yScales=new umt.Set,i._dragInteraction=new Umt.Drag,i._setupDragInteraction(),i._touchIds=Uht.map(),i._minDomainExtents=new umt.Map,i._maxDomainExtents=new umt.Map,i._minDomainValues=new umt.Map,i._maxDomainValues=new umt.Map,null!=e&&i.addXScale(e),null!=n&&i.addYScale(n),i}return Sft.__extends(e,t),e.prototype.dragInteraction=function(){return this._dragInteraction},e.prototype.wheelFilter=function(t){return 0===arguments.length?this._wheelFilter:(this._wheelFilter=t,this)},e.prototype.pan=function(t){var e=this;this.xScales().forEach((function(n){n.pan(e._constrainedTranslation(n,t.x))})),this.yScales().forEach((function(n){n.pan(e._constrainedTranslation(n,t.y))})),this._panZoomUpdateCallbacks.callCallbacks()},e.prototype.zoom=function(t,e,n){var i,r,o=this;return void 0===n&&(n=!0),null!=e&&(i=e.x,r=e.y,n&&(this.xScales().forEach((function(e){var n=o._constrainedZoom(e,t,i);i=n.centerPoint,t=n.zoomAmount})),this.yScales().forEach((function(e){var n=o._constrainedZoom(e,t,r);r=n.centerPoint,t=n.zoomAmount})))),this.xScales().forEach((function(e){var n=e.range();e.zoom(t,null==i?(n[1]+n[0])/2:i)})),this.yScales().forEach((function(e){var n=e.range();e.zoom(t,null==r?(n[1]+n[0])/2:r)})),this._panZoomUpdateCallbacks.callCallbacks(),{zoomAmount:t,centerValue:{centerX:i,centerY:r}}},e.prototype._anchor=function(e){t.prototype._anchor.call(this,e),this._dragInteraction.attachTo(e),this._mouseDispatcher=zmt.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onWheel(this._wheelCallback),this._touchDispatcher=zmt.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback),this._touchDispatcher.onTouchMove(this._touchMoveCallback),this._touchDispatcher.onTouchEnd(this._touchEndCallback),this._touchDispatcher.onTouchCancel(this._touchCancelCallback)},e.prototype._unanchor=function(){t.prototype._unanchor.call(this),this._mouseDispatcher.offWheel(this._wheelCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher.offTouchMove(this._touchMoveCallback),this._touchDispatcher.offTouchEnd(this._touchEndCallback),this._touchDispatcher.offTouchCancel(this._touchCancelCallback),this._touchDispatcher=null,this._dragInteraction.detach()},e.prototype._handleTouchStart=function(t,e,n){for(var i=0;i<t.length&&this._touchIds.size()<2;i++){var r=t[i];this._touchIds.set(r.toString(),this._translateToComponentSpace(e[r]))}},e.prototype._handlePinch=function(t,n,i){var r=this;if(!(this._touchIds.size()<2)){var o=this._touchIds.values();if(this._isInsideComponent(this._translateToComponentSpace(o[0]))&&this._isInsideComponent(this._translateToComponentSpace(o[1]))){var a=e._pointDistance(o[0],o[1]);if(0!==a){t.forEach((function(t){r._touchIds.has(t.toString())&&r._touchIds.set(t.toString(),r._translateToComponentSpace(n[t]))}));var s=this._touchIds.values(),l=e._pointDistance(s[0],s[1]);if(0!==l){var c=a/l,u=s.map((function(t,e){return{x:(t.x-o[e].x)/c,y:(t.y-o[e].y)/c}})),h=e.centerPoint(o[0],o[1]),d=this.zoom(c,h),p=d.centerValue,f=d.zoomAmount,m=p.centerX,g=p.centerY,_=o.map((function(t,e){return{x:u[e].x*f+t.x,y:u[e].y*f+t.y}}));this.pan({x:m-(_[0].x+_[1].x)/2,y:g-(_[0].y+_[1].y)/2})}}}}},e.centerPoint=function(t,e){var n=Math.min(t.x,e.x),i=Math.max(t.x,e.x),r=Math.min(t.y,e.y);return{x:(n+i)/2,y:(Math.max(t.y,e.y)+r)/2}},e._pointDistance=function(t,e){var n=Math.min(t.x,e.x),i=Math.max(t.x,e.x),r=Math.min(t.y,e.y),o=Math.max(t.y,e.y);return Math.sqrt(Math.pow(i-n,2)+Math.pow(o-r,2))},e.prototype._handleTouchEnd=function(t,e,n){var i=this;t.forEach((function(t){i._touchIds.remove(t.toString())})),this._touchIds.size()>0&&this._zoomEndCallbacks.callCallbacks()},e.prototype._handleWheelEvent=function(t,n){if(this._wheelFilter(n)){var i=this._translateToComponentSpace(t);if(this._isInsideComponent(i)){n.preventDefault();var r=Math.pow(2,(0!==n.deltaY?n.deltaY:n.deltaX)*(n.deltaMode?e._PIXELS_PER_LINE:1)*.002);this.zoom(r,i),this._zoomEndCallbacks.callCallbacks()}}},e.prototype._constrainedZoom=function(t,e,n){return vmt.constrainedZoom(t,e,n,this.minDomainExtent(t),this.maxDomainExtent(t),this.minDomainValue(t),this.maxDomainValue(t))},e.prototype._constrainedTranslation=function(t,e){return vmt.constrainedTranslation(t,e,this.minDomainValue(t),this.maxDomainValue(t))},e.prototype._setupDragInteraction=function(){var t,e=this;this._dragInteraction.constrainedToComponent(!1),this._dragInteraction.onDragStart((function(){return t=null})),this._dragInteraction.onDrag((function(n,i){e._touchIds.size()>=2||(e.pan({x:(null==t?n.x:t.x)-i.x,y:(null==t?n.y:t.y)-i.y}),t=i)})),this._dragInteraction.onDragEnd((function(){return e._panEndCallbacks.callCallbacks()}))},e.prototype._nonLinearScaleWithExtents=function(t){return!(null==this.minDomainExtent(t)||null==this.maxDomainExtent(t)||t instanceof kmt.Linear||t instanceof kmt.Time)},e.prototype.xScales=function(t){var e=this;if(null==t){var n=[];return this._xScales.forEach((function(t){n.push(t)})),n}return this._xScales=new umt.Set,t.forEach((function(t){e.addXScale(t)})),this},e.prototype.yScales=function(t){var e=this;if(null==t){var n=[];return this._yScales.forEach((function(t){n.push(t)})),n}return this._yScales=new umt.Set,t.forEach((function(t){e.addYScale(t)})),this},e.prototype.addXScale=function(t){return this._xScales.add(t),this},e.prototype.removeXScale=function(t){return this._xScales.delete(t),this._minDomainExtents.delete(t),this._maxDomainExtents.delete(t),this._minDomainValues.delete(t),this._maxDomainValues.delete(t),this},e.prototype.addYScale=function(t){return this._yScales.add(t),this},e.prototype.removeYScale=function(t){return this._yScales.delete(t),this._minDomainExtents.delete(t),this._maxDomainExtents.delete(t),this._minDomainValues.delete(t),this._maxDomainValues.delete(t),this},e.prototype.minDomainExtent=function(t,e){if(null==e)return this._minDomainExtents.get(t);if(e.valueOf()<0)throw new Error("extent must be non-negative");var n=this.maxDomainExtent(t);if(null!=n&&n.valueOf()<e.valueOf())throw new Error("minDomainExtent must be smaller than maxDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(t)&&umt.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._minDomainExtents.set(t,e),this},e.prototype.maxDomainExtent=function(t,e){if(null==e)return this._maxDomainExtents.get(t);if(e.valueOf()<=0)throw new Error("extent must be positive");var n=this.minDomainExtent(t);if(null!=n&&e.valueOf()<n.valueOf())throw new Error("maxDomainExtent must be larger than minDomainExtent for the same Scale");return this._nonLinearScaleWithExtents(t)&&umt.Window.warn("Panning and zooming with extents on a nonlinear scale may have unintended behavior."),this._maxDomainExtents.set(t,e),this},e.prototype.minDomainValue=function(t,e){return null==e?this._minDomainValues.get(t):(this._minDomainValues.set(t,e),this)},e.prototype.maxDomainValue=function(t,e){return null==e?this._maxDomainValues.get(t):(this._maxDomainValues.set(t,e),this)},e.prototype.setMinMaxDomainValuesTo=function(t){this._minDomainValues.delete(t),this._maxDomainValues.delete(t);var e=t.getTransformationDomain(),n=e[1];return this.minDomainValue(t,e[0]),this.maxDomainValue(t,n),this},e.prototype.onPanEnd=function(t){return this._panEndCallbacks.add(t),this},e.prototype.offPanEnd=function(t){return this._panEndCallbacks.delete(t),this},e.prototype.onZoomEnd=function(t){return this._zoomEndCallbacks.add(t),this},e.prototype.offZoomEnd=function(t){return this._zoomEndCallbacks.delete(t),this},e.prototype.onPanZoomUpdate=function(t){return this._panZoomUpdateCallbacks.add(t),this},e.prototype.offPanZoomUpdate=function(t){return this._panZoomUpdateCallbacks.delete(t),this},e._PIXELS_PER_LINE=120,e})(Dmt.Interaction);e.PanZoom=n})),jmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._overComponent=!1,e._pointerEnterCallbacks=new umt.CallbackSet,e._pointerMoveCallbacks=new umt.CallbackSet,e._pointerExitCallbacks=new umt.CallbackSet,e._mouseMoveCallback=function(t,n){return e._handleMouseEvent(t,n)},e._touchStartCallback=function(t,n,i){return e._handleTouchEvent(n[t[0]],i)},e}return Sft.__extends(e,t),e.prototype._anchor=function(e){t.prototype._anchor.call(this,e),this._mouseDispatcher=zmt.Mouse.getDispatcher(this._componentAttachedTo),this._mouseDispatcher.onMouseMove(this._mouseMoveCallback),this._touchDispatcher=zmt.Touch.getDispatcher(this._componentAttachedTo),this._touchDispatcher.onTouchStart(this._touchStartCallback)},e.prototype._unanchor=function(){t.prototype._unanchor.call(this),this._mouseDispatcher.offMouseMove(this._mouseMoveCallback),this._mouseDispatcher=null,this._touchDispatcher.offTouchStart(this._touchStartCallback),this._touchDispatcher=null},e.prototype._handleMouseEvent=function(t,e){var n=this._mouseDispatcher.eventInside(this._componentAttachedTo,e);this._handlePointerEvent(t,n)},e.prototype._handleTouchEvent=function(t,e){var n=this._touchDispatcher.eventInside(this._componentAttachedTo,e);this._handlePointerEvent(t,n)},e.prototype._handlePointerEvent=function(t,e){var n=this._translateToComponentSpace(t),i=this._isInsideComponent(n);i&&e?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(n),this._pointerMoveCallbacks.callCallbacks(n)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(n),this._overComponent=i&&e},e.prototype.onPointerEnter=function(t){return this._pointerEnterCallbacks.add(t),this},e.prototype.offPointerEnter=function(t){return this._pointerEnterCallbacks.delete(t),this},e.prototype.onPointerMove=function(t){return this._pointerMoveCallbacks.add(t),this},e.prototype.offPointerMove=function(t){return this._pointerMoveCallbacks.delete(t),this},e.prototype.onPointerExit=function(t){return this._pointerExitCallbacks.add(t),this},e.prototype.offPointerExit=function(t){return this._pointerExitCallbacks.delete(t),this},e})(Dmt.Interaction);e.Pointer=n})),Umt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(Bmt,e),Sft.__exportStar(Hmt,e),Sft.__exportStar(Fmt,e),Sft.__exportStar(Vmt,e),Sft.__exportStar(jmt,e),e.zoomOut=vmt.zoomOut})),Gmt=be((function(t,e){var n;
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),(function(t){t[t.VALUE=0]="VALUE",t[t.PIXEL=1]="PIXEL"})(n=e.PropertyMode||(e.PropertyMode={}));var i=(function(t){function e(){var e=t.call(this)||this;return e._boxVisible=!1,e._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}},e._xBoundsMode=n.PIXEL,e._yBoundsMode=n.PIXEL,e.addClass("selection-box-layer"),e._adjustBoundsCallback=function(){e.render()},e._overflowHidden=!0,e._xExtent=[void 0,void 0],e._yExtent=[void 0,void 0],e}return Sft.__extends(e,t),e.prototype._setup=function(){t.prototype._setup.call(this),this._box=this.content().append("g").classed("selection-box",!0).remove(),this._boxArea=this._box.append("rect").classed("selection-area",!0)},e.prototype._sizeFromOffer=function(t,e){return{width:t,height:e}},e.prototype.bounds=function(t){return null==t?this._getBounds():(this._setBounds(t),this._xBoundsMode=n.PIXEL,this._yBoundsMode=n.PIXEL,this.render(),this)},e.prototype._setBounds=function(t){var e={x:Math.min(t.topLeft.x,t.bottomRight.x),y:Math.min(t.topLeft.y,t.bottomRight.y)},n={x:Math.max(t.topLeft.x,t.bottomRight.x),y:Math.max(t.topLeft.y,t.bottomRight.y)};this._boxBounds={topLeft:e,bottomRight:n}},e.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===n.PIXEL?this._boxBounds.topLeft.x:null==this._xScale?0:Math.min(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===n.PIXEL?this._boxBounds.topLeft.y:null==this._yScale?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===n.PIXEL?this._boxBounds.bottomRight.x:null==this._xScale?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===n.PIXEL?this._boxBounds.bottomRight.y:null==this._yScale?0:Math.max(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))}}},e.prototype.renderImmediately=function(){if(t.prototype.renderImmediately.call(this),this._boxVisible){var e=this.bounds(),n=e.topLeft.y,i=e.bottomRight.y,r=e.topLeft.x,o=e.bottomRight.x;if(!(umt.Math.isValidNumber(n)&&umt.Math.isValidNumber(i)&&umt.Math.isValidNumber(r)&&umt.Math.isValidNumber(o)))throw new Error("bounds have not been properly set");this._boxArea.attrs({x:r,y:n,width:o-r,height:i-n}),this.content().node().appendChild(this._box.node())}else this._box.remove();return this},e.prototype.boxVisible=function(t){return null==t?this._boxVisible:(this._boxVisible=t,this.render(),this)},e.prototype.fixedWidth=function(){return!0},e.prototype.fixedHeight=function(){return!0},e.prototype.xScale=function(t){return null==t?this._xScale:(null!=this._xScale&&this._xScale.offUpdate(this._adjustBoundsCallback),this._xScale=t,this._xBoundsMode=n.VALUE,this._xScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},e.prototype.yScale=function(t){return null==t?this._yScale:(null!=this._yScale&&this._yScale.offUpdate(this._adjustBoundsCallback),this._yScale=t,this._yBoundsMode=n.VALUE,this._yScale.onUpdate(this._adjustBoundsCallback),this.render(),this)},e.prototype.xExtent=function(t){return null==t?this._getXExtent():(this._setXExtent(t),this._xBoundsMode=n.VALUE,this.render(),this)},e.prototype._getXExtent=function(){return this._xBoundsMode===n.VALUE?this._xExtent:null==this._xScale?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]},e.prototype._setXExtent=function(t){this._xExtent=t},e.prototype.yExtent=function(t){return null==t?this._getYExtent():(this._setYExtent(t),this._yBoundsMode=n.VALUE,this.render(),this)},e.prototype._getYExtent=function(){return this._yBoundsMode===n.VALUE?this._yExtent:null==this._yScale?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]},e.prototype._setYExtent=function(t){this._yExtent=t},e.prototype.destroy=function(){t.prototype.destroy.call(this),null!=this._xScale&&this.xScale().offUpdate(this._adjustBoundsCallback),null!=this._yScale&&this.yScale().offUpdate(this._adjustBoundsCallback)},e})(pmt.Component);e.SelectionBoxLayer=i})),Wmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._detectionRadius=3,e._resizable=!1,e._movable=!1,e._hasCorners=!0,e.addClass("drag-box-layer"),e._dragInteraction=new Umt.Drag,e._setUpCallbacks(),e._dragInteraction.attachTo(e),e._dragStartCallbacks=new umt.CallbackSet,e._dragCallbacks=new umt.CallbackSet,e._dragEndCallbacks=new umt.CallbackSet,e}return Sft.__extends(e,t),e.prototype._setUpCallbacks=function(){var t,e,n,i,r=this,o=0,a=function(a){t=r._getResizingEdges(a);var s=r.bounds(),l=s.topLeft.x<=a.x&&a.x<=s.bottomRight.x&&s.topLeft.y<=a.y&&a.y<=s.bottomRight.y;r.boxVisible()&&(t.top||t.bottom||t.left||t.right)?o=1:r.boxVisible()&&r.movable()&&l?o=2:(o=0,r._setBounds({topLeft:a,bottomRight:a}),r._xBoundsMode===vgt.PropertyMode.VALUE&&null!=r.xScale()&&r._setXExtent([r.xScale().invert(a.x),r.xScale().invert(a.x)]),r._yBoundsMode===vgt.PropertyMode.VALUE&&null!=r.yScale()&&r._setYExtent([r.yScale().invert(a.y),r.yScale().invert(a.y)]),r.render()),r.boxVisible(!0),s=r.bounds(),e={x:s.topLeft.x,y:s.topLeft.y},n={x:s.bottomRight.x,y:s.bottomRight.y},i=a,r._dragStartCallbacks.callCallbacks(s)},s=function(a,s){switch(o){case 0:n.x=s.x,n.y=s.y;break;case 1:t.bottom?n.y=s.y:t.top&&(e.y=s.y),t.right?n.x=s.x:t.left&&(e.x=s.x);break;case 2:var l=s.x-i.x,c=s.y-i.y;e.x+=l,e.y+=c,n.x+=l,n.y+=c,i=s}r._setBounds({topLeft:e,bottomRight:n}),r._xBoundsMode===vgt.PropertyMode.VALUE&&null!=r.xScale()&&r._setXExtent([r.xScale().invert(e.x),r.xScale().invert(n.x)]),r._yBoundsMode===vgt.PropertyMode.VALUE&&null!=r.yScale()&&r._setYExtent([r.yScale().invert(e.y),r.yScale().invert(n.y)]),r.render(),r._dragCallbacks.callCallbacks(r.bounds())},l=function(t,e){0===o&&t.x===e.x&&t.y===e.y&&r.boxVisible(!1),r._dragEndCallbacks.callCallbacks(r.bounds())};this._dragInteraction.onDragStart(a),this._dragInteraction.onDrag(s),this._dragInteraction.onDragEnd(l),this._disconnectInteraction=function(){r._dragInteraction.offDragStart(a),r._dragInteraction.offDrag(s),r._dragInteraction.offDragEnd(l),r._dragInteraction.detach()}},e.prototype._setup=function(){var e=this;t.prototype._setup.call(this);var n=function(){return e._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})};if(this._detectionEdgeT=n().classed("drag-edge-tb",!0),this._detectionEdgeB=n().classed("drag-edge-tb",!0),this._detectionEdgeL=n().classed("drag-edge-lr",!0),this._detectionEdgeR=n().classed("drag-edge-lr",!0),this._hasCorners){var i=function(){return e._box.append("circle").styles({opacity:0,fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=i().classed("drag-corner-tl",!0),this._detectionCornerTR=i().classed("drag-corner-tr",!0),this._detectionCornerBL=i().classed("drag-corner-bl",!0),this._detectionCornerBR=i().classed("drag-corner-br",!0)}},e.prototype._getResizingEdges=function(t){var e={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return e;var n=this.bounds(),i=n.topLeft.y,r=n.bottomRight.y,o=n.topLeft.x,a=n.bottomRight.x,s=this._detectionRadius;return o-s<=t.x&&t.x<=a+s&&(e.top=i-s<=t.y&&t.y<=i+s,e.bottom=r-s<=t.y&&t.y<=r+s),i-s<=t.y&&t.y<=r+s&&(e.left=o-s<=t.x&&t.x<=o+s,e.right=a-s<=t.x&&t.x<=a+s),e},e.prototype.renderImmediately=function(){if(t.prototype.renderImmediately.call(this),this.boxVisible()){var e=this.bounds(),n=e.topLeft.y,i=e.bottomRight.y,r=e.topLeft.x,o=e.bottomRight.x;this._detectionEdgeT.attrs({x1:r,y1:n,x2:o,y2:n,"stroke-width":2*this._detectionRadius}),this._detectionEdgeB.attrs({x1:r,y1:i,x2:o,y2:i,"stroke-width":2*this._detectionRadius}),this._detectionEdgeL.attrs({x1:r,y1:n,x2:r,y2:i,"stroke-width":2*this._detectionRadius}),this._detectionEdgeR.attrs({x1:o,y1:n,x2:o,y2:i,"stroke-width":2*this._detectionRadius}),this._hasCorners&&(this._detectionCornerTL.attrs({cx:r,cy:n,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:o,cy:n,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:r,cy:i,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:o,cy:i,r:this._detectionRadius}))}return this},e.prototype.detectionRadius=function(t){if(null==t)return this._detectionRadius;if(t<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=t,this.render(),this},e.prototype.resizable=function(t){return null==t?this._resizable:(this._resizable=t,this._setResizableClasses(t),this)},e.prototype._setResizableClasses=function(t){t&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))},e.prototype.movable=function(t){return null==t?this._movable:(this._movable=t,this._setMovableClass(),this)},e.prototype._setMovableClass=function(){this.movable()&&this.enabled()?this.addClass("movable"):this.removeClass("movable")},e.prototype.onDragStart=function(t){return this._dragStartCallbacks.add(t),this},e.prototype.offDragStart=function(t){return this._dragStartCallbacks.delete(t),this},e.prototype.onDrag=function(t){return this._dragCallbacks.add(t),this},e.prototype.offDrag=function(t){return this._dragCallbacks.delete(t),this},e.prototype.onDragEnd=function(t){return this._dragEndCallbacks.add(t),this},e.prototype.offDragEnd=function(t){return this._dragEndCallbacks.delete(t),this},e.prototype.dragInteraction=function(){return this._dragInteraction},e.prototype.enabled=function(t){return null==t?this._dragInteraction.enabled():(this._dragInteraction.enabled(t),this._setResizableClasses(this.resizable()),this._setMovableClass(),this)},e.prototype.destroy=function(){var e=this;t.prototype.destroy.call(this),this._dragStartCallbacks.forEach((function(t){return e._dragCallbacks.delete(t)})),this._dragCallbacks.forEach((function(t){return e._dragCallbacks.delete(t)})),this._dragEndCallbacks.forEach((function(t){return e._dragEndCallbacks.delete(t)})),this._disconnectInteraction()},e.prototype.detach=function(){return this._resetState(),this._dragInteraction.detach(),t.prototype.detach.call(this),this},e.prototype.anchor=function(e){return e=yft.coerceExternalD3(e),this._dragInteraction.attachTo(this),t.prototype.anchor.call(this,e),this},e.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})},e})(Gmt.SelectionBoxLayer);e.DragBoxLayer=n})),qmt=be((function(t,e){var n;
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),(function(t){t[t.VALUE=0]="VALUE",t[t.PIXEL=1]="PIXEL"})(n||(n={}));var i=(function(t){function e(i){var r=t.call(this)||this;if(r._mode=n.VALUE,i!==e.ORIENTATION_VERTICAL&&i!==e.ORIENTATION_HORIZONTAL)throw new Error(i+" is not a valid orientation for GuideLineLayer");return r._orientation=i,r._overflowHidden=!0,r.addClass("guide-line-layer"),r._isVertical()?r.addClass("vertical"):r.addClass("horizontal"),r._scaleUpdateCallback=function(){r._syncPixelPositionAndValue(),r.render()},r}return Sft.__extends(e,t),e.prototype._setup=function(){t.prototype._setup.call(this),this._guideLine=this.content().append("line").classed("guide-line",!0)},e.prototype._sizeFromOffer=function(t,e){return{width:t,height:e}},e.prototype._isVertical=function(){return this._orientation===e.ORIENTATION_VERTICAL},e.prototype.fixedWidth=function(){return!0},e.prototype.fixedHeight=function(){return!0},e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),null!=this.scale()&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),0])),this},e.prototype.renderImmediately=function(){return t.prototype.renderImmediately.call(this),this._syncPixelPositionAndValue(),this._guideLine.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition()}),this},e.prototype._syncPixelPositionAndValue=function(){null!=this.scale()&&(this._mode===n.VALUE&&null!=this.value()?this._pixelPosition=this.scale().scale(this.value()):this._mode===n.PIXEL&&null!=this.pixelPosition()&&(this._value=this.scale().invert(this.pixelPosition())))},e.prototype._setPixelPositionWithoutChangingMode=function(t){this._pixelPosition=t,null!=this.scale()&&(this._value=this.scale().invert(this.pixelPosition())),this.render()},e.prototype.scale=function(t){if(null==t)return this._scale;var e=this._scale;return null!=e&&e.offUpdate(this._scaleUpdateCallback),this._scale=t,this._scale.onUpdate(this._scaleUpdateCallback),this._syncPixelPositionAndValue(),this.redraw(),this},e.prototype.value=function(t){return null==t?this._value:(this._value=t,this._mode=n.VALUE,this._syncPixelPositionAndValue(),this.render(),this)},e.prototype.pixelPosition=function(t){if(null==t)return this._pixelPosition;if(!umt.Math.isValidNumber(t))throw new Error("pixelPosition must be a finite number");return this._pixelPosition=t,this._mode=n.PIXEL,this._syncPixelPositionAndValue(),this.render(),this},e.prototype.destroy=function(){t.prototype.destroy.call(this),null!=this.scale()&&this.scale().offUpdate(this._scaleUpdateCallback)},e.ORIENTATION_VERTICAL="vertical",e.ORIENTATION_HORIZONTAL="horizontal",e})(pmt.Component);e.GuideLineLayer=i})),Ymt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){var n=t.call(this,e)||this;n._detectionRadius=3,n._enabled=!0,n.addClass("drag-line-layer"),n.addClass("enabled"),n._dragInteraction=new Umt.Drag,n._dragInteraction.attachTo(n);var i=!1,r=function(t){(function(t){return n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=t.x&&t.x<=n.pixelPosition()+n.detectionRadius()||!n._isVertical()&&n.pixelPosition()-n.detectionRadius()<=t.y&&t.y<=n.pixelPosition()+n.detectionRadius()})(t)&&(i=!0,n._dragStartCallbacks.callCallbacks(n))};n._dragInteraction.onDragStart(r);var o=function(t,e){i&&(n._setPixelPositionWithoutChangingMode(n._isVertical()?e.x:e.y),n._dragCallbacks.callCallbacks(n))};n._dragInteraction.onDrag(o);var a=function(t,e){i&&(i=!1,n._dragEndCallbacks.callCallbacks(n))};return n._dragInteraction.onDragEnd(a),n._disconnectInteraction=function(){n._dragInteraction.offDragStart(r),n._dragInteraction.offDrag(o),n._dragInteraction.offDragEnd(a),n._dragInteraction.detach()},n._dragStartCallbacks=new umt.CallbackSet,n._dragCallbacks=new umt.CallbackSet,n._dragEndCallbacks=new umt.CallbackSet,n}return Sft.__extends(e,t),e.prototype._setup=function(){t.prototype._setup.call(this),this._detectionEdge=this.content().append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)},e.prototype.renderImmediately=function(){return t.prototype.renderImmediately.call(this),this._detectionEdge.attrs({x1:this._isVertical()?this.pixelPosition():0,y1:this._isVertical()?0:this.pixelPosition(),x2:this._isVertical()?this.pixelPosition():this.width(),y2:this._isVertical()?this.height():this.pixelPosition(),"stroke-width":2*this._detectionRadius}),this},e.prototype.detectionRadius=function(t){if(null==t)return this._detectionRadius;if(t<0)throw new Error("detection radius cannot be negative.");return this._detectionRadius=t,this.render(),this},e.prototype.enabled=function(t){return null==t?this._enabled:(this._enabled=t,t?this.addClass("enabled"):this.removeClass("enabled"),this._dragInteraction.enabled(t),this)},e.prototype.onDragStart=function(t){return this._dragStartCallbacks.add(t),this},e.prototype.offDragStart=function(t){return this._dragStartCallbacks.delete(t),this},e.prototype.onDrag=function(t){return this._dragCallbacks.add(t),this},e.prototype.offDrag=function(t){return this._dragCallbacks.delete(t),this},e.prototype.onDragEnd=function(t){return this._dragEndCallbacks.add(t),this},e.prototype.offDragEnd=function(t){return this._dragEndCallbacks.delete(t),this},e.prototype.destroy=function(){var e=this;t.prototype.destroy.call(this),this._dragStartCallbacks.forEach((function(t){return e._dragStartCallbacks.delete(t)})),this._dragCallbacks.forEach((function(t){return e._dragCallbacks.delete(t)})),this._dragEndCallbacks.forEach((function(t){return e._dragEndCallbacks.delete(t)})),this._disconnectInteraction()},e})(qmt.GuideLineLayer);e.DragLineLayer=n})),Xmt=be((function(t,e){function n(t,e,n){var i={};if(void 0!==n)for(var r=0;r<n.length;r++)i[n[r]]=n[r-1];return function(n){var r,o=t.scale(n);if(!e)return o;var a=void 0===i[n]?void 0:t.scale(i[n]);return void 0!==a&&(r=a+(o-a)/2),r}}
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var i=(function(t){function e(e,n){var i=t.call(this)||this;return i.addClass("gridlines"),i._xScale=e,i._yScale=n,i._renderCallback=function(t){return i.render()},i._xScale&&i._xScale.onUpdate(i._renderCallback),i._yScale&&i._yScale.onUpdate(i._renderCallback),i}return Sft.__extends(e,t),e.prototype.betweenX=function(t){return void 0===t?this._betweenX:(t!==this._betweenX&&(this._betweenX=t,this.render()),this)},e.prototype.betweenY=function(t){return void 0===t?this._betweenY:(t!==this._betweenY&&(this._betweenY=t,this.render()),this)},e.prototype.destroy=function(){return t.prototype.destroy.call(this),this._xScale&&this._xScale.offUpdate(this._renderCallback),this._yScale&&this._yScale.offUpdate(this._renderCallback),this},e.prototype._setup=function(){t.prototype._setup.call(this),this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0),this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)},e.prototype.renderImmediately=function(){return t.prototype.renderImmediately.call(this),this._redrawXLines(),this._redrawYLines(),this},e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),null!=this._xScale&&this._xScale.range([0,this.width()]),null!=this._yScale&&this._yScale.range([this.height(),0]),this},e.prototype._redrawXLines=function(){if(this._xScale){var t=this.betweenX(),e=this._xScale.ticks().slice(t?1:0),i=this._xLinesContainer.selectAll("line").data(e);i.enter().append("line").merge(i).attr("x1",n(this._xScale,t,this._xScale.ticks())).attr("y1",0).attr("x2",n(this._xScale,t,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",t).classed("zeroline",(function(t){return 0===t})),i.exit().remove()}},e.prototype._redrawYLines=function(){if(this._yScale){var t=this.betweenY(),e=this._yScale.ticks().slice(t?1:0),i=this._yLinesContainer.selectAll("line").data(e);i.enter().append("line").merge(i).attr("x1",0).attr("y1",n(this._yScale,t,this._yScale.ticks())).attr("x2",this.width()).attr("y2",n(this._yScale,t,this._yScale.ticks())).classed("betweenline",t).classed("zeroline",(function(t){return 0===t})),i.exit().remove()}},e})(pmt.Component);e.Gridlines=i})),$mt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._detachCallback=function(t){return e.remove(t)},e}return Sft.__extends(e,t),e.prototype.anchor=function(e){var n=this;return e=yft.coerceExternalD3(e),t.prototype.anchor.call(this,e),this._forEach((function(t){return t.anchor(n.element())})),this},e.prototype.render=function(){return this._forEach((function(t){return t.render()})),this},e.prototype.has=function(t){throw new Error("has() is not implemented on ComponentContainer")},e.prototype._adoptAndAnchor=function(t){t.parent(this),t.onDetach(this._detachCallback),this._isAnchored&&t.anchor(this.element())},e.prototype.remove=function(t){return this.has(t)&&(t.offDetach(this._detachCallback),this._remove(t),t.detach(),this.redraw()),this},e.prototype._remove=function(t){return!1},e.prototype._forEach=function(t){throw new Error("_forEach() is not implemented on ComponentContainer")},e.prototype.destroy=function(){t.prototype.destroy.call(this),this._forEach((function(t){return t.destroy()}))},e.prototype.invalidateCache=function(){this._forEach((function(t){return t.invalidateCache()}))},e})(pmt.Component);e.ComponentContainer=n})),Kmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e=[]);var n=t.call(this)||this;return n._components=[],n.addClass("component-group"),e.forEach((function(t){return n.append(t)})),n}return Sft.__extends(e,t),e.prototype._forEach=function(t){this.components().forEach(t)},e.prototype.has=function(t){return this._components.indexOf(t)>=0},e.prototype.requestedSpace=function(t,e){var n=this._components.map((function(n){return n.requestedSpace(t,e)}));return{minWidth:umt.Math.max(n,(function(t){return t.minWidth}),0),minHeight:umt.Math.max(n,(function(t){return t.minHeight}),0)}},e.prototype.computeLayout=function(e,n,i){var r=this;return t.prototype.computeLayout.call(this,e,n,i),this._forEach((function(t){t.computeLayout({x:0,y:0},r.width(),r.height())})),this},e.prototype._sizeFromOffer=function(t,e){return{width:t,height:e}},e.prototype.fixedWidth=function(){return this._components.every((function(t){return t.fixedWidth()}))},e.prototype.fixedHeight=function(){return this._components.every((function(t){return t.fixedHeight()}))},e.prototype.components=function(){return this._components.slice()},e.prototype.append=function(t){return null==t||this.has(t)||(t.detach(),this._components.push(t),this._adoptAndAnchor(t),this.redraw()),this},e.prototype._remove=function(t){var e=this._components.indexOf(t);return e>=0&&(this._components.splice(e,1),!0)},e})($mt.ComponentContainer);e.Group=n})),Zmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){var n=t.call(this)||this;if(n._textPadding=5,null==e)throw new Error("InterpolatedColorLegend requires a interpolatedColorScale");return n._scale=e,n._redrawCallback=function(t){return n.redraw()},n._scale.onUpdate(n._redrawCallback),n._formatter=fmt.general(),n._orientation="horizontal",n._expands=!1,n.addClass("legend"),n.addClass("interpolated-color-legend"),n}return Sft.__extends(e,t),e.prototype.destroy=function(){t.prototype.destroy.call(this),this._scale.offUpdate(this._redrawCallback)},e.prototype.formatter=function(t){return void 0===t?this._formatter:(this._formatter=t,this.redraw(),this)},e.prototype.expands=function(t){return null==t?this._expands:(this._expands=t,this.redraw(),this)},e._ensureOrientation=function(t){if("horizontal"===(t=t.toLowerCase())||"left"===t||"right"===t)return t;throw new Error('"'+t+'" is not a valid orientation for InterpolatedColorLegend')},e.prototype.orientation=function(t){return null==t?this._orientation:(this._orientation=e._ensureOrientation(t),this.redraw(),this)},e.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()},e.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()},e.prototype._generateTicks=function(t){void 0===t&&(t=e._DEFAULT_NUM_SWATCHES);var n=this._scale.domain();if(1===t)return[n[0]];for(var i=(n[1]-n[0])/(t-1),r=[],o=0;o<t;o++)r.push(n[0]+i*o);return r},e.prototype._setup=function(){t.prototype._setup.call(this),this._swatchContainer=this.content().append("g").classed("swatch-container",!0),this._swatchBoundingBox=this.content().append("rect").classed("swatch-bounding-box",!0),this._lowerLabel=this.content().append("g").classed(e.LEGEND_LABEL_CLASS,!0),this._upperLabel=this.content().append("g").classed(e.LEGEND_LABEL_CLASS,!0);var n=new qft.SvgContext(this.content().node());this._measurer=new qft.Measurer(n),this._wrapper=new qft.Wrapper,this._writer=new qft.Writer(this._measurer,n,this._wrapper)},e.prototype.requestedSpace=function(t,n){var i,r,o=this,a=this._measurer.measure().height,s=a,l=this._scale.domain().map((function(t){return o._measurer.measure(o._formatter(t)).width})),c=e._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var u=umt.Math.max(l,0);r=s+a+this._textPadding+u+this._textPadding,i=c*a}else i=s+a+s,r=this._textPadding+l[0]+c*a+l[1]+this._textPadding;return{minWidth:r,minHeight:i}},e.prototype._isVertical=function(){return"horizontal"!==this._orientation},e.prototype.renderImmediately=function(){var e=this;t.prototype.renderImmediately.call(this);var n,i,r,o,a,s,l=this._scale.domain(),c=this._formatter(l[0]),u=this._measurer.measure(c).width,h=this._formatter(l[1]),d=this._measurer.measure(h).width,p=this._measurer.measure().height,f=this._textPadding,m={x:0,y:0},g={x:0,y:0},_={xAlign:"center",yAlign:"center",textRotation:0},y={xAlign:"center",yAlign:"center",textRotation:0},v={x:0,y:0,width:0,height:0};if(this._isVertical()){s=Math.floor(this.height());var b=Math.max(u,d);a=(this.width()-b-2*this._textPadding)/2,n=Math.max(this.width()-a-2*f-b,0),i=1,o=function(t,n){return e.height()-(n+1)},y.yAlign="top",m.y=0,_.yAlign="bottom",g.y=0,"left"===this._orientation?(r=function(t,e){return f+b+f},y.xAlign="right",m.x=-(a+n+f),_.xAlign="right",g.x=-(a+n+f)):(r=function(t,e){return a},y.xAlign="left",m.x=a+n+f,_.xAlign="left",g.x=a+n+f),v.width=n,v.height=s*i}else a=Math.max(f,(this.height()-p)/2),s=Math.max(Math.floor(this.width()-4*f-u-d),0),n=1,i=Math.max(this.height()-2*a,0),r=function(t,e){return Math.floor(u+2*f)+e},o=function(t,e){return a},y.xAlign="right",m.x=-f,_.xAlign="left",g.x=f,v.y=a,v.width=s*n,v.height=i;v.x=r(null,0),this._upperLabel.text(""),this._writer.write(h,this.width(),this.height(),y,this._upperLabel.node()),this._upperLabel.attr("transform","translate("+m.x+", "+m.y+")"),this._lowerLabel.text(""),this._writer.write(c,this.width(),this.height(),_,this._lowerLabel.node()),this._lowerLabel.attr("transform","translate("+g.x+", "+g.y+")"),this._swatchBoundingBox.attrs(v);var x=this._generateTicks(s),w=this._swatchContainer.selectAll("rect.swatch").data(x),S=w.enter().append("rect").classed("swatch",!0),M=w.merge(S);return w.exit().remove(),M.attrs({fill:function(t,n){return e._scale.scale(t)},width:n,height:i,x:r,y:o,"shape-rendering":"crispEdges"}),emt.ADD_TITLE_ELEMENTS&&S.append("title").text((function(t){return e._formatter(t)})),this},e._DEFAULT_NUM_SWATCHES=11,e.LEGEND_LABEL_CLASS="legend-label",e})(pmt.Component);e.InterpolatedColorLegend=n})),Jmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e,n){void 0===e&&(e=""),void 0===n&&(n=0);var i=t.call(this)||this;return i.addClass("label"),i.text(e),i.angle(n),i.xAlignment("center").yAlignment("center"),i._padding=0,i}return Sft.__extends(e,t),e.prototype.requestedSpace=function(t,e){var n=this._measurer.measure(this._text);return{minWidth:(0===this.angle()?n.width:n.height)+2*this.padding(),minHeight:(0===this.angle()?n.height:n.width)+2*this.padding()}},e.prototype._setup=function(){t.prototype._setup.call(this),this._textContainer=this.content().append("g");var e=new qft.SvgContext(this._textContainer.node());this._measurer=new qft.CacheMeasurer(e),this._wrapper=new qft.Wrapper,this._writer=new qft.Writer(this._measurer,e,this._wrapper),this.text(this._text)},e.prototype.text=function(t){if(null==t)return this._text;if("string"!=typeof t)throw new Error("Label.text() only takes strings as input");return this._text=t,this.redraw(),this},e.prototype.angle=function(t){if(null==t)return this._angle;if((t%=360)>180?t-=360:t<-180&&(t+=360),-90!==t&&0!==t&&90!==t)throw new Error(t+" is not a valid angle for Label");return this._angle=t,this.redraw(),this},e.prototype.padding=function(t){if(null==t)return this._padding;if((t=+t)<0)throw new Error(t+" is not a valid padding value. Cannot be less than 0.");return this._padding=t,this.redraw(),this},e.prototype.fixedWidth=function(){return!0},e.prototype.fixedHeight=function(){return!0},e.prototype.renderImmediately=function(){t.prototype.renderImmediately.call(this),this._textContainer.selectAll("g").remove();var e=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-e.height)/2,this.padding()),0),i=Math.max(Math.min((this.width()-e.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+i+","+n+")");var r=this.width()-2*i,o=this.height()-2*n,a={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};return this._writer.write(this._text,r,o,a),this},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},e})(pmt.Component);e.Label=n;var i=(function(t){function e(n,i){var r=t.call(this,n,i)||this;return r.addClass(e.TITLE_LABEL_CLASS),r}return Sft.__extends(e,t),e.TITLE_LABEL_CLASS="title-label",e})(n);e.TitleLabel=i;var r=(function(t){function e(n,i){var r=t.call(this,n,i)||this;return r.addClass(e.AXIS_LABEL_CLASS),r}return Sft.__extends(e,t),e.AXIS_LABEL_CLASS="axis-label",e})(n);e.AxisLabel=r})),Qmt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.circle=function n(){return function(t){return Uht.symbol().type(Uht.symbolCircle).size(Math.PI*Math.pow(t/2,2))}},e.square=function i(){return function(t){return Uht.symbol().type(Uht.symbolSquare).size(Math.pow(t,2))}},e.cross=function r(){return function(t){return Uht.symbol().type(Uht.symbolCross).size(5/9*Math.pow(t,2))}},e.diamond=function o(){return function(t){return Uht.symbol().type(Uht.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(t,2)/2)}},e.triangle=function a(){return function(t){return Uht.symbol().type(Uht.symbolTriangle).size(Math.sqrt(3)*Math.pow(t/2,2))}},e.star=function s(){return function(t){return Uht.symbol().type(Uht.symbolStar).size(.8908130915292852*Math.pow(t/2,2))}};var l=3*(1/Math.sqrt(12)/2+1);e.wye=function c(){return function(t){return Uht.symbol().type(Uht.symbolWye).size(l*Math.pow(t/2.4,2))}}})),tgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e,n){void 0===t&&(t=[]),void 0===e&&(e=0),void 0===n&&(n=1/0),this.columns=t,this.bottomPadding=e,this.maxWidth=n}return t.prototype.addColumn=function(t){var e=t.width,n=this.getWidthAvailable();t.width=Math.min(n,e),this.columns.push(t)},t.prototype.getBounds=function(t){for(var e=this.columns[t],n=0,i=0;i<t;i++)n+=this.columns[i].width;return{topLeft:{x:n,y:0},bottomRight:{x:n+e.width,y:e.height}}},t.prototype.getHeight=function(){return umt.Math.max(this.columns.map((function(t){return t.height})),0)+this.bottomPadding},t.prototype.getWidth=function(){return Math.min(this.columns.reduce((function(t,e){return t+e.width}),0),this.maxWidth)},t.prototype.getWidthAvailable=function(){var t=this.getWidth();return Math.max(this.maxWidth-t,0)},t})(),i=(function(){function t(t,e,n,i){void 0===t&&(t=1/0),void 0===e&&(e=1/0),void 0===n&&(n=0),void 0===i&&(i=[]),this.maxWidth=t,this.maxHeight=e,this.padding=n,this.rows=i}return t.prototype.addRow=function(t){t.maxWidth=this.maxWidth-2*this.padding,this.rows.push(t)},t.prototype.getColumnBounds=function(t,e){var n=this.getRowBounds(t),i=this.rows[t].getBounds(e);return i.topLeft.x+=n.topLeft.x,i.bottomRight.x+=n.topLeft.x,i.topLeft.y+=n.topLeft.y,i.bottomRight.y+=n.topLeft.y,i},t.prototype.getRowBounds=function(t){for(var e=this.padding,n=this.padding,i=0;i<t;i++)n+=this.rows[i].getHeight();return{topLeft:{x:e,y:n},bottomRight:{x:e+this.rows[t].getWidth(),y:n+this.rows[t].getHeight()}}},t.prototype.getHeight=function(){return Math.min(this.rows.reduce((function(t,e){return t+e.getHeight()}),0)+2*this.padding,this.maxHeight)},t.prototype.getWidth=function(){return Math.min(umt.Math.max(this.rows.map((function(t){return t.getWidth()})),0)+2*this.padding,this.maxWidth)},t})(),r=(function(t){function e(e){var n=t.call(this)||this;if(n._padding=5,n._rowBottomPadding=3,n.addClass("legend"),n.maxEntriesPerRow(1),null==e)throw new Error("Legend requires a colorScale");return n._colorScale=e,n._redrawCallback=function(t){return n.redraw()},n._colorScale.onUpdate(n._redrawCallback),n._formatter=fmt.identity(),n.maxLinesPerEntry(1),n.xAlignment("right").yAlignment("top"),n.comparator((function(t,e){var i=n._colorScale.domain().slice().map((function(t){return n._formatter(t)}));return i.indexOf(t)-i.indexOf(e)})),n._symbolFactoryAccessor=function(){return Qmt.circle()},n._symbolOpacityAccessor=function(){return 1},n}return Sft.__extends(e,t),e.prototype._setup=function(){t.prototype._setup.call(this);var n=this.content().append("g").classed(e.LEGEND_ROW_CLASS,!0);n.append("g").classed(e.LEGEND_ENTRY_CLASS,!0).append("text");var i=new qft.SvgContext(n.node(),null,emt.ADD_TITLE_ELEMENTS);this._measurer=new qft.CacheMeasurer(i),this._wrapper=(new qft.Wrapper).maxLines(this.maxLinesPerEntry()),this._writer=new qft.Writer(this._measurer,i,this._wrapper)},e.prototype.formatter=function(t){return null==t?this._formatter:(this._formatter=t,this.redraw(),this)},e.prototype.maxEntriesPerRow=function(t){return null==t?this._maxEntriesPerRow:(this._maxEntriesPerRow=t,this.redraw(),this)},e.prototype.maxLinesPerEntry=function(t){return null==t?this._maxLinesPerEntry:(this._maxLinesPerEntry=t,this.redraw(),this)},e.prototype.maxWidth=function(t){return null==t?this._maxWidth:(this._maxWidth=t,this.redraw(),this)},e.prototype.comparator=function(t){return null==t?this._comparator:(this._comparator=t,this.redraw(),this)},e.prototype.colorScale=function(t){return null!=t?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=t,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale},e.prototype.destroy=function(){t.prototype.destroy.call(this),this._colorScale.offUpdate(this._redrawCallback)},e.prototype._buildLegendTable=function(t,e){var r=this,o=this._measurer.measure().height,a=new i(t,e,this._padding),s=this._colorScale.domain().slice().sort((function(t,e){return r._comparator(r._formatter(t),r._formatter(e))})),l=new n;return a.addRow(l),l.bottomPadding=this._rowBottomPadding,s.forEach((function(t,e){l.columns.length/2===r.maxEntriesPerRow()&&((l=new n).bottomPadding=r._rowBottomPadding,a.addRow(l));var i=l.getWidthAvailable(),s=r._formatter(t),c=r._measurer.measure(s).width;i-o-c<0&&l.columns.length>1&&((l=new n).bottomPadding=r._rowBottomPadding,a.addRow(l)),l.addColumn({width:o,height:o,data:{name:t,type:"symbol"}}),i=l.getWidthAvailable();var u=Math.min(i,c);r._wrapper.maxLines(r.maxLinesPerEntry());var h=r._wrapper.wrap(s,r._measurer,u).noLines;l.addColumn({width:u,height:h*o,data:{name:t,type:"text"}})})),a},e.prototype.requestedSpace=function(t,e){var n=this._buildLegendTable(umt.Math.min([this.maxWidth(),t],t),e);return{minHeight:n.getHeight(),minWidth:n.getWidth()}},e.prototype.entitiesAt=function(t){var n=this;if(!this._isSetup)return[];var i=this._buildLegendTable(this.width(),this.height());return i.rows.reduce((function(r,o,a){if(0!==r.length)return r;var s=i.getRowBounds(a);return umt.Math.within(t,s)?o.columns.reduce((function(r,o,s){var l=i.getColumnBounds(a,s);if(umt.Math.within(t,l)){var c=n.content().selectAll("."+e.LEGEND_ROW_CLASS).nodes()[a],u=Uht.select(c).selectAll("."+e.LEGEND_ENTRY_CLASS).nodes()[Math.floor(s/2)],h=Uht.select(u).select("."+e.LEGEND_SYMBOL_CLASS),d=umt.DOM.getTranslateValues(Uht.select(c)),p=umt.DOM.getTranslateValues(h);return[{bounds:umt.DOM.elementBBox(Uht.select(c)),datum:o.data.name,position:{x:d[0]+p[0],y:d[1]+p[1]},selection:Uht.select(u),component:n}]}return r}),r):r}),[])},e.prototype.renderImmediately=function(){t.prototype.renderImmediately.call(this);var n=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var i=this.content().selectAll("g."+e.LEGEND_ROW_CLASS).data(n.rows),r=i.enter().append("g").classed(e.LEGEND_ROW_CLASS,!0).merge(i);i.exit().remove(),r.attr("transform",(function(t,e){var i=n.getRowBounds(e);return"translate("+i.topLeft.x+", "+i.topLeft.y+")"}));var o=this;return r.each((function(t,i){for(var r=[],a=0;a<t.columns.length;a+=2)r.push([t.columns[a],t.columns[a+1]]);var s=Uht.select(this).selectAll("g."+e.LEGEND_ENTRY_CLASS).data(r),l=s.enter().append("g").classed(e.LEGEND_ENTRY_CLASS,!0).merge(s);l.append("path").attr("d",(function(t,e){var n=t[0];return o.symbol()(n.data.name,i)(.6*n.height)(null)})).attr("transform",(function(t,e){var r=t[0],o=n.rows[i].columns.indexOf(r);return"translate("+(n.getColumnBounds(i,o).topLeft.x+r.width/2)+", "+r.height/2+")"})).attr("fill",(function(t){return o._colorScale.scale(t[0].data.name)})).attr("opacity",(function(t,e){return o.symbolOpacity()(t[0].data.name,i)})).classed(e.LEGEND_SYMBOL_CLASS,!0),l.append("g").classed("text-container",!0).attr("transform",(function(t,e){var r=n.rows[i].columns.indexOf(t[1]);return"translate("+n.getColumnBounds(i,r).topLeft.x+", 0)"})).each((function(t,e,n){var i=Uht.select(this),r=t[1];o._writer.write(o._formatter(r.data.name),r.width,o.height(),{xAlign:"left",yAlign:"top",textRotation:0},i.node())})),s.exit().remove()})),this},e.prototype.symbol=function(t){return null==t?this._symbolFactoryAccessor:(this._symbolFactoryAccessor=t,this.render(),this)},e.prototype.symbolOpacity=function(t){return null==t?this._symbolOpacityAccessor:(this._symbolOpacityAccessor="number"==typeof t?function(){return t}:t,this.render(),this)},e.prototype.fixedWidth=function(){return!0},e.prototype.fixedHeight=function(){return!0},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},e.LEGEND_ROW_CLASS="legend-row",e.LEGEND_ENTRY_CLASS="legend-entry",e.LEGEND_SYMBOL_CLASS="legend-symbol",e})(pmt.Component);e.Legend=r})),egt=be((function(t,e){var n;
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),(n=e.Animator||(e.Animator={})).MAIN="main",n.RESET="reset"}));function ngt(t){return!0===(function t(e){return null!=e&&"object"==typeof e&&!1===Array.isArray(e)})(t)&&"[object Object]"===Object.prototype.toString.call(t)}var igt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=0,i=(function(){function t(t,e){void 0===t&&(t=[]),void 0===e&&(e={}),this._updateId=n++,this._data=t,this._metadata=e,this._callbacks=new umt.CallbackSet}return t.prototype.onUpdate=function(t){return this._callbacks.add(t),this},t.prototype.offUpdate=function(t){return this._callbacks.delete(t),this},t.prototype.data=function(t){return null==t?this._data:(this._data=t,this._dispatchUpdate(),this)},t.prototype.metadata=function(t){return null==t?this._metadata:(this._metadata=t,this._dispatchUpdate(),this)},t.prototype.updateId=function(){return this._updateId},t.prototype._dispatchUpdate=function(){this._updateId=n++,this._callbacks.callCallbacks(this)},t})();e.Dataset=i})),rgt=be((function(t,e){function n(t){return t instanceof l?t:t instanceof Date?o(t.valueOf()):t instanceof bmt.Scale?i(t):t instanceof igt.Dataset?r(t):(function t(e){var n,i;return!1!==ngt(e)&&"function"==typeof(n=e.constructor)&&!1!==ngt(i=n.prototype)&&!1!==i.hasOwnProperty("isPrototypeOf")})(t)?s(t):Array.isArray(t)?a(t):o(t)}function i(t){return s({domain:t.domain(),range:t.range(),updateId:t.updateId(),ref:o(t)})}function r(t){return s({ref:o(t),updateId:t.updateId()})}function o(t){return new u(t)}function a(t){return new c(t.map((function(t){return n(t)})))}function s(t){var e={};for(var i in t)t.hasOwnProperty(i)&&(e[i]=n(t[i]));return new h(e)}
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     * @fileoverview Implements the Signature API to help in comparing when two
     * Plottable objects have "changed".
     *
     * Memoization in Plottable is complicated by mutable scales and datasets. We cannot simply
     * reference compare two e.g. scales since it may have internally mutated. To resolve this,
     * we write a recursive Signature interface that holds an immutable snapshot of whatever
     * state the scale/data was in at the time. Then on memoized function invocation we sign the
     * new inputs and compare the signatures to decide if we should recompute.
     *
     * We must hand-write a signature for each custom class we wish to support.
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.sign=n,e.signScale=i,e.signDataset=r,e.signRef=o,e.signArray=a,e.signObj=s;var l=(function(){function t(){}return t.prototype.isDifferent=function(t){return!(t instanceof this.constructor)||this.isSignatureDifferent(t)},t})();e.Signature=l;var c=(function(t){function e(e){var n=t.call(this)||this;return n.array=e,n}return Sft.__extends(e,t),e.prototype.isSignatureDifferent=function(t){if(t.array.length!==this.array.length)return!0;for(var e=0;e<this.array.length;e++)if(this.array[e].isDifferent(t.array[e]))return!0;return!1},e})(l);e.ArraySignature=c;var u=(function(t){function e(e){var n=t.call(this)||this;return n.ref=e,n}return Sft.__extends(e,t),e.prototype.isSignatureDifferent=function(t){return this.ref!==t.ref},e})(l);e.ReferenceSignature=u;var h=(function(t){function e(e){var n=t.call(this)||this;return n.obj=e,n}return Sft.__extends(e,t),e.prototype.isSignatureDifferent=function(t){var e=Object.keys(this.obj),n=Object.keys(t.obj);if(e.length!==n.length)return!0;for(var i=0,r=e;i<r.length;i++){var o=r[i];if(!t.obj.hasOwnProperty(o))return!0;if(this.obj[o].isDifferent(t.obj[o]))return!0}return!1},e})(l);e.ObjectSignature=h})),ogt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     * @fileoverview Implements a function memoizer using the Signature API.
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.memoize=function n(t){var e,n=void 0,i=!1,r=!1,o=function(){for(var o=[],a=0;a<arguments.length;a++)o[a]=arguments[a];if(i)return e;var s=rgt.signArray(o);return void 0===n||n.isDifferent(s)?(r&&console.warn("cache miss! computing"),n=s,e=t.apply(this,o)):r&&console.warn("cache hit!"),e};return o.doLocked=function(t){if(i)throw new Error("Locking an already locked memoize function!");i=!0;var e=t.apply(this);return i=!1,e},o.logPerformance=function(t){return void 0===t&&(t=!0),r=t,this},o}})),agt=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){this.map=Object.create(null),this.exists=Object.create(null)}return t.prototype.delete=function(t){return delete this.map[t],delete this.exists[t],!0},t.prototype.get=function(t){return this.map[t]},t.prototype.has=function(t){return!!this.exists[t]},t.prototype.set=function(t,e){return this.map[t]=e,this.exists[t]=!0,this},t})(),i=(function(){function t(){this.map=new n}return t.prototype.get=function(t){return this.map.get(t[0]).get(t[1])},t.prototype.has=function(t){return this.map.has(t[0])&&this.map.get(t[0]).has(t[1])},t.prototype.set=function(t,e){return this.map.has(t[0])||this.map.set(t[0],new n),this.map.get(t[0]).set(t[1],e),this},t.prototype.delete=function(t){return this.map.has(t[0])&&this.map.get(t[0]).delete(t[1]),!0},t.prototype.clear=function(){this.map=new n},t.resolver=function(t,e,n){return[n.updateId(),e]},t})();function r(t){var e=Qft.memoize(t,i.resolver);return e.cache=new i,e}e.memoizeProjector=r,e.memoizeProjectors=function o(t){return Object.keys(t).forEach((function(e){t[e]=r(t[e])})),t}})),sgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     * @fileoverview Implements a convenient thunk function to handle the common case
     * of creating a memoized function that takes its inputs from mutable class properties.
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.memThunk=function n(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];var n=t.slice(0,-1),i=t[t.length-1],r=lgt.memoize(i),o=function(){var t=this,e=n.map((function(e){return e.apply(t)}));return r.apply(void 0,e)};return o}})),lgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(ogt,e),Sft.__exportStar(agt,e),Sft.__exportStar(sgt,e),e.sign=rgt.sign})),cgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e){this._context=t,this._drawStep=e}return t.prototype.getDrawStep=function(){return this._drawStep},t.prototype.draw=function(t,e){var n=e[e.length-1].attrToAppliedProjector;this._context.save(),this._drawStep(this._context,t,n),this._context.restore()},t.prototype.getVisualPrimitives=function(){return[]},t.prototype.getVisualPrimitiveAtIndex=function(t){return null},t.prototype.remove=function(){},t})();function i(t,e,n,i){for(var r={},o=0,a=e;o<a.length;o++){var s=a[o];t.hasOwnProperty(s)&&(r[s]=t[s](n,i))}return r}function r(t){return null!=t["stroke-width"]?parseFloat(t["stroke-width"]):1}function o(t){var e=t["stroke-dasharray"];if(null!=e)try{return e.split(/[ ,]+/).map((function(t){return parseInt(t,10)}))}catch(t){return console.error("getStrokeDashArray failed with: "+t),[]}return[]}function a(t,e){if(e.stroke){t.lineWidth=r(e);var n=Uht.color(e.stroke),i=o(e);t.setLineDash(i),n.opacity*=(function a(t){var e=null!=t.opacity?parseFloat(t.opacity):1;return(null!=t["stroke-opacity"]?parseFloat(t["stroke-opacity"]):1)*e})(e),t.strokeStyle=n.toString(),t.stroke()}if(e.fill){var s=Uht.color(e.fill);s.opacity*=(function l(t){var e=null!=t.opacity?parseFloat(t.opacity):1;return(null!=t["fill-opacity"]?parseFloat(t["fill-opacity"]):1)*e})(e),t.fillStyle=s.toString(),t.fill()}}e.CanvasDrawer=n,e.ContextStyleAttrs=["fill-opacity","fill","opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"],e.resolveAttributesSubsetWithStyles=function s(t,n,r,o){return i(t,e.ContextStyleAttrs.concat(n),r,o)},e.resolveAttributes=i,e.getStrokeWidth=r,e.getStrokeDashArray=o,e.renderArea=function l(t,e,n,i){t.save(),t.beginPath(),e.context(t),e(n),t.lineJoin="round",a(t,i),t.restore()},e.renderLine=function c(t,e,n,i){t.save(),t.beginPath(),e.context(t),e(n),t.lineJoin="round",a(t,i),t.restore()},e.renderPathWithStyle=a})),ugt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e){this._svgDrawerFactory=t,this._canvasDrawerFactory=e}return t.prototype.useSVG=function(t){null!=this._currentDrawer&&this._currentDrawer.remove();var e=this._svgDrawerFactory();e.attachTo(t),this._currentDrawer=e},t.prototype.useCanvas=function(t){null!=this._currentDrawer&&this._currentDrawer.remove(),this._currentDrawer=this._canvasDrawerFactory(t.node().getContext("2d"))},t.prototype.getDrawer=function(){return this._currentDrawer},t.prototype.remove=function(){null!=this._currentDrawer&&this._currentDrawer.remove()},t.prototype.draw=function(t,e){this._currentDrawer.draw(t,e)},t.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()},t.prototype.getVisualPrimitiveAtIndex=function(t){return this._currentDrawer.getVisualPrimitiveAtIndex(t)},t})();e.ProxyDrawer=n})),hgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(t,e){this._root=Uht.select(document.createElementNS("http://www.w3.org/2000/svg","g")),this._className=e,this._svgElementName=t}return t.prototype.draw=function(t,e){var n=this;this._createAndDestroyDOMElements(t);for(var i=0,r=e.length,o=function(r){var o=e[r];umt.Window.setTimeout((function(){return n._drawStep(o)}),i),i+=o.animator.totalTime(t.length)},a=0;a<r;a++)o(a)},t.prototype.getVisualPrimitives=function(){return null==this._cachedVisualPrimitivesNodes&&(this._cachedVisualPrimitivesNodes=this._selection.nodes()),this._cachedVisualPrimitivesNodes},t.prototype.getVisualPrimitiveAtIndex=function(t){return null==this._cachedVisualPrimitivesNodeMap?null:this._cachedVisualPrimitivesNodeMap.get(t)},t.prototype.remove=function(){this._root.remove()},t.prototype.attachTo=function(t){t.node().appendChild(this._root.node())},t.prototype.getRoot=function(){return this._root},t.prototype.selector=function(){return this._svgElementName},t.prototype._applyDefaultAttributes=function(t){},t.prototype._createAndDestroyDOMElements=function(t){var e=t.map((function(t,e){return null!=t?{d:t,i:e}:null})).filter((function(t){return null!=t})),n=this._root.selectAll(this.selector()).data(e);this._selection=n.enter().append(this._svgElementName).merge(n),n.exit().remove();var i=new umt.Map;this._selection.each((function(t){i.set(t.i,this)})),this._cachedVisualPrimitivesNodeMap=i,this._cachedVisualPrimitivesNodes=null,this._selection.data(this._selection.data().map((function(t){return t.d}))),null!=this._className&&this._selection.classed(this._className,!0),this._applyDefaultAttributes(this._selection)},t.prototype._drawStep=function(t){var e=this;["fill","stroke"].forEach((function(n){null!=t.attrToAppliedProjector[n]&&e._selection.attr(n,t.attrToAppliedProjector[n])})),t.animator.animate(this._selection,t.attrToAppliedProjector),null!=this._className&&this._selection.classed(this._className,!0)},t})();e.SVGDrawer=n})),dgt=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(){var t=this;this.scale=0,this.translate=0,this.cachedDomain=[null,null],this.lastSeenDomain=[null,null],this.updateDomain=function(e){t.lastSeenDomain=e.getTransformationDomain();var n=e.scaleTransformation(t.cachedDomain[1])-e.scaleTransformation(t.cachedDomain[0]),i=e.scaleTransformation(t.lastSeenDomain[1])-e.scaleTransformation(t.lastSeenDomain[0]);t.scale=n/i||1,t.translate=e.scaleTransformation(t.cachedDomain[0])-e.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}return t.prototype.reset=function(){this.scale=1,this.translate=0,this.cachedDomain=this.lastSeenDomain},t.prototype.setDomain=function(t){this.cachedDomain=t.getTransformationDomain()},t})(),i=(function(){function t(e,i){var r=this;this.renderCallback=e,this.applyTransformCallback=i,this.domainTransformX=new n,this.domainTransformY=new n,this.renderDeferred=function(){r.applyTransform(),clearTimeout(r.timeoutToken),r.timeoutToken=setTimeout((function(){r.renderCallback()}),t.DEFERRED_RENDERING_DELAY)}}return t.prototype.setDomains=function(t,e){t&&this.domainTransformX.setDomain(t),e&&this.domainTransformY.setDomain(e),this.renderDeferred()},t.prototype.updateDomains=function(t,e){t&&this.domainTransformX.updateDomain(t),e&&this.domainTransformY.updateDomain(e),this.renderDeferred()},t.prototype.resetTransforms=function(){this.domainTransformX.reset(),this.domainTransformY.reset(),this.applyTransform()},t.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)},t.DEFERRED_RENDERING_DELAY=200,t})();e.DeferredRenderer=i})),pgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.Renderer=vft.makeEnum(["svg","canvas"]);var n=(function(t){function e(){var n=t.call(this)||this;n._dataChanged=!1,n._attrExtents={},n._animate=!1,n._animators={},n._propertyExtents={},n._resetEntityStore=function(){n._cachedEntityStore=void 0},n._overflowHidden=!0,n.addClass("plot"),n._datasetToDrawer=new umt.Map,n._attrBindings=Uht.map(),n._includedValuesProvider=function(t,e){return n._includedValuesForScale(t,e)},n._renderCallback=function(){return n.render()},n._onDatasetUpdateCallback=function(){return n._onDatasetUpdate()},n._propertyBindings=Uht.map();var i=(new Mft.Easing).maxTotalDuration(e._ANIMATION_MAX_DURATION);return n.animator(egt.Animator.MAIN,i),n.animator(egt.Animator.RESET,new Mft.Null),n._deferredResetEntityStore=umt.Window.debounce(dgt.DeferredRenderer.DEFERRED_RENDERING_DELAY,n._resetEntityStore),n}return Sft.__extends(e,t),e.getTotalDrawTime=function(t,e){return e.reduce((function(e,n){return e+n.animator.totalTime(t.length)}),0)},e.applyDrawSteps=function(t,e){return t.map((function(t){var n=t.attrToProjector,i={};return Object.keys(n).forEach((function(t){i[t]=function(i,r){return n[t](i,r,e)}})),{attrToAppliedProjector:i,animator:t.animator}}))},e.prototype.anchor=function(e){return e=yft.coerceExternalD3(e),t.prototype.anchor.call(this,e),this._dataChanged=!0,this._resetEntityStore(),this._updateExtents(),this},e.prototype._setup=function(){var e=this;this._isSetup||(t.prototype._setup.call(this),null!=this._canvas&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",!0),this.datasets().forEach((function(t){return e._createNodesForDataset(t)})))},e.prototype._appendCanvasNode=function(){var t=this.element().select(".plot-canvas-container");t.empty()&&(t=this.element().append("div").classed("plot-canvas-container",!0)).node().appendChild(this._canvas.node())},e.prototype.setBounds=function(e,n,i,r){if(t.prototype.setBounds.call(this,e,n,i,r),this._updateExtents(),null!=this._canvas){if(this._bufferCanvas&&!this._bufferCanvasValid){this._bufferCanvas.attr("width",this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height"));var o=this._bufferCanvas.node().getContext("2d");if(o){var a=this._canvas.node();a.width>0&&a.height>0?o.canvas.width>0&&o.canvas.height>0&&o.drawImage(a,0,0):console.warn("Failed to fill buffer canvas with with 0x0 canvas")}this._bufferCanvasValid=!0}var s=null!=window.devicePixelRatio?window.devicePixelRatio:1;this._canvas.attr("width",e*s),this._canvas.attr("height",n*s);var l=this._canvas.node().getContext("2d");if(l&&(l.setTransform(s,0,0,s,0,0),this._bufferCanvas)){var c=this._bufferCanvas.node();c.width>0&&c.height>0?l.canvas.width>0&&l.canvas.height>0&&l.drawImage(c,0,0,e,n):console.warn("Failed to fill canvas with 0x0 buffer canvas")}}return this},e.prototype.destroy=function(){var e=this;t.prototype.destroy.call(this),this._scales().forEach((function(t){return t.offUpdate(e._renderCallback)})),this.datasets([])},e.prototype._createNodesForDataset=function(t){var e=this._datasetToDrawer.get(t);return"svg"===this.renderer()?e.useSVG(this._renderArea):e.useCanvas(this._canvas),e},e.prototype._createDrawer=function(t){return new ugt.ProxyDrawer((function(){return new hgt.SVGDrawer("path","")}),(function(t){return new cgt.CanvasDrawer(t,(function(){}))}))},e.prototype._getAnimator=function(t){return this._animateOnNextRender()&&this._animators[t]||new Mft.Null},e.prototype._onDatasetUpdate=function(){this._updateExtents(),this._dataChanged=!0,this._resetEntityStore(),this.renderLowPriority()},e.prototype.attr=function(t,e,n){return null==e?this._attrBindings.get(t):(this._bindAttr(t,e,n),this.render(),this)},e.prototype._bindProperty=function(t,e,n,i){var r=this._propertyBindings.get(t),o=null!=r?r.scale:null;this._propertyBindings.set(t,{accessor:"function"==typeof e?e:function(){return e},scale:n,postScale:i}),null!=o&&this._uninstallScaleForKey(o,t),null!=n&&this._installScaleForKey(n,t),this._clearAttrToProjectorCache()},e.prototype._bindAttr=function(t,e,n){var i=this._attrBindings.get(t),r=null!=i?i.scale:null;this._attrBindings.set(t,{accessor:"function"==typeof e?e:function(){return e},scale:n}),null!=r&&this._uninstallScaleForKey(r,t),null!=n&&this._installScaleForKey(n,t),this._clearAttrToProjectorCache()},e.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector},e.prototype._getAttrToProjector=function(){if(null==this._cachedAttrToProjector){var t=this._generateAttrToProjector();e.OPTIMIZE_MEMOIZE_PROJECTORS&&(t=lgt.memoizeProjectors(t)),this._cachedAttrToProjector=t}return umt.assign({},this._cachedAttrToProjector)},e.prototype._generateAttrToProjector=function(){var t={};this._attrBindings.each((function(n,i){t[i]=e._scaledAccessor(n)}));var n=this._propertyProjectors();return Object.keys(n).forEach((function(e){null==t[e]&&(t[e]=n[e])})),t},e.prototype.renderImmediately=function(){return t.prototype.renderImmediately.call(this),this._isAnchored&&(this._paint(),this._dataChanged=!1),this},e.prototype.renderLowPriority=function(){return this._renderCallback(),this},e.prototype.animated=function(t){return null==t?this._animate:(this._animate=t,this)},e.prototype.detach=function(){return t.prototype.detach.call(this),this._updateExtents(),this},e.prototype._scales=function(){var t=[];return this._attrBindings.each((function(e,n){var i=e.scale;null!=i&&-1===t.indexOf(i)&&t.push(i)})),this._propertyBindings.each((function(e,n){var i=e.scale;null!=i&&-1===t.indexOf(i)&&t.push(i)})),t},e.prototype._updateExtents=function(){var t=this;this._resetEntityStore(),this._scales().forEach((function(e){return e.addIncludedValuesProvider(t._includedValuesProvider)}))},e.prototype._filterForProperty=function(t){return null},e.prototype.getExtentsForAttr=function(t){var e=this;if(null==this._attrExtents[t]){var n=lgt.memThunk((function(){return e.datasets()}),(function(){return e._attrBindings.get(t)}),(function(t,e){return null==e||null==e.accessor?null:t.map((function(t){return i(t,e,null)}))}));this._attrExtents[t]=n}return this._attrExtents[t]()},e.prototype.getExtentsForProperty=function(t){var e=this;if(null==this._propertyExtents[t]){var n=lgt.memThunk((function(){return e.datasets()}),(function(){return e._propertyBindings.get(t)}),(function(){return e._filterForProperty(t)}),(function(t,e,n){return null==e||null==e.accessor?null:t.map((function(t){return i(t,e,n)}))}));this._propertyExtents[t]=n}return this._propertyExtents[t]()},e.prototype._includedValuesForScale=function(t,e){var n=this;if(!this._isAnchored&&!e)return[];var i=[];return this._attrBindings.each((function(e,r){if(e.scale===t){var o=n.getExtentsForAttr(r);null!=o&&(i=i.concat(Uht.merge(o)))}})),this._propertyBindings.each((function(e,r){if(e.scale===t){var o=n.getExtentsForProperty(r);null!=o&&(i=i.concat(Uht.merge(o)))}})),i},e.prototype.animator=function(t,e){return void 0===e?this._animators[t]:(this._animators[t]=e,this)},e.prototype.renderer=function(t){var e=this;return void 0===t?null==this._canvas?"svg":"canvas":(null==this._canvas&&"canvas"===t?(this._canvas=Uht.select(document.createElement("canvas")).classed("plot-canvas",!0),this._bufferCanvas=Uht.select(document.createElement("canvas")),null!=this.element()&&this._appendCanvasNode(),this._datasetToDrawer.forEach((function(t){t.useCanvas(e._canvas)})),this.render()):null!=this._canvas&&"svg"==t&&(this._canvas.remove(),this._canvas=null,this._bufferCanvas=null,this._datasetToDrawer.forEach((function(t){t.useSVG(e._renderArea)})),this.render()),this)},e.prototype.addDataset=function(t){return this._addDataset(t),this._onDatasetUpdate(),this},e.prototype._addDataset=function(t){this._removeDataset(t);var e=this._createDrawer(t);return this._datasetToDrawer.set(t,e),this._isSetup&&this._createNodesForDataset(t),t.onUpdate(this._onDatasetUpdateCallback),this},e.prototype.removeDataset=function(t){return this._removeDataset(t),this._onDatasetUpdate(),this},e.prototype._removeDataset=function(t){return-1===this.datasets().indexOf(t)||(this._removeDatasetNodes(t),t.offUpdate(this._onDatasetUpdateCallback),this._datasetToDrawer.delete(t)),this},e.prototype._removeDatasetNodes=function(t){this._datasetToDrawer.get(t).remove()},e.prototype.datasets=function(t){var e=this,n=[];return this._datasetToDrawer.forEach((function(t,e){return n.push(e)})),null==t?n:(n.forEach((function(t){return e._removeDataset(t)})),t.forEach((function(t){return e._addDataset(t)})),this._onDatasetUpdate(),this)},e.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new Mft.Null}]},e.prototype._additionalPaint=function(t){},e.prototype._buildLightweightPlotEntities=function(t){var e=this,n=[];return t.forEach((function(t,i){for(var r=e._datasetToDrawer.get(t),o=0,a=t.data(),s=a.length,l=function(s){var l=a[s],c=e._pixelPoint(l,s,t);if(umt.Math.isNaN(c.x)||umt.Math.isNaN(c.y))return"continue";var u=e;n.push({datum:l,get position(){return u._pixelPoint.call(u,l,s,t)},index:s,dataset:t,datasetIndex:i,component:e,drawer:r,validDatumIndex:o}),o++},c=0;c<s;c++)l(c)})),n},e.prototype._getDataToDraw=function(){var t=new umt.Map;return this.datasets().forEach((function(e){return t.set(e,e.data())})),t},e.prototype._paint=function(){var t=this;delete this._cachedAttrToProjector;var n=this._generateDrawSteps(),i=this._getDataToDraw(),r=this.datasets().map((function(e){return t._datasetToDrawer.get(e)}));if("canvas"===this.renderer()){var o=this._canvas.node();o.getContext("2d").clearRect(0,0,o.clientWidth,o.clientHeight),this._bufferCanvasValid=!1}this.datasets().forEach((function(t,o){var a=e.applyDrawSteps(n,t);r[o].draw(i.get(t),a)}));var a=this.datasets().map((function(t,r){return e.getTotalDrawTime(i.get(t),n)})),s=umt.Math.max(a,0);this._additionalPaint(s)},e.prototype.selections=function(t){var e=this;if(void 0===t&&(t=this.datasets()),"canvas"===this.renderer())return Uht.selectAll();var n=[];return t.forEach((function(t){var i=e._datasetToDrawer.get(t);if(null!=i){var r=i.getVisualPrimitives();n.push.apply(n,r)}})),Uht.selectAll(n)},e.prototype.entities=function(t){var e=this;return this._getEntityStore(t).entities().map((function(t){return e._lightweightPlotEntityToPlotEntity(t)}))},e.prototype.filterEntities=function(t){var e=this;return this._getEntityStore().entities().filter(t).map((function(t){return e._lightweightPlotEntityToPlotEntity(t)}))},e.prototype._getEntityStore=function(t){var e,n=this,i=function(t){return n._entityBounds(t)};return void 0!==t?((e=new umt.EntityStore).addAll(this._buildLightweightPlotEntities(t),i,this._localOriginBounds()),e):(void 0===this._cachedEntityStore&&((e=new umt.EntityStore).addAll(this._buildLightweightPlotEntities(this.datasets()),i,this._localOriginBounds()),this._cachedEntityStore=e),this._cachedEntityStore)},e.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}},e.prototype._entityBounds=function(t){var e=this._pixelPoint(t.datum,t.index,t.dataset);return{x:e.x,y:e.y,width:0,height:0}},e.prototype._lightweightPlotEntityToPlotEntity=function(t){return{bounds:this._entityBounds(t),component:t.component,dataset:t.dataset,datasetIndex:t.datasetIndex,datum:t.datum,index:t.index,position:t.position,selection:Uht.select(t.drawer.getVisualPrimitiveAtIndex(t.validDatumIndex))}},e.prototype.entitiesAt=function(t){throw new Error("plots must implement entitiesAt")},e.prototype.entityNearest=function(t){var e=this._getEntityStore().entityNearest(t);return void 0===e?void 0:this._lightweightPlotEntityToPlotEntity(e)},e.prototype.entitiesIn=function(t,e){return this.entitiesInBounds(null==e?{x:t.topLeft.x,y:t.topLeft.y,width:t.bottomRight.x-t.topLeft.x,height:t.bottomRight.y-t.topLeft.y}:{x:t.min,y:e.min,width:t.max-t.min,height:e.max-e.min})},e.prototype.entitiesInBounds=function(t){var e=this,n=this._getEntityStore().entitiesInBounds(t);if(n)return n.map((function(t){return e._lightweightPlotEntityToPlotEntity(t)}))},e.prototype.entitiesInXBounds=function(t){var e=this,n=this._getEntityStore().entitiesInXBounds(t);if(n)return n.map((function(t){return e._lightweightPlotEntityToPlotEntity(t)}))},e.prototype.entitiesInYBounds=function(t){var e=this,n=this._getEntityStore().entitiesInYBounds(t);if(n)return n.map((function(t){return e._lightweightPlotEntityToPlotEntity(t)}))},e.prototype._uninstallScaleForKey=function(t,e){t.offUpdate(this._renderCallback),t.offUpdate(this._deferredResetEntityStore),t.removeIncludedValuesProvider(this._includedValuesProvider)},e.prototype._installScaleForKey=function(t,e){t.onUpdate(this._renderCallback),t.onUpdate(this._deferredResetEntityStore),t.addIncludedValuesProvider(this._includedValuesProvider)},e.prototype._propertyProjectors=function(){return{}},e._scaledAccessor=function(t){var e=t.scale,n=t.accessor,i=t.postScale,r=null==e?n:function(t,i,r){return e.scale(n(t,i,r))};return null==i?r:function(t,e,n){return i(r(t,e,n),t,e,n)}},e.prototype._pixelPoint=function(t,e,n){return{x:0,y:0}},e.prototype._animateOnNextRender=function(){return this._animate&&this._dataChanged},e.OPTIMIZE_MEMOIZE_PROJECTORS=!1,e._ANIMATION_MAX_DURATION=600,e})(pmt.Component);function i(t,e,n){var i=e.accessor,r=e.scale;if(null==r)return[];var o=t.data();null!=n&&(o=o.filter((function(e,i){return n(e,i,t)})));var a=o.map((function(e,n){return i(e,n,t)}));return r.extentOfValues(a)}e.Plot=n})),fgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return Sft.__extends(e,t),e.prototype.entityNearest=function(t){var e,n=1/0;return this.components().forEach((function(i){var r=i.entityNearest(t);if(null!=r){var o=umt.Math.distanceSquared(r.position,t);o<=n&&(n=o,e=r)}})),e},e.prototype.append=function(e){if(null!=e&&!(e instanceof pgt.Plot))throw new Error("Plot Group only accepts plots");return t.prototype.append.call(this,e),this},e})(Kmt.Group);e.PlotGroup=n})),mgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e=[]);var n=t.call(this)||this;return n._rowPadding=0,n._columnPadding=0,n._rows=[],n._rowWeights=[],n._columnWeights=[],n._nRows=0,n._nCols=0,n._calculatedLayout=null,n.addClass("table"),e.forEach((function(t,e){t.forEach((function(t,i){null!=t&&n.add(t,e,i)}))})),n}return Sft.__extends(e,t),e.prototype._forEach=function(t){for(var e=0;e<this._nRows;e++)for(var n=0;n<this._nCols;n++)null!=this._rows[e][n]&&t(this._rows[e][n])},e.prototype.has=function(t){for(var e=0;e<this._nRows;e++)for(var n=0;n<this._nCols;n++)if(this._rows[e][n]===t)return!0;return!1},e.prototype.componentAt=function(t,e){return t<0||t>=this._nRows||e<0||e>=this._nCols?null:this._rows[t][e]},e.prototype.add=function(t,e,n){if(null==t)throw Error("Cannot add null to a table cell");if(!this.has(t)){if(null!=(this._rows[e]&&this._rows[e][n]))throw new Error("cell is occupied");t.detach(),this._nRows=Math.max(e+1,this._nRows),this._nCols=Math.max(n+1,this._nCols),this._padTableToSize(this._nRows,this._nCols),this._rows[e][n]=t,this._adoptAndAnchor(t),this.redraw()}return this},e.prototype._remove=function(t){for(var e=0;e<this._nRows;e++)for(var n=0;n<this._nCols;n++)if(this._rows[e][n]===t)return this._rows[e][n]=null,!0;return!1},e.prototype._iterateLayout=function(t,n,i){void 0===i&&(i=!1);for(var r,o,a,s,l,c=this._rows,u=Uht.transpose(this._rows),h=t-this._columnPadding*(this._nCols-1),d=n-this._rowPadding*(this._nRows-1),p=e._calcComponentWeights(this._rowWeights,c,(function(t){return null==t||t.fixedHeight()})),f=e._calcComponentWeights(this._columnWeights,u,(function(t){return null==t||t.fixedWidth()})),m=f.map((function(t){return 0===t?.5:t})),g=p.map((function(t){return 0===t?.5:t})),_=e._calcProportionalSpace(m,h),y=e._calcProportionalSpace(g,d),v=umt.Array.createFilledArray(0,this._nCols),b=umt.Array.createFilledArray(0,this._nRows),x=0;;){var w=umt.Array.add(b,y),S=umt.Array.add(v,_);v=(a=this._determineGuarantees(S,w,i)).guaranteedWidths,b=a.guaranteedHeights,s=a.wantsWidthArr.some((function(t){return t})),l=a.wantsHeightArr.some((function(t){return t}));var M=r,E=o;r=h-Uht.sum(a.guaranteedWidths),o=d-Uht.sum(a.guaranteedHeights);var T=void 0;s?(T=a.wantsWidthArr.map((function(t){return t?.1:0})),T=umt.Array.add(T,f)):T=f;var A=void 0;if(l?(A=a.wantsHeightArr.map((function(t){return t?.1:0})),A=umt.Array.add(A,p)):A=p,_=e._calcProportionalSpace(T,r),y=e._calcProportionalSpace(A,o),x++,!(r>0&&r!==M||o>0&&o!==E))break;if(x>5)break}return r=h-Uht.sum(a.guaranteedWidths),o=d-Uht.sum(a.guaranteedHeights),{colProportionalSpace:_=e._calcProportionalSpace(f,r),rowProportionalSpace:y=e._calcProportionalSpace(p,o),guaranteedWidths:a.guaranteedWidths,guaranteedHeights:a.guaranteedHeights,wantsWidth:s,wantsHeight:l}},e.prototype._determineGuarantees=function(t,e,n){void 0===n&&(n=!1);var i=umt.Array.createFilledArray(0,this._nCols),r=umt.Array.createFilledArray(0,this._nRows),o=umt.Array.createFilledArray(!1,this._nCols),a=umt.Array.createFilledArray(!1,this._nRows);return this._rows.forEach((function(s,l){s.forEach((function(s,c){var u;u=null!=s?s.requestedSpace(t[c],e[l]):{minWidth:0,minHeight:0};var h=n?Math.min(u.minWidth,t[c]):u.minWidth;i[c]=Math.max(i[c],h);var d=n?Math.min(u.minHeight,e[l]):u.minHeight;r[l]=Math.max(r[l],d),o[c]=o[c]||u.minWidth>t[c],a[l]=a[l]||u.minHeight>e[l]}))})),{guaranteedWidths:i,guaranteedHeights:r,wantsWidthArr:o,wantsHeightArr:a}},e.prototype.requestedSpace=function(t,e){return this._calculatedLayout=this._iterateLayout(t,e),{minWidth:Uht.sum(this._calculatedLayout.guaranteedWidths),minHeight:Uht.sum(this._calculatedLayout.guaranteedHeights)}},e.prototype.computeLayout=function(e,n,i){var r=this;t.prototype.computeLayout.call(this,e,n,i);var o=Uht.sum(this._calculatedLayout.guaranteedWidths),a=Uht.sum(this._calculatedLayout.guaranteedHeights),s=this._calculatedLayout;(o>this.width()||a>this.height())&&(s=this._iterateLayout(this.width(),this.height(),!0));var l=0,c=umt.Array.add(s.rowProportionalSpace,s.guaranteedHeights),u=umt.Array.add(s.colProportionalSpace,s.guaranteedWidths);return this._rows.forEach((function(t,e){var n=0;t.forEach((function(t,i){null!=t&&t.computeLayout({x:n,y:l},u[i],c[e]),n+=u[i]+r._columnPadding})),l+=c[e]+r._rowPadding})),this},e.prototype.rowPadding=function(t){if(null==t)return this._rowPadding;if(!umt.Math.isValidNumber(t)||t<0)throw Error("rowPadding must be a non-negative finite value");return this._rowPadding=t,this.redraw(),this},e.prototype.columnPadding=function(t){if(null==t)return this._columnPadding;if(!umt.Math.isValidNumber(t)||t<0)throw Error("columnPadding must be a non-negative finite value");return this._columnPadding=t,this.redraw(),this},e.prototype.rowWeight=function(t,e){if(null==e)return this._rowWeights[t];if(!umt.Math.isValidNumber(e)||e<0)throw Error("rowWeight must be a non-negative finite value");return this._rowWeights[t]=e,this.redraw(),this},e.prototype.columnWeight=function(t,e){if(null==e)return this._columnWeights[t];if(!umt.Math.isValidNumber(e)||e<0)throw Error("columnWeight must be a non-negative finite value");return this._columnWeights[t]=e,this.redraw(),this},e.prototype.fixedWidth=function(){var t=Uht.transpose(this._rows);return e._fixedSpace(t,(function(t){return null==t||t.fixedWidth()}))},e.prototype.fixedHeight=function(){return e._fixedSpace(this._rows,(function(t){return null==t||t.fixedHeight()}))},e.prototype._padTableToSize=function(t,e){for(var n=0;n<t;n++){void 0===this._rows[n]&&(this._rows[n]=[],this._rowWeights[n]=null);for(var i=0;i<e;i++)void 0===this._rows[n][i]&&(this._rows[n][i]=null)}for(i=0;i<e;i++)void 0===this._columnWeights[i]&&(this._columnWeights[i]=null)},e._calcComponentWeights=function(t,e,n){return t.map((function(t,i){return null!=t?t:e[i].map(n).reduce((function(t,e){return t&&e}),!0)?0:1}))},e._calcProportionalSpace=function(t,e){var n=Uht.sum(t);return 0===n?umt.Array.createFilledArray(0,t.length):t.map((function(t){return e*t/n}))},e._fixedSpace=function(t,e){var n=function(t){return t.reduce((function(t,e){return t&&e}),!0)};return n(t.map((function(t){return n(t.map(e))})))},e})($mt.ComponentContainer);e.Table=n})),ggt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._maxLines=2,e}return Sft.__extends(e,t),e.prototype.requestedSpace=function(t,e){this._wrapper.maxLines(this._maxLines);var n=0===this.angle()?t:e;0===n&&(n=1/0);var i=this._wrapper.wrap(this._text,this._measurer,n),r=this._measurer.measure(i.wrappedText);return{minWidth:(0===this.angle()?r.width:r.height)+2*this.padding(),minHeight:(0===this.angle()?r.height:r.width)+2*this.padding()}},e.prototype.maxLines=function(t){return 0===arguments.length?this._maxLines:(this._maxLines=t,this.redraw(),this)},e})(Jmt.Label);e.WrappedLabel=n})),_gt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e.addClass("x-drag-box-layer"),e._hasCorners=!1,e}return Sft.__extends(e,t),e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),this._setBounds(this.bounds()),this},e.prototype._setBounds=function(e){t.prototype._setBounds.call(this,{topLeft:{x:e.topLeft.x,y:0},bottomRight:{x:e.bottomRight.x,y:this.height()}})},e.prototype._setResizableClasses=function(t){t&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")},e.prototype.yScale=function(e){if(null==e)return t.prototype.yScale.call(this);throw new Error("yScales cannot be set on an XDragBoxLayer")},e.prototype.yExtent=function(e){if(null==e)return t.prototype.yExtent.call(this);throw new Error("XDragBoxLayer has no yExtent")},e})(Wmt.DragBoxLayer);e.XDragBoxLayer=n})),ygt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e.addClass("y-drag-box-layer"),e._hasCorners=!1,e}return Sft.__extends(e,t),e.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),this._setBounds(this.bounds()),this},e.prototype._setBounds=function(e){t.prototype._setBounds.call(this,{topLeft:{x:0,y:e.topLeft.y},bottomRight:{x:this.width(),y:e.bottomRight.y}})},e.prototype._setResizableClasses=function(t){t&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")},e.prototype.xScale=function(e){if(null==e)return t.prototype.xScale.call(this);throw new Error("xScales cannot be set on an YDragBoxLayer")},e.prototype.xExtent=function(e){if(null==e)return t.prototype.xExtent.call(this);throw new Error("YDragBoxLayer has no xExtent")},e})(Wmt.DragBoxLayer);e.YDragBoxLayer=n})),vgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(Wmt,e),Sft.__exportStar(Ymt,e),Sft.__exportStar(Xmt,e),Sft.__exportStar(Kmt,e),Sft.__exportStar(qmt,e),Sft.__exportStar(Zmt,e),Sft.__exportStar(Jmt,e),Sft.__exportStar(tgt,e),Sft.__exportStar(fgt,e),Sft.__exportStar(Gmt,e),Sft.__exportStar(mgt,e),Sft.__exportStar(ggt,e),Sft.__exportStar(_gt,e),Sft.__exportStar(ygt,e)})),bgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"path","arc fill")||this}return Sft.__extends(e,t),e.prototype._applyDefaultAttributes=function(t){t.style("stroke","none")},e})(hgt.SVGDrawer);e.ArcSVGDrawer=n})),xgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"path","arc outline")||this}return Sft.__extends(e,t),e.prototype._applyDefaultAttributes=function(t){t.style("fill","none")},e})(hgt.SVGDrawer);e.ArcOutlineSVGDrawer=n})),wgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"path","area")||this}return Sft.__extends(e,t),e.prototype._applyDefaultAttributes=function(t){t.style("stroke","none")},e.prototype.getVisualPrimitiveAtIndex=function(e){return t.prototype.getVisualPrimitiveAtIndex.call(this,0)},e})(hgt.SVGDrawer);e.AreaSVGDrawer=n;var i=["opacity","fill","fill-opacity"],r=["opacity","stroke","stroke-width"];e.makeAreaCanvasDrawStep=function o(t,e){return function(n,o,a){var s=cgt.resolveAttributes(a,i,o[0],0);cgt.renderArea(n,t(),o[0],s);var l=cgt.resolveAttributes(a,r,o[0],0);cgt.renderLine(n,e(),o[0],l)}}})),Sgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"path","line")||this}return Sft.__extends(e,t),e.prototype._applyDefaultAttributes=function(t){t.style("fill","none")},e.prototype.getVisualPrimitiveAtIndex=function(e){return t.prototype.getVisualPrimitiveAtIndex.call(this,0)},e})(hgt.SVGDrawer);e.LineSVGDrawer=n;var i=["opacity","stroke-opacity","stroke-width","stroke","stroke-dasharray"];e.makeLineCanvasDrawStep=function r(t){return function(e,n,r){var o=cgt.resolveAttributes(r,i,n[0],0);cgt.renderLine(e,t(),n[0],o)}}})),Mgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e="");var n=t.call(this,"rect","")||this;return n._rootClassName=e,n._root.classed(n._rootClassName,!0),n}return Sft.__extends(e,t),e})(hgt.SVGDrawer);e.RectangleSVGDrawer=n;var i=cgt.ContextStyleAttrs.concat(["x","y","width","height"]);e.RectangleCanvasDrawStep=function(t,e,n){t.save();for(var r=e.length,o=0;o<r;o++){var a=e[o];if(null!=a){var s=cgt.resolveAttributes(n,i,a,o);t.beginPath(),t.rect(s.x,s.y,s.width,s.height),cgt.renderPathWithStyle(t,s)}}t.restore()};var r=(function(t){function n(n){return t.call(this,n,e.RectangleCanvasDrawStep)||this}return Sft.__extends(n,t),n})(cgt.CanvasDrawer);e.RectangleCanvasDrawer=r})),Egt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"line","")||this}return Sft.__extends(e,t),e})(hgt.SVGDrawer);e.SegmentSVGDrawer=n})),Tgt=be((function(t,e){
/**
     * Copyright 2017-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(){function t(e,n,i){void 0===i&&(i=window.devicePixelRatio),this.screenWidth=e,this.screenHeight=n,this.devicePixelRatio=i,this.pixelWidth=e*i,this.pixelHeight=n*i,this.canvas=document.createElement("canvas"),this.ctx=this.canvas.getContext("2d"),t.sizePixels(this.ctx,e,n,i)}return t.sizePixels=function(t,e,n,i){var r=t.canvas;r.width=e*i,r.height=n*i,r.style.width=e+"px",r.style.height=n+"px",t.setTransform(1,0,0,1,0,0),t.scale(i,i)},t.prototype.blit=function(t,e,n){void 0===e&&(e=0),void 0===n&&(n=0),t.drawImage(this.canvas,e,n,this.screenWidth,this.screenHeight)},t.prototype.blitCenter=function(t,e,n){void 0===e&&(e=0),void 0===n&&(n=0),this.blit(t,Math.floor(e-this.screenWidth/2),Math.floor(n-this.screenHeight/2))},t.prototype.resize=function(e,n,i){void 0===i&&(i=!1);var r=this.devicePixelRatio;return this.screenWidth=e,this.screenHeight=n,this.pixelWidth=e*r,this.pixelHeight=n*r,t.sizePixels(this.ctx,e,n,r),i&&this.ctx.translate(e/2,e/2),this},t.prototype.clear=function(t){var e=this,n=e.pixelWidth,i=e.pixelHeight,r=e.ctx;return r.save(),r.setTransform(1,0,0,1,0,0),null==t?r.clearRect(0,0,n,i):(r.fillStyle=t,r.fillRect(0,0,n,i)),r.restore(),this},t.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)},t})();e.CanvasBuffer=n})),Agt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){return t.call(this,"path","symbol")||this}return Sft.__extends(e,t),e})(hgt.SVGDrawer);e.SymbolSVGDrawer=n;var i=cgt.ContextStyleAttrs.concat(["x","y"]);function r(t,e,n,i,r){return n+r>=0&&n-r<=t&&i+r>=0&&i-r<=e}function o(t,e,n){if(null==t)return!1;for(var i=0;i<n.length;i++){var r=n[i];if(t[r]!=e[r])return!1}return!0}e.makeSymbolCanvasDrawStep=function a(t,e,n,s){var l=this;return function(a,c,u){for(var h=a.canvas,d=h.clientWidth,p=h.clientHeight,f=void 0===s?new Tgt.CanvasBuffer(0,0):s,m=e(),g=n(),_=null,y=null,v=null,b=0;b<c.length;b++){var x=c[b];if(null!=x){var w=cgt.resolveAttributes(u,i,x,b),S=g(x,b,t);if(r(d,p,w.x,w.y,S)){var M=o(_,w,cgt.ContextStyleAttrs),E=m(x,b,l._dataset);if(M&&v==S&&y==E);else{var T=S+cgt.getStrokeWidth(w)+1;(T>f.screenWidth||T>f.screenHeight)&&f.resize(T,T,!0),f.clear();var A=f.ctx;A.beginPath(),E(S).context(A)(null),A.closePath(),cgt.renderPathWithStyle(A,w),y=E,v=S,_=w}f.blitCenter(a,w.x,w.y)}}}}}})),Cgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(bgt,e),Sft.__exportStar(xgt,e),Sft.__exportStar(wgt,e),Sft.__exportStar(cgt,e),Sft.__exportStar(ugt,e),Sft.__exportStar(Sgt,e),Sft.__exportStar(Mgt,e),Sft.__exportStar(Egt,e),Sft.__exportStar(hgt,e),Sft.__exportStar(Agt,e)})),kgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._autoAdjustXScaleDomain=!1,e._autoAdjustYScaleDomain=!1,e._deferredRendering=!1,e._applyDeferredRenderingTransform=function(t,n,i,r){e._isAnchored&&(null!=e._renderArea&&e._renderArea.attr("transform","translate("+t+", "+n+") scale("+i+", "+r+")"),null!=e._canvas&&e._canvas.style("transform","translate("+t+"px, "+n+"px) scale("+i+", "+r+")"))},e.addClass("xy-plot"),e._adjustYDomainOnChangeFromXCallback=function(t){return e._adjustYDomainOnChangeFromX()},e._adjustXDomainOnChangeFromYCallback=function(t){return e._adjustXDomainOnChangeFromY()},e._renderCallback=function(){if(e.deferredRendering()){var t=e.x()&&e.x().scale,n=e.y()&&e.y().scale;e._deferredRenderer.updateDomains(t,n)}else e.render()},e._deferredRenderer=new dgt.DeferredRenderer((function(){return e.render()}),e._applyDeferredRenderingTransform),e}return Sft.__extends(e,t),e.prototype.render=function(){return this.deferredRendering()&&this._deferredRenderer.resetTransforms(),t.prototype.render.call(this)},e.prototype.deferredRendering=function(t){if(null==t)return this._deferredRendering;if(t){var e=this.x()&&this.x().scale,n=this.y()&&this.y().scale;this._deferredRenderer.setDomains(e,n)}return this._deferredRendering=t,this},e.prototype.x=function(t,n,i){if(null==t)return this._propertyBindings.get(e._X_KEY);this._bindProperty(e._X_KEY,t,n,i);var r=this.width();return null!=n&&null!=r&&n.range([0,r]),this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain(),this.render(),this},e.prototype.y=function(t,n,i){if(null==t)return this._propertyBindings.get(e._Y_KEY);this._bindProperty(e._Y_KEY,t,n,i);var r=this.height();return null!=n&&null!=r&&n.range(n instanceof kmt.Category?[0,r]:[r,0]),this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain(),this.render(),this},e.prototype._filterForProperty=function(t){return"x"===t&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):"y"!==t&&"y0"!==t||!this._autoAdjustYScaleDomain?null:this._makeFilterByProperty("x")},e.prototype._makeFilterByProperty=function(t){var e=this._propertyBindings.get(t);if(null!=e){var n=e.accessor,i=e.scale;if(null!=i)return function(t,e,r){var o=i.range();return umt.Math.inRange(i.scale(n(t,e,r)),o[0],o[1])}}return null},e.prototype._uninstallScaleForKey=function(n,i){t.prototype._uninstallScaleForKey.call(this,n,i),n.offUpdate(i===e._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)},e.prototype._installScaleForKey=function(n,i){t.prototype._installScaleForKey.call(this,n,i),n.onUpdate(i===e._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)},e.prototype.destroy=function(){return t.prototype.destroy.call(this),this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback),this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback),this},e.prototype.autorangeMode=function(t){if(null==t)return this._autoAdjustXScaleDomain?"x":this._autoAdjustYScaleDomain?"y":"none";switch(t){case"x":this._autoAdjustXScaleDomain=!0,this._autoAdjustYScaleDomain=!1,this._adjustXDomainOnChangeFromY();break;case"y":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!0,this._adjustYDomainOnChangeFromX();break;case"none":this._autoAdjustXScaleDomain=!1,this._autoAdjustYScaleDomain=!1;break;default:throw new Error("Invalid scale name '"+t+"', must be 'x', 'y' or 'none'")}return this},e.prototype.computeLayout=function(e,n,i){t.prototype.computeLayout.call(this,e,n,i);var r=this.x(),o=r&&r.scale;null!=o&&o.range([0,this.width()]);var a=this.y(),s=a&&a.scale;return null!=s&&s.range(s instanceof kmt.Category?[0,this.height()]:[this.height(),0]),this},e.prototype._updateXExtentsAndAutodomain=function(){var t=this.x().scale;null!=t&&t.autoDomain()},e.prototype._updateYExtentsAndAutodomain=function(){var t=this.y().scale;null!=t&&t.autoDomain()},e.prototype.showAllData=function(){return this._updateXExtentsAndAutodomain(),this._updateYExtentsAndAutodomain(),this},e.prototype._adjustYDomainOnChangeFromX=function(){this._projectorsReady()&&this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()},e.prototype._adjustXDomainOnChangeFromY=function(){this._projectorsReady()&&this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()},e.prototype._projectorsReady=function(){var t=this.x(),e=this.y();return null!=t&&null!=t.accessor&&null!=e&&null!=e.accessor},e.prototype._pixelPoint=function(t,e,n){var i=pgt.Plot._scaledAccessor(this.x()),r=pgt.Plot._scaledAccessor(this.y());return{x:i(t,e,n),y:r(t,e,n)}},e.prototype._getDataToDraw=function(){var e=this,n=t.prototype._getDataToDraw.call(this),i=this.attr("defined");return this.datasets().forEach((function(t){n.set(t,n.get(t).filter((function(n,r){return(function(t,n,r){var o=pgt.Plot._scaledAccessor(e.x())(t,n,r),a=pgt.Plot._scaledAccessor(e.y())(t,n,r);return(!i||!1!==i.accessor(t,n,r))&&umt.Math.isValidNumber(o)&&umt.Math.isValidNumber(a)})(n,r,t)})))})),n},e._X_KEY="x",e._Y_KEY="y",e})(pgt.Plot);e.XYPlot=n})),Lgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n={linear:Uht.curveLinear,linearClosed:Uht.curveLinearClosed,step:Uht.curveStep,stepBefore:Uht.curveStepBefore,stepAfter:Uht.curveStepAfter,basis:Uht.curveBasis,basisOpen:Uht.curveBasisOpen,basisClosed:Uht.curveBasisClosed,bundle:Uht.curveBundle,cardinal:Uht.curveCardinal,cardinalOpen:Uht.curveCardinalOpen,cardinalClosed:Uht.curveCardinalClosed,monotone:Uht.curveMonotoneX};e.CurveName=vft.makeEnum(["linear","linearClosed","step","stepBefore","stepAfter","basis","basisOpen","basisClosed","bundle","cardinal","cardinalOpen","cardinalClosed","monotone"]);var i=(function(t){function e(){var e=t.call(this)||this;e._curve="linear",e._autorangeSmooth=!1,e._croppedRenderingEnabled=!0,e._collapseDenseVerticalLinesEnabled=!1,e._downsamplingEnabled=!1,e.addClass("line-plot");var n=new Mft.Easing;return n.stepDuration(pgt.Plot._ANIMATION_MAX_DURATION),n.easingMode("expInOut"),n.maxTotalDuration(pgt.Plot._ANIMATION_MAX_DURATION),e.animator(Vgt.Animator.MAIN,n),e.attr("stroke",(new kmt.Color).range()[0]),e.attr("stroke-width","2px"),e}return Sft.__extends(e,t),e.prototype.x=function(e,n,i){return null==e?t.prototype.x.call(this):(t.prototype.x.call(this,e,n,i),this._setScaleSnapping(),this)},e.prototype.y=function(e,n,i){return null==e?t.prototype.y.call(this):(t.prototype.y.call(this,e,n,i),this._setScaleSnapping(),this)},e.prototype.autorangeMode=function(e){return null==e?t.prototype.autorangeMode.call(this):(t.prototype.autorangeMode.call(this,e),this._setScaleSnapping(),this)},e.prototype.autorangeSmooth=function(t){return null==t?this._autorangeSmooth:(this._autorangeSmooth=t,this._setScaleSnapping(),this)},e.prototype._setScaleSnapping=function(){"x"===this.autorangeMode()&&this.x()&&this.x().scale&&this.x().scale instanceof Mmt.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth()),"y"===this.autorangeMode()&&this.y()&&this.y().scale&&this.y().scale instanceof Mmt.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())},e.prototype.curve=function(t){return null==t?this._curve:(this._curve=t,this.render(),this)},e.prototype.downsamplingEnabled=function(t){return null==t?this._downsamplingEnabled:(this._downsamplingEnabled=t,this)},e.prototype.croppedRenderingEnabled=function(t){return null==t?this._croppedRenderingEnabled:(this._croppedRenderingEnabled=t,this.render(),this)},e.prototype.collapseDenseLinesEnabled=function(t){return null==t?this._collapseDenseVerticalLinesEnabled:(this._collapseDenseVerticalLinesEnabled=t,this.render(),this)},e.prototype._createDrawer=function(t){var e=this;return new ugt.ProxyDrawer((function(){return new Sgt.LineSVGDrawer}),(function(n){return new Cgt.CanvasDrawer(n,Sgt.makeLineCanvasDrawStep((function(){return e._d3LineFactory(t)})))}))},e.prototype.getExtentsForProperty=function(e){var n=t.prototype.getExtentsForProperty.call(this,e);if(!this._autorangeSmooth)return n;if(this.autorangeMode()!==e)return n;if("x"!==this.autorangeMode()&&"y"!==this.autorangeMode())return n;var i,r=this._getEdgeIntersectionPoints();return i="y"===this.autorangeMode()?r.left.concat(r.right).map((function(t){return t.y})):r.top.concat(r.bottom).map((function(t){return t.x})),n.map((function(t){return Uht.extent(Uht.merge([t,i]))}))},e.prototype._getEdgeIntersectionPoints=function(){var t=this;if(!(this.y().scale instanceof Mmt.QuantitativeScale&&this.x().scale instanceof Mmt.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};var e=this.y().scale,n=this.x().scale,i={left:[],right:[],top:[],bottom:[]},r=n.scale(n.domain()[0]),o=n.scale(n.domain()[1]),a=e.scale(e.domain()[0]),s=e.scale(e.domain()[1]);return this.datasets().forEach((function(l){for(var c,u,h,d,p=l.data(),f=1;f<p.length;f++)c=h||n.scale(t.x().accessor(p[f-1],f-1,l)),u=d||e.scale(t.y().accessor(p[f-1],f-1,l)),h=n.scale(t.x().accessor(p[f],f,l)),d=e.scale(t.y().accessor(p[f],f,l)),c<r==r<=h&&i.left.push({x:r,y:e.invert(u+(r-c)*(d-u)/(h-c))}),c<o==o<=h&&i.right.push({x:o,y:e.invert(u+(o-c)*(d-u)/(h-c))}),u<s==s<=d&&i.top.push({x:n.invert(c+(s-u)*(h-c)/(d-u)),y:s}),u<a==a<=d&&i.bottom.push({x:n.invert(c+(a-u)*(h-c)/(d-u)),y:a})})),i},e.prototype._getResetYFunction=function(){var t=this.y().scale.domain(),e=Math.max(t[0],t[1]),n=Math.min(t[0],t[1]),i=e<0&&e||n>0&&n||0,r=this.y().scale.scale(i);return function(t,e,n){return r}},e.prototype._generateDrawSteps=function(){var t=[];if(this._animateOnNextRender()){var e=this._getAttrToProjector();e.d=this._constructLineProjector(pgt.Plot._scaledAccessor(this.x()),this._getResetYFunction()),t.push({attrToProjector:e,animator:this._getAnimator(Vgt.Animator.RESET)})}return t.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Vgt.Animator.MAIN)}),t},e.prototype._generateAttrToProjector=function(){var e=t.prototype._generateAttrToProjector.call(this);return Object.keys(e).forEach((function(t){if("d"!==t){var n=e[t];e[t]=function(t,e,i){return t.length>0?n(t[0],e,i):null}}})),e},e.prototype.entitiesAt=function(t){var e=this.entityNearestByXThenY(t);return null!=e?[e]:[]},e.prototype.entityNearestByXThenY=function(t){for(var e,n=1/0,i=1/0,r=this.bounds(),o=this.entities(),a=o.length,s=0;s<a;s++){var l=o[s];if(umt.Math.within(l.position,r)){var c=Math.abs(t.x-l.position.x),u=Math.abs(t.y-l.position.y);(c<n||c===n&&u<i)&&(e=l,n=c,i=u)}}return e},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this);return e.d=this._constructLineProjector(pgt.Plot._scaledAccessor(this.x()),pgt.Plot._scaledAccessor(this.y())),e},e.prototype._constructLineProjector=function(t,e){var n=this;return function(i,r,o){return n._d3LineFactory(o,t,e)(i)}},e.prototype._d3LineFactory=function(t,e,n){return void 0===e&&(e=pgt.Plot._scaledAccessor(this.x())),void 0===n&&(n=pgt.Plot._scaledAccessor(this.y())),Uht.line().x((function(n,i){return e(n,i,t)})).y((function(e,i){return n(e,i,t)})).curve(this._getCurveFactory()).defined((function(i,r){return(function(t,i,r){var o=e(t,i,r),a=n(t,i,r);return umt.Math.isValidNumber(o)&&umt.Math.isValidNumber(a)})(i,r,t)}))},e.prototype._getCurveFactory=function(){var t=this.curve();if("string"==typeof t){var e=n[t];return null==e?n.linear:e}return t},e.prototype._getDataToDraw=function(){var t=this,e=new umt.Map;return this.datasets().forEach((function(n){var i=n.data();if(t._croppedRenderingEnabled||t._downsamplingEnabled){for(var r=[],o=i.length,a=0;a<o;a++)r[a]=a;t._croppedRenderingEnabled&&(r=t._filterCroppedRendering(n,r)),t._downsamplingEnabled&&(r=t._filterDownsampling(n,r)),t._collapseDenseVerticalLinesEnabled&&(r=t._filterDenseLines(n,r));var s=[],l=r.length;for(a=0;a<l;a++)s[a]=i[r[a]];e.set(n,[s])}else e.set(n,[i])})),e},e.prototype._filterCroppedRendering=function(t,e){for(var n=this,i=pgt.Plot._scaledAccessor(this.x()),r=pgt.Plot._scaledAccessor(this.y()),o=t.data(),a=[],s=function(t,e){return umt.Math.inRange(t,0,n.width())&&umt.Math.inRange(e,0,n.height())},l=0;l<e.length;l++){var c=s(i(o[e[l]],e[l],t),r(o[e[l]],e[l],t));if(!c&&null!=e[l-1]&&null!=o[e[l-1]]){var u=i(o[e[l-1]],e[l-1],t),h=r(o[e[l-1]],e[l-1],t);c=c||s(u,h)}if(!c&&null!=e[l+1]&&null!=o[e[l+1]]){var d=i(o[e[l+1]],e[l+1],t),p=r(o[e[l+1]],e[l+1],t);c=c||s(d,p)}c&&a.push(e[l])}return a},e.prototype._filterDownsampling=function(t,e){if(0===e.length)return[];for(var n=t.data(),i=pgt.Plot._scaledAccessor(this.x()),r=pgt.Plot._scaledAccessor(this.y()),o=[e[0]],a=function(o,a){var s=i(n[e[o]],e[o],t),l=r(n[e[o]],e[o],t),c=i(n[e[o+1]],e[o+1],t),u=r(n[e[o+1]],e[o+1],t);if(a===1/0)return Math.floor(s)===Math.floor(c);var h=l+(c-s)*a;return Math.floor(u)===Math.floor(h)},s=0;s<e.length-1;){for(var l=e[s],c=i(n[e[s]],e[s],t),u=r(n[e[s]],e[s],t),h=i(n[e[s+1]],e[s+1],t),d=r(n[e[s+1]],e[s+1],t),p=Math.floor(c)===Math.floor(h)?1/0:(d-u)/(h-c),f=e[s],m=p===1/0?u:c,g=f,_=m,y=!0;s<e.length-1&&(y||a(s,p));){s++,y=!1;var v=p===1/0?r(n[e[s]],e[s],t):i(n[e[s]],e[s],t);v>_&&(_=v,g=e[s]),v<m&&(m=v,f=e[s])}var b=e[s];f!==l&&o.push(f),g!==f&&g!==l&&o.push(g),b!==l&&b!==f&&b!==g&&o.push(b)}return o},e.prototype._filterDenseLines=function(t,e){if(0===e.length)return[];var n=t.data(),i=pgt.Plot._scaledAccessor(this.x()),r=pgt.Plot._scaledAccessor(this.y());return this._bucketByX(t,e,(function(e){return i(n[e],e,t)}),(function(e){return r(n[e],e,t)}))},e.prototype._bucketByX=function(t,e,n,i){for(var r=[],o=t.data(),a=null,s=e.length,l=0;l<=s;++l){var c=e[l];if(null!=o[c]){var u=Math.floor(n(c)),h=i(c);null==a?a=new umt.Bucket(c,u,h):a.isInBucket(u)?a.addToBucket(h,c):(r.push.apply(r,a.getUniqueIndices()),a=new umt.Bucket(c,u,h))}}return null!=a&&r.push.apply(r,a.getUniqueIndices()),r},e})(kgt.XYPlot);e.Line=i})),Pgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e.addClass("area-plot"),e.y0(0),e.attr("fill-opacity",.25),e.attr("fill",(new kmt.Color).range()[0]),e._lineDrawers=new umt.Map,e}return Sft.__extends(e,t),e.prototype.y=function(n,i){if(null==n)return t.prototype.y.call(this);if(null==i?t.prototype.y.call(this,n):t.prototype.y.call(this,n,i),null!=i){var r=this.y0().accessor;null!=r&&this._bindProperty(e._Y0_KEY,r,i),this._updateYScale()}return this},e.prototype.y0=function(t){if(null==t)return this._propertyBindings.get(e._Y0_KEY);var n=this.y();return this._bindProperty(e._Y0_KEY,t,n&&n.scale),this._updateYScale(),this.render(),this},e.prototype._onDatasetUpdate=function(){t.prototype._onDatasetUpdate.call(this),this._updateYScale()},e.prototype._addDataset=function(e){var n=this;return this._lineDrawers.set(e,new Cgt.ProxyDrawer((function(){return new Sgt.LineSVGDrawer}),(function(t){return new Cgt.CanvasDrawer(t,Sgt.makeLineCanvasDrawStep((function(){var t=pgt.Plot._scaledAccessor(n.x()),i=pgt.Plot._scaledAccessor(n.y());return n._d3LineFactory(e,t,i)})))}))),t.prototype._addDataset.call(this,e),this},e.prototype._createNodesForDataset=function(e){t.prototype._createNodesForDataset.call(this,e);var n=this._lineDrawers.get(e);return"svg"===this.renderer()?n.useSVG(this._renderArea):n.useCanvas(this._canvas),n},e.prototype._removeDatasetNodes=function(e){t.prototype._removeDatasetNodes.call(this,e),this._lineDrawers.get(e).remove()},e.prototype._additionalPaint=function(){var t=this,e=this._generateLineDrawSteps(),n=this._getDataToDraw();this.datasets().forEach((function(i){var r=pgt.Plot.applyDrawSteps(e,i);t._lineDrawers.get(i).draw(n.get(i),r)}))},e.prototype._generateLineDrawSteps=function(){var t=[];if(this._animateOnNextRender()){var e=this._generateLineAttrToProjector();e.d=this._constructLineProjector(pgt.Plot._scaledAccessor(this.x()),this._getResetYFunction()),t.push({attrToProjector:e,animator:this._getAnimator(Vgt.Animator.RESET)})}return t.push({attrToProjector:this._generateLineAttrToProjector(),animator:this._getAnimator(Vgt.Animator.MAIN)}),t},e.prototype._generateLineAttrToProjector=function(){var t=this._getAttrToProjector();return t.d=this._constructLineProjector(pgt.Plot._scaledAccessor(this.x()),pgt.Plot._scaledAccessor(this.y())),t},e.prototype._createDrawer=function(t){var e=this;return new ugt.ProxyDrawer((function(){return new wgt.AreaSVGDrawer}),(function(n){return new Cgt.CanvasDrawer(n,wgt.makeAreaCanvasDrawStep((function(){var n=e._coordinateProjectors(),i=n[0],r=n[1],o=n[2],a=e._createDefinedProjector(i,r);return e._createAreaGenerator(i,r,o,a,t)}),(function(){var n=e._coordinateProjectors(),i=n[0],r=n[1],o=e._createDefinedProjector(i,r);return e._createTopLineGenerator(i,r,o,t)})))}))},e.prototype._generateDrawSteps=function(){var t=[];if(this._animateOnNextRender()){var e=this._getAttrToProjector();e.d=this._constructAreaProjector(pgt.Plot._scaledAccessor(this.x()),this._getResetYFunction(),pgt.Plot._scaledAccessor(this.y0())),t.push({attrToProjector:e,animator:this._getAnimator(Vgt.Animator.RESET)})}return t.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Vgt.Animator.MAIN)}),t},e.prototype._updateYScale=function(){var t=this.getExtentsForProperty("y0"),e=umt.Array.flatten(t),n=umt.Array.uniq(e),i=1===n.length?n[0]:null,r=this.y(),o=r&&r.scale;null!=o&&(null!=this._constantBaselineValueProvider&&(o.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),null!=i&&(this._constantBaselineValueProvider=function(){return[i]},o.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))},e.prototype._getResetYFunction=function(){return pgt.Plot._scaledAccessor(this.y0())},e.prototype._coordinateProjectors=function(){return[pgt.Plot._scaledAccessor(this.x()),pgt.Plot._scaledAccessor(this.y()),pgt.Plot._scaledAccessor(this.y0())]},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this),n=this._coordinateProjectors();return e.d=this._constructAreaProjector(n[0],n[1],n[2]),e},e.prototype.selections=function(e){var n=this;if(void 0===e&&(e=this.datasets()),"canvas"===this.renderer())return Uht.selectAll();var i=t.prototype.selections.call(this,e).nodes();return e.map((function(t){return n._lineDrawers.get(t)})).filter((function(t){return null!=t})).forEach((function(t){return i.push.apply(i,t.getVisualPrimitives())})),Uht.selectAll(i)},e.prototype._constructAreaProjector=function(t,e,n){var i=this,r=this._createDefinedProjector(pgt.Plot._scaledAccessor(this.x()),pgt.Plot._scaledAccessor(this.y()));return function(o,a,s){return i._createAreaGenerator(t,e,n,r,s)(o)}},e.prototype._createDefinedProjector=function(t,e){return function(n,i,r){var o=t(n,i,r),a=e(n,i,r);return umt.Math.isValidNumber(o)&&umt.Math.isValidNumber(a)}},e.prototype._createAreaGenerator=function(t,e,n,i,r){var o=this._getCurveFactory();return Uht.area().x((function(e,n){return t(e,n,r)})).y1((function(t,n){return e(t,n,r)})).y0((function(t,e){return n(t,e,r)})).curve(o).defined((function(t,e){return i(t,e,r)}))},e.prototype._createTopLineGenerator=function(t,e,n,i){var r=this._getCurveFactory();return Uht.line().x((function(e,n){return t(e,n,i)})).y((function(t,n){return e(t,n,i)})).curve(r).defined((function(t,e){return n(t,e,i)}))},e._Y0_KEY="y0",e})(Lgt.Line);e.Area=n})),Igt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.BarOrientation=vft.makeEnum(["vertical","horizontal"]),e.LabelsPosition=vft.makeEnum(["start","middle","end","outside"]),e.BarAlignment=vft.makeEnum(["start","middle","end"]);var n=(function(t){function n(r){void 0===r&&(r="vertical");var o=t.call(this)||this;if(o._labelFormatter=fmt.identity(),o._labelsEnabled=!1,o._labelsPosition=e.LabelsPosition.end,o._hideBarsIfAnyAreTooWide=!0,o._barAlignment="middle",o._computeBarPixelThickness=lgt.memoize(i),o._fixedBarPixelThickness=!0,o.addClass("bar-plot"),"vertical"!==r&&"horizontal"!==r)throw new Error(r+" is not a valid orientation for Plots.Bar");return o._isVertical="vertical"===r,o.animator("baseline",new Mft.Null),o.attr("fill",(new kmt.Color).range()[0]),o.attr(n._BAR_THICKNESS_KEY,(function(){return o._barPixelThickness()})),o._labelConfig=new umt.Map,o._baselineValueProvider=function(){return[o.baselineValue()]},o}return Sft.__extends(n,t),n.prototype.computeLayout=function(e,n,i){return t.prototype.computeLayout.call(this,e,n,i),this._updateExtents(),this},n.prototype.x=function(e,n){return null==e?t.prototype.x.call(this):(null==n?t.prototype.x.call(this,e):t.prototype.x.call(this,e,n),this._updateThicknessAttr(),this._updateLengthScale(),this)},n.prototype.y=function(e,n){return null==e?t.prototype.y.call(this):(null==n?t.prototype.y.call(this,e):t.prototype.y.call(this,e,n),this._updateLengthScale(),this)},n.prototype.length=function(){return this._isVertical?this.y():this.x()},n.prototype.position=function(){return this._isVertical?this.x():this.y()},n.prototype.barEnd=function(t){if(null==t)return this._propertyBindings.get(n._BAR_END_KEY);var e=this.position();return this._bindProperty(n._BAR_END_KEY,t,e&&e.scale),this._updateThicknessAttr(),this._updateLengthScale(),this.render(),this},n.prototype.barAlignment=function(t){return null==t?this._barAlignment:(this._barAlignment=t,this._clearAttrToProjectorCache(),this.render(),this)},n.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"},n.prototype._createDrawer=function(){return new ugt.ProxyDrawer((function(){return new Mgt.RectangleSVGDrawer(n._BAR_AREA_CLASS)}),(function(t){return new Cgt.RectangleCanvasDrawer(t)}))},n.prototype._setup=function(){t.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},n.prototype.baselineValue=function(t){if(null==t){if(null!=this._baselineValue)return this._baselineValue;if(!this._projectorsReady())return 0;var e=this.length().scale;return e&&e instanceof kmt.Time?new Date(0):0}return this._baselineValue=t,this._updateLengthScale(),this._clearAttrToProjectorCache(),this.render(),this},n.prototype.addDataset=function(e){return t.prototype.addDataset.call(this,e),this},n.prototype._addDataset=function(e){return t.prototype._addDataset.call(this,e),this},n.prototype.removeDataset=function(e){return t.prototype.removeDataset.call(this,e),this},n.prototype._removeDataset=function(e){return t.prototype._removeDataset.call(this,e),this},n.prototype.datasets=function(e){return null==e?t.prototype.datasets.call(this):(t.prototype.datasets.call(this,e),this)},n.prototype.labelsEnabled=function(t,e){return null==t?this._labelsEnabled:(this._labelsEnabled=t,null!=e&&(this._labelsPosition=e),this._clearAttrToProjectorCache(),this.render(),this)},n.prototype.labelFormatter=function(t){return null==t?this._labelFormatter:(this._labelFormatter=t,this._clearAttrToProjectorCache(),this.render(),this)},n.prototype._createNodesForDataset=function(e){var i=t.prototype._createNodesForDataset.call(this,e),r=this._renderArea.append("g").classed(n._LABEL_AREA_CLASS,!0),o=new qft.SvgContext(r.node()),a=new qft.CacheMeasurer(o),s=new qft.Writer(a,o);return this._labelConfig.set(e,{labelArea:r,measurer:a,writer:s}),i},n.prototype._removeDatasetNodes=function(e){t.prototype._removeDatasetNodes.call(this,e);var n=this._labelConfig.get(e);null!=n&&(n.labelArea.remove(),this._labelConfig.delete(e))},n.prototype.entityNearest=function(t){var e=this,n=function(){var n=e._isVertical?e._getEntityStore().entityNearestX(t):e._getEntityStore().entityNearestY(t);return void 0===n?void 0:e._lightweightPlotEntityToPlotEntity(n)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(n):n()},n.prototype.entitiesAt=function(t){var e=this,n=function(){return e._entitiesIntersecting(t.x,t.y)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(n):n()},n.prototype.entitiesInBounds=function(e){var n=this,i=function(){return t.prototype.entitiesInBounds.call(n,e)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},n.prototype.entitiesInXBounds=function(e){var n=this,i=function(){return t.prototype.entitiesInXBounds.call(n,e)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},n.prototype.entitiesInYBounds=function(e){var n=this,i=function(){return t.prototype.entitiesInYBounds.call(n,e)};return this._fixedBarPixelThickness?this._computeBarPixelThickness.doLocked(i):i()},n.prototype._entitiesIntersecting=function(t,e){for(var n=[],i=this._getEntityStore().entities(),r=i.length,o=0;o<r;o++){var a=i[o];umt.DOM.intersectsBBox(t,e,this._entityBounds(a))&&n.push(this._lightweightPlotEntityToPlotEntity(a))}return n},n.prototype._updateLengthScale=function(){if(this._projectorsReady()){var t=this.length().scale;t instanceof Mmt.QuantitativeScale&&(t.addPaddingExceptionsProvider(this._baselineValueProvider),t.addIncludedValuesProvider(this._baselineValueProvider))}},n.prototype.renderImmediately=function(){var e=this;return this._barPixelThickness(),this._computeBarPixelThickness.doLocked((function(){return t.prototype.renderImmediately.call(e)}))},n.prototype._additionalPaint=function(t){var e=this,n=this.length().scale.scale(this.baselineValue()),i={x1:this._isVertical?0:n,y1:this._isVertical?n:0,x2:this._isVertical?this.width():n,y2:this._isVertical?n:this.height()};this._getAnimator("baseline").animate(this._baseline,i),this.datasets().forEach((function(t){return e._labelConfig.get(t).labelArea.selectAll("g").remove()})),this._labelsEnabled&&umt.Window.setTimeout((function(){return e._drawLabels()}),t)},n.prototype.getExtentsForProperty=function(e){var n,i=this,r=t.prototype.getExtentsForProperty.call(this,e);if("x"===e&&this._isVertical)n=this.x();else{if("y"!==e||this._isVertical)return r;n=this.y()}if(!(n&&n.scale&&n.scale instanceof Mmt.QuantitativeScale))return r;var o=n.scale,a=this._barPixelThickness();return r.map((function(t){return Uht.extent([o.invert(i._getPositionAttr(o.scale(t[0]),a)),o.invert(i._getPositionAttr(o.scale(t[0]),a)+a),o.invert(i._getPositionAttr(o.scale(t[1]),a)),o.invert(i._getPositionAttr(o.scale(t[1]),a)+a)])}))},n.prototype._getPositionAttr=function(t,e){switch(this._isVertical||(t-=e,e*=-1),this._barAlignment){case"start":return t;case"end":return t-e;case"middle":default:return t-e/2}},n.prototype._drawLabels=function(){var t=this,e=this._getDataToDraw(),n=this._getAttrToProjector(),i=this.datasets().some((function(i){return e.get(i).some((function(e,r){return null!=e&&t._drawLabel(e,r,i,n)}))}));this._hideBarsIfAnyAreTooWide&&i&&this.datasets().forEach((function(e){return t._labelConfig.get(e).labelArea.selectAll("g").remove()}))},n.prototype._drawLabel=function(t,e,n,i){var r=this._labelConfig.get(n),o=r.labelArea,a=r.measurer,s=r.writer,l=(0,this.length().accessor)(t,e,n),c=this.length().scale,u=null!=c?c.scale(l):l,h=null!=c?c.scale(this.baselineValue()):this.baselineValue(),d={x:i.x(t,e,n),y:i.y(t,e,n)},p={width:i.width(t,e,n),height:i.height(t,e,n)},f=this._labelFormatter(l,t,e,n),m=a.measure(f),g=this._shouldShowLabelOnBar(d,p,m),_=this._calculateLabelProperties(d,p,m,g,this._isVertical?u<=h:u<h),y=_.containerDimensions,v=_.labelContainerOrigin,b=_.labelOrigin,x=_.alignment,w=i.fill(t,e,n),S=this._createLabelContainer(o,v,b,m,g,w);return s.write(f,y.width,y.height,{xAlign:x.x,yAlign:x.y},S.node()),this._isVertical?p.width<m.width:p.height<m.height},n.prototype._shouldShowLabelOnBar=function(t,i,r){if(this._labelsPosition===e.LabelsPosition.outside)return!1;var o=this._isVertical?t.y:t.x,a=this._isVertical?i.height:i.width,s=this._isVertical?this.height():this.width(),l=o+a,c=a;return l>s?c=s-o:o<0&&(c=l),(this._isVertical?r.height:r.width)+n._LABEL_MARGIN_INSIDE_BAR<=c},n.prototype._calculateLabelProperties=function(t,i,r,o,a){var s=this,l=this._isVertical?t.y:t.x,c=this._isVertical?i.height:i.width,u=this._isVertical?r.height:r.width,h="center",d=c,p=l,f=l,m=function(t){switch(t){case"topLeft":return h=s._isVertical?"top":"left",p+=n._LABEL_MARGIN_INSIDE_BAR,void(f+=n._LABEL_MARGIN_INSIDE_BAR);case"center":return void(f+=(c+u)/2);case"bottomRight":return h=s._isVertical?"bottom":"right",p-=n._LABEL_MARGIN_INSIDE_BAR,void(f+=d-n._LABEL_MARGIN_INSIDE_BAR-u)}};if(o)switch(this._labelsPosition){case e.LabelsPosition.start:m(a?"bottomRight":"topLeft");break;case e.LabelsPosition.middle:m("center");break;case e.LabelsPosition.end:m(a?"topLeft":"bottomRight")}else a?(h=this._isVertical?"top":"left",d=c+n._LABEL_MARGIN_INSIDE_BAR+u,p-=n._LABEL_MARGIN_INSIDE_BAR+u,f-=n._LABEL_MARGIN_INSIDE_BAR+u):(h=this._isVertical?"bottom":"right",d=c+n._LABEL_MARGIN_INSIDE_BAR+u,f+=c+n._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?i.width:d,height:this._isVertical?d:i.height},labelContainerOrigin:{x:this._isVertical?t.x:p,y:this._isVertical?p:t.y},labelOrigin:{x:this._isVertical?t.x+i.width/2-r.width/2:f,y:this._isVertical?f:t.y+i.height/2-r.height/2},alignment:{x:this._isVertical?"center":h,y:this._isVertical?h:"center"}}},n.prototype._createLabelContainer=function(t,e,n,i,r,o){var a=t.append("g").attr("transform","translate("+e.x+", "+e.y+")");if(r){a.classed("on-bar-label",!0);var s=1.6*umt.Color.contrast("white",o)<umt.Color.contrast("black",o);a.classed(s?"dark-label":"light-label",!0)}else a.classed("off-bar-label",!0);return a},n.prototype._generateDrawSteps=function(){var t=[];if(this._animateOnNextRender()){var e=this._getAttrToProjector(),n=this.length().scale.scale(this.baselineValue()),i=this._isVertical?"height":"width";e[this._isVertical?"y":"x"]=function(){return n},e[i]=function(){return 0},t.push({attrToProjector:e,animator:this._getAnimator(Vgt.Animator.RESET)})}return t.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Vgt.Animator.MAIN)}),t},n.prototype._generateAttrToProjector=function(){var e=this,i=t.prototype._generateAttrToProjector.call(this),r=this.length().scale.scale(this.baselineValue()),o=this._isVertical?"y":"x",a=this._isVertical?"x":"y",s=pgt.Plot._scaledAccessor(this.position()),l=pgt.Plot._scaledAccessor(this.length()),c=function(t,e,n){return Math.abs(r-l(t,e,n))},u=i[n._BAR_THICKNESS_KEY],h=i.gap,d=null==h?u:function(t,e,i){var r=u(t,e,i);return r<n._BAR_GAPLESS_THRESHOLD_PX?r:r-h(t,e,i)};return i.width=this._isVertical?d:c,i.height=this._isVertical?c:d,i[o]=function(t,e,n){var i=l(t,e,n);return i>r?r:i},i[a]=function(t,n,i){return e._getPositionAttr(s(t,n,i),u(t,n,i))},i},n.prototype._updateThicknessAttr=function(){var t=this,e=this.position(),i=this.barEnd();null!=e&&null!=i?(this._fixedBarPixelThickness=!1,this.attr(n._BAR_THICKNESS_KEY,(function(t,n,r){var o=e.accessor(t,n,r),a=i.accessor(t,n,r);return o=e.scale?e.scale.scale(o):o,a=i.scale?i.scale.scale(a):a,Math.abs(a-o)}))):(this._fixedBarPixelThickness=!0,this.attr(n._BAR_THICKNESS_KEY,(function(){return t._barPixelThickness()})))},n.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness&&this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0},n.prototype.entities=function(e){return void 0===e&&(e=this.datasets()),this._projectorsReady()?t.prototype.entities.call(this,e):[]},n.prototype._entityBounds=function(t){return this._pixelBounds(t.datum,t.index,t.dataset)},n.prototype._pixelBounds=function(t,e,n){var i=this._getAttrToProjector();return{x:i.x(t,e,n),y:i.y(t,e,n),width:i.width(t,e,n),height:i.height(t,e,n)}},n.prototype._pixelPoint=function(t,e,n){var i=this._pixelBounds(t,e,n),r=pgt.Plot._scaledAccessor(this._isVertical?this.y():this.x())(t,e,n),o=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(r,o,i)},n.prototype._pixelPointBar=function(t,e,n){var i,r;return this._isVertical?(i=n.x+n.width/2,r=t<=e?n.y:n.y+n.height):(i=t>=e?n.x+n.width:n.x,r=n.y+n.height/2),{x:i,y:r}},n.prototype._uninstallScaleForKey=function(e,n){t.prototype._uninstallScaleForKey.call(this,e,n)},n.prototype._getDataToDraw=function(){var t=this,e=new umt.Map,n=this._getAttrToProjector(),i=this.width(),r=this.height();return this.datasets().forEach((function(o){var a=o.data().map((function(e,a){return t._isDatumOnScreen(n,i,r,e,a,o)?e:null}));e.set(o,a)})),e},n.prototype._isDatumOnScreen=function(t,e,n,i,r,o){var a=t.x(i,r,o),s=t.y(i,r,o),l=t.width(i,r,o),c=t.height(i,r,o);return!!(umt.Math.isValidNumber(a)&&umt.Math.isValidNumber(s)&&umt.Math.isValidNumber(l)&&umt.Math.isValidNumber(c))&&umt.Math.boundsIntersects(a,s,l,c,0,0,e,n)},n.prototype.invalidateCache=function(){var e=this;t.prototype.invalidateCache.call(this),this.datasets().forEach((function(t){return e._labelConfig.get(t).measurer.reset()}))},n._BAR_THICKNESS_RATIO=.95,n._BAR_GAPLESS_THRESHOLD_PX=3,n._SINGLE_BAR_DIMENSION_RATIO=.4,n._BAR_AREA_CLASS="bar-area",n._BAR_END_KEY="barEnd",n._BAR_THICKNESS_KEY="width",n._LABEL_AREA_CLASS="bar-label-text-area",n._LABEL_MARGIN_INSIDE_BAR=10,n})(kgt.XYPlot);function i(t,e,i){var r,o=t.scale;if(o instanceof kmt.Category)r=o.rangeBand();else{var a=t.accessor,s=Uht.set(umt.Array.flatten(e.map((function(t){return t.data().map((function(e,n){return a(e,n,t)})).filter((function(t){return null!=t})).map((function(t){return t.valueOf()}))})))).values().map((function(t){return+t}));s.sort((function(t,e){return t-e}));var l=s.map((function(t){return o.scale(t)})),c=Uht.pairs(l);r=umt.Math.min(c,(function(t,e){return Math.abs(t[1]-t[0])}),i*n._SINGLE_BAR_DIMENSION_RATIO),r*=n._BAR_THICKNESS_RATIO}return r}e.Bar=n})),Ngt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e="vertical");var n=t.call(this,e)||this;return n._clusterOffsets=new umt.Map,n}return Sft.__extends(e,t),e.prototype._generateAttrToProjector=function(){var e=this,n=t.prototype._generateAttrToProjector.call(this),i=this._makeInnerScale(),r=function(t,e){return i.rangeBand()};n.width=this._isVertical?r:n.width,n.height=this._isVertical?n.height:r;var o=n.x,a=n.y;return n.x=this._isVertical?function(t,n,i){return o(t,n,i)+e._clusterOffsets.get(i)}:function(t,e,n){return o(t,e,n)},n.y=this._isVertical?function(t,e,n){return a(t,e,n)}:function(t,n,i){return a(t,n,i)+e._clusterOffsets.get(i)},n},e.prototype._updateClusterPosition=function(){var t=this,e=this._makeInnerScale();this.datasets().forEach((function(n,i){return t._clusterOffsets.set(n,e.scale(String(i))-e.rangeBand()/2)}))},e.prototype._makeInnerScale=function(){var t=new kmt.Category;t.domain(this.datasets().map((function(t,e){return String(e)})));var e=pgt.Plot._scaledAccessor(this.attr(Igt.Bar._BAR_THICKNESS_KEY));return t.range([0,e(null,0,null)]),t},e.prototype._getDataToDraw=function(){return this._updateClusterPosition(),t.prototype._getDataToDraw.call(this)},e})(Igt.Bar);e.ClusteredBar=n})),Ogt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._startAngle=0,e._endAngle=2*Math.PI,e._labelFormatter=fmt.identity(),e._labelsEnabled=!1,e.innerRadius(0),e.outerRadius((function(){var t=e._pieCenter();return Math.min(Math.max(e.width()-t.x,t.x),Math.max(e.height()-t.y,t.y))})),e.addClass("pie-plot"),e.attr("fill",(function(t,e){return String(e)}),new kmt.Color),e._strokeDrawers=new umt.Map,e}return Sft.__extends(e,t),e.prototype._setup=function(){var e=this;t.prototype._setup.call(this),this._strokeDrawers.forEach((function(t){return t.attachTo(e._renderArea)}))},e.prototype.computeLayout=function(e,n,i){t.prototype.computeLayout.call(this,e,n,i);var r=this._pieCenter();this._renderArea.attr("transform","translate("+r.x+","+r.y+")");var o=Math.min(Math.max(this.width()-r.x,r.x),Math.max(this.height()-r.y,r.y));return null!=this.innerRadius().scale&&this.innerRadius().scale.range([0,o]),null!=this.outerRadius().scale&&this.outerRadius().scale.range([0,o]),this},e.prototype.addDataset=function(e){return t.prototype.addDataset.call(this,e),this},e.prototype._addDataset=function(e){if(1===this.datasets().length)return umt.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles(),t.prototype._addDataset.call(this,e);var n=new xgt.ArcOutlineSVGDrawer;return this._isSetup&&n.attachTo(this._renderArea),this._strokeDrawers.set(e,n),this},e.prototype.removeDataset=function(e){return t.prototype.removeDataset.call(this,e),this},e.prototype._removeDatasetNodes=function(e){t.prototype._removeDatasetNodes.call(this,e),this._strokeDrawers.get(e).remove()},e.prototype._removeDataset=function(e){return t.prototype._removeDataset.call(this,e),this._strokeDrawers.delete(e),this._startAngles=[],this._endAngles=[],this},e.prototype.selections=function(e){var n=this;void 0===e&&(e=this.datasets());var i=t.prototype.selections.call(this,e).nodes();return e.forEach((function(t){var e=n._strokeDrawers.get(t);null!=e&&i.push.apply(i,e.getVisualPrimitives())})),Uht.selectAll(i)},e.prototype._onDatasetUpdate=function(){t.prototype._onDatasetUpdate.call(this),this._updatePieAngles(),this.render()},e.prototype._createDrawer=function(){return new ugt.ProxyDrawer((function(){return new bgt.ArcSVGDrawer}),(function(){return nmt.warn("canvas renderer is not supported on Pie Plot!"),null}))},e.prototype.entities=function(e){var n=this;return void 0===e&&(e=this.datasets()),t.prototype.entities.call(this,e).map((function(t){t.position.x+=n.width()/2,t.position.y+=n.height()/2;var e=Uht.select(n._strokeDrawers.get(t.dataset).getVisualPrimitiveAtIndex(t.index)),i=t;return i.strokeSelection=e,i}))},e.prototype.sectorValue=function(t,n){return null==t?this._propertyBindings.get(e._SECTOR_VALUE_KEY):(this._bindProperty(e._SECTOR_VALUE_KEY,t,n),this._updatePieAngles(),this.render(),this)},e.prototype.innerRadius=function(t,n){return null==t?this._propertyBindings.get(e._INNER_RADIUS_KEY):(this._bindProperty(e._INNER_RADIUS_KEY,t,n),this.render(),this)},e.prototype.outerRadius=function(t,n){return null==t?this._propertyBindings.get(e._OUTER_RADIUS_KEY):(this._bindProperty(e._OUTER_RADIUS_KEY,t,n),this.render(),this)},e.prototype.startAngle=function(t){return null==t?this._startAngle:(this._startAngle=t,this._updatePieAngles(),this.render(),this)},e.prototype.endAngle=function(t){return null==t?this._endAngle:(this._endAngle=t,this._updatePieAngles(),this.render(),this)},e.prototype.labelsEnabled=function(t){return null==t?this._labelsEnabled:(this._labelsEnabled=t,this.render(),this)},e.prototype.labelFormatter=function(t){return null==t?this._labelFormatter:(this._labelFormatter=t,this.render(),this)},e.prototype.entitiesAt=function(t){var e=this.width()/2,n=this.height()/2,i=this._sliceIndexForPoint({x:t.x-e,y:t.y-n});return null==i?[]:[this.entities()[i]]},e.prototype._propertyProjectors=function(){var e=this,n=t.prototype._propertyProjectors.call(this),i=pgt.Plot._scaledAccessor(this.innerRadius()),r=pgt.Plot._scaledAccessor(this.outerRadius());return n.d=function(t,n,o){return Uht.arc().innerRadius(i(t,n,o)).outerRadius(r(t,n,o)).startAngle(e._startAngles[n]).endAngle(e._endAngles[n])(t,n)},n},e.prototype._updatePieAngles=function(){if(null!=this.sectorValue()&&0!==this.datasets().length){var t=pgt.Plot._scaledAccessor(this.sectorValue()),e=this.datasets()[0],n=this._getDataToDraw().get(e),i=Uht.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value((function(n,i){return t(n,i,e)}))(n);this._startAngles=i.map((function(t){return t.startAngle})),this._endAngles=i.map((function(t){return t.endAngle}))}},e.prototype._pieCenter=function(){var t,e,n,i,r=this._startAngle<this._endAngle?this._startAngle:this._endAngle,o=this._startAngle<this._endAngle?this._endAngle:this._startAngle,a=Math.sin(r),s=Math.cos(r),l=Math.sin(o),c=Math.cos(o);return a>=0&&l>=0?s>=0&&c>=0?(t=s,e=0,i=0,n=l):s<0&&c<0?(t=0,e=-c,i=0,n=a):s>=0&&c<0?(t=s,e=-c,i=0,n=a):s<0&&c>=0&&(t=1,e=1,i=1,n=Math.max(a,l)):a>=0&&l<0?s>=0&&c>=0?(t=Math.max(s,c),e=1,i=1,n=1):s<0&&c<0?(t=0,e=1,i=-l,n=a):s>=0&&c<0?(t=s,e=1,i=-l,n=1):s<0&&c>=0&&(t=c,e=1,i=1,n=a):a<0&&l>=0?s>=0&&c>=0?(t=1,e=0,i=-a,n=l):s<0&&c<0?(t=1,e=Math.max(-s,-c),i=1,n=1):s>=0&&c<0?(t=1,e=-c,i=-a,n=1):s<0&&c>=0&&(t=1,e=-s,i=1,n=l):a<0&&l<0&&(s>=0&&c>=0?(t=c,e=0,i=-a,n=0):s<0&&c<0?(t=0,e=-s,i=-l,n=0):s>=0&&c<0?(t=1,e=1,i=Math.max(s,-c),n=1):s<0&&c>=0&&(t=c,e=-s,i=1,n=0)),{x:i+n==0?0:i/(i+n)*this.width(),y:t+e==0?0:t/(t+e)*this.height()}},e.prototype._getDataToDraw=function(){var n=t.prototype._getDataToDraw.call(this);if(0===this.datasets().length)return n;var i=pgt.Plot._scaledAccessor(this.sectorValue()),r=this.datasets()[0],o=n.get(r).filter((function(t,n){return e._isValidData(i(t,n,r))}));return n.set(r,o),n},e._isValidData=function(t){return umt.Math.isValidNumber(t)&&t>=0},e.prototype._pixelPoint=function(t,n,i){var r=pgt.Plot._scaledAccessor(this.sectorValue());if(!e._isValidData(r(t,n,i)))return{x:NaN,y:NaN};var o=(pgt.Plot._scaledAccessor(this.innerRadius())(t,n,i)+pgt.Plot._scaledAccessor(this.outerRadius())(t,n,i))/2,a=Uht.pie().sort(null).value((function(t,n){var o=r(t,n,i);return e._isValidData(o)?o:0})).startAngle(this._startAngle).endAngle(this._endAngle)(i.data()),s=(a[n].startAngle+a[n].endAngle)/2;return{x:o*Math.sin(s),y:-o*Math.cos(s)}},e.prototype._additionalPaint=function(t){var e=this;this._renderArea.select(".label-area").remove(),this._labelsEnabled&&umt.Window.setTimeout((function(){return e._drawLabels()}),t);var n=this._generateStrokeDrawSteps(),i=this._getDataToDraw();this.datasets().forEach((function(t){var r=pgt.Plot.applyDrawSteps(n,t);e._strokeDrawers.get(t).draw(i.get(t),r)}))},e.prototype._generateStrokeDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new Mft.Null}]},e.prototype._sliceIndexForPoint=function(t){var e,n=Math.sqrt(Math.pow(t.x,2)+Math.pow(t.y,2)),i=Math.acos(-t.y/n);t.x<0&&(i=2*Math.PI-i);for(var r=0;r<this._startAngles.length;r++)if(this._startAngles[r]<i&&this._endAngles[r]>i){e=r;break}if(void 0!==e){var o=this.datasets()[0],a=o.data()[e],s=this.innerRadius().accessor(a,e,o),l=this.outerRadius().accessor(a,e,o);if(n>s&&n<l)return e}return null},e.prototype._drawLabels=function(){for(var t=this,e=this._getAttrToProjector(),n=this._renderArea.append("g").classed("label-area",!0),i=new qft.SvgContext(n.node()),r=new qft.CacheMeasurer(i),o=new qft.Writer(r,i),a=this.datasets()[0],s=this._getDataToDraw().get(a),l=s.length,c=function(i){var l=s[i],c=u.sectorValue().accessor(l,i,a);if(!umt.Math.isValidNumber(c))return"continue";c=u._labelFormatter(c,l,i,a);var h=r.measure(c),d=(u._endAngles[i]+u._startAngles[i])/2,p=u.outerRadius().accessor(l,i,a);u.outerRadius().scale&&(p=u.outerRadius().scale.scale(p));var f=u.innerRadius().accessor(l,i,a);u.innerRadius().scale&&(f=u.innerRadius().scale.scale(f));var m=(p+f)/2,g=Math.sin(d)*m-h.width/2,_=-Math.cos(d)*m-h.height/2,y=[{x:g,y:_},{x:g,y:_+h.height},{x:g+h.width,y:_},{x:g+h.width,y:_+h.height}],v=y.every((function(e){return Math.abs(e.x)<=t.width()/2&&Math.abs(e.y)<=t.height()/2}));v&&(v=y.map((function(e){return t._sliceIndexForPoint(e)})).every((function(t){return t===i})));var b=e.fill(l,i,a),x=1.6*umt.Color.contrast("white",b)<umt.Color.contrast("black",b),w=n.append("g").attr("transform","translate("+g+","+_+")");w.classed(x?"dark-label":"light-label",!0),w.style("visibility",v?"inherit":"hidden"),o.write(c,h.width,h.height,{xAlign:"center",yAlign:"center"},w.node())},u=this,h=0;h<l;h++)c(h)},e._INNER_RADIUS_KEY="inner-radius",e._OUTER_RADIUS_KEY="outer-radius",e._SECTOR_VALUE_KEY="sector-value",e})(pgt.Plot);e.Pie=n})),Rgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._labelsEnabled=!1,e._label=null,e.animator("rectangles",new Mft.Null),e.addClass("rectangle-plot"),e.attr("fill",(new kmt.Color).range()[0]),e}return Sft.__extends(e,t),e.prototype._createDrawer=function(){return new ugt.ProxyDrawer((function(){return new Mgt.RectangleSVGDrawer}),(function(t){return new Cgt.RectangleCanvasDrawer(t)}))},e.prototype._generateAttrToProjector=function(){var n=this,i=t.prototype._generateAttrToProjector.call(this),r=pgt.Plot._scaledAccessor(this.x()),o=i[e._X2_KEY],a=pgt.Plot._scaledAccessor(this.y()),s=i[e._Y2_KEY],l=this.x().scale,c=this.y().scale;return null!=o?(i.width=function(t,e,n){return Math.abs(o(t,e,n)-r(t,e,n))},i.x=function(t,e,n){return Math.min(o(t,e,n),r(t,e,n))}):(i.width=function(t,e,i){return n._rectangleWidth(l)},i.x=function(t,e,n){return r(t,e,n)-.5*i.width(t,e,n)}),null!=s?(i.height=function(t,e,n){return Math.abs(s(t,e,n)-a(t,e,n))},i.y=function(t,e,n){return Math.max(s(t,e,n),a(t,e,n))-i.height(t,e,n)}):(i.height=function(t,e,i){return n._rectangleWidth(c)},i.y=function(t,e,n){return a(t,e,n)-.5*i.height(t,e,n)}),delete i[e._X2_KEY],delete i[e._Y2_KEY],i},e.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]},e.prototype._filterForProperty=function(e){return t.prototype._filterForProperty.call(this,"x2"===e?"x":"y2"===e?"y":e)},e.prototype.x=function(n,i,r){if(null==n)return t.prototype.x.call(this);if(null==i?t.prototype.x.call(this,n):t.prototype.x.call(this,n,i,r),null!=i){var o=this.x2(),a=o&&o.accessor;null!=a&&this._bindProperty(e._X2_KEY,a,i,o.postScale)}return i instanceof kmt.Category&&i.innerPadding(0).outerPadding(0),this},e.prototype.x2=function(t,n){if(null==t)return this._propertyBindings.get(e._X2_KEY);var i=this.x();return this._bindProperty(e._X2_KEY,t,i&&i.scale,n),this.render(),this},e.prototype.y=function(n,i,r){if(null==n)return t.prototype.y.call(this);if(null==i?t.prototype.y.call(this,n):t.prototype.y.call(this,n,i,r),null!=i){var o=this.y2(),a=o&&o.accessor;null!=a&&this._bindProperty(e._Y2_KEY,a,i,o.postScale)}return i instanceof kmt.Category&&i.innerPadding(0).outerPadding(0),this},e.prototype.y2=function(t,n){if(null==t)return this._propertyBindings.get(e._Y2_KEY);var i=this.y();return this._bindProperty(e._Y2_KEY,t,i&&i.scale,n),this.render(),this},e.prototype.entitiesAt=function(t){var e=this._getAttrToProjector();return this.entities().filter((function(n){var i=n.datum,r=n.index,o=n.dataset,a=e.x(i,r,o),s=e.y(i,r,o),l=e.width(i,r,o),c=e.height(i,r,o);return a<=t.x&&t.x<=a+l&&s<=t.y&&t.y<=s+c}))},e.prototype._entityBounds=function(t){return this._entityBBox(t.datum,t.index,t.dataset,this._getAttrToProjector())},e.prototype._entityBBox=function(t,e,n,i){return{x:i.x(t,e,n),y:i.y(t,e,n),width:i.width(t,e,n),height:i.height(t,e,n)}},e.prototype.label=function(t){return null==t?this._label:(this._label=t,this.render(),this)},e.prototype.labelsEnabled=function(t){return null==t?this._labelsEnabled:(this._labelsEnabled=t,this.render(),this)},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this);return null!=this.x2()&&(e.x2=pgt.Plot._scaledAccessor(this.x2())),null!=this.y2()&&(e.y2=pgt.Plot._scaledAccessor(this.y2())),e},e.prototype._pixelPoint=function(t,e,n){var i=this._getAttrToProjector(),r=i.x(t,e,n),o=i.y(t,e,n);return{x:r+i.width(t,e,n)/2,y:o+i.height(t,e,n)/2}},e.prototype._rectangleWidth=function(t){if(t instanceof kmt.Category)return t.rangeBand();var e=t===this.x().scale?this.x().accessor:this.y().accessor,n=Uht.set(umt.Array.flatten(this.datasets().map((function(t){return t.data().map((function(n,i){return e(n,i,t).valueOf()}))})))).values().map((function(t){return+t})),i=umt.Math.min(n,0),r=umt.Math.max(n,0),o=t.scale(i);return(t.scale(r)-o)/Math.abs(r-i)},e.prototype._getDataToDraw=function(){var t=new umt.Map,e=this._getAttrToProjector();return this.datasets().forEach((function(n){var i=n.data().map((function(t,i){return umt.Math.isValidNumber(e.x(t,i,n))&&umt.Math.isValidNumber(e.y(t,i,n))&&umt.Math.isValidNumber(e.width(t,i,n))&&umt.Math.isValidNumber(e.height(t,i,n))?t:null}));t.set(n,i)})),t},e.prototype._additionalPaint=function(t){var e=this;this._renderArea.selectAll(".label-area").remove(),this._labelsEnabled&&null!=this.label()&&umt.Window.setTimeout((function(){return e._drawLabels()}),t)},e.prototype._drawLabels=function(){var t=this,e=this._getDataToDraw();this.datasets().forEach((function(n,i){return t._drawLabel(e,n,i)}))},e.prototype._drawLabel=function(t,e,n){for(var i=this._getAttrToProjector(),r=this._renderArea.append("g").classed("label-area",!0),o=new qft.SvgContext(r.node()),a=new qft.CacheMeasurer(o),s=new qft.Writer(a,o),l=this.x().scale.range(),c=this.y().scale.range(),u=Math.min.apply(null,l),h=Math.max.apply(null,l),d=Math.min.apply(null,c),p=Math.max.apply(null,c),f=t.get(e),m=f.length,g=0;g<m;g++){var _=f[g];if(null!=_){var y=""+this.label()(_,g,e),v=a.measure(y),b=i.x(_,g,e),x=i.y(_,g,e),w=i.width(_,g,e),S=i.height(_,g,e);if(v.height<=S&&v.width<=w){var M={min:b+=(w-v.width)/2,max:b+v.width},E={min:x+=(S-v.height)/2,max:x+v.height};if(M.min<u||M.max>h||E.min<d||E.max>p)continue;if(this._overlayLabel(M,E,g,n,t))continue;var T=i.fill(_,g,e),A=1.6*umt.Color.contrast("white",T)<umt.Color.contrast("black",T),C=r.append("g").attr("transform","translate("+b+","+x+")");C.classed(A?"dark-label":"light-label",!0),s.write(y,v.width,v.height,{xAlign:"center",yAlign:"center"},C.node())}}}},e.prototype._overlayLabel=function(t,e,n,i,r){for(var o=this._getAttrToProjector(),a=this.datasets(),s=i;s<a.length;s++)for(var l=a[s],c=r.get(l),u=c.length,h=s===i?n+1:0;h<u;h++)if(umt.DOM.intersectsBBox(t,e,this._entityBBox(c[h],h,l,o)))return!0;return!1},e._X2_KEY="x2",e._Y2_KEY="y2",e})(kgt.XYPlot);e.Rectangle=n})),zgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;e._labelFormatter=fmt.identity(),e._labelsEnabled=!1,e.addClass("scatter-plot");var n=new Mft.Easing;n.startDelay(5),n.stepDuration(250),n.maxTotalDuration(pgt.Plot._ANIMATION_MAX_DURATION),e.animator(Vgt.Animator.MAIN,n),e.attr("opacity",.6),e.attr("fill",(new kmt.Color).range()[0]),e.size(6);var i=Qmt.circle();return e.symbol((function(){return i})),e._labelConfig=new umt.Map,e}return Sft.__extends(e,t),e.prototype._buildLightweightPlotEntities=function(e){var n=this;return t.prototype._buildLightweightPlotEntities.call(this,e).map((function(t){var e=pgt.Plot._scaledAccessor(n.size())(t.datum,t.index,t.dataset);return t.diameter=e,t}))},e.prototype._createDrawer=function(t){var e=this;return new ugt.ProxyDrawer((function(){return new Agt.SymbolSVGDrawer}),(function(n){return new Cgt.CanvasDrawer(n,Agt.makeSymbolCanvasDrawStep(t,(function(){return pgt.Plot._scaledAccessor(e.symbol())}),(function(){return pgt.Plot._scaledAccessor(e.size())})))}))},e.prototype.size=function(t,n){return null==t?this._propertyBindings.get(e._SIZE_KEY):(this._bindProperty(e._SIZE_KEY,t,n),this.render(),this)},e.prototype.symbol=function(t){return null==t?this._propertyBindings.get(e._SYMBOL_KEY):(this._propertyBindings.set(e._SYMBOL_KEY,{accessor:t}),this.render(),this)},e.prototype._generateDrawSteps=function(){var t=[];if(this._animateOnNextRender()){var e=this._getAttrToProjector(),n=pgt.Plot._scaledAccessor(this.symbol());e.d=function(t,e,i){return n(t,e,i)(0)(null)},t.push({attrToProjector:e,animator:this._getAnimator(Vgt.Animator.RESET)})}return t.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(Vgt.Animator.MAIN)}),t},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this),n=pgt.Plot._scaledAccessor(this.x()),i=pgt.Plot._scaledAccessor(this.y());return e.x=n,e.y=i,e.transform=function(t,e,r){return"translate("+n(t,e,r)+","+i(t,e,r)+")"},e.d=this._constructSymbolGenerator(),e},e.prototype._constructSymbolGenerator=function(){var t=pgt.Plot._scaledAccessor(this.symbol()),e=pgt.Plot._scaledAccessor(this.size());return function(n,i,r){return t(n,i,r)(e(n,i,r))(null)}},e.prototype._entityBounds=function(t){return{x:t.position.x-t.diameter/2,y:t.position.y-t.diameter/2,width:t.diameter,height:t.diameter}},e.prototype._entityVisibleOnPlot=function(t,e){var n={min:e.topLeft.x,max:e.bottomRight.x},i={min:e.topLeft.y,max:e.bottomRight.y},r=this._entityBounds(t);return umt.DOM.intersectsBBox(n,i,r)},e.prototype.entitiesAt=function(t){var e=pgt.Plot._scaledAccessor(this.x()),n=pgt.Plot._scaledAccessor(this.y()),i=pgt.Plot._scaledAccessor(this.size());return this.entities().filter((function(r){var o=r.datum,a=r.index,s=r.dataset,l=e(o,a,s),c=n(o,a,s),u=i(o,a,s);return l-u/2<=t.x&&t.x<=l+u/2&&c-u/2<=t.y&&t.y<=c+u/2}))},e.prototype.labelsEnabled=function(t){return null==t?this._labelsEnabled:(this._labelsEnabled=t,this._clearAttrToProjectorCache(),this.render(),this)},e.prototype._createNodesForDataset=function(n){var i=t.prototype._createNodesForDataset.call(this,n),r=this._renderArea.append("g").classed(e._LABEL_AREA_CLASS,!0),o=new qft.SvgContext(r.node()),a=new qft.CacheMeasurer(o),s=new qft.Writer(a,o);return this._labelConfig.set(n,{labelArea:r,measurer:a,writer:s}),i},e.prototype._removeDatasetNodes=function(e){t.prototype._removeDatasetNodes.call(this,e);var n=this._labelConfig.get(e);null!=n&&(n.labelArea.remove(),this._labelConfig.delete(e))},e.prototype._additionalPaint=function(t){var e=this;this.datasets().forEach((function(t){return e._labelConfig.get(t).labelArea.selectAll("g").remove()})),this._labelsEnabled&&umt.Window.setTimeout((function(){return e._drawLabels()}),t)},e.prototype._drawLabels=function(){var t=this,e=this._getDataToDraw(),n=this._getAttrToProjector();this.datasets().forEach((function(i){for(var r=e.get(i),o=r.length,a=0;a<o;a++){var s=r[a];null!=s&&t._drawLabel(s,a,i,n)}}))},e.prototype._drawLabel=function(t,e,n,i){if(null!=t.label){var r=this._labelConfig.get(n),o=r.labelArea,a=r.measurer,s=r.writer,l={x:i.x(t,e,n),y:i.y(t,e,n)},c=pgt.Plot._scaledAccessor(this.size())(t,e,n),u=this._labelFormatter(t.label,t,e,n),h=a.measure(u),d=this._calculateLabelProperties(l,c,h),p=d.containerDimensions,f=d.alignment,m=this._createLabelContainer(o,d.labelContainerOrigin,d.labelOrigin,h);s.write(u,p.width,p.height,{xAlign:f.x,yAlign:f.y},m.node())}},e.prototype._calculateLabelProperties=function(t,n,i){return{containerDimensions:{width:i.width,height:i.height},labelContainerOrigin:{x:t.x-i.width/2,y:t.y-i.height/2+(n<i.height?n/2+e._LABEL_MARGIN_FROM_BUBBLE:0)},labelOrigin:{x:t.x,y:t.y},alignment:{x:"center",y:"center"}}},e.prototype._createLabelContainer=function(t,e,n,i){var r=t.append("g").attr("transform","translate("+e.x+", "+e.y+")");return r.classed("on-bar-label",!0),r},e._SIZE_KEY="size",e._SYMBOL_KEY="symbol",e._LABEL_AREA_CLASS="scatter-label-text-area",e._LABEL_MARGIN_FROM_BUBBLE=15,e})(kgt.XYPlot);e.Scatter=n})),Dgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e.addClass("segment-plot"),e.attr("stroke",(new kmt.Color).range()[0]),e.attr("stroke-width","2px"),e}return Sft.__extends(e,t),e.prototype._createDrawer=function(){return new ugt.ProxyDrawer((function(){return new Egt.SegmentSVGDrawer}),(function(){return nmt.warn("canvas renderer is not supported on Segment Plot!"),null}))},e.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new Mft.Null}]},e.prototype._filterForProperty=function(e){return t.prototype._filterForProperty.call(this,"x2"===e?"x":"y2"===e?"y":e)},e.prototype.x=function(n,i){if(null==n)return t.prototype.x.call(this);if(null==i)t.prototype.x.call(this,n);else{t.prototype.x.call(this,n,i);var r=this.x2(),o=r&&r.accessor;null!=o&&this._bindProperty(e._X2_KEY,o,i)}return this},e.prototype.x2=function(t){if(null==t)return this._propertyBindings.get(e._X2_KEY);var n=this.x();return this._bindProperty(e._X2_KEY,t,n&&n.scale),this.render(),this},e.prototype.y=function(n,i){if(null==n)return t.prototype.y.call(this);if(null==i)t.prototype.y.call(this,n);else{t.prototype.y.call(this,n,i);var r=this.y2(),o=r&&r.accessor;null!=o&&this._bindProperty(e._Y2_KEY,o,i)}return this},e.prototype.y2=function(t){if(null==t)return this._propertyBindings.get(e._Y2_KEY);var n=this.y();return this._bindProperty(e._Y2_KEY,t,n&&n.scale),this.render(),this},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this);return e.x1=pgt.Plot._scaledAccessor(this.x()),e.x2=null==this.x2()?pgt.Plot._scaledAccessor(this.x()):pgt.Plot._scaledAccessor(this.x2()),e.y1=pgt.Plot._scaledAccessor(this.y()),e.y2=null==this.y2()?pgt.Plot._scaledAccessor(this.y()):pgt.Plot._scaledAccessor(this.y2()),e},e.prototype.entitiesAt=function(t){var e=this.entityNearest(t);return null!=e?[e]:[]},e.prototype.entitiesIn=function(t,e){var n,i;return null==e?(n={min:t.topLeft.x,max:t.bottomRight.x},i={min:t.topLeft.y,max:t.bottomRight.y}):(n=t,i=e),this._entitiesIntersecting(n,i)},e.prototype._entitiesIntersecting=function(t,e){for(var n=[],i=this._getAttrToProjector(),r=this.entities(),o=r.length,a=0;a<o;a++){var s=r[a];this._lineIntersectsBox(s,t,e,i)&&n.push(s)}return n},e.prototype._lineIntersectsBox=function(t,e,n,i){var r=this,o=i.x1(t.datum,t.index,t.dataset),a=i.x2(t.datum,t.index,t.dataset),s=i.y1(t.datum,t.index,t.dataset),l=i.y2(t.datum,t.index,t.dataset);if(e.min<=o&&o<=e.max&&n.min<=s&&s<=n.max||e.min<=a&&a<=e.max&&n.min<=l&&l<=n.max)return!0;var c={x:o,y:s},u={x:a,y:l},h=[{x:e.min,y:n.min},{x:e.min,y:n.max},{x:e.max,y:n.max},{x:e.max,y:n.min}];return h.filter((function(t,e){return 0!==e&&r._lineIntersectsSegment(c,u,t,h[e-1])&&r._lineIntersectsSegment(t,h[e-1],c,u)})).length>0},e.prototype._lineIntersectsSegment=function(t,e,n,i){var r=function(t,e,n){return(e.x-t.x)*(n.y-e.y)-(e.y-t.y)*(n.x-e.x)};return r(t,e,n)*r(t,e,i)<0},e._X2_KEY="x2",e._Y2_KEY="y2",e})(kgt.XYPlot);e.Segment=n})),Bgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._stackingResult=lgt.memThunk((function(){return e.datasets()}),(function(){return e.x().accessor}),(function(){return e.y().accessor}),(function(){return e._stackingOrder}),(function(t,e,n,i){return umt.Stacking.stack(t,e,n,i)})),e._stackedExtent=lgt.memThunk(e._stackingResult,(function(){return e.x().accessor}),(function(){return e._filterForProperty("y")}),(function(t,e,n){return umt.Stacking.stackedExtent(t,e,n)})),e._baselineValue=0,e._stackingOrder="bottomup",e.addClass("stacked-area-plot"),e._baselineValueProvider=function(){return[e._baselineValue]},e.croppedRenderingEnabled(!1),e}return Sft.__extends(e,t),e.prototype.croppedRenderingEnabled=function(e){return null==e?t.prototype.croppedRenderingEnabled.call(this):e?(umt.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):t.prototype.croppedRenderingEnabled.call(this,e)},e.prototype._getAnimator=function(t){return new Mft.Null},e.prototype._setup=function(){t.prototype._setup.call(this),this._baseline=this._renderArea.append("line").classed("baseline",!0)},e.prototype.x=function(e,n){return null==e?t.prototype.x.call(this):(null==n?t.prototype.x.call(this,e):t.prototype.x.call(this,e,n),this._checkSameDomain(),this)},e.prototype.y=function(e,n){return null==e?t.prototype.y.call(this):(null==n?t.prototype.y.call(this,e):t.prototype.y.call(this,e,n),this._checkSameDomain(),this)},e.prototype.yOffset=function(t,e){var n=this._stackingResult();if(null!=n){var i=n.get(t);if(null!=i){var r=i.get(String(e));if(null!=r)return r.offset}}},e.prototype.stackingOrder=function(t){return null==t?this._stackingOrder:(this._stackingOrder=t,this._onDatasetUpdate(),this)},e.prototype.downsamplingEnabled=function(e){return null==e?t.prototype.downsamplingEnabled.call(this):(umt.Window.warn("Warning: Stacked Area Plot does not support downsampling"),this)},e.prototype._additionalPaint=function(){var t=this.y().scale.scale(this._baselineValue),e={x1:0,y1:t,x2:this.width(),y2:t};this._getAnimator("baseline").animate(this._baseline,e)},e.prototype._updateYScale=function(){var t=this.y(),e=t&&t.scale;null!=e&&(e.addPaddingExceptionsProvider(this._baselineValueProvider),e.addIncludedValuesProvider(this._baselineValueProvider))},e.prototype._onDatasetUpdate=function(){return this._checkSameDomain(),t.prototype._onDatasetUpdate.call(this),this},e.prototype.getExtentsForProperty=function(e){return"y"===e?[this._stackedExtent()]:t.prototype.getExtentsForProperty.call(this,e)},e.prototype._checkSameDomain=function(){if(this._projectorsReady()){var t=this.datasets(),n=this.x().accessor,i=t.map((function(t){return Uht.set(t.data().map((function(e,i){return umt.Stacking.normalizeKey(n(e,i,t))}))).values()})),r=e._domainKeys(t,n);i.some((function(t){return t.length!==r.length}))&&umt.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}},e._domainKeys=function(t,e){var n=Uht.set();return t.forEach((function(t){for(var i=t.data(),r=i.length,o=0;o<r;o++)n.add(e(i[o],o,t))})),n.values()},e.prototype._coordinateProjectors=function(){var t=this,e=pgt.Plot._scaledAccessor(this.x()),n=this.y().accessor,i=this.x().accessor,r=function(t,e,n){return umt.Stacking.normalizeKey(i(t,e,n))},o=this._stackingResult();return[e,function(e,i,a){var s=+n(e,i,a),l=o.get(a).get(r(e,i,a)).offset;return t.y().scale.scale(s+l)},function(e,n,i){var a=o.get(i).get(r(e,n,i)).offset;return t.y().scale.scale(a)}]},e.prototype._propertyProjectors=function(){var e=t.prototype._propertyProjectors.call(this),n=this._coordinateProjectors();return e.d=this._constructAreaProjector(n[0],n[1],n[2]),e},e.prototype._pixelPoint=function(e,n,i){var r=t.prototype._pixelPoint.call(this,e,n,i),o=this.x().accessor(e,n,i),a=this.y().accessor(e,n,i),s=this.y().scale.scale(+a+this._stackingResult().get(i).get(umt.Stacking.normalizeKey(o)).offset);return{x:r.x,y:s}},e})(Pgt.Area);e.StackedArea=n})),Hgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(e){void 0===e&&(e="vertical");var n=t.call(this,e)||this;return n._extremaFormatter=fmt.identity(),n._stackingResult=lgt.memThunk((function(){return n.datasets()}),(function(){return n.position().accessor}),(function(){return n.length().accessor}),(function(){return n._stackingOrder}),(function(t,e,n,i){return umt.Stacking.stack(t,e,n,i)})),n._stackedExtent=lgt.memThunk(n._stackingResult,(function(){return n.position().accessor}),(function(){return n._filterForProperty(n._isVertical?"y":"x")}),(function(t,e,n){return umt.Stacking.stackedExtent(t,e,n)})),n.addClass("stacked-bar-plot"),n._stackingOrder="bottomup",n}return Sft.__extends(e,t),e.prototype.stackingOrder=function(t){return null==t?this._stackingOrder:(this._stackingOrder=t,this._onDatasetUpdate(),this)},e.prototype.extremaFormatter=function(t){return 0===arguments.length?this._extremaFormatter:(this._extremaFormatter=t,this.render(),this)},e.prototype._setup=function(){t.prototype._setup.call(this),this._labelArea=this._renderArea.append("g").classed(Igt.Bar._LABEL_AREA_CLASS,!0);var e=new qft.SvgContext(this._labelArea.node());this._measurer=new qft.CacheMeasurer(e),this._writer=new qft.Writer(this._measurer,e)},e.prototype._drawLabels=function(){var n=this;t.prototype._drawLabels.call(this),this._labelArea.selectAll("g").remove();var i=+this.baselineValue(),r=this.position().scale,o=this.length().scale,a=umt.Stacking.stackedExtents(this._stackingResult()),s=a.minimumExtents,l=[],c=function(t,e){var a=n._generateAttrToProjector(),s=n.width(),c=n.height();t.forEach((function(t){if(t.extent!==i){var u=n.extremaFormatter()(t.extent),h=n._measurer.measure(u),d=t.stackedDatum,p=d.originalDatum,f=d.originalIndex,m=d.originalDataset;if(!n._isDatumOnScreen(a,s,c,p,f,m))return;var g=pgt.Plot._scaledAccessor(n.attr(Igt.Bar._BAR_THICKNESS_KEY))(p,f,m),_=o.scale(t.extent),y=n._getPositionAttr(r.scale(t.axisValue),g)+g/2,v=e(n._isVertical?{x:y,y:_}:{x:_,y:y},h,g),b=(function(t,e,i){var r=e.topLeft,o=r.x,a=r.y,s=e.bottomRight.x-e.topLeft.x,l=e.bottomRight.y-e.topLeft.y,c=n._isVertical?s>i:l>i;if(!c){var u=n._labelArea.append("g").attr("transform","translate("+o+", "+a+")");u.classed("stacked-bar-label",!0),n._writer.write(t,s,l,{xAlign:"center",yAlign:"center"},u.node())}return c})(u,{topLeft:v,bottomRight:{x:v.x+h.width,y:v.y+h.height}},g);l.push(b)}}))};c(a.maximumExtents,(function(t,i,r){var o=n._isVertical?i.width:i.height;return{x:n._isVertical?t.x-o/2:t.x+e._EXTREMA_LABEL_MARGIN_FROM_BAR,y:n._isVertical?t.y-(n._isVertical?i.height:i.width):t.y-o/2}})),c(s,(function(t,i,r){var o=n._isVertical?i.width:i.height;return{x:n._isVertical?t.x-o/2:t.x-(n._isVertical?i.height:i.width),y:n._isVertical?t.y+e._EXTREMA_LABEL_MARGIN_FROM_BAR:t.y-o/2}})),l.some((function(t){return t}))&&this._labelArea.selectAll("g").remove()},e.prototype._generateAttrToProjector=function(){var e=this,n=t.prototype._generateAttrToProjector.call(this),i=this._isVertical?"y":"x",r=this.length().scale,o=this.length().accessor,a=this.position().accessor,s=function(t,e,n){return umt.Stacking.normalizeKey(a(t,e,n))},l=this._stackingResult(),c=function(t,e,n){return r.scale(l.get(n).get(s(t,e,n)).offset)},u=function(t,e,n){return r.scale(+o(t,e,n)+l.get(n).get(s(t,e,n)).offset)},h=function(t,e,n){return Math.abs(u(t,e,n)-c(t,e,n))};n[this._isVertical?"height":"width"]=h;var d=function(t,e,n){return+o(t,e,n)<0?c(t,e,n):u(t,e,n)};return n[i]=function(t,n,i){return e._isVertical?d(t,n,i):d(t,n,i)-h(t,n,i)},n},e.prototype.getExtentsForProperty=function(e){return e===(this._isVertical?"y":"x")?[this._stackedExtent()]:t.prototype.getExtentsForProperty.call(this,e)},e.prototype.invalidateCache=function(){t.prototype.invalidateCache.call(this),this._measurer.reset()},e._EXTREMA_LABEL_MARGIN_FROM_BAR=5,e})(Igt.Bar);e.StackedBar=n})),Fgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0});var n=(function(t){function e(){var e=t.call(this)||this;return e._connectorsEnabled=!1,e.addClass("waterfall-plot"),e}return Sft.__extends(e,t),e.prototype.connectorsEnabled=function(t){return null==t?this._connectorsEnabled:(this._connectorsEnabled=t,this)},e.prototype.total=function(t){return null==t?this._propertyBindings.get(e._TOTAL_KEY):(this._bindProperty(e._TOTAL_KEY,t,null),this)},e.prototype._additionalPaint=function(t){var e=this;this._connectorArea.selectAll("line").remove(),this._connectorsEnabled&&umt.Window.setTimeout((function(){return e._drawConnectors()}),t)},e.prototype._createNodesForDataset=function(n){var i=t.prototype._createNodesForDataset.call(this,n);return this._connectorArea=this._renderArea.append("g").classed(e._CONNECTOR_AREA_CLASS,!0),i},e.prototype.getExtentsForProperty=function(e){return"y"===e?[this._extent]:t.prototype.getExtentsForProperty.call(this,e)},e.prototype._generateAttrToProjector=function(){var n=this,i=t.prototype._generateAttrToProjector.call(this),r=this.y().scale,o=pgt.Plot._scaledAccessor(this.total());return null==this.attr("y")&&(i.y=function(t,e,i){var a=n.y().accessor(t,e,i);if(o(t,e,i))return Math.min(r.scale(a),r.scale(0));var s=n._subtotals[e];if(0===e)return r.scale(a<0?s-a:s);var l=n._subtotals[e-1];return r.scale(s>l?s:l)}),null==this.attr("height")&&(i.height=function(t,e,i){var a=o(t,e,i),s=n.y().accessor(t,e,i);if(a)return Math.abs(r.scale(s)-r.scale(0));var l=n._subtotals[e];if(0===e)return Math.abs(r.scale(l)-r.scale(l-s));var c=n._subtotals[e-1];return Math.abs(r.scale(l)-r.scale(c))}),i.class=function(t,i,r){var a="";return null!=n.attr("class")&&(a=n.attr("class").accessor(t,i,r)+" "),o(t,i,r)?a+e._BAR_TOTAL_CLASS:a+(n.y().accessor(t,i,r)>0?e._BAR_GROWTH_CLASS:e._BAR_DECLINE_CLASS)},i},e.prototype._onDatasetUpdate=function(){return this._updateSubtotals(),t.prototype._onDatasetUpdate.call(this),this},e.prototype._calculateSubtotalsAndExtent=function(t){for(var e=Number.MAX_VALUE,n=Number.MIN_VALUE,i=0,r=!1,o=t.data(),a=o.length,s=0;s<a;s++){var l=o[s],c=this.y().accessor(l,s,t),u=this.total().accessor(l,s,t);if(u&&0!==s||(i+=c),this._subtotals.push(i),i<e&&(e=i),i>n&&(n=i),u&&(c<e&&(e=c),c>n&&(n=c)),!r&&u){for(var h=c-i,d=0;d<this._subtotals.length;d++)this._subtotals[d]+=h;r=!0,i+=h,e+=h,n+=h}}this._extent=[e,n]},e.prototype._drawConnectors=function(){for(var t=this._getAttrToProjector(),n=this.datasets()[0],i=1;i<n.data().length;i++){var r=i-1,o=n.data()[i],a=n.data()[r],s=t.x(a,r,n),l=t.x(o,i,n)+t.width(o,i,n),c=t.y(o,i,n);(this._subtotals[i]>0&&this._subtotals[i]>this._subtotals[r]||this._subtotals[i]<0&&this._subtotals[i]>=this._subtotals[r])&&(c=t.y(o,i,n)+t.height(o,i,n)),this._connectorArea.append("line").classed(e._CONNECTOR_CLASS,!0).attr("x1",s).attr("x2",l).attr("y1",c).attr("y2",c)}},e.prototype._updateSubtotals=function(){var t=this.datasets();if(t.length>0){var e=t[t.length-1];this._subtotals=new Array,this._calculateSubtotalsAndExtent(e)}},e._BAR_DECLINE_CLASS="waterfall-decline",e._BAR_GROWTH_CLASS="waterfall-growth",e._BAR_TOTAL_CLASS="waterfall-total",e._CONNECTOR_CLASS="connector",e._CONNECTOR_AREA_CLASS="connector-area",e._TOTAL_KEY="total",e})(Igt.Bar);e.Waterfall=n})),Vgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),Sft.__exportStar(Pgt,e),Sft.__exportStar(Igt,e),Sft.__exportStar(egt,e),Sft.__exportStar(Ngt,e),Sft.__exportStar(Lgt,e),Sft.__exportStar(Ogt,e),Sft.__exportStar(Rgt,e),Sft.__exportStar(zgt,e),Sft.__exportStar(Dgt,e),Sft.__exportStar(Bgt,e),Sft.__exportStar(Hgt,e),Sft.__exportStar(Fgt,e)})),jgt=be((function(t,e){
/**
     * Copyright 2014-present Palantir Technologies
     * @license MIT
     */
Object.defineProperty(e,"__esModule",{value:!0}),e.version="3.9.0"})),Ugt=be((function(t,e){Object.defineProperty(e,"__esModule",{value:!0}),e.Animators=Mft,e.Axes=Pmt,e.Components=vgt,e.Configs=emt,e.Formatters=fmt,e.RenderController=dmt,e.RenderPolicies=hmt,e.SymbolFactories=Qmt,e.Dispatchers=zmt,e.Drawers=Cgt,e.Interactions=Umt,e.Plots=Vgt,e.Scales=kmt,e.Utils=umt,Sft.__exportStar(mmt,e),e.TimeInterval=Lmt.TimeInterval,Sft.__exportStar(pmt,e),Sft.__exportStar($mt,e),Sft.__exportStar(igt,e),e.version=jgt.version,Sft.__exportStar(Imt,e),Sft.__exportStar(ugt,e),Sft.__exportStar(Dmt,e),Sft.__exportStar(Fmt,e),Sft.__exportStar(kgt,e),Sft.__exportStar(pgt,e),Sft.__exportStar(Mmt,e),Sft.__exportStar(bmt,e)}));const Ggt=[{character:"◼",method:Ugt.SymbolFactories.square},{character:"◆",method:Ugt.SymbolFactories.diamond},{character:"▲",method:Ugt.SymbolFactories.triangle},{character:"★",method:Ugt.SymbolFactories.star},{character:"✚",method:Ugt.SymbolFactories.cross}];var Wgt;function qgt(t){return e=>{let n,i=Math.abs(e);return i<1e-15&&(i=0),n=py(i>=1e4||i>0&&i<.01?"."+t+"~e":"."+t+"~g"),n(e)}}!(function(t){t.STEP="step",t.RELATIVE="relative",t.WALL_TIME="wall_time"})(Wgt||(Wgt={}));const Ygt=py(".4~s");function Xgt(){let t=new Ugt.Scales.Linear;t.tickGenerator(Ugt.Scales.TickGenerators.integerTickGenerator());let e=new Ugt.Axes.Numeric(t,"bottom");return e.formatter(Ygt),{scale:t,axis:e,accessor:t=>t.step}}let $gt=Ugt.Formatters.time("%a %b %e, %H:%M:%S"),Kgt=(t,e,n)=>{if(null!=t.relative)return t.relative;let i=n.data();return(+t.wall_time-(i.length>0?+i[0].wall_time:0))/36e5},Zgt=t=>{let e="",n=Math.floor(t/24);t-=24*n,n&&(e+=n+"d ");let i=Math.floor(t);t-=i,t*=60,(i||n)&&(e+=i+"h ");let r=Math.floor(t);return t-=r,t*=60,(r||i||n)&&(e+=r+"m "),e+Math.floor(t)+"s"};function Jgt(t){switch(t){case Wgt.STEP:return Xgt();case Wgt.WALL_TIME:return(function e(){let t=new Ugt.Scales.Time;return{scale:t,axis:new Ugt.Axes.Time(t,"bottom"),accessor:t=>t.wall_time}})();case Wgt.RELATIVE:return(function n(){let t=new Ugt.Scales.Linear;return{scale:t,axis:new Ugt.Axes.Numeric(t,"bottom"),accessor:Kgt}})();default:throw new Error("invalid xType: "+t)}}var Qgt;function t_t(t){return class extends t{constructor(){super(...arguments),this.loadKey="",this.dataToLoad=[],this.getDataLoadName=t=>String(t),this.dataLoading=!1,this._isConnected=!1,this._dataLoadState=new Map,this._canceller=new EO,this._loadDataAsync=null,this._loadData=we.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})}connectedCallback(){super.connectedCallback(),this._isConnected=!0}disconnectedCallback(){super.disconnectedCallback(),this._isConnected=!1}static get properties(){return{active:{type:Boolean,observer:"_loadDataIfActive"},_isConnected:{type:Boolean},loadKey:{type:String},dataToLoad:{type:Array},getDataLoadName:{type:Object},loadDataCallback:{type:Object},requestData:{type:Object}}}static get observers(){return["_dataToLoadChanged(_isConnected, dataToLoad.*)"]}onLoadFinish(){}reload(){this._dataLoadState.clear(),this._loadData()}reset(){null!=this._loadDataAsync&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null),this._canceller&&this._canceller.cancelAll(),this._dataLoadState&&this._dataLoadState.clear(),this._isConnected&&this._loadData()}_dataToLoadChanged(){this._isConnected&&this._loadData()}detached(){null!=this._loadDataAsync&&(clearTimeout(this._loadDataAsync),this._loadDataAsync=null)}_loadDataIfActive(){this.active&&this._loadData()}_loadDataImpl(){this.active&&(null!==this._loadDataAsync&&clearTimeout(this._loadDataAsync),this._loadDataAsync=setTimeout(this._canceller.cancellable((t=>{if(t.cancelled)return;this.dataLoading=!0;const e=this.dataToLoad.filter((t=>{const e=this.getDataLoadName(t);return!this._dataLoadState.has(e)}));for(const t of e){const e=this.getDataLoadName(t);this._dataLoadState.set(e,Qgt.LOADING)}const n=this._canceller.cancellable((t=>{if(t.cancelled)return;const{item:e,data:n}=t.value,i=this.getDataLoadName(e);this._dataLoadState.set(i,Qgt.LOADED),this.loadDataCallback(this,e,n)})),i=this._canceller.cancellable((t=>{if(!t.cancelled){const t=new Set(e.map((t=>this.getDataLoadName(t))));this.dataToLoad.some((e=>t.has(this.getDataLoadName(e))))&&this.onLoadFinish(),this._loadDataAsync=null}Array.from(this._dataLoadState.values()).includes(Qgt.LOADING)||(this.dataLoading=!1)}));this.requestData(e,n,(()=>i(void 0)))}))))}}}!(function(t){t[t.LOADING=0]="LOADING",t[t.LOADED=1]="LOADED"})(Qgt||(Qgt={})),nl({moduleName:"plottable-style",styleContent:"\n    \n.plottable-colors-0 {\n  background-color: #5279c7; /* INDIGO */\n}\n\n.plottable-colors-1 {\n  background-color: #fd373e; /* CORAL_RED */\n}\n\n.plottable-colors-2 {\n  background-color: #63c261; /* FERN */\n}\n\n.plottable-colors-3 {\n  background-color: #fad419; /* BRIGHT_SUN */\n}\n\n.plottable-colors-4 {\n  background-color: #2c2b6f; /* JACARTA */\n}\n\n.plottable-colors-5 {\n  background-color: #ff7939; /* BURNING_ORANGE */\n}\n\n.plottable-colors-6 {\n  background-color: #db2e65; /* CERISE_RED */\n}\n\n.plottable-colors-7 {\n  background-color: #99ce50; /* CONIFER */\n}\n\n.plottable-colors-8 {\n  background-color: #962565; /* ROYAL_HEATH */\n}\n\n.plottable-colors-9 {\n  background-color: #06cccc; /* ROBINS_EGG_BLUE */\n}\n\n/**\n * User-supplied renderTo element.\n */\n.plottable {\n  display: block; /* must be block elements for width/height calculations to work in Firefox. */\n  pointer-events: visibleFill;\n  position: relative;\n  /**\n   * Pre 3.0, users could set the dimension of the root element in two ways: either using CSS\n   * (inline or through a stylesheet), or using the SVG width/height attributes. By default, we\n   * set the SVG width/height attributes to 100%.\n   *\n   * Post 3.0 the root element is always a normal div and the only way to set the dimensions is\n   * to use CSS. To replicate the \"100%-by-default\" behavior, we apply width/height 100%.\n   */\n  width: 100%;\n  height: 100%;\n}\n\n/**\n * The _element that roots each Component's DOM.\n */\n.plottable .component {\n  /* Allow components to be positioned with explicit left/top/width/height styles */\n  position: absolute;\n}\n\n.plottable .background-container,\n.plottable .content,\n.plottable .foreground-container {\n  position: absolute;\n  width: 100%;\n  height: 100%;\n}\n\n/**\n * Don't allow svg elements above the content to steal events\n */\n.plottable .foreground-container {\n  pointer-events: none;\n}\n\n.plottable .component-overflow-hidden {\n  overflow: hidden;\n}\n\n.plottable .component-overflow-visible {\n  overflow: visible;\n}\n\n.plottable .plot-canvas-container {\n  width: 100%;\n  height: 100%;\n  overflow: hidden;\n}\n\n.plottable .plot-canvas {\n  width: 100%;\n  height: 100%;\n  /**\n   * Play well with deferred rendering.\n   */\n  transform-origin: 0px 0px 0px;\n}\n\n.plottable text {\n  text-rendering: geometricPrecision;\n}\n\n.plottable .label text {\n  fill: #32313F;\n}\n\n.plottable .bar-label-text-area text,\n.plottable .scatter-label-text-area text {\n  font-size: 12px;\n}\n\n.plottable .label-area text {\n  fill: #32313F;\n  font-size: 14px;\n}\n\n.plottable .light-label text {\n  fill: white;\n}\n\n.plottable .dark-label text {\n  fill: #32313F;\n}\n\n.plottable .off-bar-label text {\n  fill: #32313F;\n}\n\n.plottable .stacked-bar-label text {\n  fill: #32313F;\n  font-style: normal;\n}\n\n.plottable .stacked-bar-plot .off-bar-label {\n  /* HACKHACK #2795: correct off-bar label logic to be implemented on StackedBar */\n  visibility: hidden !important;\n}\n\n.plottable .axis-label text {\n  font-size: 10px;\n  font-weight: bold;\n  letter-spacing: 1px;\n  line-height: normal;\n  text-transform: uppercase;\n}\n\n.plottable .title-label text {\n  font-size: 20px;\n  font-weight: bold;\n}\n\n.plottable .axis line.baseline {\n  stroke: #CCC;\n  stroke-width: 1px;\n}\n\n.plottable .axis line.tick-mark {\n  stroke: #CCC;\n  stroke-width: 1px;\n}\n\n.plottable .axis text {\n  fill: #32313F;\n  font-size: 12px;\n  font-weight: 200;\n  line-height: normal;\n}\n\n.plottable .axis .annotation-circle {\n  fill: white;\n  stroke-width: 1px;\n  stroke: #CCC;\n}\n\n.plottable .axis .annotation-line {\n  stroke: #CCC;\n  stroke-width: 1px;\n}\n\n.plottable .axis .annotation-rect {\n  stroke: #CCC;\n  stroke-width: 1px;\n  fill: white;\n}\n\n.plottable .bar-plot .baseline {\n  stroke: #999;\n}\n\n.plottable .gridlines line {\n  stroke: #3C3C3C; /* hackhack: gridlines should be solid; see #820 */\n  opacity: 0.25;\n  stroke-width: 1px;\n}\n\n.plottable .selection-box-layer .selection-area {\n  fill: black;\n  fill-opacity: 0.03;\n  stroke: #CCC;\n}\n/* DragBoxLayer */\n.plottable .drag-box-layer.x-resizable .drag-edge-lr {\n  cursor: ew-resize;\n}\n.plottable .drag-box-layer.y-resizable .drag-edge-tb {\n  cursor: ns-resize;\n}\n\n.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tl {\n  cursor: nwse-resize;\n}\n.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-tr {\n  cursor: nesw-resize;\n}\n.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-bl {\n  cursor: nesw-resize;\n}\n.plottable .drag-box-layer.x-resizable.y-resizable .drag-corner-br {\n  cursor: nwse-resize;\n}\n\n.plottable .drag-box-layer.movable .selection-area {\n  cursor: move; /* IE fallback */\n  cursor: -moz-grab;\n  cursor: -webkit-grab;\n  cursor: grab;\n}\n\n.plottable .drag-box-layer.movable .selection-area:active {\n  cursor: -moz-grabbing;\n  cursor: -webkit-grabbing;\n  cursor: grabbing;\n}\n/* /DragBoxLayer */\n\n.plottable .guide-line-layer line.guide-line {\n  stroke: #CCC;\n  stroke-width: 1px;\n}\n\n.plottable .drag-line-layer.enabled.vertical line.drag-edge {\n  cursor: ew-resize;\n}\n\n.plottable .drag-line-layer.enabled.horizontal line.drag-edge {\n  cursor: ns-resize;\n}\n\n.plottable .legend text {\n  fill: #32313F;\n  font-size: 12px;\n  font-weight: bold;\n  line-height: normal;\n}\n\n.plottable .interpolated-color-legend rect.swatch-bounding-box {\n  fill: none;\n  stroke: #CCC;\n  stroke-width: 1px;\n  pointer-events: none;\n}\n\n.plottable .waterfall-plot line.connector {\n  stroke: #CCC;\n  stroke-width: 1px;\n}\n\n.plottable .pie-plot .arc.outline {\n  stroke-linejoin: round;\n}\n\n"});const e_t=[1,0,0,1,0,0];class n_t extends Ugt.Utils.Translator{computePosition(t,e){const n={x:t,y:e},i=(function r(t){const e=(function n(t){const e=[];for(;t&&t instanceof HTMLElement;)if(e.push(t),t.assignedSlot)t=t.assignedSlot;else if(t.parentElement)t=t.parentElement;else{const e=t.parentNode;t=e instanceof DocumentFragment?e.host:e!==t?e:null}return e})(t);let i=e_t,r=null;for(const t of e){const e=Ugt.Utils.DOM.getElementTransform(t);if(null!=e){const n=t.clientWidth/2,r=t.clientHeight/2;i=Ugt.Utils.Math.multiplyTranslate(i,[n,r]),i=Ugt.Utils.Math.multiplyMatrix(i,Ugt.Utils.Math.invertMatrix(e)),i=Ugt.Utils.Math.multiplyTranslate(i,[-n,-r])}let n=t.scrollLeft,o=t.scrollTop;null!==r&&t!==r||(n-=t.offsetLeft+t.clientLeft,o-=t.offsetTop+t.clientTop,r=t.offsetParent),i=Ugt.Utils.Math.multiplyTranslate(i,[n,o])}return i})(this._rootElement);return null==i?n:Ugt.Utils.Math.applyTransform(i,n)}}class i_t extends Ugt.Dispatchers.Mouse{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new n_t(t.root().rootElement().node())}static getDispatcher(t){const e=t.root().rootElement();let n=e[i_t._DISPATCHER_KEY];return n||(n=new i_t(t),e[i_t._DISPATCHER_KEY]=n),n}}class r_t extends Ugt.Dispatchers.Touch{constructor(t){super(t),this._eventTarget=t.root().rootElement().node(),this._translator=new n_t(t.root().rootElement().node())}static getDispatcher(t){const e=t.root().rootElement();let n=e[r_t._DISPATCHER_KEY];return n||(n=new r_t(t),e[r_t._DISPATCHER_KEY]=n),n}}Ugt.Interaction.prototype._isInsideComponent=function(t){return 0<=t.x&&0<=t.y&&t.x<this._componentAttachedTo.width()&&t.y<this._componentAttachedTo.height()};class o_t extends Ugt.Interactions.Pointer{_anchor(t){const e=this;e._isAnchored=!0,e._mouseDispatcher=i_t.getDispatcher(e._componentAttachedTo),e._mouseDispatcher.onMouseMove(e._mouseMoveCallback),e._touchDispatcher=r_t.getDispatcher(e._componentAttachedTo),e._touchDispatcher.onTouchStart(e._touchStartCallback)}}var a_t;!(function(t){t.AUTO="auto",t.BOTTOM="bottom",t.RIGHT="right"})(a_t||(a_t={}));const s_t={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5};let l_t=class extends(tr(ye)){constructor(){super(...arguments),this.position=a_t.AUTO,this.minDistFromEdge=15,this._styleCache=null,this._raf=null,this._tunnel=null}ready(){this._styleCache=null,this._raf=null,this._tunnel=null}attached(){this._tunnel=this._createTunnel(),this._hideOnBlur=()=>{document.hidden&&this.hide()},window.addEventListener("visibilitychange",this._hideOnBlur)}detached(){this.hide(),this._removeTunnel(this._tunnel),this._tunnel=null,window.removeEventListener("visibilitychange",this._hideOnBlur)}content(){return this._tunnel.shadowRoot}hide(){window.cancelAnimationFrame(this._raf),this._styleCache=null,this._tunnel.style.opacity=0}updateAndPosition(t){window.cancelAnimationFrame(this._raf),this._raf=window.requestAnimationFrame((()=>{this.isAttached&&this._repositionImpl(t)}))}_repositionImpl(t){const e=this._tunnel,n=t.getBoundingClientRect(),i=e.getBoundingClientRect(),r=window.innerHeight,o=document.body.clientWidth,a=n.top,s=a+n.height,l=i.height+20;let c=null,u=Math.max(this.minDistFromEdge,n.left),h=null,d=a;this.position==a_t.RIGHT?u=n.right:(d=s+20,o<u+i.width+this.minDistFromEdge&&(u=null,h=this.minDistFromEdge)),this.position==a_t.AUTO&&n.top-l>0&&r<n.top+n.height+l&&(d=null,c=r-a+20);const p={contain:"content",opacity:1,left:u?`${u}px`:null,right:h?`${h}px`:null,top:d?`${d}px`:null,bottom:c?`${c}px`:null};we.isEqual(this._styleCache,p)||(Object.assign(e.style,p),this._styleCache=p)}_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");const t=document.createElement(this.contentComponentName);return Object.assign(t.style,s_t),document.body.appendChild(t),t}_removeTunnel(t){document.body.removeChild(t)}};t([o({type:String}),e("design:type",String)],l_t.prototype,"contentComponentName",void 0),t([o({type:String}),e("design:type",String)],l_t.prototype,"position",void 0),t([o({type:Number}),e("design:type",Number)],l_t.prototype,"minDistFromEdge",void 0),l_t=t([i("vz-chart-tooltip")],l_t);const c_t=py(".2~e"),u_t=py("~"),h_t=py(",~");function d_t(t){if(0===t)return"0";const e=Math.abs(t);return e>=1e5||e<.001?c_t(t):u_t(t)}const p_t={formatTick:d_t,formatShort:d_t,formatReadable:t=>h_t(t)};py(".4~");const f_t=FA().tickFormat();let m_t;const g_t={formatTick:t=>f_t(new Date(t)),formatShort:t=>new Date(t).toLocaleString(m_t,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:t=>new Date(t).toLocaleString(m_t,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};var __t;!(function(t){t[t.LINEAR=0]="LINEAR",t[t.LOG10=1]="LOG10",t[t.TIME=2]="TIME"})(__t||(__t={}));class y_t{constructor(){this.defaultFormatter=p_t}transform(t,e,n){const[i,r]=t,o=r-i,[a,s]=e;return 0===o?a:(s-a)/o*(n-i)+a}forward(t,e,n){return this.transform(t,e,n)}reverse(t,e,n){return this.transform(e,t,n)}niceDomain(t){let[e,n]=t;if(n<e)throw new Error("Unexpected input: min is larger than max");if(n===e)return 0===e?[-1,1]:e<0?[2*e,0]:[0,2*e];const i=zM(),r=.05*(n-e+Number.EPSILON),[o,a]=i.domain([e-r,n+r]).nice().domain();return[o,a]}ticks(t,e){return zM().domain(t).ticks(e)}isSafeNumber(t){return Number.isFinite(t)}}class v_t{constructor(){this.defaultFormatter=p_t}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,e,n){if(n<=0)return e[0];const[i,r]=t,[o,a]=e,s=this.transform(i),l=this.transform(r)-s,c=a-o;return n=this.transform(n),c/(l+Number.EPSILON)*(n-s)+o}reverse(t,e,n){const[i,r]=t,[o,a]=e,s=this.transform(i),l=this.transform(r);return this.untransform((l-s)/(a-o+Number.EPSILON)*(n-o)+s)}niceDomain(t){const[e,n]=t;if(e>n)throw new Error("Unexpected input: min is larger than max");const i=Math.max(e,Number.MIN_VALUE),r=Math.max(n,Number.MIN_VALUE);return n<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*i),2*r]}ticks(t,e){const n=t[0]<=0?Number.MIN_VALUE:t[0],i=t[1]<=0?Number.MIN_VALUE:t[1],r=WM().domain([n,i]).ticks(e);return r.length?r:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}}class b_t{constructor(){this.scale=FA(),this.defaultFormatter=g_t}forward(t,e,n){return this.scale.domain(t).range(e)(n)}reverse(t,e,n){return this.scale.domain(t).range(e).invert(n).getTime()}niceDomain(t){const[e,n]=this.scale.domain(t).nice().domain();return[e.getTime(),n.getTime()]}ticks(t,e){return this.scale.domain(t).ticks(e).map((t=>t.getTime()))}isSafeNumber(t){return Number.isFinite(t)}}class x_t extends Ugt.Scales.Linear{constructor(){super(),this._ignoreOutlier=!1,this.padProportion(.2)}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}_niceDomain(t,e){const[n,i]=t;return(function r(t){switch(t){case __t.LINEAR:return new y_t;case __t.LOG10:return new v_t;case __t.TIME:return new b_t;default:throw new RangeError(`ScaleType ${t} not supported.`)}})(__t.LINEAR).niceDomain([n,i])}_getUnboundedExtent(t){const e=this._getAllIncludedValues(t);let n=this._defaultExtent();if(0!==e.length){const t=[Ugt.Utils.Math.min(e,n[0]),Ugt.Utils.Math.max(e,n[1])];n=this._niceDomain(t)}return n}_getAllIncludedValues(t=!1){const e=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(e)}extentOfValues(t){const e=t.filter((t=>Ugt.Utils.Math.isValidNumber(t)));let n=e;if(this.ignoreOutlier()){const t=e.sort(((t,e)=>t-e)),i=Gl(t,.05),r=Gl(t,.95);n=e.filter((t=>t>=i&&t<=r))}const i=Ll(n);return null==i[0]||null==i[1]?[]:i}ignoreOutlier(t){return"boolean"==typeof t?(this._ignoreOutlier=t,this):this._ignoreOutlier}}class w_t extends Ugt.QuantitativeScale{constructor(){super(...arguments),this._ignoreOutlier=!1}setValueProviderForDomain(t){return this._valueProviderForDomain=t,this}ignoreOutlier(t){return"boolean"==typeof t?(this._ignoreOutlier=t,this):this._ignoreOutlier}_getAllIncludedValues(t=!1){const e=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(e)}}const S_t=Math.pow(2,-1074);function M_t(t){return Math.log10(t)}function E_t(t){return Math.pow(10,t)}class T_t extends w_t{constructor(){super(),this._d3LogScale=WM(),this.padProportion(.2)}scale(t){return t<=0?NaN:this._d3LogScale(t)}invert(t){return this._d3LogScale.invert(t)}scaleTransformation(t){return this.scale(t)}invertedTransformation(t){return this.invert(t)}getTransformationDomain(){return this.domain()}setTransformationDomain(t){this.domain(t)}getTransformationExtent(){return this._getUnboundedExtent(!0)}_getDomain(){return this._untransformedDomain}_setDomain(t){this._untransformedDomain=t;const[e,n]=t;super._setDomain([Math.max(S_t,e),n])}_niceDomain(t,e){const[n,i]=t,r=Math.max(M_t(S_t),M_t(n)),o=M_t(i),a=o-r,s=a?a*this.padProportion():1;return[E_t(Math.max(M_t(S_t),r-s)),E_t(o+s)]}_getUnboundedExtent(t){const e=this._getAllIncludedValues(t);let n=this._defaultExtent();if(0!==e.length){const t=[Ugt.Utils.Math.min(e,n[0]),Ugt.Utils.Math.max(e,n[1])];n=this._niceDomain(t)}return n}_getAllIncludedValues(t=!1){return super._getAllIncludedValues().map((t=>t>0?t:S_t))}_defaultExtent(){return[1,10]}_backingScaleDomain(t){return null==t?this._d3LogScale.domain():(this._d3LogScale.domain(t),this)}_getRange(){return this._d3LogScale.range()}_setRange(t){this._d3LogScale.range(t)}defaultTicks(){return this._d3LogScale.ticks(1)}ticks(){return this._d3LogScale.ticks()}extentOfValues(t){const e=t.filter((t=>Ugt.Utils.Math.isValidNumber(t)&&t>0));let n=e;if(this.ignoreOutlier()){const t=e.map(M_t).sort(((t,e)=>t-e)),i=Gl(t,.05),r=Gl(t,.95);n=t.filter((t=>t>=i&&t<=r)).map(E_t)}const i=Ll(n);return null==i[0]||null==i[1]?[]:i}}class A_t extends Ugt.Components.SelectionBoxLayer{constructor(t,e,n){super(),this.easeFn=Tf,this._animationTime=750,this.xScale(t),this.yScale(e),this._dragInteraction=new Ugt.Interactions.Drag,this._doubleClickInteraction=new Ugt.Interactions.Click,this.setupCallbacks(),this.unzoomMethod=n,this.onDetach((()=>{this._doubleClickInteraction.detachFrom(this),this._dragInteraction.detachFrom(this)})),this.onAnchor((()=>{this._doubleClickInteraction.attachTo(this),this._dragInteraction.attachTo(this)}))}interactionStart(t){this.onStart=t}interactionEnd(t){this.onEnd=t}dragInteraction(){return this._dragInteraction}setupCallbacks(){let t=!1;this._dragInteraction.onDragStart((t=>{this.bounds({topLeft:t,bottomRight:t}),this.onStart()})),this._dragInteraction.onDrag(((e,n)=>{this.bounds({topLeft:e,bottomRight:n}),this.boxVisible(!0),t=!0})),this._dragInteraction.onDragEnd(((e,n)=>{this.boxVisible(!1),this.bounds({topLeft:e,bottomRight:n}),t?this.zoom():this.onEnd(),t=!1})),this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(t){if(null==t)return this._animationTime;if(t<0)throw new Error("animationTime cannot be negative");return this._animationTime=t,this}ease(t){if("function"!=typeof t)throw new Error("ease function must be a function");return 0===t(0)&&1===t(1)||Ugt.Utils.Window.warn("Easing function does not maintain invariant f(0)==0 && f(1)==1. Bad behavior may result."),this.easeFn=t,this}zoom(){let t=this.xExtent()[0].valueOf(),e=this.xExtent()[1].valueOf(),n=this.yExtent()[1].valueOf(),i=this.yExtent()[0].valueOf();t!==e&&n!==i&&this.interpolateZoom(t,e,n,i)}unzoom(){let t=this.xScale();t._domainMin=null,t._domainMax=null;let e=t._getExtent();this.xScale().domain(e),this.unzoomMethod()}isZooming(t){this._dragInteraction.enabled(!t),this._doubleClickInteraction.enabled(!t)}interpolateZoom(t,e,n,i){let r=this.xScale().domain()[0].valueOf(),o=this.xScale().domain()[1].valueOf(),a=this.yScale().domain()[0].valueOf(),s=this.yScale().domain()[1].valueOf(),l=this.easeFn,c=(t,e,n)=>Bd(t,e)(l(n));this.isZooming(!0);let u=Date.now(),h=()=>{let l=Date.now(),d=0===this._animationTime?1:Math.min(1,(l-u)/this._animationTime),p=c(r,t,d),f=c(o,e,d),m=c(a,n,d),g=c(s,i,d);this.xScale().domain([p,f]),this.yScale().domain([m,g]),d<1?Ugt.Utils.DOM.requestAnimationFramePolyfill(h):(this.onEnd(),this.isZooming(!1))};h()}}var C_t,k_t,L_t,P_t;!(function(t){t[t.NONE=0]="NONE",t[t.DRAG_ZOOMING=1]="DRAG_ZOOMING",t[t.PANNING=2]="PANNING"})(C_t||(C_t={}));class I_t extends Ugt.Components.Group{constructor(t,e,n){super(),this.state=C_t.NONE,this.panStartCallback=new Ugt.Utils.CallbackSet,this.panEndCallback=new Ugt.Utils.CallbackSet,this.panZoom=new Ugt.Interactions.PanZoom(t,e),this.panZoom.dragInteraction().mouseFilter((t=>I_t.isPanKey(t)&&0===t.button)),this.panZoom.wheelFilter(this.canScrollZoom),this.dragZoomLayer=new A_t(t,e,n),this.dragZoomLayer.dragInteraction().mouseFilter((t=>!I_t.isPanKey(t)&&0===t.button)),this.append(this.dragZoomLayer);const i=this.onWheel.bind(this);this.onAnchor((()=>{this._mouseDispatcher=Ugt.Dispatchers.Mouse.getDispatcher(this),this._mouseDispatcher.onWheel(i),this.panZoom.attachTo(this)})),this.onDetach((()=>{this.panZoom.detachFrom(this),this._mouseDispatcher&&(this._mouseDispatcher.offWheel(i),this._mouseDispatcher=null)})),this.panZoom.dragInteraction().onDragStart((()=>{this.state==C_t.NONE&&this.setState(C_t.PANNING)})),this.panZoom.dragInteraction().onDragEnd((()=>{this.state==C_t.PANNING&&this.setState(C_t.NONE)})),this.dragZoomLayer.dragInteraction().onDragStart((()=>{this.state==C_t.NONE&&this.setState(C_t.DRAG_ZOOMING)})),this.dragZoomLayer.dragInteraction().onDragEnd((()=>{this.state==C_t.DRAG_ZOOMING&&this.setState(C_t.NONE)}))}onWheel(t,e){if(this.canScrollZoom(e))return;const n=this.element();if(!n.select(".help").empty())return;const i=n.append("div").classed("help",!0);i.append("span").text("Alt + Scroll to Zoom"),i.on("animationend",(()=>{i.remove()}))}static isPanKey(t){return Boolean(t.altKey)||Boolean(t.shiftKey)}canScrollZoom(t){return t.altKey}setState(t){if(this.state==t)return;const e=this.state;this.state=t,this.root().removeClass(this.stateClassName(e)),this.root().addClass(this.stateClassName(t)),e==C_t.PANNING&&this.panEndCallback.callCallbacks(),t==C_t.PANNING&&this.panStartCallback.callCallbacks()}stateClassName(t){switch(t){case C_t.PANNING:return"panning";case C_t.DRAG_ZOOMING:return"drag-zooming";case C_t.NONE:default:return""}}onPanStart(t){this.panStartCallback.add(t)}onPanEnd(t){this.panEndCallback.add(t)}onScrollZoom(t){this.panZoom.onZoomEnd(t)}onDragZoomStart(t){this.dragZoomLayer.interactionStart(t)}onDragZoomEnd(t){this.dragZoomLayer.interactionEnd(t)}}!(function(t){t[t.TEXT=0]="TEXT",t[t.DOM=1]="DOM"})(k_t||(k_t={})),(function(t){t.LOG="log",t.LINEAR="linear"})(L_t||(L_t={}));class N_t{constructor(t,e,n,i,r,o,a,s,l,c,u){this.dirtyDatasets=new Set,this.seriesNames=[],this.name2datasets={},this.colorScale=i,this.tooltip=r,this.datasets=[],this._ignoreYOutliers=!1,this.lastPointsDataset=new Ugt.Dataset,this.nanDataset=new Ugt.Dataset,this.yValueAccessor=e,this.symbolFunction=c,this._defaultXRange=s,this._defaultYRange=l,this.tooltipColumns=o,this.buildChart(t,e,n,a,u)}buildChart(t,e,n,i,r){this.destroy();const o=t();this.xAccessor=o.accessor,this.xScale=o.scale,this.xAxis=o.axis,this.xAxis.margin(0).tickLabelPadding(3),r&&this.xAxis.formatter(r),this.yScale=N_t.getYScaleFromType(n),this.yScale.setValueProviderForDomain((()=>this.getValuesForYAxisDomainCompute())),this.yAxis=new Ugt.Axes.Numeric(this.yScale,"left");let a=qgt(3);this.yAxis.margin(0).tickLabelPadding(5).formatter(a),this.yAxis.usesTextWidthApproximation(!0),this.fillArea=i;const s=new I_t(this.xScale,this.yScale,(()=>this.resetDomain()));this.tooltipInteraction=this.createTooltipInteraction(s),this.tooltipPointsComponent=new Ugt.Component;const l=this.buildPlot(this.xScale,this.yScale,i);this.gridlines=new Ugt.Components.Gridlines(this.xScale,this.yScale);let c=null;n!==L_t.LOG&&(c=new Ugt.Components.GuideLineLayer("horizontal"),c.scale(this.yScale).value(0));let u=new Ugt.Components.GuideLineLayer("vertical");u.scale(this.xScale).value(0),this.center=new Ugt.Components.Group([this.gridlines,c,u,l,this.tooltipPointsComponent,s]),this.center.addClass("main"),this.outer=new Ugt.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,e,n){n&&(this.marginAreaPlot=new Ugt.Plots.Area,this.marginAreaPlot.x(this.xAccessor,t),this.marginAreaPlot.y(n.higherAccessor,e),this.marginAreaPlot.y0(n.lowerAccessor),this.marginAreaPlot.attr("fill",((t,e,n)=>this.colorScale.scale(n.metadata().name))),this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0)),this.smoothedAccessor=t=>t.smoothed;let i=new Ugt.Plots.Line;i.x(this.xAccessor,t),i.y(this.yValueAccessor,e),i.attr("stroke",((t,e,n)=>this.colorScale.scale(n.metadata().name))),this.linePlot=i,this.setupTooltips(i);let r=new Ugt.Plots.Line;if(r.x(this.xAccessor,t),r.y(this.smoothedAccessor,e),r.attr("stroke",((t,e,n)=>this.colorScale.scale(n.metadata().name))),this.smoothLinePlot=r,this.symbolFunction){const n=new Ugt.Plots.Scatter;n.x(this.xAccessor,t),n.y(this.yValueAccessor,e),n.attr("fill",((t,e,n)=>this.colorScale.scale(n.metadata().name))),n.attr("opacity",1),n.size(8),n.symbol(((t,e,n)=>this.symbolFunction(n.metadata().name))),this.markersScatterPlot=n}let o=new Ugt.Plots.Scatter;o.x(this.xAccessor,t),o.y(this.yValueAccessor,e),o.attr("fill",(t=>this.colorScale.scale(t.name))),o.attr("opacity",1),o.size(8),o.datasets([this.lastPointsDataset]),this.scatterPlot=o;let a=new Ugt.Plots.Scatter;a.x(this.xAccessor,t),a.y((t=>t.displayY),e),a.attr("fill",(t=>this.colorScale.scale(t.name))),a.attr("opacity",1),a.size(12),a.datasets([this.nanDataset]),a.symbol(Ugt.SymbolFactories.triangle),this.nanDisplay=a;const s=[a,o,r,i];return this.marginAreaPlot&&s.push(this.marginAreaPlot),this.markersScatterPlot&&s.push(this.markersScatterPlot),new Ugt.Components.Group(s)}ignoreYOutliers(t){t!==this._ignoreYOutliers&&(this._ignoreYOutliers=t,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(t),this.resetYDomain())}getValuesForYAxisDomainCompute(){const t=this.getAccessorsForComputingYRange();return we.flattenDeep(this.datasets.map((e=>t.map((t=>e.data().map((n=>t(n,-1,e)))))))).filter(isFinite)}updateSpecialDatasets(){const t=this.getYAxisAccessor();let e=this.datasets.map((e=>{let n=null,i=e.data().filter((n=>!isNaN(t(n,-1,e))));return i.length>0&&(n=i[i.length-1],n.name=e.metadata().name,n.relative=Kgt(n,0,e)),n})).filter((t=>null!=t));this.lastPointsDataset.data(e),this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));let n=we.flatten(this.datasets.map((e=>{let n=null,i=e.data(),r=0;for(;r<i.length&&null==n;)isNaN(t(i[r],-1,e))||(n=t(i[r],-1,e)),r++;null==n&&(n=0);let o=[];for(r=0;r<i.length;r++)isNaN(t(i[r],-1,e))?(i[r].name=e.metadata().name,i[r].displayY=n,i[r].relative=Kgt(i[r],0,e),o.push(i[r])):n=t(i[r],-1,e);return o})));this.nanDataset.data(n)}resetDomain(){this.resetXDomain(),this.resetYDomain()}resetXDomain(){let t;if(null!=this._defaultXRange)t=this._defaultXRange;else{const e=this.xScale;e._domainMin=null,e._domainMax=null,t=e._getExtent()}this.xScale.domain(t)}resetYDomain(){null!=this._defaultYRange?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){const t=[this.getYAxisAccessor()];return this.fillArea&&t.push(this.fillArea.lowerAccessor,this.fillArea.higherAccessor),t}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(t){const e=new o_t,n=()=>{e.enabled(!1),this.hideTooltips()},i=()=>e.enabled(!0);return t.onPanStart(n),t.onDragZoomStart(n),t.onPanEnd(i),t.onDragZoomEnd(i),t.onScrollZoom((()=>this.updateTooltipContent(this._lastMousePosition))),e.onPointerMove((t=>{this._lastMousePosition=t,this.updateTooltipContent(t)})),e.onPointerExit((()=>this.hideTooltips())),e}updateTooltipContent(t){this.linePlot&&(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame((()=>{let e={x:t.x,y:t.y,datum:null,dataset:null},n=this.gridlines.content().node().getBBox(),i=this.linePlot.datasets().map((t=>this.findClosestPoint(e,t))).filter(Boolean),r=Ugt.Utils.DOM.intersectsBBox,o=i.filter((t=>r(t.x,t.y,n)||isNaN(this.yValueAccessor(t.datum,0,t.dataset)))),a=o.filter((t=>!isNaN(this.yValueAccessor(t.datum,0,t.dataset))));if(0!==i.length){this.scatterPlot.attr("display","none");const t=this.tooltipPointsComponent.content().selectAll(".point").data(a,(t=>t.dataset.metadata().name));t.enter().append("circle").classed("point",!0),t.attr("r",4).attr("cx",(t=>t.x)).attr("cy",(t=>t.y)).style("stroke","none").attr("fill",(t=>this.colorScale.scale(t.dataset.metadata().name))),t.exit().remove(),this.drawTooltips(o,e,this.tooltipColumns)}else this.hideTooltips()})))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this.tooltip.hide(),this.scatterPlot.attr("display","block"),this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(t){t.onDetach((()=>{this.tooltipInteraction.detachFrom(t),this.tooltipInteraction.enabled(!1)})),t.onAnchor((()=>{this.tooltipInteraction.attachTo(t),this.tooltipInteraction.enabled(!0)}))}drawTooltips(t,e,n){if(!t.length)return void this.tooltip.hide();const{colorScale:i}=this;n=[{title:"",static:!1,evalType:k_t.DOM,evaluate(t){return Su(this).select("span").style("background-color",(()=>i.scale(t.dataset.metadata().name))),""},enter(t){Su(this).append("span").classed("swatch",!0).style("background-color",(()=>i.scale(t.dataset.metadata().name)))}},...n];const r=t=>Math.pow(t.x-e.x,2)+Math.pow(t.y-e.y,2),o=we.min(t.map(r)),a=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;t="ascending"===this.tooltipSortingMethod?we.sortBy(t,(t=>a(t.datum,-1,t.dataset))):"descending"===this.tooltipSortingMethod?we.sortBy(t,(t=>a(t.datum,-1,t.dataset))).reverse():"nearest"===this.tooltipSortingMethod?we.sortBy(t,r):t.slice(0).reverse();const s=this,l=Su(this.tooltip.content()).select("table"),c=l.select("thead").selectAll("th").data(n,((t,e,n)=>t.title));c.enter().append("th").text((t=>t.title)).nodes(),c.exit().remove();const u=l.select("tbody").selectAll("tr").data(t,((t,e,n)=>t.dataset.metadata().name));u.classed("distant",(t=>{let n=t.dataset.data()[0],i=we.last(t.dataset.data()),r=this.xScale.scale(this.xAccessor(n,0,t.dataset)),o=this.xScale.scale(this.xAccessor(i,0,t.dataset)),a=this.smoothingEnabled?t.datum.smoothed:this.yValueAccessor(t.datum,0,t.dataset);return e.x<r||e.x>o||isNaN(a)})).classed("closest",(t=>r(t)===o)).each((function(t){s.drawTooltipRow(this,n,t)})).order(),u.exit().remove(),u.enter().append("tr").each((function(t){s.drawTooltipRow(this,n,t)})).nodes(),this.tooltip.updateAndPosition(this.targetSVG.node())}drawTooltipRow(t,e,n){const i=this,r=Su(t).selectAll("td").data(e);r.each((function(t){t.static||i.drawTooltipColumn.call(i,this,t,n)})),r.exit().remove(),r.enter().append("td").each((function(t){"enter"in t&&t.enter&&t.enter.call(this,n),i.drawTooltipColumn.call(i,this,t,n)}))}drawTooltipColumn(t,e,n){const{smoothingEnabled:i}=this;"evalType"in e&&e.evalType==k_t.DOM?e.evaluate.call(t,n,{smoothingEnabled:i}):Su(t).text(e.evaluate.call(t,n,{smoothingEnabled:i}))}findClosestPoint(t,e){const n=e.data().map(((t,n)=>this.xScale.scale(this.xAccessor(t,n,e))));let i=we.sortedIndex(n,t.x);if(0==n.length)return null;i===n.length?i-=1:0!==i&&(i=Math.abs(n[i-1]-t.x)<Math.abs(n[i]-t.x)?i-1:i);const r=e.data()[i],o=this.smoothingEnabled?this.smoothedAccessor(r,i,e):this.yValueAccessor(r,i,e);return{x:n[i],y:this.yScale.scale(o),datum:r,dataset:e}}resmoothDataset(t){let e=t.data();const n=this.smoothingWeight;let i=e.length>0?0:NaN,r=0;const o=e.map(((e,n)=>this.yValueAccessor(e,n,t))),a=o.every((t=>t==o[0]));e.forEach(((t,e)=>{const s=o[e];if(a||!Number.isFinite(s))t.smoothed=s;else{i=i*n+(1-n)*s,r++;let e=1;1!==n&&(e=1-Math.pow(n,r)),t.smoothed=i/e}}))}getDataset(t){return void 0===this.name2datasets[t]&&(this.name2datasets[t]=new Ugt.Dataset([],{name:t,meta:null})),this.name2datasets[t]}static getYScaleFromType(t){if(t===L_t.LOG)return new T_t;if(t===L_t.LINEAR)return new x_t;throw new Error("Unrecognized yScale type "+t)}setVisibleSeries(t){this.disableChanges(),(t=t.sort()).reverse(),this.seriesNames=t}disableChanges(){this.dirtyDatasets.size||(this.linePlot.datasets([]),this.smoothLinePlot&&this.smoothLinePlot.datasets([]),this.marginAreaPlot&&this.marginAreaPlot.datasets([]))}commitChanges(){this.datasets=this.seriesNames.map((t=>this.getDataset(t))),[...this.dirtyDatasets].forEach((t=>{this.smoothingEnabled&&this.resmoothDataset(this.getDataset(t))})),this.updateSpecialDatasets(),this.linePlot.datasets(this.datasets),this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets),this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets),this.measureBBoxAndMaybeInvalidateLayoutInRaf(),this.dirtyDatasets.clear()}createSampledDatasetForMarkers(t){const e=t.data();if(e.length<=20)return t;const n=Math.ceil(e.length/20),i=new Array(Math.floor(e.length/n));for(let t=0,r=0;t<i.length;t++,r+=n)i[t]=e[r];return new Ugt.Dataset(i,t.metadata())}setSeriesData(t,e){this.disableChanges(),this.getDataset(t).data(e),this.dirtyDatasets.add(t)}setSeriesMetadata(t,e){this.disableChanges(),this.getDataset(t).metadata(Object.assign(Object.assign({},this.getDataset(t).metadata()),{meta:e})),this.dirtyDatasets.add(t)}smoothingUpdate(t){this.smoothingWeight=t,this.datasets.forEach((t=>this.resmoothDataset(t))),this.smoothingEnabled||(this.linePlot.addClass("ghost"),this.scatterPlot.y(this.smoothedAccessor,this.yScale),this.smoothingEnabled=!0,this.smoothLinePlot.datasets(this.datasets)),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale),this.updateSpecialDatasets()}smoothingDisable(){this.smoothingEnabled&&(this.linePlot.removeClass("ghost"),this.scatterPlot.y(this.yValueAccessor,this.yScale),this.smoothLinePlot.datasets([]),this.smoothingEnabled=!1,this.updateSpecialDatasets()),this.markersScatterPlot&&this.markersScatterPlot.y(this.getYAxisAccessor(),this.yScale)}setColorScale(t){this.colorScale=t}setTooltipColumns(t){this.tooltipColumns=t}setTooltipSortingMethod(t){this.tooltipSortingMethod=t}renderTo(t){this.targetSVG=t,this.outer.renderTo(t),null!=this._defaultXRange&&this.resetXDomain(),null!=this._defaultYRange&&this.resetYDomain(),this.measureBBoxAndMaybeInvalidateLayoutInRaf()}redraw(){window.cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame((()=>{this.measureBBoxAndMaybeInvalidateLayout(),this.outer.redraw()}))}measureBBoxAndMaybeInvalidateLayoutInRaf(){window.cancelAnimationFrame(this._invalidateLayoutRaf),this._invalidateLayoutRaf=window.requestAnimationFrame((()=>{this.measureBBoxAndMaybeInvalidateLayout()}))}measureBBoxAndMaybeInvalidateLayout(){if(this._lastDrawBBox){const{width:t}=this._lastDrawBBox,{width:e}=this.targetSVG.node().getBoundingClientRect();0==t&&t<e&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf),window.cancelAnimationFrame(this._invalidateLayoutRaf),this.outer&&this.outer.destroy()}onAnchor(t){this.outer&&this.outer.onAnchor(t)}isDataFitToDomain(){return t(this.xAxis.getScale())&&t(this.yAxis.getScale());function t(t){const e=t.getTransformationDomain(),n=t.getTransformationExtent();return n[0]===e[0]&&n[1]===e[1]}}}!(function(t){t.GROUP="G",t.DIV="DIV",t.SVG="SVG",t.TEXT="TEXT"})(P_t||(P_t={}));class O_t extends class{constructor(t){this.uniqueId=0,this.root=t}exportAsString(){const t=this.convert(this.root);if(!t)return"";const e=this.createRootSvg();return e.appendChild(t),e.outerHTML}createUniqueId(t){return`${t}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){const t=document.createElement("svg"),e=this.getSize();return t.setAttributeNS("svg","viewBox",`0 0 ${e.width} ${e.height}`),t.setAttribute("xmlns","http://www.w3.org/2000/svg"),t}convert(t){let e=null;const n=t.nodeName.toUpperCase();if(t.nodeType!=Node.ELEMENT_NODE||n!=P_t.DIV&&n!=P_t.SVG)e=t.cloneNode();else{e=document.createElement(P_t.GROUP);const n=window.getComputedStyle(t),i=parseInt(n.left,10),r=parseInt(n.top,10);if(i||r){const t=this.createUniqueId("clip");e.setAttribute("transform",`translate(${i}, ${r})`),e.setAttribute("clip-path",`url(#${t})`);const o=parseInt(n.width,10),a=parseInt(n.height,10),s=document.createElement("rect");s.setAttribute("width",String(o)),s.setAttribute("height",String(a));const l=document.createElementNS("svg","clipPath");l.id=t,l.appendChild(s),e.appendChild(l)}}return Array.from(t.childNodes).map((t=>this.convert(t))).filter(Boolean).forEach((t=>e.appendChild(t))),e.nodeName.toUpperCase()==P_t.GROUP&&!e.hasChildNodes()||this.shouldOmitNode(t)?null:this.stripClass(this.transferStyle(t,e))}stripClass(t){return t.nodeType==Node.ELEMENT_NODE&&t.removeAttribute("class"),t}transferStyle(t,e){if(e.nodeType!=Node.ELEMENT_NODE)return e;const n=e,i=e.nodeName.toUpperCase(),r=window.getComputedStyle(t);return i==P_t.TEXT&&Object.assign(n.style,{fontFamily:r.fontFamily,fontSize:r.fontSize,fontWeight:r.fontWeight}),i!=P_t.GROUP&&(n.setAttribute("fill",r.fill),n.setAttribute("stroke",r.stroke),n.setAttribute("stroke-width",r.strokeWidth)),"1"!=r.opacity&&n.setAttribute("opacity",r.opacity),e}shouldOmitNode(t){return!1}}{shouldOmitNode(t){return t.nodeType==Node.ELEMENT_NODE&&t.classList.contains("scatter-plot")}}nl({moduleName:"vz-pan-zoom-style",styleContent:"\n    .help {\n      align-items: center;\n      animation-delay: 1s;\n      animation-duration: 1s;\n      animation-name: fade-out;\n      background: rgba(30, 30, 30, 0.6);\n      bottom: 0;\n      color: #fff;\n      display: flex;\n      justify-content: center;\n      left: 0;\n      opacity: 1;\n      padding: 20px;\n      pointer-events: none;\n      position: absolute;\n      right: 0;\n      top: 0;\n    }\n\n    .help > span {\n      white-space: normal;\n    }\n\n    @keyframes fade-out {\n      0% {\n        opacity: 1;\n      }\n\n      100% {\n        opacity: 0;\n      }\n    }\n  "});const R_t=qgt(4),z_t=t=>isNaN(t)?"NaN":R_t(t),D_t=[{title:"Name",evaluate:t=>t.dataset.metadata().name},{title:"Smoothed",evaluate(t,e){const{smoothingEnabled:n}=e;return z_t(n?t.datum.smoothed:t.datum.scalar)}},{title:"Value",evaluate:t=>z_t(t.datum.scalar)},{title:"Step",evaluate:t=>Ygt(t.datum.step)},{title:"Time",evaluate:t=>$gt(t.datum.wall_time)},{title:"Relative",evaluate:t=>Zgt(Kgt(t.datum,0,t.dataset))}];let B_t=class extends(tr(ye)){constructor(){super(...arguments),this.colorScale=(new Ugt.Scales.Color).range(YA.slice(0)),this.smoothingEnabled=!1,this.smoothingWeight=.6,this.xType=null,this.xComponentsCreationMethod=null,this.yValueAccessor=t=>t.scalar,this.tooltipColumns=D_t,this.yScaleType=L_t.LINEAR,this.ignoreYOutliers=!1,this.tooltipSortingMethod="default",this.tooltipPosition=a_t.BOTTOM,this._visibleSeriesCache=[],this._seriesDataCache={},this._seriesMetadataCache={},this._makeChartAsyncCallbackId=null}ready(){super.ready(),this.scopeSubtree(this.$.chartdiv,!0)}attached(){const t={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),t),this._listen(this,"mouseup",this._onMouseUp.bind(this),t),this._listen(window,"keydown",this._onKeyDown.bind(this),t),this._listen(window,"keyup",this._onKeyUp.bind(this),t)}detached(){this.cancelAsync(this._makeChartAsyncCallbackId),this._chart&&(this._chart.destroy(),this._chart=void 0),this._listeners&&(this._listeners.forEach((({node:t,eventName:e,func:n,option:i})=>{t.removeEventListener(e,n,i)})),this._listeners.clear())}_listen(t,e,n,i={}){this._listeners||(this._listeners=new Set),this._listeners.add({node:t,eventName:e,func:n,option:i}),t.addEventListener(e,n,i)}_onKeyDown(t){this.toggleClass("pankey",I_t.isPanKey(t))}_onKeyUp(t){this.toggleClass("pankey",I_t.isPanKey(t))}_onMouseDown(t){this.toggleClass("mousedown",!0)}_onMouseUp(t){this.toggleClass("mousedown",!1)}isDataFitToDomain(){return!this._chart||this._chart.isDataFitToDomain()}setVisibleSeries(t){we.isEqual(this._visibleSeriesCache,t)||(this._visibleSeriesCache=t)}setSeriesData(t,e){this._seriesDataCache[t]=e,this._chart&&this._chart.setSeriesData(t,e)}setSeriesMetadata(t,e){this._seriesMetadataCache[t]=e,this._chart&&this._chart.setSeriesMetadata(t,e)}commitChanges(){this._chart&&this._chart.commitChanges()}resetDomain(){this._chart&&this._chart.resetDomain()}redraw(){this._chart&&this._chart.redraw()}_makeChart(){null!==this._makeChartAsyncCallbackId&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null),this._makeChartAsyncCallbackId=this.async((function(){this._makeChartAsyncCallbackId=null;let t=this.xComponentsCreationMethod;if(this.xType||t?this.xType&&(t=()=>Jgt(this.xType)):t=Xgt,t&&this.yValueAccessor&&this.tooltipColumns){var e=new N_t(t,this.yValueAccessor,this.yScaleType,this.colorScale,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,this.symbolFunction,this.xAxisFormatter),n=Su(this.$.chartdiv);e.renderTo(n),this._chart&&this._chart.destroy(),this._chart=e,this._chart.onAnchor((()=>this.fire("chart-attached")))}}),350)}_reloadFromCache(){this._chart&&(this._visibleSeriesCache.forEach((t=>{this._chart.setSeriesData(t,this._seriesDataCache[t]||[])})),this._visibleSeriesCache.filter((t=>this._seriesMetadataCache[t])).forEach((t=>{this._chart.setSeriesMetadata(t,this._seriesMetadataCache[t])})),this._chart.setVisibleSeries(this._visibleSeriesCache),this._chart.commitChanges())}_smoothingChanged(){this._chart&&(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())}_outliersChanged(){this._chart&&this._chart.ignoreYOutliers(this.ignoreYOutliers)}_colorScaleChanged(){this._chart&&(this._chart.setColorScale(this.colorScale),this._chart.redraw())}_tooltipColumnsChanged(){this._chart&&this._chart.setTooltipColumns(this.tooltipColumns)}_tooltipSortingMethodChanged(){this._chart&&this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)}getExporter(){return new O_t(this.$.chartdiv)}};B_t.template=_e`
    <div id="chartdiv"></div>
    <vz-chart-tooltip
      id="tooltip"
      position="[[tooltipPosition]]"
      content-component-name="vz-line-chart-tooltip"
    ></vz-chart-tooltip>
    <style include="plottable-style"></style>
    <style include="vz-pan-zoom-style"></style>
    <style>
      :host {
        -moz-user-select: none;
        -webkit-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        outline: none;
        position: relative;
        white-space: nowrap;
      }
      div {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #chartdiv .main {
        contain: strict;
        cursor: crosshair;
      }

      :host(.pankey) #chartdiv :not(.drag-zooming) .main {
        cursor: -webkit-grab;
        cursor: grab;
      }

      :host(.mousedown) #chartdiv .panning .main {
        cursor: -webkit-grabbing;
        cursor: grabbing;
      }

      #chartdiv {
        contain: strict;
      }

      #chartdiv line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover .main {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Ugt.Scales.Color)],B_t.prototype,"colorScale",void 0),t([o({type:Object}),e("design:type",Function)],B_t.prototype,"symbolFunction",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],B_t.prototype,"smoothingEnabled",void 0),t([o({type:Number}),e("design:type",Number)],B_t.prototype,"smoothingWeight",void 0),t([o({type:String}),e("design:type",String)],B_t.prototype,"xType",void 0),t([o({type:Object}),e("design:type",Function)],B_t.prototype,"xComponentsCreationMethod",void 0),t([o({type:Object}),e("design:type",Function)],B_t.prototype,"xAxisFormatter",void 0),t([o({type:Object}),e("design:type",Function)],B_t.prototype,"yValueAccessor",void 0),t([o({type:Array}),e("design:type",Array)],B_t.prototype,"tooltipColumns",void 0),t([o({type:Object}),e("design:type",Object)],B_t.prototype,"fillArea",void 0),t([o({type:Array}),e("design:type",Array)],B_t.prototype,"defaultXRange",void 0),t([o({type:Array}),e("design:type",Array)],B_t.prototype,"defaultYRange",void 0),t([o({type:String}),e("design:type",String)],B_t.prototype,"yScaleType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],B_t.prototype,"ignoreYOutliers",void 0),t([o({type:String}),e("design:type",String)],B_t.prototype,"tooltipSortingMethod",void 0),t([o({type:String}),e("design:type",String)],B_t.prototype,"tooltipPosition",void 0),t([o({type:Object}),e("design:type",Object)],B_t.prototype,"_chart",void 0),t([o({type:Array}),e("design:type",Array)],B_t.prototype,"_visibleSeriesCache",void 0),t([o({type:Object}),e("design:type",Object)],B_t.prototype,"_seriesDataCache",void 0),t([o({type:Object}),e("design:type",Object)],B_t.prototype,"_seriesMetadataCache",void 0),t([o({type:Number}),e("design:type",Number)],B_t.prototype,"_makeChartAsyncCallbackId",void 0),t([a("xComponentsCreationMethod","xType","yValueAccessor","yScaleType","isAttached"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_makeChart",null),t([a("_chart","_visibleSeriesCache"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_reloadFromCache",null),t([a("smoothingEnabled","smoothingWeight","_chart"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_smoothingChanged",null),t([a("ignoreYOutliers","_chart"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_outliersChanged",null),t([a("colorScale"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_colorScaleChanged",null),t([a("tooltipColumns"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_tooltipColumnsChanged",null),t([a("tooltipSortingMethod","_chart"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],B_t.prototype,"_tooltipSortingMethodChanged",null),B_t=t([i("vz-line-chart2")],B_t);let H_t=class extends ye{};H_t.template=_e`
    <div class="content">
      <table>
        <thead></thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host {
        pointer-events: none;
      }

      .content {
        background: rgba(0, 0, 0, 0.8);
        border-radius: 4px;
        color: #fff;
        overflow: hidden;
        pointer-events: none;
      }

      table {
        font-size: 13px;
        line-height: 1.4em;
        margin-top: 10px;
        padding: 8px;
      }

      thead {
        font-size: 14px;
      }

      tbody {
        font-size: 13px;
        line-height: 21px;
        white-space: nowrap;
      }

      td {
        padding: 0 5px;
      }

      .swatch {
        border-radius: 50%;
        display: block;
        height: 18px;
        width: 18px;
      }

      .closest .swatch {
        box-shadow: inset 0 0 0 2px #fff;
      }

      th {
        padding: 0 5px;
        text-align: left;
      }

      .distant td:not(.swatch) {
        opacity: 0.8;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  `,H_t=t([i("vz-line-chart-tooltip")],H_t);const F_t=[],V_t=we.throttle((function t(){if(0==F_t.length)return;const e=F_t.shift();e&&e.active&&(e.redraw(),e._maybeRenderedInBadState=!1),window.cancelAnimationFrame(0),window.requestAnimationFrame(t)}),100);let j_t=class extends(t_t(tr(ye))){constructor(){super(...arguments),this._redrawRaf=null,this.active=!1,this.logScaleActive=!1,this.colorScale={scale:xO},this._resetDomainOnNextLoad=!0,this._maybeRenderedInBadState=!1}onLoadFinish(){this.commitChanges(),this.dataToLoad.length>0&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.getChart().resetDomain()),this.redraw()}disconnectedCallback(){super.disconnectedCallback(),null!==this._redrawRaf&&cancelAnimationFrame(this._redrawRaf)}exportAsSvgString(){return this.getChart().getExporter().exportAsString()}getChart(){return this.$.chart}resetDomain(){this.getChart().resetDomain()}setSeriesData(t,e){this.getChart().setSeriesData(t,e)}setSeriesMetadata(t,e){this.getChart().setSeriesMetadata(t,e)}commitChanges(){this.getChart().commitChanges()}redraw(){null!==this._redrawRaf&&cancelAnimationFrame(this._redrawRaf),this._redrawRaf=window.requestAnimationFrame((()=>{this.active?this.getChart().redraw():this._maybeRenderedInBadState=!0}))}_loadKeyChanged(){this.reset(),this._resetDomainOnNextLoad=!0}_dataSeriesChanged(){this.getChart().setVisibleSeries(this.dataSeries)}_logScaleChanged(t){this.getChart().yScaleType=t?L_t.LOG:L_t.LINEAR,this.redraw()}_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(F_t.push(this),V_t())}_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}};j_t.template=_e`
    <div id="chart-and-spinner-container">
      <vz-line-chart2
        id="chart"
        data-loading$="[[dataLoading]]"
        color-scale="[[colorScale]]"
        default-x-range="[[defaultXRange]]"
        default-y-range="[[defaultYRange]]"
        fill-area="[[fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        on-chart-attached="_onChartAttached"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[symbolFunction]]"
        tooltip-columns="[[tooltipColumns]]"
        tooltip-position="[[tooltipPosition]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-components-creation-method="[[xComponentsCreationMethod]]"
        x-type="[[xType]]"
        y-value-accessor="[[yValueAccessor]]"
      ></vz-line-chart2>
      <template is="dom-if" if="[[dataLoading]]">
        <div id="loading-spinner-container">
          <paper-spinner-lite active=""></paper-spinner-lite>
        </div>
      </template>
    </div>
    <style>
      :host {
        height: 100%;
        width: 100%;
        display: flex;
        flex-direction: column;
      }

      :host([_maybe-rendered-in-bad-state]) vz-line-chart {
        visibility: hidden;
      }

      #chart-and-spinner-container {
        display: flex;
        flex-grow: 1;
        position: relative;
      }

      #loading-spinner-container {
        align-items: center;
        bottom: 0;
        display: flex;
        display: flex;
        justify-content: center;
        left: 0;
        pointer-events: none;
        position: absolute;
        right: 0;
        top: 0;
      }

      vz-line-chart2 {
        -webkit-user-select: none;
        -moz-user-select: none;
      }

      vz-line-chart2[data-loading] {
        opacity: 0.3;
      }
    </style>
  `,t([o({type:Boolean,observer:"_fixBadStateWhenActive"}),e("design:type",Boolean)],j_t.prototype,"active",void 0),t([o({type:Array}),e("design:type",Array)],j_t.prototype,"dataSeries",void 0),t([o({type:Object}),e("design:type",hr)],j_t.prototype,"requestManager",void 0),t([o({type:Boolean,observer:"_logScaleChanged"}),e("design:type",Boolean)],j_t.prototype,"logScaleActive",void 0),t([o({type:Object}),e("design:type",Object)],j_t.prototype,"xComponentsCreationMethod",void 0),t([o({type:String}),e("design:type",String)],j_t.prototype,"xType",void 0),t([o({type:Object}),e("design:type",Function)],j_t.prototype,"yValueAccessor",void 0),t([o({type:Object}),e("design:type",Object)],j_t.prototype,"fillArea",void 0),t([o({type:Boolean}),e("design:type",Boolean)],j_t.prototype,"smoothingEnabled",void 0),t([o({type:Number}),e("design:type",Number)],j_t.prototype,"smoothingWeight",void 0),t([o({type:Array}),e("design:type",Array)],j_t.prototype,"tooltipColumns",void 0),t([o({type:String}),e("design:type",Object)],j_t.prototype,"tooltipSortingMethod",void 0),t([o({type:String}),e("design:type",String)],j_t.prototype,"tooltipPosition",void 0),t([o({type:Boolean}),e("design:type",Boolean)],j_t.prototype,"ignoreYOutliers",void 0),t([o({type:Array}),e("design:type",Array)],j_t.prototype,"defaultXRange",void 0),t([o({type:Array}),e("design:type",Array)],j_t.prototype,"defaultYRange",void 0),t([o({type:Object}),e("design:type",Function)],j_t.prototype,"symbolFunction",void 0),t([o({type:Object}),e("design:type",Object)],j_t.prototype,"colorScale",void 0),t([o({type:Boolean}),e("design:type",Boolean)],j_t.prototype,"_resetDomainOnNextLoad",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],j_t.prototype,"_maybeRenderedInBadState",void 0),t([a("loadKey"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],j_t.prototype,"_loadKeyChanged",null),t([a("dataSeries.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],j_t.prototype,"_dataSeriesChanged",null),j_t=t([i("tf-line-chart-data-loader")],j_t),nl({moduleName:"tf-custom-scalar-card-style",styleContent:"\n    :host {\n      margin: 5px 10px;\n      display: inline-block;\n      width: 330px;\n      vertical-align: text-top;\n    }\n\n    :host([_expanded]) {\n      width: 100%;\n    }\n\n    :host([_expanded]) #tf-line-chart-data-loader-container {\n      height: 400px;\n    }\n\n    h1 {\n      font-size: 19px;\n      font-weight: normal;\n    }\n\n    #tf-line-chart-data-loader-container {\n      height: 200px;\n      width: 100%;\n    }\n\n    #buttons {\n      display: flex;\n      flex-direction: row;\n    }\n\n    paper-icon-button {\n      color: #2196f3;\n      border-radius: 100%;\n      width: 32px;\n      height: 32px;\n      padding: 4px;\n    }\n\n    paper-icon-button[selected] {\n      background: var(--tb-ui-light-accent);\n    }\n\n    .download-links {\n      display: flex;\n      height: 32px;\n    }\n\n    .download-links a {\n      font-size: 10px;\n      align-self: center;\n      margin: 2px;\n    }\n\n    .download-links paper-dropdown-menu {\n      width: 100px;\n      --paper-input-container-label: {\n        font-size: 10px;\n      }\n      --paper-input-container-input: {\n        font-size: 10px;\n      }\n    }\n  "});class U_t{constructor(t,e,n,i,r){this.run=t,this.tag=e,this.name=n,this.scalarData=i,this.symbol=r}getName(){return this.name}setData(t){this.scalarData=t}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}}function G_t(t,e){return`${e} (${t})`}class W_t{constructor(t){this.runBasedColorScale=t}scale(t){return this.runBasedColorScale.scale(this.parseRunName(t))}parseRunName(t){const e=t.match(/\((.*)\)$/);return e?e[1]:""}}let q_t=class extends(tr(ye)){constructor(){super(...arguments),this.active=!0,this._colorScale=new W_t({scale:xO}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,e,n)=>{const i=gr().pluginRoute("custom_scalars","/scalars");Promise.all(t.map((t=>{const n=OO(i,{tag:this._tagFilter,run:t});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1,this._fillArea={lowerAccessor:t=>t.lower,higherAccessor:t=>t.upper},this._tooltipColumns=(()=>{const t=qgt(4),e=e=>isNaN(e)?"NaN":t(e);return[{title:"Name",evaluate:t=>t.dataset.metadata().name},{title:"Value",evaluate:t=>e(t.datum.scalar)},{title:"Lower Margin",evaluate:t=>e(t.datum.lower)},{title:"Upper Margin",evaluate:t=>e(t.datum.upper)},{title:"Step",evaluate:t=>Ygt(t.datum.step)},{title:"Time",evaluate:t=>$gt(t.datum.wall_time)},{title:"Relative",evaluate:t=>Zgt(Kgt(t.datum,0,t.dataset))}]})(),this._missingTags=[],this._missingTagsCollapsibleOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){const t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,e){return e?OO(this._downloadDataUrl(t,e),{format:"csv"}):""}_jsonUrl(t,e){return e?OO(this._downloadDataUrl(t,e),{format:"json"}):""}_downloadDataUrl(t,e){const n=t[e],i={tag:n.getTag(),run:n.getRun()};return OO(gr().pluginRoute("custom_scalars","/download_data"),i)}_createProcessDataFunction(t){return(e,n,i)=>{if(!i.regex_valid)return void this.set("_tagFilterInvalid",!0);const r=we.clone(this._nameToDataSeries),o=[];we.forEach(t,(t=>{let e=!1;const a=i.tag_to_events[t.value],s=i.tag_to_events[t.lower],l=i.tag_to_events[t.upper];if(we.isUndefined(a)&&(o.push(t.value),e=!0),we.isUndefined(s)&&(o.push(t.lower),e=!0),we.isUndefined(l)&&(o.push(t.upper),e=!0),e)return;const c=t=>t[1],u=this._findStepMismatch(t,a.map(c),s.map(c),l.map(c));if(u)return void this.set("_stepsMismatch",u);const h=t=>t[2],d=a.map(((t,e)=>({wall_time:new Date(1e3*t[0]),step:c(t),scalar:h(t),lower:h(s[e]),upper:h(l[e])}))),p=G_t(n,t.value),f=r[p];if(f)f.setData(d);else{const e=this._createNewDataSeries(n,t.value,p,d);r[p]=e}})),this.set("_nameToDataSeries",r);const a=we.findIndex(this._missingTags,(t=>t.run===n));if(o.length&&3!=o.length){const t={run:n,tags:o};a>=0?this.splice("_missingTags",a,1,t):this.push("_missingTags",t)}else a>=0&&this.splice("_missingTags",a,1)}}_findStepMismatch(t,e,n,i){return we.isEqual(n,e)&&we.isEqual(i,e)?null:{seriesObject:t,valueSteps:e,lowerSteps:n,upperSteps:i}}_createNewDataSeries(t,e,n,i){this._runToNextAvailableSymbolIndex[t]|=0;const r=new U_t(t,e,n,i,Ggt[this._runToNextAvailableSymbolIndex[t]]);return this._runToNextAvailableSymbolIndex[t]=(this._runToNextAvailableSymbolIndex[t]+1)%Ggt.length,r}_updateChart(){we.forOwn(this._nameToDataSeries,(t=>{this.$.loader.setSeriesData(t.getName(),t.getData())})),this.$.loader.commitChanges()}get _seriesNames(){const t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter((([e,n])=>t.has(n.run))).map((([t])=>t))}_determineColor(t,e){return t.scale(e)}_refreshDataSeries(){this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,e){return t[e].getSymbol().character}get _tagFilter(){return we.flatten(this.marginChartSeries.map((t=>[t.value,t.lower,t.upper]))).map((t=>"("+this._escapeRegexCharacters(t)+")")).join("|")}_escapeRegexCharacters(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}_getToggleCollapsibleIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){return this.title||"untitled"}_separateWithCommas(t){return t.join(", ")}_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)}_matchListEntryColorUpdated(){const t=this.$$("#match-list-repeat");t&&this.root.querySelectorAll(".match-list-entry").forEach((e=>{const n=t.itemForElement(e);e.style.color=this._determineColor(this._colorScale,n)}))}};q_t.template=_e`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        fill-area="[[_fillArea]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction(marginChartSeries)]]"
        request-manager="[[requestManager]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>

    <!-- here -->
    <template is="dom-if" if="[[_missingTags.length]]">
      <div class="collapsible-list-title">
        <paper-icon-button
          icon="[[_getToggleCollapsibleIcon(_missingTagsCollapsibleOpened)]]"
          on-click="_toggleMissingTagsCollapsibleOpen"
          class="toggle-collapsible-button"
        >
        </paper-icon-button>
        <span class="collapsible-title-text">
          <iron-icon icon="icons:error"></iron-icon> Missing Tags
        </span>
      </div>
      <iron-collapse opened="[[_missingTagsCollapsibleOpened]]">
        <div class="error-content">
          <iron-icon class="error-icon" icon="icons:error"></iron-icon>
          <template is="dom-repeat" items="[[_missingTags]]" as="missingEntry">
            <div class="missing-tags-for-run-container">
              Run "[[missingEntry.run]]" lacks data for tags
              <ul>
                <template
                  is="dom-repeat"
                  items="[[missingEntry.tags]]"
                  as="tag"
                >
                  <li>[[tag]]</li>
                </template>
              </ul>
            </div>
          </template>
        </div>
      </iron-collapse>
    </template>

    <template is="dom-if" if="[[_tagFilterInvalid]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        This regular expresion is invalid:<br />
        <span class="invalid-regex">[[_tagFilter]]</span>
      </div>
    </template>

    <template is="dom-if" if="[[_stepsMismatch]]">
      <div class="error-content">
        <iron-icon class="error-icon" icon="icons:error"></iron-icon>
        The steps for value, lower, and upper tags do not match:
        <ul>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.value]]</span>:
            [[_separateWithCommas(_stepsMismatch.valueSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.lower]]</span>:
            [[_separateWithCommas(_stepsMismatch.lowerSteps)]]
          </li>
          <li>
            <span class="tag-name">[[_stepsMismatch.seriesObject.upper]]</span>:
            [[_separateWithCommas(_stepsMismatch.upperSteps)]]
          </li>
        </ul>
      </div>
    </template>

    <div id="matches-container">
      <div class="collapsible-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleCollapsibleIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="collapsible-title-text">
          Matches ([[_seriesNames.length]])
        </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      .error-content {
        background: #f00;
        border-radius: 5px;
        color: #fff;
        margin: 10px 0 0 0;
        padding: 10px;
      }

      .error-icon {
        display: block;
        fill: #fff;
        margin: 0 auto 5px auto;
      }

      .invalid-regex {
        font-weight: bold;
      }

      .error-content ul {
        margin: 1px 0 0 0;
        padding: 0 0 0 19px;
      }

      .tag-name {
        font-weight: bold;
      }

      .collapsible-list-title {
        margin: 10px 0 5px 0;
      }

      .collapsible-title-text {
        vertical-align: middle;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .missing-tags-for-run-container {
        margin: 8px 0 0 0;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],q_t.prototype,"runs",void 0),t([o({type:String}),e("design:type",String)],q_t.prototype,"xType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"active",void 0),t([o({type:String}),e("design:type",String)],q_t.prototype,"title",void 0),t([o({type:Array}),e("design:type",Array)],q_t.prototype,"marginChartSeries",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"ignoreYOutliers",void 0),t([o({type:Object}),e("design:type",hr)],q_t.prototype,"requestManager",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"showDownloadLinks",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"tagMetadata",void 0),t([o({type:String}),e("design:type",String)],q_t.prototype,"tooltipSortingMethod",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"_colorScale",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"_tagFilterInvalid",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"_nameToDataSeries",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],q_t.prototype,"_expanded",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"_logScaleActive",void 0),t([o({type:Object}),e("design:type",Function)],q_t.prototype,"_requestData",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"_runToNextAvailableSymbolIndex",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"_matchesListOpened",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"_fillArea",void 0),t([o({type:Array}),e("design:type",Array)],q_t.prototype,"_tooltipColumns",void 0),t([o({type:Array}),e("design:type",Array)],q_t.prototype,"_missingTags",void 0),t([o({type:Boolean}),e("design:type",Boolean)],q_t.prototype,"_missingTagsCollapsibleOpened",void 0),t([o({type:Object}),e("design:type",Object)],q_t.prototype,"_stepsMismatch",void 0),t([a("_nameToDataSeries"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],q_t.prototype,"_updateChart",null),t([s("_nameToDataSeries","runs"),e("design:type",Object),e("design:paramtypes",[])],q_t.prototype,"_seriesNames",null),t([a("_tagFilter"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],q_t.prototype,"_refreshDataSeries",null),t([s("marginChartSeries"),e("design:type",String),e("design:paramtypes",[])],q_t.prototype,"_tagFilter",null),t([s("title"),e("design:type",String),e("design:paramtypes",[])],q_t.prototype,"_titleDisplayString",null),q_t=t([i("tf-custom-scalar-margin-chart-card")],q_t);var Y_t=Object.freeze({__proto__:null,TYPES:[],getRunsNamed:function X_t(t){return we.keys(t).sort(er)},getTags:or,filterTags:function $_t(t,e){let n=[];return e.forEach((e=>n=n.concat(t[e]))),we.uniq(n).sort(er)},ListenKey:fl,BaseStore:ml,Canceller:EO,EnvironmentStore:gl,environmentStore:_l,ExperimentsStore:_O,experimentsStore:yO,RequestCancellationError:ar,InvalidRequestOptionsError:sr,RequestNetworkError:lr,get HttpMethodType(){return cr},RequestOptions:ur,RequestManager:hr,createRouter:mr,getRouter:gr,setRouter:function K_t(t){if(null==t)throw new Error("Router required, but got: "+t);fr=t},createSearchParam:yr,RunsStore:yl,runsStore:vl,addParams:OO});let Z_t=class extends(tr(ye)){constructor(){super(...arguments),this.active=!0,this._colorScale=new W_t({scale:xO}),this._nameToDataSeries={},this._expanded=!1,this._requestData=(t,e,n)=>{const i=gr().pluginRoute("custom_scalars","/scalars");Promise.all(t.map((t=>{const n=OO(i,{tag:this._tagFilter,run:t});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this._runToNextAvailableSymbolIndex={},this._matchesListOpened=!1}reload(){this.$.loader.reload()}redraw(){this.$.loader.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){const t=this.$.loader;t&&t.resetDomain()}_csvUrl(t,e){return e?OO(this._downloadDataUrl(t,e),{format:"csv"}):""}_jsonUrl(t,e){return e?OO(this._downloadDataUrl(t,e),{format:"json"}):""}_downloadDataUrl(t,e){const n=t[e],i={tag:n.getTag(),run:n.getRun()};return OO(gr().pluginRoute("custom_scalars","/download_data"),i)}_createProcessDataFunction(){return(t,e,n)=>{if(n.regex_valid){const t=we.clone(this._nameToDataSeries);we.forOwn(n.tag_to_events,((n,i)=>{const r=n.map((t=>({wall_time:new Date(1e3*t[0]),step:t[1],scalar:t[2]}))),o=G_t(e,i),a=t[o];if(a)a.setData(r);else{we.isUndefined(this._runToNextAvailableSymbolIndex[e])&&(this._runToNextAvailableSymbolIndex[e]=0);const n=new U_t(e,i,o,r,Ggt[this._runToNextAvailableSymbolIndex[e]]);t[o]=n,this._runToNextAvailableSymbolIndex[e]=(this._runToNextAvailableSymbolIndex[e]+1)%Ggt.length}})),this.set("_nameToDataSeries",t)}}}_updateChart(){Object.entries(this._nameToDataSeries).forEach((([t,e])=>{this.$.loader.setSeriesData(t,e.getData())})),this.$.loader.commitChanges()}_computeSelectedRunsSet(t){const e={};return we.forEach(t,(t=>{e[t]=1})),e}get _seriesNames(){const t=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter((([e,n])=>t.has(n.run))).map((([t])=>t))}_determineColor(t,e){return t.scale(e)}_refreshDataSeries(){this.set("_nameToDataSeries",{})}_createSymbolFunction(){return t=>this._nameToDataSeries[t].getSymbol().method()}_determineSymbol(t,e){return t[e].getSymbol().character}get _tagFilter(){var t=this.tagRegexes;return 1===t.length?t[0]:t.map((t=>"("+t+")")).join("|")}_getToggleMatchesIcon(t){return t?"expand-less":"expand-more"}_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)}get _titleDisplayString(){return this.title||"untitled"}_matchListEntryColorUpdated(t){const e=this.$$("#match-list-repeat");e&&this.root.querySelectorAll(".match-list-entry").forEach((t=>{const n=e.itemForElement(t);t.style.color=this._determineColor(this._colorScale,n)}))}};Z_t.template=_e`
    <tf-card-heading display-name="[[_titleDisplayString]]"></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        id="loader"
        active="[[active]]"
        color-scale="[[_colorScale]]"
        data-series="[[_seriesNames]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-key="[[_tagFilter]]"
        data-to-load="[[runs]]"
        request-data="[[_requestData]]"
        log-scale-active="[[_logScaleActive]]"
        load-data-callback="[[_createProcessDataFunction()]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        symbol-function="[[_createSymbolFunction()]]"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <paper-dropdown-menu
            no-label-float="true"
            label="series to download"
            selected-item-label="{{_dataSeriesNameToDownload}}"
          >
            <paper-listbox class="dropdown-content" slot="dropdown-content">
              <template
                is="dom-repeat"
                items="[[_seriesNames]]"
                as="dataSeriesName"
              >
                <paper-item no-label-float="true"
                  >[[dataSeriesName]]</paper-item
                >
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
          <a
            download="[[_dataSeriesNameToDownload]].csv"
            href="[[_csvUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >CSV</a
          >
          <a
            download="[[_dataSeriesNameToDownload]].json"
            href="[[_jsonUrl(_nameToDataSeries, _dataSeriesNameToDownload)]]"
            >JSON</a
          >
        </div>
      </template>
    </div>
    <div id="matches-container">
      <div id="matches-list-title">
        <template is="dom-if" if="[[_seriesNames.length]]">
          <paper-icon-button
            icon="[[_getToggleMatchesIcon(_matchesListOpened)]]"
            on-click="_toggleMatchesOpen"
            class="toggle-matches-button"
          >
          </paper-icon-button>
        </template>

        <span class="matches-text"> Matches ([[_seriesNames.length]]) </span>
      </div>
      <template is="dom-if" if="[[_seriesNames.length]]">
        <iron-collapse opened="[[_matchesListOpened]]">
          <div id="matches-list">
            <template
              is="dom-repeat"
              items="[[_seriesNames]]"
              as="seriesName"
              id="match-list-repeat"
              on-dom-change="_matchListEntryColorUpdated"
            >
              <div class="match-list-entry">
                <span class="match-entry-symbol">
                  [[_determineSymbol(_nameToDataSeries, seriesName)]]
                </span>
                [[seriesName]]
              </div>
            </template>
          </div>
        </iron-collapse>
      </template>
    </div>

    <style include="tf-custom-scalar-card-style"></style>
    <style>
      #matches-list-title {
        margin: 10px 0 5px 0;
      }

      #matches-list {
        max-height: 200px;
        overflow-y: auto;
      }

      .match-list-entry {
        margin: 0 0 5px 0;
      }

      .match-entry-symbol {
        font-family: arial, sans-serif;
        display: inline-block;
        width: 10px;
      }

      .matches-text {
        vertical-align: middle;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],Z_t.prototype,"runs",void 0),t([o({type:String}),e("design:type",String)],Z_t.prototype,"xType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"active",void 0),t([o({type:String}),e("design:type",String)],Z_t.prototype,"title",void 0),t([o({type:Array}),e("design:type",Array)],Z_t.prototype,"tagRegexes",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"ignoreYOutliers",void 0),t([o({type:Object}),e("design:type",hr)],Z_t.prototype,"requestManager",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"showDownloadLinks",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"smoothingEnabled",void 0),t([o({type:Number}),e("design:type",Number)],Z_t.prototype,"smoothingWeight",void 0),t([o({type:Object}),e("design:type",Object)],Z_t.prototype,"tagMetadata",void 0),t([o({type:String}),e("design:type",String)],Z_t.prototype,"tooltipSortingMethod",void 0),t([o({type:Object}),e("design:type",W_t)],Z_t.prototype,"_colorScale",void 0),t([o({type:Object}),e("design:type",Object)],Z_t.prototype,"_nameToDataSeries",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],Z_t.prototype,"_expanded",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"_logScaleActive",void 0),t([o({type:Object}),e("design:type",Function)],Z_t.prototype,"_requestData",void 0),t([o({type:Object}),e("design:type",Object)],Z_t.prototype,"_runToNextAvailableSymbolIndex",void 0),t([o({type:Boolean}),e("design:type",Boolean)],Z_t.prototype,"_matchesListOpened",void 0),t([a("_nameToDataSeries"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],Z_t.prototype,"_updateChart",null),t([s("_nameToDataSeries","runs"),e("design:type",Object),e("design:paramtypes",[])],Z_t.prototype,"_seriesNames",null),t([a("_tagFilter"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],Z_t.prototype,"_refreshDataSeries",null),t([s("tagRegexes"),e("design:type",String),e("design:paramtypes",[])],Z_t.prototype,"_tagFilter",null),t([s("title"),e("design:type",String),e("design:paramtypes",[])],Z_t.prototype,"_titleDisplayString",null),Z_t=t([i("tf-custom-scalar-multi-line-chart-card")],Z_t);let J_t=class extends ye{constructor(){super(...arguments),this._requestManager=new hr(50),this._canceller=new EO,this._showDownloadLinks=zs("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=Vs("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=zs("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType="step",this._active=!0,this.reloadOnReady=!0,this._showDownloadLinksObserver=Ds("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=js("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=Ds("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){const t=gr().pluginsListing(),e=this._canceller.cancellable((t=>{t.cancelled||(this.set("_dataNotFound",!t.value.custom_scalars),this._dataNotFound||this._retrieveLayoutAndData())}));this._requestManager.request(t).then(e)}_reloadCharts(){this.root.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card").forEach((t=>{t.reload()}))}_retrieveLayoutAndData(){const t=gr().pluginRoute("custom_scalars","/layout"),e=this._canceller.cancellable((t=>{t.cancelled||(this.set("_layout",t.value),this._dataNotFound||this._reloadCharts())}));this._requestManager.request(t).then(e)}get _smoothingEnabled(){return this._smoothingWeight>0}get _categories(){var t=this._layout;if(!t.category)return[];let e=!1;return this._openedCategories||(e=!0,this._openedCategories={}),t.category.map((t=>(e&&!t.closed&&(this._openedCategories[t.title]=!0),{name:t.title,items:t.chart,metadata:{type:vr.PREFIX_GROUP,opened:!!this._openedCategories[t.title]}})))}_categoryOpenedToggled(t){const e=t.target;e.opened?this._openedCategories[e.category.name]=!0:delete this._openedCategories[e.category.name]}};J_t.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div id="tooltip-sorting-label">Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float=""
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="1"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center" id="categories-container">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>The custom scalars dashboard is inactive.</h3>
            <p>Probable causes:</p>
            <ol>
              <li>You haven't laid out the dashboard.</li>
              <li>You haven’t written any scalar data to your event files.</li>
            </ol>

            <p>
              To lay out the dashboard, pass a <code>Layout</code> protobuffer
              to the <code>set_layout</code> method. For example,
            </p>
            <pre>
from tensorboard import summary
from tensorboard.plugins.custom_scalar import layout_pb2
...
# This action does not have to be performed at every step, so the action is not
# taken care of by an op in the graph. We only need to specify the layout once
# (instead of per step).
layout_summary = summary_lib.custom_scalar_pb(layout_pb2.Layout(
  category=[
    layout_pb2.Category(
      title='losses',
      chart=[
          layout_pb2.Chart(
              title='losses',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'loss.*'],
              )),
          layout_pb2.Chart(
              title='baz',
              margin=layout_pb2.MarginChartContent(
                series=[
                  layout_pb2.MarginChartContent.Series(
                    value='loss/baz/scalar_summary',
                    lower='baz_lower/baz/scalar_summary',
                    upper='baz_upper/baz/scalar_summary'),
                ],
              )),
      ]),
    layout_pb2.Category(
      title='trig functions',
      chart=[
          layout_pb2.Chart(
              title='wave trig functions',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/cosine', r'trigFunctions/sine'],
              )),
          # The range of tangent is different. Let's give it its own chart.
          layout_pb2.Chart(
              title='tan',
              multiline=layout_pb2.MultilineChartContent(
                tag=[r'trigFunctions/tangent'],
              )),
      ],
      # This category we care less about. Let's make it initially closed.
      closed=True),
  ]))
writer.add_summary(layout_summary)
</pre
            >
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              as="chart"
              category="[[category]]"
              disable-pagination
              initial-opened="[[category.metadata.opened]]"
            >
              <template>
                <template is="dom-if" if="[[chart.multiline]]">
                  <tf-custom-scalar-multi-line-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    smoothing-enabled="[[_smoothingEnabled]]"
                    smoothing-weight="[[_smoothingWeight]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    tag-regexes="[[chart.multiline.tag]]"
                  ></tf-custom-scalar-multi-line-chart-card>
                </template>
                <template is="dom-if" if="[[chart.margin]]">
                  <tf-custom-scalar-margin-chart-card
                    active="[[active]]"
                    request-manager="[[_requestManager]]"
                    runs="[[_selectedRuns]]"
                    title="[[chart.title]]"
                    x-type="[[_xType]]"
                    tooltip-sorting-method="[[tooltipSortingMethod]]"
                    ignore-y-outliers="[[_ignoreYOutliers]]"
                    show-download-links="[[_showDownloadLinks]]"
                    margin-chart-series="[[chart.margin.series]]"
                  ></tf-custom-scalar-margin-chart-card>
                </template>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Object}),e("design:type",hr)],J_t.prototype,"_requestManager",void 0),t([o({type:Object}),e("design:type",EO)],J_t.prototype,"_canceller",void 0),t([o({type:Array}),e("design:type",Array)],J_t.prototype,"_selectedRuns",void 0),t([o({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),e("design:type",Boolean)],J_t.prototype,"_showDownloadLinks",void 0),t([o({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),e("design:type",Number)],J_t.prototype,"_smoothingWeight",void 0),t([o({type:Boolean,observer:"_ignoreYOutliersObserver"}),e("design:type",Boolean)],J_t.prototype,"_ignoreYOutliers",void 0),t([o({type:String}),e("design:type",String)],J_t.prototype,"_xType",void 0),t([o({type:Object}),e("design:type",Object)],J_t.prototype,"_layout",void 0),t([o({type:Boolean}),e("design:type",Boolean)],J_t.prototype,"_dataNotFound",void 0),t([o({type:Object}),e("design:type",Object)],J_t.prototype,"_openedCategories",void 0),t([o({type:Boolean}),e("design:type",Boolean)],J_t.prototype,"_active",void 0),t([o({type:Boolean}),e("design:type",Boolean)],J_t.prototype,"reloadOnReady",void 0),t([s("_smoothingWeight"),e("design:type",Boolean),e("design:paramtypes",[])],J_t.prototype,"_smoothingEnabled",null),t([s("_layout"),e("design:type",Array),e("design:paramtypes",[])],J_t.prototype,"_categories",null),J_t=t([i("tf-custom-scalar-dashboard")],J_t);class Q_t{constructor(t,e){this.run2datasets={},this.colorScale=e,this.buildChart(t)}getDataset(t){return void 0===this.run2datasets[t]&&(this.run2datasets[t]=new Ugt.Dataset([],{run:t})),this.run2datasets[t]}buildChart(t){this.outer&&this.outer.destroy();let e=Jgt(t);this.xAccessor=e.accessor,this.xScale=e.scale,this.xAxis=e.axis,this.xAxis.margin(0),this.xAxis.tickLabelPadding(3),this.yScale=new Ugt.Scales.Linear,this.yAxis=new Ugt.Axes.Numeric(this.yScale,"left");let n=qgt(3);this.yAxis.margin(0).tickLabelPadding(5).formatter(n),this.yAxis.usesTextWidthApproximation(!0);let i=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new Ugt.Components.Gridlines(this.xScale,this.yScale),this.center=new Ugt.Components.Group([this.gridlines,i]),this.outer=new Ugt.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(t,e,n){let i=[0,228,1587,3085,5e3,6915,8413,9772,1e4],r=we.range(i.length-1).map((t=>(i[t+1]-i[t])/2500)),o=i.map(((t,e)=>t=>t[e][1])),a=o[4],s=we.range(o.length-1).map((i=>{let a=new Ugt.Plots.Area;a.x(t,e);let s=i>4?o[i]:o[i+1];return a.y(i>4?o[i+1]:o[i],n),a.y0(s),a.attr("fill",((t,e,n)=>this.colorScale.scale(n.metadata().run))),a.attr("stroke",((t,e,n)=>this.colorScale.scale(n.metadata().run))),a.attr("stroke-weight",((t,e,n)=>"0.5px")),a.attr("stroke-opacity",(()=>r[i])),a.attr("fill-opacity",(()=>r[i])),a})),l=new Ugt.Plots.Line;return l.x(t,e),l.y(a,n),l.attr("stroke",((t,e,n)=>this.colorScale.scale(n.run))),this.plots=s,new Ugt.Components.Group(s)}setVisibleSeries(t){this.runs=t;let e=t.map((t=>this.getDataset(t)));this.plots.forEach((t=>t.datasets(e)))}setSeriesData(t,e){this.getDataset(t).data(e)}renderTo(t){this.targetSVG=t,this.outer.renderTo(t)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}}let tyt=class extends(tr(ye)){constructor(){super(...arguments),this.colorScale=(new Ugt.Scales.Color).range(YA.slice()),this.xType="step",this._visibleSeriesCache=[],this._seriesDataCache={},this._makeChartAsyncCallbackId=null}setVisibleSeries(t){this._visibleSeriesCache=t,this._chart&&(this._chart.setVisibleSeries(t),this.redraw())}setSeriesData(t,e){this._seriesDataCache[t]=e,this._chart&&this._chart.setSeriesData(t,e)}redraw(){this._chart.redraw()}_makeChart(){var t=this.xType,e=this.colorScale,n=this._attached;null===this._makeChartAsyncCallbackId&&this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=this.async((function(){if(this._makeChartAsyncCallbackId=null,n){this._chart&&this._chart.destroy();var i=new Q_t(t,e),r=Su(this.$.chartdiv);i.renderTo(r),this._chart=i}}),350)}_reloadFromCache(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),this._visibleSeriesCache.forEach(function(t){this._chart.setSeriesData(t,this._seriesDataCache[t]||[])}.bind(this)))}attached(){this._attached=!0}detached(){this._attached=!1}};tyt.template=_e`
    <style include="plottable-style"></style>
    <div id="chartdiv"></div>
    <style>
      :host {
        -webkit-user-select: none;
        -moz-user-select: none;
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }
      #chartdiv {
        -webkit-user-select: none;
        -moz-user-select: none;
        flex-grow: 1;
        flex-shrink: 1;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Ugt.Scales.Color)],tyt.prototype,"colorScale",void 0),t([o({type:String}),e("design:type",String)],tyt.prototype,"xType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],tyt.prototype,"_attached",void 0),t([o({type:Object}),e("design:type",Q_t)],tyt.prototype,"_chart",void 0),t([o({type:Array}),e("design:type",Array)],tyt.prototype,"_visibleSeriesCache",void 0),t([o({type:Object}),e("design:type",Object)],tyt.prototype,"_seriesDataCache",void 0),t([o({type:Number}),e("design:type",Number)],tyt.prototype,"_makeChartAsyncCallbackId",void 0),t([a("xType","colorScale","_attached"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tyt.prototype,"_makeChart",null),t([a("_chart"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tyt.prototype,"_reloadFromCache",null),tyt=t([i("vz-distribution-chart")],tyt);let eyt=class extends(t_t(tr(ye))){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,e,n)=>{const i=gr().pluginRoute("distributions","/distributions");Promise.all(t.map((t=>{const n=OO(i,{tag:t.tag,run:t.run});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this.loadDataCallback=(t,e,n)=>{const i=n.map((t=>{const[e,n,i]=t;return i.wall_time=new Date(1e3*e),i.step=n,i})),r=this.getDataLoadName(e);this.$.chart.setSeriesData(r,i),this.$.chart.setVisibleSeries([r])},this._colorScale={scale:xO},this._expanded=!1,this._canceller=new EO}_reloadOnRunTagChange(){this.reload()}_updateDataToLoad(){this.dataToLoad=[{run:this.run,tag:this.tag}]}get _runColor(){return this._colorScale.scale(this.run)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};eyt.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main distribution that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-distribution-chart
      id="chart"
      x-type="[[xType]]"
      color-scale="[[_colorScale]]"
    ></vz-distribution-chart>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],eyt.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],eyt.prototype,"tag",void 0),t([o({type:Object}),e("design:type",Object)],eyt.prototype,"tagMetadata",void 0),t([o({type:String}),e("design:type",String)],eyt.prototype,"xType",void 0),t([o({type:Object}),e("design:type",Object)],eyt.prototype,"getDataLoadName",void 0),t([o({type:Object}),e("design:type",Object)],eyt.prototype,"loadDataCallback",void 0),t([o({type:Object}),e("design:type",Object)],eyt.prototype,"_colorScale",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],eyt.prototype,"_expanded",void 0),t([o({type:Object}),e("design:type",hr)],eyt.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",EO)],eyt.prototype,"_canceller",void 0),t([a("run","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eyt.prototype,"_reloadOnRunTagChange",null),t([a("run","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eyt.prototype,"_updateDataToLoad",null),t([s("run"),e("design:type",String),e("design:paramtypes",[])],eyt.prototype,"_runColor",null),eyt=t([i("tf-distribution-loader")],eyt);let nyt=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._xType="step",this._requestManager=new hr}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadDistributions()}))}_fetchTags(){const t=gr().pluginRoute("distributions","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=we.mapValues(t,(t=>Object.keys(t))),n=or(e);this.set("_dataNotFound",0===n.length),this.set("_runToTag",e),this.set("_runToTagInfo",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadDistributions(){this.root.querySelectorAll("tf-distribution-loader").forEach((t=>{t.reload()}))}_shouldOpen(t){return t<=2}get _categories(){return Sr(this._runToTag,this._selectedRuns,this._tagFilter)}_tagMetadata(t,e,n){return t[e][n]}};nyt.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="xTypeSelector"
              name="Horizontal axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>

      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No distribution data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
                (Histograms and distributions both use the histogram summary
                operation.)
              </li>

              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-distribution-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  x-type="[[_xType]]"
                  request-manager="[[_requestManager]]"
                ></tf-distribution-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],nyt.prototype,"reloadOnReady",void 0),t([o({type:String}),e("design:type",String)],nyt.prototype,"_xType",void 0),t([o({type:Array}),e("design:type",Array)],nyt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],nyt.prototype,"_runToTag",void 0),t([o({type:Object}),e("design:type",Object)],nyt.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],nyt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],nyt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],nyt.prototype,"_categoriesDomReady",void 0),t([o({type:Object}),e("design:type",hr)],nyt.prototype,"_requestManager",void 0),t([s("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Array),e("design:paramtypes",[])],nyt.prototype,"_categories",null),nyt=t([i("tf-distribution-dashboard")],nyt);var iyt=Object.freeze({__proto__:null,ListenKey:hs,addHashListener:fs,addStorageListener:ms,fireStorageChanged:gs,removeHashListenerByKey:_s,removeStorageListenerByKey:ys,TAB:Ts,DISAMBIGUATOR:"disambiguator",getUrlDict:Cs,getString:ks,setString:Ls,getStringInitializer:Ps,getStringObserver:Is,disposeStringBinding:Ns,getBoolean:Os,setBoolean:Rs,getBooleanInitializer:zs,getBooleanObserver:Ds,disposeBooleanBinding:Bs,getNumber:Hs,setNumber:Fs,getNumberInitializer:Vs,getNumberObserver:js,disposeNumberBinding:Us,getObject:Gs,setObject:Ws,getObjectInitializer:qs,getObjectObserver:Ys,disposeObjectBinding:Xs,makeBindings:$s,migrateLegacyURLScheme:function ryt(){const t=new Set(["examplesPath","hideModelPane2","modelName1","modelName2","inferenceAddress1","inferenceAddress2","modelType","modelVersion1","modelVersion2","modelSignature1","modelSignature2","maxExamples","labelVocabPath","multiClass","sequenceExamples","maxClassesToDisplay","samplingOdds","usePredictApi","predictInputTensor","predictOutputTensor"]),e=tl(Zs());if("whatif"===e[Ts])for(let n of t)n in e&&(e[`p.whatif.${n}`]=e[n]);Js(Qs(e)),As=e}}),oyt=function ayt(t,e){return t===e||t!=t&&e!=e},syt=function lyt(t,e){for(var n=t.length;n--;)if(oyt(t[n][0],e))return n;return-1},cyt=Array.prototype.splice;function uyt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}uyt.prototype.clear=function hyt(){this.__data__=[],this.size=0},uyt.prototype.delete=function dyt(t){var e=this.__data__,n=syt(e,t);return!(n<0||(n==e.length-1?e.pop():cyt.call(e,n,1),--this.size,0))},uyt.prototype.get=function pyt(t){var e=this.__data__,n=syt(e,t);return n<0?void 0:e[n][1]},uyt.prototype.has=function fyt(t){return syt(this.__data__,t)>-1},uyt.prototype.set=function myt(t,e){var n=this.__data__,i=syt(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this};var gyt,_yt=uyt,yyt="object"==typeof ve&&ve&&ve.Object===Object&&ve,vyt="object"==typeof self&&self&&self.Object===Object&&self,byt=yyt||vyt||Function("return this")(),xyt=byt.Symbol,wyt=Object.prototype,Syt=wyt.hasOwnProperty,Myt=wyt.toString,Eyt=xyt?xyt.toStringTag:void 0,Tyt=Object.prototype.toString,Ayt=xyt?xyt.toStringTag:void 0,Cyt=function kyt(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":Ayt&&Ayt in Object(t)?(function e(t){var e=Syt.call(t,Eyt),n=t[Eyt];try{t[Eyt]=void 0;var i=!0}catch(t){}var r=Myt.call(t);return i&&(e?t[Eyt]=n:delete t[Eyt]),r})(t):(function n(t){return Tyt.call(t)})(t)},Lyt=function Pyt(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)},Iyt=function Nyt(t){if(!Lyt(t))return!1;var e=Cyt(t);return"[object Function]"==e||"[object GeneratorFunction]"==e||"[object AsyncFunction]"==e||"[object Proxy]"==e},Oyt=byt["__core-js_shared__"],Ryt=(gyt=/[^.]+$/.exec(Oyt&&Oyt.keys&&Oyt.keys.IE_PROTO||""))?"Symbol(src)_1."+gyt:"",zyt=Function.prototype.toString,Dyt=function Byt(t){if(null!=t){try{return zyt.call(t)}catch(t){}try{return t+""}catch(t){}}return""},Hyt=/^\[object .+?Constructor\]$/,Fyt=RegExp("^"+Function.prototype.toString.call(Object.prototype.hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),Vyt=function jyt(t,e){var n=(function i(t,e){return null==t?void 0:t[e]})(t,e);return(function r(t){return!(!Lyt(t)||(function e(t){return!!Ryt&&Ryt in t})(t))&&(Iyt(t)?Fyt:Hyt).test(Dyt(t))})(n)?n:void 0},Uyt=Vyt(byt,"Map"),Gyt=Vyt(Object,"create"),Wyt=Object.prototype.hasOwnProperty,qyt=Object.prototype.hasOwnProperty;function Yyt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}Yyt.prototype.clear=function Xyt(){this.__data__=Gyt?Gyt(null):{},this.size=0},Yyt.prototype.delete=function $yt(t){var e=this.has(t)&&delete this.__data__[t];return this.size-=e?1:0,e},Yyt.prototype.get=function Kyt(t){var e=this.__data__;if(Gyt){var n=e[t];return"__lodash_hash_undefined__"===n?void 0:n}return Wyt.call(e,t)?e[t]:void 0},Yyt.prototype.has=function Zyt(t){var e=this.__data__;return Gyt?void 0!==e[t]:qyt.call(e,t)},Yyt.prototype.set=function Jyt(t,e){var n=this.__data__;return this.size+=this.has(t)?0:1,n[t]=Gyt&&void 0===e?"__lodash_hash_undefined__":e,this};var Qyt=Yyt,tvt=function evt(t,e){var n=t.__data__;return(function i(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t})(e)?n["string"==typeof e?"string":"hash"]:n.map};function nvt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}nvt.prototype.clear=function ivt(){this.size=0,this.__data__={hash:new Qyt,map:new(Uyt||_yt),string:new Qyt}},nvt.prototype.delete=function rvt(t){var e=tvt(this,t).delete(t);return this.size-=e?1:0,e},nvt.prototype.get=function ovt(t){return tvt(this,t).get(t)},nvt.prototype.has=function avt(t){return tvt(this,t).has(t)},nvt.prototype.set=function svt(t,e){var n=tvt(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this};var lvt=nvt;function cvt(t){var e=this.__data__=new _yt(t);this.size=e.size}cvt.prototype.clear=function uvt(){this.__data__=new _yt,this.size=0},cvt.prototype.delete=function hvt(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n},cvt.prototype.get=function dvt(t){return this.__data__.get(t)},cvt.prototype.has=function pvt(t){return this.__data__.has(t)},cvt.prototype.set=function fvt(t,e){var n=this.__data__;if(n instanceof _yt){var i=n.__data__;if(!Uyt||i.length<199)return i.push([t,e]),this.size=++n.size,this;n=this.__data__=new lvt(i)}return n.set(t,e),this.size=n.size,this};var mvt=cvt,gvt=function _vt(t,e){for(var n=-1,i=null==t?0:t.length;++n<i&&!1!==e(t[n],n,t););return t},yvt=(function(){try{var t=Vyt(Object,"defineProperty");return t({},"",{}),t}catch(t){}})(),vvt=function bvt(t,e,n){"__proto__"==e&&yvt?yvt(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n},xvt=Object.prototype.hasOwnProperty,wvt=function Svt(t,e,n){var i=t[e];xvt.call(t,e)&&oyt(i,n)&&(void 0!==n||e in t)||vvt(t,e,n)},Mvt=function Evt(t,e,n,i){var r=!n;n||(n={});for(var o=-1,a=e.length;++o<a;){var s=e[o],l=i?i(n[s],t[s],s,n,t):void 0;void 0===l&&(l=t[s]),r?vvt(n,s,l):wvt(n,s,l)}return n},Tvt=function Avt(t){return null!=t&&"object"==typeof t},Cvt=function kvt(t){return Tvt(t)&&"[object Arguments]"==Cyt(t)},Lvt=Object.prototype,Pvt=Lvt.hasOwnProperty,Ivt=Lvt.propertyIsEnumerable,Nvt=Cvt((function(){return arguments})())?Cvt:function(t){return Tvt(t)&&Pvt.call(t,"callee")&&!Ivt.call(t,"callee")},Ovt=Array.isArray,Rvt=function zvt(){return!1},Dvt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n?byt.Buffer:void 0;t.exports=(r?r.isBuffer:void 0)||Rvt})),Bvt=/^(?:0|[1-9]\d*)$/,Hvt=function Fvt(t,e){var n=typeof t;return!!(e=null==e?9007199254740991:e)&&("number"==n||"symbol"!=n&&Bvt.test(t))&&t>-1&&t%1==0&&t<e},Vvt=function jvt(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=9007199254740991},Uvt={};Uvt["[object Float32Array]"]=Uvt["[object Float64Array]"]=Uvt["[object Int8Array]"]=Uvt["[object Int16Array]"]=Uvt["[object Int32Array]"]=Uvt["[object Uint8Array]"]=Uvt["[object Uint8ClampedArray]"]=Uvt["[object Uint16Array]"]=Uvt["[object Uint32Array]"]=!0,Uvt["[object Arguments]"]=Uvt["[object Array]"]=Uvt["[object ArrayBuffer]"]=Uvt["[object Boolean]"]=Uvt["[object DataView]"]=Uvt["[object Date]"]=Uvt["[object Error]"]=Uvt["[object Function]"]=Uvt["[object Map]"]=Uvt["[object Number]"]=Uvt["[object Object]"]=Uvt["[object RegExp]"]=Uvt["[object Set]"]=Uvt["[object String]"]=Uvt["[object WeakMap]"]=!1;var Gvt=function Wvt(t){return function(e){return t(e)}},qvt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n&&yyt.process,o=(function(){try{return i&&i.require&&i.require("util").types||r&&r.binding&&r.binding("util")}catch(t){}})();t.exports=o})),Yvt=qvt&&qvt.isTypedArray,Xvt=Yvt?Gvt(Yvt):function $vt(t){return Tvt(t)&&Vvt(t.length)&&!!Uvt[Cyt(t)]},Kvt=Object.prototype.hasOwnProperty,Zvt=function Jvt(t,e){var n=Ovt(t),i=!n&&Nvt(t),r=!n&&!i&&Dvt(t),o=!n&&!i&&!r&&Xvt(t),a=n||i||r||o,s=a?(function l(t,e){for(var n=-1,i=Array(t);++n<t;)i[n]=e(n);return i})(t.length,String):[],c=s.length;for(var u in t)!e&&!Kvt.call(t,u)||a&&("length"==u||r&&("offset"==u||"parent"==u)||o&&("buffer"==u||"byteLength"==u||"byteOffset"==u)||Hvt(u,c))||s.push(u);return s},Qvt=Object.prototype,tbt=function ebt(t){var e=t&&t.constructor;return t===("function"==typeof e&&e.prototype||Qvt)},nbt=function ibt(t,e){return function(n){return t(e(n))}},rbt=nbt(Object.keys,Object),obt=Object.prototype.hasOwnProperty,abt=function sbt(t){if(!tbt(t))return rbt(t);var e=[];for(var n in Object(t))obt.call(t,n)&&"constructor"!=n&&e.push(n);return e},lbt=function cbt(t){return null!=t&&Vvt(t.length)&&!Iyt(t)},ubt=function hbt(t){return lbt(t)?Zvt(t):abt(t)},dbt=Object.prototype.hasOwnProperty,pbt=function fbt(t){return lbt(t)?Zvt(t,!0):(function e(t){if(!Lyt(t))return(function e(t){var e=[];if(null!=t)for(var n in Object(t))e.push(n);return e})(t);var n=tbt(t),i=[];for(var r in t)("constructor"!=r||!n&&dbt.call(t,r))&&i.push(r);return i})(t)},mbt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n?byt.Buffer:void 0,o=r?r.allocUnsafe:void 0;t.exports=function a(t,e){if(e)return t.slice();var n=t.length,i=o?o(n):new t.constructor(n);return t.copy(i),i}})),gbt=function _bt(t,e){for(var n=-1,i=null==t?0:t.length,r=0,o=[];++n<i;){var a=t[n];e(a,n,t)&&(o[r++]=a)}return o},ybt=function vbt(){return[]},bbt=Object.prototype.propertyIsEnumerable,xbt=Object.getOwnPropertySymbols,wbt=xbt?function(t){return null==t?[]:(t=Object(t),gbt(xbt(t),(function(e){return bbt.call(t,e)})))}:ybt,Sbt=function Mbt(t,e){for(var n=-1,i=e.length,r=t.length;++n<i;)t[r+n]=e[n];return t},Ebt=nbt(Object.getPrototypeOf,Object),Tbt=Object.getOwnPropertySymbols?function(t){for(var e=[];t;)Sbt(e,wbt(t)),t=Ebt(t);return e}:ybt,Abt=function Cbt(t,e,n){var i=e(t);return Ovt(t)?i:Sbt(i,n(t))},kbt=function Lbt(t){return Abt(t,ubt,wbt)},Pbt=function Ibt(t){return Abt(t,pbt,Tbt)},Nbt=Vyt(byt,"DataView"),Obt=Vyt(byt,"Promise"),Rbt=Vyt(byt,"Set"),zbt=Vyt(byt,"WeakMap"),Dbt="[object Map]",Bbt="[object Promise]",Hbt="[object Set]",Fbt="[object WeakMap]",Vbt="[object DataView]",jbt=Dyt(Nbt),Ubt=Dyt(Uyt),Gbt=Dyt(Obt),Wbt=Dyt(Rbt),qbt=Dyt(zbt),Ybt=Cyt;(Nbt&&Ybt(new Nbt(new ArrayBuffer(1)))!=Vbt||Uyt&&Ybt(new Uyt)!=Dbt||Obt&&Ybt(Obt.resolve())!=Bbt||Rbt&&Ybt(new Rbt)!=Hbt||zbt&&Ybt(new zbt)!=Fbt)&&(Ybt=function(t){var e=Cyt(t),n="[object Object]"==e?t.constructor:void 0,i=n?Dyt(n):"";if(i)switch(i){case jbt:return Vbt;case Ubt:return Dbt;case Gbt:return Bbt;case Wbt:return Hbt;case qbt:return Fbt}return e});var Xbt=Ybt,$bt=Object.prototype.hasOwnProperty,Kbt=byt.Uint8Array,Zbt=function Jbt(t){var e=new t.constructor(t.byteLength);return new Kbt(e).set(new Kbt(t)),e},Qbt=/\w*$/,txt=xyt?xyt.prototype:void 0,ext=txt?txt.valueOf:void 0,nxt=Object.create,ixt=(function(){function t(){}return function(e){if(!Lyt(e))return{};if(nxt)return nxt(e);t.prototype=e;var n=new t;return t.prototype=void 0,n}})(),rxt=qvt&&qvt.isMap,oxt=rxt?Gvt(rxt):function axt(t){return Tvt(t)&&"[object Map]"==Xbt(t)},sxt=qvt&&qvt.isSet,lxt=sxt?Gvt(sxt):function cxt(t){return Tvt(t)&&"[object Set]"==Xbt(t)},uxt="[object Arguments]",hxt="[object Function]",dxt="[object Object]",pxt={};pxt[uxt]=pxt["[object Array]"]=pxt["[object ArrayBuffer]"]=pxt["[object DataView]"]=pxt["[object Boolean]"]=pxt["[object Date]"]=pxt["[object Float32Array]"]=pxt["[object Float64Array]"]=pxt["[object Int8Array]"]=pxt["[object Int16Array]"]=pxt["[object Int32Array]"]=pxt["[object Map]"]=pxt["[object Number]"]=pxt[dxt]=pxt["[object RegExp]"]=pxt["[object Set]"]=pxt["[object String]"]=pxt["[object Symbol]"]=pxt["[object Uint8Array]"]=pxt["[object Uint8ClampedArray]"]=pxt["[object Uint16Array]"]=pxt["[object Uint32Array]"]=!0,pxt["[object Error]"]=pxt[hxt]=pxt["[object WeakMap]"]=!1;var fxt=function t(e,n,i,r,o,a){var s,l=1&n,c=2&n,u=4&n;if(i&&(s=o?i(e,r,o,a):i(e)),void 0!==s)return s;if(!Lyt(e))return e;var h=Ovt(e);if(h){if(s=(function d(t){var e=t.length,n=new t.constructor(e);return e&&"string"==typeof t[0]&&$bt.call(t,"index")&&(n.index=t.index,n.input=t.input),n})(e),!l)return(function p(t,e){var n=-1,i=t.length;for(e||(e=Array(i));++n<i;)e[n]=t[n];return e})(e,s)}else{var f=Xbt(e),m=f==hxt||"[object GeneratorFunction]"==f;if(Dvt(e))return mbt(e,l);if(f==dxt||f==uxt||m&&!o){if(s=c||m?{}:(function g(t){return"function"!=typeof t.constructor||tbt(t)?{}:ixt(Ebt(t))})(e),!l)return c?(function y(t,e){return Mvt(t,Tbt(t),e)})(e,(function _(t,e){return t&&Mvt(e,pbt(e),t)})(s,e)):(function b(t,e){return Mvt(t,wbt(t),e)})(e,(function v(t,e){return t&&Mvt(e,ubt(e),t)})(s,e))}else{if(!pxt[f])return o?e:{};s=(function x(t,e,n){var i=t.constructor;switch(e){case"[object ArrayBuffer]":return Zbt(t);case"[object Boolean]":case"[object Date]":return new i(+t);case"[object DataView]":return(function r(t,e){var n=e?Zbt(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.byteLength)})(t,n);case"[object Float32Array]":case"[object Float64Array]":case"[object Int8Array]":case"[object Int16Array]":case"[object Int32Array]":case"[object Uint8Array]":case"[object Uint8ClampedArray]":case"[object Uint16Array]":case"[object Uint32Array]":return(function o(t,e){var n=e?Zbt(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.length)})(t,n);case"[object Map]":return new i;case"[object Number]":case"[object String]":return new i(t);case"[object RegExp]":return(function a(t){var e=new t.constructor(t.source,Qbt.exec(t));return e.lastIndex=t.lastIndex,e})(t);case"[object Set]":return new i;case"[object Symbol]":return(function s(t){return ext?Object(ext.call(t)):{}})(t)}})(e,f,l)}}a||(a=new mvt);var w=a.get(e);if(w)return w;a.set(e,s),lxt(e)?e.forEach((function(r){s.add(t(r,n,i,r,e,a))})):oxt(e)&&e.forEach((function(r,o){s.set(o,t(r,n,i,o,e,a))}));var S=u?c?Pbt:kbt:c?keysIn:ubt,M=h?void 0:S(e);return gvt(M||e,(function(r,o){M&&(r=e[o=r]),wvt(s,o,t(r,n,i,o,e,a))})),s},mxt=function gxt(t){return function(){return t}},_xt=(function yxt(t){return function(e,n,i){for(var r=-1,o=Object(e),a=i(e),s=a.length;s--;){var l=a[t?s:++r];if(!1===n(o[l],l,o))break}return e}})(),vxt=function bxt(t,e){return t&&_xt(t,e,ubt)},xxt=(function wxt(t,e){return function(n,i){if(null==n)return n;if(!lbt(n))return t(n,i);for(var r=n.length,o=e?r:-1,a=Object(n);(e?o--:++o<r)&&!1!==i(a[o],o,a););return n}})(vxt),Sxt=function Mxt(t){return t},Ext=function Txt(t,e){var n=[];return xxt(t,(function(t,i,r){e(t,i,r)&&n.push(t)})),n};function Axt(t){var e=-1,n=null==t?0:t.length;for(this.__data__=new lvt;++e<n;)this.add(t[e])}Axt.prototype.add=Axt.prototype.push=function Cxt(t){return this.__data__.set(t,"__lodash_hash_undefined__"),this},Axt.prototype.has=function kxt(t){return this.__data__.has(t)};var Lxt=Axt,Pxt=function Ixt(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(e(t[n],n,t))return!0;return!1},Nxt=function Oxt(t,e){return t.has(e)},Rxt=function zxt(t,e,n,i,r,o){var a=1&n,s=t.length,l=e.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(t);if(c&&o.get(e))return c==e;var u=-1,h=!0,d=2&n?new Lxt:void 0;for(o.set(t,e),o.set(e,t);++u<s;){var p=t[u],f=e[u];if(i)var m=a?i(f,p,u,e,t,o):i(p,f,u,t,e,o);if(void 0!==m){if(m)continue;h=!1;break}if(d){if(!Pxt(e,(function(t,e){if(!Nxt(d,e)&&(p===t||r(p,t,n,i,o)))return d.push(e)}))){h=!1;break}}else if(p!==f&&!r(p,f,n,i,o)){h=!1;break}}return o.delete(t),o.delete(e),h},Dxt=function Bxt(t){var e=-1,n=Array(t.size);return t.forEach((function(t,i){n[++e]=[i,t]})),n},Hxt=function Fxt(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=t})),n},Vxt=xyt?xyt.prototype:void 0,jxt=Vxt?Vxt.valueOf:void 0,Uxt=Object.prototype.hasOwnProperty,Gxt="[object Arguments]",Wxt="[object Array]",qxt="[object Object]",Yxt=Object.prototype.hasOwnProperty,Xxt=function t(e,n,i,r,o){return e===n||(null==e||null==n||!Tvt(e)&&!Tvt(n)?e!=e&&n!=n:(function a(t,e,n,i,r,o){var a=Ovt(t),s=Ovt(e),l=a?Wxt:Xbt(t),c=s?Wxt:Xbt(e),u=(l=l==Gxt?qxt:l)==qxt,h=(c=c==Gxt?qxt:c)==qxt,d=l==c;if(d&&Dvt(t)){if(!Dvt(e))return!1;a=!0,u=!1}if(d&&!u)return o||(o=new mvt),a||Xvt(t)?Rxt(t,e,n,i,r,o):(function p(t,e,n,i,r,o,a){switch(n){case"[object DataView]":if(t.byteLength!=e.byteLength||t.byteOffset!=e.byteOffset)return!1;t=t.buffer,e=e.buffer;case"[object ArrayBuffer]":return!(t.byteLength!=e.byteLength||!o(new Kbt(t),new Kbt(e)));case"[object Boolean]":case"[object Date]":case"[object Number]":return oyt(+t,+e);case"[object Error]":return t.name==e.name&&t.message==e.message;case"[object RegExp]":case"[object String]":return t==e+"";case"[object Map]":var s=Dxt;case"[object Set]":if(s||(s=Hxt),t.size!=e.size&&!(1&i))return!1;var l=a.get(t);if(l)return l==e;i|=2,a.set(t,e);var c=Rxt(s(t),s(e),i,r,o,a);return a.delete(t),c;case"[object Symbol]":if(jxt)return jxt.call(t)==jxt.call(e)}return!1})(t,e,l,n,i,r,o);if(!(1&n)){var f=u&&Yxt.call(t,"__wrapped__"),m=h&&Yxt.call(e,"__wrapped__");if(f||m){var g=f?t.value():t,_=m?e.value():e;return o||(o=new mvt),r(g,_,n,i,o)}}return!!d&&(o||(o=new mvt),(function y(t,e,n,i,r,o){var a=1&n,s=kbt(t),l=s.length;if(l!=kbt(e).length&&!a)return!1;for(var c=l;c--;){var u=s[c];if(!(a?u in e:Uxt.call(e,u)))return!1}var h=o.get(t);if(h&&o.get(e))return h==e;var d=!0;o.set(t,e),o.set(e,t);for(var p=a;++c<l;){var f=t[u=s[c]],m=e[u];if(i)var g=a?i(m,f,u,e,t,o):i(f,m,u,t,e,o);if(!(void 0===g?f===m||r(f,m,n,i,o):g)){d=!1;break}p||(p="constructor"==u)}if(d&&!p){var _=t.constructor,y=e.constructor;_==y||!("constructor"in t)||!("constructor"in e)||"function"==typeof _&&_ instanceof _&&"function"==typeof y&&y instanceof y||(d=!1)}return o.delete(t),o.delete(e),d})(t,e,n,i,r,o))})(e,n,i,r,t,o))},$xt=function Kxt(t){return t==t&&!Lyt(t)},Zxt=function Jxt(t,e){return function(n){return null!=n&&n[t]===e&&(void 0!==e||t in Object(n))}},Qxt=function twt(t){return"symbol"==typeof t||Tvt(t)&&"[object Symbol]"==Cyt(t)},ewt=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,nwt=/^\w*$/,iwt=function rwt(t,e){if(Ovt(t))return!1;var n=typeof t;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=t&&!Qxt(t))||nwt.test(t)||!ewt.test(t)||null!=e&&t in Object(e)};function owt(t,e){if("function"!=typeof t||null!=e&&"function"!=typeof e)throw new TypeError("Expected a function");var n=function(){var i=arguments,r=e?e.apply(this,i):i[0],o=n.cache;if(o.has(r))return o.get(r);var a=t.apply(this,i);return n.cache=o.set(r,a)||o,a};return n.cache=new(owt.Cache||lvt),n}owt.Cache=lvt;var awt,swt=owt,lwt=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,cwt=/\\(\\)?/g,uwt=(function hwt(t){var e=swt(t,(function(t){return 500===n.size&&n.clear(),t})),n=e.cache;return e})((function(t){var e=[];return 46===t.charCodeAt(0)&&e.push(""),t.replace(lwt,(function(t,n,i,r){e.push(i?r.replace(cwt,"$1"):n||t)})),e})),dwt=function pwt(t,e){for(var n=-1,i=null==t?0:t.length,r=Array(i);++n<i;)r[n]=e(t[n],n,t);return r},fwt=xyt?xyt.prototype:void 0,mwt=fwt?fwt.toString:void 0,gwt=function t(e){if("string"==typeof e)return e;if(Ovt(e))return dwt(e,t)+"";if(Qxt(e))return mwt?mwt.call(e):"";var n=e+"";return"0"==n&&1/e==-1/0?"-0":n},_wt=function ywt(t){return null==t?"":gwt(t)},vwt=function bwt(t,e){return Ovt(t)?t:iwt(t,e)?[t]:uwt(_wt(t))},xwt=function wwt(t){if("string"==typeof t||Qxt(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e},Swt=function Mwt(t,e){for(var n=0,i=(e=vwt(e,t)).length;null!=t&&n<i;)t=t[xwt(e[n++])];return n&&n==i?t:void 0},Ewt=function Twt(t,e){return null!=t&&e in Object(t)},Awt=function Cwt(t,e,n){for(var i=-1,r=(e=vwt(e,t)).length,o=!1;++i<r;){var a=xwt(e[i]);if(!(o=null!=t&&n(t,a)))break;t=t[a]}return o||++i!=r?o:!!(r=null==t?0:t.length)&&Vvt(r)&&Hvt(a,r)&&(Ovt(t)||Nvt(t))},kwt=function Lwt(t){return function(e){return null==e?void 0:e[t]}},Pwt=function Iwt(t){return"function"==typeof t?t:null==t?Sxt:"object"==typeof t?Ovt(t)?(function e(t,n){return iwt(t)&&$xt(n)?Zxt(xwt(t),n):function(e){var i=(function r(t,e,n){var i=null==t?void 0:Swt(t,e);return void 0===i?n:i})(e,t);return void 0===i&&i===n?(function o(t,e){return null!=t&&Awt(t,e,Ewt)})(e,t):Xxt(n,i,3)}})(t[0],t[1]):(function n(t){var e=(function n(t){for(var e=ubt(t),n=e.length;n--;){var i=e[n],r=t[i];e[n]=[i,r,$xt(r)]}return e})(t);return 1==e.length&&e[0][2]?Zxt(e[0][0],e[0][1]):function(n){return n===t||(function i(t,e,n,r){var o=n.length,a=o,s=!r;if(null==t)return!a;for(t=Object(t);o--;){var l=n[o];if(s&&l[2]?l[1]!==t[l[0]]:!(l[0]in t))return!1}for(;++o<a;){var c=(l=n[o])[0],u=t[c],h=l[1];if(s&&l[2]){if(void 0===u&&!(c in t))return!1}else{var d=new mvt;if(r)var p=r(u,h,c,t,e,d);if(!(void 0===p?Xxt(h,u,3,r,d):p))return!1}}return!0})(n,t,e)}})(t):(function i(t){return iwt(t)?kwt(xwt(t)):(function e(t){return function(e){return Swt(e,t)}})(t)})(t)},Nwt=Object.prototype.hasOwnProperty,Owt=function Rwt(t,e){return null!=t&&Nwt.call(t,e)},zwt=Object.prototype.hasOwnProperty,Dwt=function Bwt(t,e){var n=-1,i=lbt(t)?Array(t.length):[];return xxt(t,(function(t,r,o){i[++n]=e(t,r,o)})),i},Hwt=function Fwt(t,e,n,i){var r=-1,o=null==t?0:t.length;for(i&&o&&(n=t[++r]);++r<o;)n=e(n,t[r],r,t);return n},Vwt=function jwt(t,e,n,i,r){return r(t,(function(t,r,o){n=i?(i=!1,t):e(n,t,r,o)})),n},Uwt=kwt("length"),Gwt=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]"),Wwt="[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",qwt="\\ud83c[\\udffb-\\udfff]",Ywt="[^\\ud800-\\udfff]",Xwt="(?:\\ud83c[\\udde6-\\uddff]){2}",$wt="[\\ud800-\\udbff][\\udc00-\\udfff]",Kwt="(?:"+Wwt+"|"+qwt+")?",Zwt="[\\ufe0e\\ufe0f]?",Jwt=Zwt+Kwt+"(?:\\u200d(?:"+[Ywt,Xwt,$wt].join("|")+")"+Zwt+Kwt+")*",Qwt="(?:"+[Ywt+Wwt+"?",Wwt,Xwt,$wt,"[\\ud800-\\udfff]"].join("|")+")",tSt=RegExp(qwt+"(?="+qwt+")|"+Qwt+Jwt,"g"),eSt=xyt?xyt.isConcatSpreadable:void 0,nSt=function iSt(t){return Ovt(t)||Nvt(t)||!!(eSt&&t&&t[eSt])},rSt=function t(e,n,i,r,o){var a=-1,s=e.length;for(i||(i=nSt),o||(o=[]);++a<s;){var l=e[a];n>0&&i(l)?n>1?t(l,n-1,i,r,o):Sbt(o,l):r||(o[o.length]=l)}return o},oSt=function aSt(t,e,n){switch(n.length){case 0:return t.call(e);case 1:return t.call(e,n[0]);case 2:return t.call(e,n[0],n[1]);case 3:return t.call(e,n[0],n[1],n[2])}return t.apply(e,n)},sSt=Math.max,lSt=Date.now,cSt=(function uSt(t){var e=0,n=0;return function(){var i=lSt(),r=16-(i-n);if(n=i,r>0){if(++e>=800)return arguments[0]}else e=0;return t.apply(void 0,arguments)}})(yvt?function(t,e){return yvt(t,"toString",{configurable:!0,enumerable:!1,value:mxt(e),writable:!0})}:Sxt),hSt=function dSt(t){return t!=t},pSt=function fSt(t,e){return!(null==t||!t.length)&&(function n(t,e,i){return e==e?(function r(t,e,n){for(var i=n-1,r=t.length;++i<r;)if(t[i]===e)return i;return-1})(t,e,i):(function o(t,e,n,i){for(var r=t.length,o=n+(i?1:-1);i?o--:++o<r;)if(e(t[o],o,t))return o;return-1})(t,hSt,i)})(t,e,0)>-1},mSt=function gSt(t,e,n){for(var i=-1,r=null==t?0:t.length;++i<r;)if(n(e,t[i]))return!0;return!1},_St=Rbt&&1/Hxt(new Rbt([,-0]))[1]==1/0?function(t){return new Rbt(t)}:function ySt(){},vSt=function bSt(t){return Tvt(t)&&lbt(t)},xSt=(function wSt(t,e){return cSt((function n(t,e,i){return e=sSt(void 0===e?t.length-1:e,0),function(){for(var n=arguments,r=-1,o=sSt(n.length-e,0),a=Array(o);++r<o;)a[r]=n[e+r];r=-1;for(var s=Array(e+1);++r<e;)s[r]=n[r];return s[e]=i(a),oSt(t,this,s)}})(t,e,Sxt),t+"")})((function(t){return(function e(t,n,i){var r=-1,o=pSt,a=t.length,s=!0,l=[],c=l;if(i)s=!1,o=mSt;else if(a>=200){var u=n?null:_St(t);if(u)return Hxt(u);s=!1,o=Nxt,c=new Lxt}else c=n?[]:l;t:for(;++r<a;){var h=t[r],d=n?n(h):h;if(h=i||0!==h?h:0,s&&d==d){for(var p=c.length;p--;)if(c[p]===d)continue t;n&&c.push(d),l.push(h)}else o(c,d,i)||(c!==l&&c.push(d),l.push(h))}return l})(rSt(t,1,vSt,!0))}));try{awt={clone:function SSt(t){return fxt(t,4)},constant:mxt,each:function MSt(t,e){return(Ovt(t)?gvt:xxt)(t,(function n(t){return"function"==typeof t?t:Sxt})(e))},filter:function ESt(t,e){return(Ovt(t)?gbt:Ext)(t,Pwt(e))},has:function TSt(t,e){return null!=t&&Awt(t,e,Owt)},isArray:Ovt,isEmpty:function ASt(t){if(null==t)return!0;if(lbt(t)&&(Ovt(t)||"string"==typeof t||"function"==typeof t.splice||Dvt(t)||Xvt(t)||Nvt(t)))return!t.length;var e=Xbt(t);if("[object Map]"==e||"[object Set]"==e)return!t.size;if(tbt(t))return!abt(t).length;for(var n in t)if(zwt.call(t,n))return!1;return!0},isFunction:Iyt,isUndefined:function CSt(t){return void 0===t},keys:ubt,map:function kSt(t,e){return(Ovt(t)?dwt:Dwt)(t,Pwt(e))},reduce:function LSt(t,e,n){var i=Ovt(t)?Hwt:Vwt,r=arguments.length<3;return i(t,Pwt(e),n,r,xxt)},size:function PSt(t){if(null==t)return 0;if(lbt(t))return(function e(t){return"string"==typeof t||!Ovt(t)&&Tvt(t)&&"[object String]"==Cyt(t)})(t)?(function n(t){return(function e(t){return Gwt.test(t)})(t)?(function n(t){for(var e=tSt.lastIndex=0;tSt.test(t);)++e;return e})(t):Uwt(t)})(t):t.length;var i=Xbt(t);return"[object Map]"==i||"[object Set]"==i?t.size:abt(t).length},transform:function ISt(t,e,n){var i=Ovt(t),r=i||Dvt(t)||Xvt(t);if(e=Pwt(e),null==n){var o=t&&t.constructor;n=r?i?new o:[]:Lyt(t)&&Iyt(o)?ixt(Ebt(t)):{}}return(r?gvt:vxt)(t,(function(t,i,r){return e(n,t,i,r)})),n},union:xSt,values:function NSt(t){return null==t?[]:(function e(t,n){return dwt(n,(function(e){return t[e]}))})(t,ubt(t))}}}catch(t){}awt||(awt=window._);var OSt=awt,RSt=DSt,zSt="\0";function DSt(t){this._isDirected=!OSt.has(t,"directed")||t.directed,this._isMultigraph=!!OSt.has(t,"multigraph")&&t.multigraph,this._isCompound=!!OSt.has(t,"compound")&&t.compound,this._label=void 0,this._defaultNodeLabelFn=OSt.constant(void 0),this._defaultEdgeLabelFn=OSt.constant(void 0),this._nodes={},this._isCompound&&(this._parent={},this._children={},this._children["\0"]={}),this._in={},this._preds={},this._out={},this._sucs={},this._edgeObjs={},this._edgeLabels={}}function BSt(t,e){t[e]?t[e]++:t[e]=1}function HSt(t,e){--t[e]||delete t[e]}function FSt(t,e,n,i){var r=""+e,o=""+n;if(!t&&r>o){var a=r;r=o,o=a}return r+""+o+""+(OSt.isUndefined(i)?"\0":i)}function VSt(t,e,n,i){var r=""+e,o=""+n;if(!t&&r>o){var a=r;r=o,o=a}var s={v:r,w:o};return i&&(s.name=i),s}function jSt(t,e){return FSt(t,e.v,e.w,e.name)}DSt.prototype._nodeCount=0,DSt.prototype._edgeCount=0,DSt.prototype.isDirected=function(){return this._isDirected},DSt.prototype.isMultigraph=function(){return this._isMultigraph},DSt.prototype.isCompound=function(){return this._isCompound},DSt.prototype.setGraph=function(t){return this._label=t,this},DSt.prototype.graph=function(){return this._label},DSt.prototype.setDefaultNodeLabel=function(t){return OSt.isFunction(t)||(t=OSt.constant(t)),this._defaultNodeLabelFn=t,this},DSt.prototype.nodeCount=function(){return this._nodeCount},DSt.prototype.nodes=function(){return OSt.keys(this._nodes)},DSt.prototype.sources=function(){var t=this;return OSt.filter(this.nodes(),(function(e){return OSt.isEmpty(t._in[e])}))},DSt.prototype.sinks=function(){var t=this;return OSt.filter(this.nodes(),(function(e){return OSt.isEmpty(t._out[e])}))},DSt.prototype.setNodes=function(t,e){var n=arguments,i=this;return OSt.each(t,(function(t){n.length>1?i.setNode(t,e):i.setNode(t)})),this},DSt.prototype.setNode=function(t,e){return OSt.has(this._nodes,t)?(arguments.length>1&&(this._nodes[t]=e),this):(this._nodes[t]=arguments.length>1?e:this._defaultNodeLabelFn(t),this._isCompound&&(this._parent[t]=zSt,this._children[t]={},this._children["\0"][t]=!0),this._in[t]={},this._preds[t]={},this._out[t]={},this._sucs[t]={},++this._nodeCount,this)},DSt.prototype.node=function(t){return this._nodes[t]},DSt.prototype.hasNode=function(t){return OSt.has(this._nodes,t)},DSt.prototype.removeNode=function(t){var e=this;if(OSt.has(this._nodes,t)){var n=function(t){e.removeEdge(e._edgeObjs[t])};delete this._nodes[t],this._isCompound&&(this._removeFromParentsChildList(t),delete this._parent[t],OSt.each(this.children(t),(function(t){e.setParent(t)})),delete this._children[t]),OSt.each(OSt.keys(this._in[t]),n),delete this._in[t],delete this._preds[t],OSt.each(OSt.keys(this._out[t]),n),delete this._out[t],delete this._sucs[t],--this._nodeCount}return this},DSt.prototype.setParent=function(t,e){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(OSt.isUndefined(e))e=zSt;else{for(var n=e+="";!OSt.isUndefined(n);n=this.parent(n))if(n===t)throw new Error("Setting "+e+" as parent of "+t+" would create a cycle");this.setNode(e)}return this.setNode(t),this._removeFromParentsChildList(t),this._parent[t]=e,this._children[e][t]=!0,this},DSt.prototype._removeFromParentsChildList=function(t){delete this._children[this._parent[t]][t]},DSt.prototype.parent=function(t){if(this._isCompound){var e=this._parent[t];if(e!==zSt)return e}},DSt.prototype.children=function(t){if(OSt.isUndefined(t)&&(t=zSt),this._isCompound){var e=this._children[t];if(e)return OSt.keys(e)}else{if(t===zSt)return this.nodes();if(this.hasNode(t))return[]}},DSt.prototype.predecessors=function(t){var e=this._preds[t];if(e)return OSt.keys(e)},DSt.prototype.successors=function(t){var e=this._sucs[t];if(e)return OSt.keys(e)},DSt.prototype.neighbors=function(t){var e=this.predecessors(t);if(e)return OSt.union(e,this.successors(t))},DSt.prototype.isLeaf=function(t){return 0===(this.isDirected()?this.successors(t):this.neighbors(t)).length},DSt.prototype.filterNodes=function(t){var e=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,compound:this._isCompound});e.setGraph(this.graph());var n=this;OSt.each(this._nodes,(function(n,i){t(i)&&e.setNode(i,n)})),OSt.each(this._edgeObjs,(function(t){e.hasNode(t.v)&&e.hasNode(t.w)&&e.setEdge(t,n.edge(t))}));var i={};function r(t){var o=n.parent(t);return void 0===o||e.hasNode(o)?(i[t]=o,o):o in i?i[o]:r(o)}return this._isCompound&&OSt.each(e.nodes(),(function(t){e.setParent(t,r(t))})),e},DSt.prototype.setDefaultEdgeLabel=function(t){return OSt.isFunction(t)||(t=OSt.constant(t)),this._defaultEdgeLabelFn=t,this},DSt.prototype.edgeCount=function(){return this._edgeCount},DSt.prototype.edges=function(){return OSt.values(this._edgeObjs)},DSt.prototype.setPath=function(t,e){var n=this,i=arguments;return OSt.reduce(t,(function(t,r){return i.length>1?n.setEdge(t,r,e):n.setEdge(t,r),r})),this},DSt.prototype.setEdge=function(){var t,e,n,i,r=!1,o=arguments[0];"object"==typeof o&&null!==o&&"v"in o?(t=o.v,e=o.w,n=o.name,2===arguments.length&&(i=arguments[1],r=!0)):(t=o,e=arguments[1],n=arguments[3],arguments.length>2&&(i=arguments[2],r=!0)),t=""+t,e=""+e,OSt.isUndefined(n)||(n=""+n);var a=FSt(this._isDirected,t,e,n);if(OSt.has(this._edgeLabels,a))return r&&(this._edgeLabels[a]=i),this;if(!OSt.isUndefined(n)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph = false");this.setNode(t),this.setNode(e),this._edgeLabels[a]=r?i:this._defaultEdgeLabelFn(t,e,n);var s=VSt(this._isDirected,t,e,n);return t=s.v,e=s.w,Object.freeze(s),this._edgeObjs[a]=s,BSt(this._preds[e],t),BSt(this._sucs[t],e),this._in[e][a]=s,this._out[t][a]=s,this._edgeCount++,this},DSt.prototype.edge=function(t,e,n){var i=1===arguments.length?jSt(this._isDirected,arguments[0]):FSt(this._isDirected,t,e,n);return this._edgeLabels[i]},DSt.prototype.hasEdge=function(t,e,n){var i=1===arguments.length?jSt(this._isDirected,arguments[0]):FSt(this._isDirected,t,e,n);return OSt.has(this._edgeLabels,i)},DSt.prototype.removeEdge=function(t,e,n){var i=1===arguments.length?jSt(this._isDirected,arguments[0]):FSt(this._isDirected,t,e,n),r=this._edgeObjs[i];return r&&(t=r.v,e=r.w,delete this._edgeLabels[i],delete this._edgeObjs[i],HSt(this._preds[e],t),HSt(this._sucs[t],e),delete this._in[e][i],delete this._out[t][i],this._edgeCount--),this},DSt.prototype.inEdges=function(t,e){var n=this._in[t];if(n){var i=OSt.values(n);return e?OSt.filter(i,(function(t){return t.v===e})):i}},DSt.prototype.outEdges=function(t,e){var n=this._out[t];if(n){var i=OSt.values(n);return e?OSt.filter(i,(function(t){return t.w===e})):i}},DSt.prototype.nodeEdges=function(t,e){var n=this.inEdges(t,e);if(n)return n.concat(this.outEdges(t,e))};var USt={Graph:RSt,version:"2.1.8"},GSt={write:function WSt(t){var e={options:{directed:t.isDirected(),multigraph:t.isMultigraph(),compound:t.isCompound()},nodes:YSt(t),edges:XSt(t)};return OSt.isUndefined(t.graph())||(e.value=OSt.clone(t.graph())),e},read:function qSt(t){var e=new RSt(t.options).setGraph(t.value);return OSt.each(t.nodes,(function(t){e.setNode(t.v,t.value),t.parent&&e.setParent(t.v,t.parent)})),OSt.each(t.edges,(function(t){e.setEdge({v:t.v,w:t.w,name:t.name},t.value)})),e}};function YSt(t){return OSt.map(t.nodes(),(function(e){var n=t.node(e),i=t.parent(e),r={v:e};return OSt.isUndefined(n)||(r.value=n),OSt.isUndefined(i)||(r.parent=i),r}))}function XSt(t){return OSt.map(t.edges(),(function(e){var n=t.edge(e),i={v:e.v,w:e.w};return OSt.isUndefined(e.name)||(i.name=e.name),OSt.isUndefined(n)||(i.value=n),i}))}var $St=KSt;function KSt(){this._arr=[],this._keyIndices={}}KSt.prototype.size=function(){return this._arr.length},KSt.prototype.keys=function(){return this._arr.map((function(t){return t.key}))},KSt.prototype.has=function(t){return OSt.has(this._keyIndices,t)},KSt.prototype.priority=function(t){var e=this._keyIndices[t];if(void 0!==e)return this._arr[e].priority},KSt.prototype.min=function(){if(0===this.size())throw new Error("Queue underflow");return this._arr[0].key},KSt.prototype.add=function(t,e){var n=this._keyIndices;if(t=String(t),!OSt.has(n,t)){var i=this._arr,r=i.length;return n[t]=r,i.push({key:t,priority:e}),this._decrease(r),!0}return!1},KSt.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var t=this._arr.pop();return delete this._keyIndices[t.key],this._heapify(0),t.key},KSt.prototype.decrease=function(t,e){var n=this._keyIndices[t];if(e>this._arr[n].priority)throw new Error("New priority is greater than current priority. Key: "+t+" Old: "+this._arr[n].priority+" New: "+e);this._arr[n].priority=e,this._decrease(n)},KSt.prototype._heapify=function(t){var e=this._arr,n=2*t,i=n+1,r=t;n<e.length&&(r=e[n].priority<e[r].priority?n:r,i<e.length&&(r=e[i].priority<e[r].priority?i:r),r!==t&&(this._swap(t,r),this._heapify(r)))},KSt.prototype._decrease=function(t){for(var e,n=this._arr,i=n[t].priority;0!==t&&!(n[e=t>>1].priority<i);)this._swap(t,e),t=e},KSt.prototype._swap=function(t,e){var n=this._arr,i=this._keyIndices,r=n[t],o=n[e];n[t]=o,n[e]=r,i[o.key]=t,i[r.key]=e};var ZSt=function JSt(t,e,n,i){return(function r(t,e,n,i){var r,o,a={},s=new $St,l=function(t){var e=t.v!==r?t.v:t.w,i=a[e],l=n(t),c=o.distance+l;if(l<0)throw new Error("dijkstra does not allow negative edge weights. Bad edge: "+t+" Weight: "+l);c<i.distance&&(i.distance=c,i.predecessor=r,s.decrease(e,c))};for(t.nodes().forEach((function(t){var n=t===e?0:Number.POSITIVE_INFINITY;a[t]={distance:n},s.add(t,n)}));s.size()>0&&(r=s.removeMin(),(o=a[r]).distance!==Number.POSITIVE_INFINITY);)i(r).forEach(l);return a})(t,String(e),n||QSt,i||function(e){return t.outEdges(e)})},QSt=OSt.constant(1),tMt=function eMt(t){var e=0,n=[],i={},r=[];function o(a){var s=i[a]={onStack:!0,lowlink:e,index:e++};if(n.push(a),t.successors(a).forEach((function(t){OSt.has(i,t)?i[t].onStack&&(s.lowlink=Math.min(s.lowlink,i[t].index)):(o(t),s.lowlink=Math.min(s.lowlink,i[t].lowlink))})),s.lowlink===s.index){var l,c=[];do{l=n.pop(),i[l].onStack=!1,c.push(l)}while(a!==l);r.push(c)}}return t.nodes().forEach((function(t){OSt.has(i,t)||o(t)})),r},nMt=OSt.constant(1),iMt=rMt;function rMt(t){var e={},n={},i=[];if(OSt.each(t.sinks(),(function r(o){if(OSt.has(n,o))throw new oMt;OSt.has(e,o)||(n[o]=!0,e[o]=!0,OSt.each(t.predecessors(o),r),delete n[o],i.push(o))})),OSt.size(e)!==t.nodeCount())throw new oMt;return i}function oMt(){}rMt.CycleException=oMt,oMt.prototype=new Error;var aMt=function sMt(t,e,n){OSt.isArray(e)||(e=[e]);var i=(t.isDirected()?t.successors:t.neighbors).bind(t),r=[],o={};return OSt.each(e,(function(e){if(!t.hasNode(e))throw new Error("Graph does not have node: "+e);lMt(t,e,"post"===n,o,i,r)})),r};function lMt(t,e,n,i,r,o){OSt.has(i,e)||(i[e]=!0,n||o.push(e),OSt.each(r(e),(function(e){lMt(t,e,n,i,r,o)})),n&&o.push(e))}var cMt,uMt={Graph:USt.Graph,json:GSt,alg:{components:function hMt(t){var e,n={},i=[];function r(i){OSt.has(n,i)||(n[i]=!0,e.push(i),OSt.each(t.successors(i),r),OSt.each(t.predecessors(i),r))}return OSt.each(t.nodes(),(function(t){e=[],r(t),e.length&&i.push(e)})),i},dijkstra:ZSt,dijkstraAll:function dMt(t,e,n){return OSt.transform(t.nodes(),(function(i,r){i[r]=ZSt(t,r,e,n)}),{})},findCycles:function pMt(t){return OSt.filter(tMt(t),(function(e){return e.length>1||1===e.length&&t.hasEdge(e[0],e[0])}))},floydWarshall:function fMt(t,e,n){return(function i(t,e,n){var i={},r=t.nodes();return r.forEach((function(t){i[t]={},i[t][t]={distance:0},r.forEach((function(e){t!==e&&(i[t][e]={distance:Number.POSITIVE_INFINITY})})),n(t).forEach((function(n){var r=n.v===t?n.w:n.v,o=e(n);i[t][r]={distance:o,predecessor:t}}))})),r.forEach((function(t){var e=i[t];r.forEach((function(n){var o=i[n];r.forEach((function(n){var i=e[n],r=o[n],a=o[t].distance+i.distance;a<r.distance&&(r.distance=a,r.predecessor=i.predecessor)}))}))})),i})(t,e||nMt,n||function(e){return t.outEdges(e)})},isAcyclic:function mMt(t){try{iMt(t)}catch(t){if(t instanceof iMt.CycleException)return!1;throw t}return!0},postorder:function gMt(t,e){return aMt(t,e,"post")},preorder:function _Mt(t,e){return aMt(t,e,"pre")},prim:function yMt(t,e){var n,i=new RSt,r={},o=new $St;function a(t){var i=t.v===n?t.w:t.v,a=o.priority(i);if(void 0!==a){var s=e(t);s<a&&(r[i]=n,o.decrease(i,s))}}if(0===t.nodeCount())return i;OSt.each(t.nodes(),(function(t){o.add(t,Number.POSITIVE_INFINITY),i.setNode(t)})),o.decrease(t.nodes()[0],0);for(var s=!1;o.size()>0;){if(n=o.removeMin(),OSt.has(r,n))i.setEdge(n,r[n]);else{if(s)throw new Error("Input graph is not connected: "+t);s=!0}t.nodeEdges(n).forEach(a)}return i},tarjan:tMt,topsort:iMt},version:USt.version};try{cMt=uMt}catch(t){}cMt||(cMt=window.graphlib);var vMt=cMt,bMt=function xMt(t,e){return t===e||t!=t&&e!=e},wMt=function SMt(t,e){for(var n=t.length;n--;)if(bMt(t[n][0],e))return n;return-1},MMt=Array.prototype.splice;function EMt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}EMt.prototype.clear=function TMt(){this.__data__=[],this.size=0},EMt.prototype.delete=function AMt(t){var e=this.__data__,n=wMt(e,t);return!(n<0||(n==e.length-1?e.pop():MMt.call(e,n,1),--this.size,0))},EMt.prototype.get=function CMt(t){var e=this.__data__,n=wMt(e,t);return n<0?void 0:e[n][1]},EMt.prototype.has=function kMt(t){return wMt(this.__data__,t)>-1},EMt.prototype.set=function LMt(t,e){var n=this.__data__,i=wMt(n,t);return i<0?(++this.size,n.push([t,e])):n[i][1]=e,this};var PMt=EMt,IMt="object"==typeof ve&&ve&&ve.Object===Object&&ve,NMt="object"==typeof self&&self&&self.Object===Object&&self,OMt=IMt||NMt||Function("return this")(),RMt=OMt.Symbol,zMt=Object.prototype,DMt=zMt.hasOwnProperty,BMt=zMt.toString,HMt=RMt?RMt.toStringTag:void 0,FMt=Object.prototype.toString,VMt=RMt?RMt.toStringTag:void 0,jMt=function UMt(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":VMt&&VMt in Object(t)?(function e(t){var e=DMt.call(t,HMt),n=t[HMt];try{t[HMt]=void 0;var i=!0}catch(t){}var r=BMt.call(t);return i&&(e?t[HMt]=n:delete t[HMt]),r})(t):(function n(t){return FMt.call(t)})(t)},GMt=function WMt(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)},qMt=function YMt(t){if(!GMt(t))return!1;var e=jMt(t);return"[object Function]"==e||"[object GeneratorFunction]"==e||"[object AsyncFunction]"==e||"[object Proxy]"==e},XMt=OMt["__core-js_shared__"],$Mt=(function(){var t=/[^.]+$/.exec(XMt&&XMt.keys&&XMt.keys.IE_PROTO||"");return t?"Symbol(src)_1."+t:""})(),KMt=Function.prototype.toString,ZMt=function JMt(t){if(null!=t){try{return KMt.call(t)}catch(t){}try{return t+""}catch(t){}}return""},QMt=/^\[object .+?Constructor\]$/,tEt=RegExp("^"+Function.prototype.toString.call(Object.prototype.hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),eEt=function nEt(t,e){var n=(function i(t,e){return null==t?void 0:t[e]})(t,e);return(function r(t){return!(!GMt(t)||(function e(t){return!!$Mt&&$Mt in t})(t))&&(qMt(t)?tEt:QMt).test(ZMt(t))})(n)?n:void 0},iEt=eEt(OMt,"Map"),rEt=eEt(Object,"create"),oEt=Object.prototype.hasOwnProperty,aEt=Object.prototype.hasOwnProperty;function sEt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}sEt.prototype.clear=function lEt(){this.__data__=rEt?rEt(null):{},this.size=0},sEt.prototype.delete=function cEt(t){var e=this.has(t)&&delete this.__data__[t];return this.size-=e?1:0,e},sEt.prototype.get=function uEt(t){var e=this.__data__;if(rEt){var n=e[t];return"__lodash_hash_undefined__"===n?void 0:n}return oEt.call(e,t)?e[t]:void 0},sEt.prototype.has=function hEt(t){var e=this.__data__;return rEt?void 0!==e[t]:aEt.call(e,t)},sEt.prototype.set=function dEt(t,e){var n=this.__data__;return this.size+=this.has(t)?0:1,n[t]=rEt&&void 0===e?"__lodash_hash_undefined__":e,this};var pEt=sEt,fEt=function mEt(t,e){var n=t.__data__;return(function i(t){var e=typeof t;return"string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t})(e)?n["string"==typeof e?"string":"hash"]:n.map};function gEt(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e<n;){var i=t[e];this.set(i[0],i[1])}}gEt.prototype.clear=function _Et(){this.size=0,this.__data__={hash:new pEt,map:new(iEt||PMt),string:new pEt}},gEt.prototype.delete=function yEt(t){var e=fEt(this,t).delete(t);return this.size-=e?1:0,e},gEt.prototype.get=function vEt(t){return fEt(this,t).get(t)},gEt.prototype.has=function bEt(t){return fEt(this,t).has(t)},gEt.prototype.set=function xEt(t,e){var n=fEt(this,t),i=n.size;return n.set(t,e),this.size+=n.size==i?0:1,this};var wEt=gEt;function SEt(t){var e=this.__data__=new PMt(t);this.size=e.size}SEt.prototype.clear=function MEt(){this.__data__=new PMt,this.size=0},SEt.prototype.delete=function EEt(t){var e=this.__data__,n=e.delete(t);return this.size=e.size,n},SEt.prototype.get=function TEt(t){return this.__data__.get(t)},SEt.prototype.has=function AEt(t){return this.__data__.has(t)},SEt.prototype.set=function CEt(t,e){var n=this.__data__;if(n instanceof PMt){var i=n.__data__;if(!iEt||i.length<199)return i.push([t,e]),this.size=++n.size,this;n=this.__data__=new wEt(i)}return n.set(t,e),this.size=n.size,this};var kEt=SEt,LEt=function PEt(t,e){for(var n=-1,i=null==t?0:t.length;++n<i&&!1!==e(t[n],n,t););return t},IEt=(function(){try{var t=eEt(Object,"defineProperty");return t({},"",{}),t}catch(t){}})(),NEt=function OEt(t,e,n){"__proto__"==e&&IEt?IEt(t,e,{configurable:!0,enumerable:!0,value:n,writable:!0}):t[e]=n},REt=Object.prototype.hasOwnProperty,zEt=function DEt(t,e,n){var i=t[e];REt.call(t,e)&&bMt(i,n)&&(void 0!==n||e in t)||NEt(t,e,n)},BEt=function HEt(t,e,n,i){var r=!n;n||(n={});for(var o=-1,a=e.length;++o<a;){var s=e[o],l=i?i(n[s],t[s],s,n,t):void 0;void 0===l&&(l=t[s]),r?NEt(n,s,l):zEt(n,s,l)}return n},FEt=function VEt(t){return null!=t&&"object"==typeof t},jEt=function UEt(t){return FEt(t)&&"[object Arguments]"==jMt(t)},GEt=Object.prototype,WEt=GEt.hasOwnProperty,qEt=GEt.propertyIsEnumerable,YEt=jEt((function(){return arguments})())?jEt:function(t){return FEt(t)&&WEt.call(t,"callee")&&!qEt.call(t,"callee")},XEt=Array.isArray,$Et=function KEt(){return!1},ZEt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n?OMt.Buffer:void 0;t.exports=(r?r.isBuffer:void 0)||$Et})),JEt=/^(?:0|[1-9]\d*)$/,QEt=function tTt(t,e){var n=typeof t;return!!(e=null==e?9007199254740991:e)&&("number"==n||"symbol"!=n&&JEt.test(t))&&t>-1&&t%1==0&&t<e},eTt=function nTt(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=9007199254740991},iTt={};iTt["[object Float32Array]"]=iTt["[object Float64Array]"]=iTt["[object Int8Array]"]=iTt["[object Int16Array]"]=iTt["[object Int32Array]"]=iTt["[object Uint8Array]"]=iTt["[object Uint8ClampedArray]"]=iTt["[object Uint16Array]"]=iTt["[object Uint32Array]"]=!0,iTt["[object Arguments]"]=iTt["[object Array]"]=iTt["[object ArrayBuffer]"]=iTt["[object Boolean]"]=iTt["[object DataView]"]=iTt["[object Date]"]=iTt["[object Error]"]=iTt["[object Function]"]=iTt["[object Map]"]=iTt["[object Number]"]=iTt["[object Object]"]=iTt["[object RegExp]"]=iTt["[object Set]"]=iTt["[object String]"]=iTt["[object WeakMap]"]=!1;var rTt=function oTt(t){return function(e){return t(e)}},aTt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n&&IMt.process,o=(function(){try{return i&&i.require&&i.require("util").types||r&&r.binding&&r.binding("util")}catch(t){}})();t.exports=o})),sTt=aTt&&aTt.isTypedArray,lTt=sTt?rTt(sTt):function cTt(t){return FEt(t)&&eTt(t.length)&&!!iTt[jMt(t)]},uTt=Object.prototype.hasOwnProperty,hTt=function dTt(t,e){var n=XEt(t),i=!n&&YEt(t),r=!n&&!i&&ZEt(t),o=!n&&!i&&!r&&lTt(t),a=n||i||r||o,s=a?(function l(t,e){for(var n=-1,i=Array(t);++n<t;)i[n]=e(n);return i})(t.length,String):[],c=s.length;for(var u in t)!e&&!uTt.call(t,u)||a&&("length"==u||r&&("offset"==u||"parent"==u)||o&&("buffer"==u||"byteLength"==u||"byteOffset"==u)||QEt(u,c))||s.push(u);return s},pTt=Object.prototype,fTt=function mTt(t){var e=t&&t.constructor;return t===("function"==typeof e&&e.prototype||pTt)},gTt=function _Tt(t,e){return function(n){return t(e(n))}},yTt=gTt(Object.keys,Object),vTt=Object.prototype.hasOwnProperty,bTt=function xTt(t){return null!=t&&eTt(t.length)&&!qMt(t)},wTt=function STt(t){return bTt(t)?hTt(t):(function e(t){if(!fTt(t))return yTt(t);var e=[];for(var n in Object(t))vTt.call(t,n)&&"constructor"!=n&&e.push(n);return e})(t)},MTt=Object.prototype.hasOwnProperty,ETt=function TTt(t){return bTt(t)?hTt(t,!0):(function e(t){if(!GMt(t))return(function e(t){var e=[];if(null!=t)for(var n in Object(t))e.push(n);return e})(t);var n=fTt(t),i=[];for(var r in t)("constructor"!=r||!n&&MTt.call(t,r))&&i.push(r);return i})(t)},ATt=be((function(t,e){var n=e&&!e.nodeType&&e,i=n&&t&&!t.nodeType&&t,r=i&&i.exports===n?OMt.Buffer:void 0,o=r?r.allocUnsafe:void 0;t.exports=function a(t,e){if(e)return t.slice();var n=t.length,i=o?o(n):new t.constructor(n);return t.copy(i),i}})),CTt=function kTt(t,e){var n=-1,i=t.length;for(e||(e=Array(i));++n<i;)e[n]=t[n];return e},LTt=function PTt(t,e){for(var n=-1,i=null==t?0:t.length,r=0,o=[];++n<i;){var a=t[n];e(a,n,t)&&(o[r++]=a)}return o},ITt=function NTt(){return[]},OTt=Object.prototype.propertyIsEnumerable,RTt=Object.getOwnPropertySymbols,zTt=RTt?function(t){return null==t?[]:(t=Object(t),LTt(RTt(t),(function(e){return OTt.call(t,e)})))}:ITt,DTt=function BTt(t,e){for(var n=-1,i=e.length,r=t.length;++n<i;)t[r+n]=e[n];return t},HTt=gTt(Object.getPrototypeOf,Object),FTt=Object.getOwnPropertySymbols?function(t){for(var e=[];t;)DTt(e,zTt(t)),t=HTt(t);return e}:ITt,VTt=function jTt(t,e,n){var i=e(t);return XEt(t)?i:DTt(i,n(t))},UTt=function GTt(t){return VTt(t,wTt,zTt)},WTt=function qTt(t){return VTt(t,ETt,FTt)},YTt=eEt(OMt,"DataView"),XTt=eEt(OMt,"Promise"),$Tt=eEt(OMt,"Set"),KTt=eEt(OMt,"WeakMap"),ZTt="[object Map]",JTt="[object Promise]",QTt="[object Set]",tAt="[object WeakMap]",eAt="[object DataView]",nAt=ZMt(YTt),iAt=ZMt(iEt),rAt=ZMt(XTt),oAt=ZMt($Tt),aAt=ZMt(KTt),sAt=jMt;(YTt&&sAt(new YTt(new ArrayBuffer(1)))!=eAt||iEt&&sAt(new iEt)!=ZTt||XTt&&sAt(XTt.resolve())!=JTt||$Tt&&sAt(new $Tt)!=QTt||KTt&&sAt(new KTt)!=tAt)&&(sAt=function(t){var e=jMt(t),n="[object Object]"==e?t.constructor:void 0,i=n?ZMt(n):"";if(i)switch(i){case nAt:return eAt;case iAt:return ZTt;case rAt:return JTt;case oAt:return QTt;case aAt:return tAt}return e});var lAt=sAt,cAt=Object.prototype.hasOwnProperty,uAt=OMt.Uint8Array,hAt=function dAt(t){var e=new t.constructor(t.byteLength);return new uAt(e).set(new uAt(t)),e},pAt=/\w*$/,fAt=RMt?RMt.prototype:void 0,mAt=fAt?fAt.valueOf:void 0,gAt=function _At(t,e){var n=e?hAt(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.length)},yAt=Object.create,vAt=(function(){function t(){}return function(e){if(!GMt(e))return{};if(yAt)return yAt(e);t.prototype=e;var n=new t;return t.prototype=void 0,n}})(),bAt=function xAt(t){return"function"!=typeof t.constructor||fTt(t)?{}:vAt(HTt(t))},wAt=aTt&&aTt.isMap,SAt=wAt?rTt(wAt):function MAt(t){return FEt(t)&&"[object Map]"==lAt(t)},EAt=aTt&&aTt.isSet,TAt=EAt?rTt(EAt):function AAt(t){return FEt(t)&&"[object Set]"==lAt(t)},CAt="[object Arguments]",kAt="[object Function]",LAt="[object Object]",PAt={};PAt[CAt]=PAt["[object Array]"]=PAt["[object ArrayBuffer]"]=PAt["[object DataView]"]=PAt["[object Boolean]"]=PAt["[object Date]"]=PAt["[object Float32Array]"]=PAt["[object Float64Array]"]=PAt["[object Int8Array]"]=PAt["[object Int16Array]"]=PAt["[object Int32Array]"]=PAt["[object Map]"]=PAt["[object Number]"]=PAt[LAt]=PAt["[object RegExp]"]=PAt["[object Set]"]=PAt["[object String]"]=PAt["[object Symbol]"]=PAt["[object Uint8Array]"]=PAt["[object Uint8ClampedArray]"]=PAt["[object Uint16Array]"]=PAt["[object Uint32Array]"]=!0,PAt["[object Error]"]=PAt[kAt]=PAt["[object WeakMap]"]=!1;var IAt=function t(e,n,i,r,o,a){var s,l=1&n,c=2&n,u=4&n;if(i&&(s=o?i(e,r,o,a):i(e)),void 0!==s)return s;if(!GMt(e))return e;var h=XEt(e);if(h){if(s=(function d(t){var e=t.length,n=new t.constructor(e);return e&&"string"==typeof t[0]&&cAt.call(t,"index")&&(n.index=t.index,n.input=t.input),n})(e),!l)return CTt(e,s)}else{var p=lAt(e),f=p==kAt||"[object GeneratorFunction]"==p;if(ZEt(e))return ATt(e,l);if(p==LAt||p==CAt||f&&!o){if(s=c||f?{}:bAt(e),!l)return c?(function g(t,e){return BEt(t,FTt(t),e)})(e,(function m(t,e){return t&&BEt(e,ETt(e),t)})(s,e)):(function y(t,e){return BEt(t,zTt(t),e)})(e,(function _(t,e){return t&&BEt(e,wTt(e),t)})(s,e))}else{if(!PAt[p])return o?e:{};s=(function v(t,e,n){var i=t.constructor;switch(e){case"[object ArrayBuffer]":return hAt(t);case"[object Boolean]":case"[object Date]":return new i(+t);case"[object DataView]":return(function r(t,e){var n=e?hAt(t.buffer):t.buffer;return new t.constructor(n,t.byteOffset,t.byteLength)})(t,n);case"[object Float32Array]":case"[object Float64Array]":case"[object Int8Array]":case"[object Int16Array]":case"[object Int32Array]":case"[object Uint8Array]":case"[object Uint8ClampedArray]":case"[object Uint16Array]":case"[object Uint32Array]":return gAt(t,n);case"[object Map]":return new i;case"[object Number]":case"[object String]":return new i(t);case"[object RegExp]":return(function o(t){var e=new t.constructor(t.source,pAt.exec(t));return e.lastIndex=t.lastIndex,e})(t);case"[object Set]":return new i;case"[object Symbol]":return(function a(t){return mAt?Object(mAt.call(t)):{}})(t)}})(e,p,l)}}a||(a=new kEt);var b=a.get(e);if(b)return b;a.set(e,s),TAt(e)?e.forEach((function(r){s.add(t(r,n,i,r,e,a))})):SAt(e)&&e.forEach((function(r,o){s.set(o,t(r,n,i,o,e,a))}));var x=u?c?WTt:UTt:c?keysIn:wTt,w=h?void 0:x(e);return LEt(w||e,(function(r,o){w&&(r=e[o=r]),zEt(s,o,t(r,n,i,o,e,a))})),s},NAt=function OAt(t){return function(){return t}},RAt=function zAt(t){return t},DAt=function BAt(t,e,n){switch(n.length){case 0:return t.call(e);case 1:return t.call(e,n[0]);case 2:return t.call(e,n[0],n[1]);case 3:return t.call(e,n[0],n[1],n[2])}return t.apply(e,n)},HAt=Math.max,FAt=function VAt(t,e,n){return e=HAt(void 0===e?t.length-1:e,0),function(){for(var i=arguments,r=-1,o=HAt(i.length-e,0),a=Array(o);++r<o;)a[r]=i[e+r];r=-1;for(var s=Array(e+1);++r<e;)s[r]=i[r];return s[e]=n(a),DAt(t,this,s)}},jAt=Date.now,UAt=(function GAt(t){var e=0,n=0;return function(){var i=jAt(),r=16-(i-n);if(n=i,r>0){if(++e>=800)return arguments[0]}else e=0;return t.apply(void 0,arguments)}})(IEt?function(t,e){return IEt(t,"toString",{configurable:!0,enumerable:!1,value:NAt(e),writable:!0})}:RAt),WAt=function qAt(t,e){return UAt(FAt(t,e,RAt),t+"")},YAt=function XAt(t,e,n){if(!GMt(n))return!1;var i=typeof e;return!!("number"==i?bTt(n)&&QEt(e,n.length):"string"==i&&e in n)&&bMt(n[e],t)},$At=Object.prototype,KAt=$At.hasOwnProperty,ZAt=WAt((function(t,e){t=Object(t);var n=-1,i=e.length,r=i>2?e[2]:void 0;for(r&&YAt(e[0],e[1],r)&&(i=1);++n<i;)for(var o=e[n],a=ETt(o),s=-1,l=a.length;++s<l;){var c=a[s],u=t[c];(void 0===u||bMt(u,$At[c])&&!KAt.call(t,c))&&(t[c]=o[c])}return t})),JAt=(function QAt(t){return function(e,n,i){for(var r=-1,o=Object(e),a=i(e),s=a.length;s--;){var l=a[t?s:++r];if(!1===n(o[l],l,o))break}return e}})(),tCt=function eCt(t,e){return t&&JAt(t,e,wTt)},nCt=(function iCt(t,e){return function(n,i){if(null==n)return n;if(!bTt(n))return t(n,i);for(var r=n.length,o=e?r:-1,a=Object(n);(e?o--:++o<r)&&!1!==i(a[o],o,a););return n}})(tCt),rCt=function oCt(t){return"function"==typeof t?t:RAt},aCt=function sCt(t,e){return(XEt(t)?LEt:nCt)(t,rCt(e))},lCt=aCt,cCt=function uCt(t,e){var n=[];return nCt(t,(function(t,i,r){e(t,i,r)&&n.push(t)})),n};function hCt(t){var e=-1,n=null==t?0:t.length;for(this.__data__=new wEt;++e<n;)this.add(t[e])}hCt.prototype.add=hCt.prototype.push=function dCt(t){return this.__data__.set(t,"__lodash_hash_undefined__"),this},hCt.prototype.has=function pCt(t){return this.__data__.has(t)};var fCt=hCt,mCt=function gCt(t,e){for(var n=-1,i=null==t?0:t.length;++n<i;)if(e(t[n],n,t))return!0;return!1},_Ct=function yCt(t,e){return t.has(e)},vCt=function bCt(t,e,n,i,r,o){var a=1&n,s=t.length,l=e.length;if(s!=l&&!(a&&l>s))return!1;var c=o.get(t);if(c&&o.get(e))return c==e;var u=-1,h=!0,d=2&n?new fCt:void 0;for(o.set(t,e),o.set(e,t);++u<s;){var p=t[u],f=e[u];if(i)var m=a?i(f,p,u,e,t,o):i(p,f,u,t,e,o);if(void 0!==m){if(m)continue;h=!1;break}if(d){if(!mCt(e,(function(t,e){if(!_Ct(d,e)&&(p===t||r(p,t,n,i,o)))return d.push(e)}))){h=!1;break}}else if(p!==f&&!r(p,f,n,i,o)){h=!1;break}}return o.delete(t),o.delete(e),h},xCt=function wCt(t){var e=-1,n=Array(t.size);return t.forEach((function(t,i){n[++e]=[i,t]})),n},SCt=function MCt(t){var e=-1,n=Array(t.size);return t.forEach((function(t){n[++e]=t})),n},ECt=RMt?RMt.prototype:void 0,TCt=ECt?ECt.valueOf:void 0,ACt=Object.prototype.hasOwnProperty,CCt="[object Arguments]",kCt="[object Array]",LCt="[object Object]",PCt=Object.prototype.hasOwnProperty,ICt=function t(e,n,i,r,o){return e===n||(null==e||null==n||!FEt(e)&&!FEt(n)?e!=e&&n!=n:(function a(t,e,n,i,r,o){var a=XEt(t),s=XEt(e),l=a?kCt:lAt(t),c=s?kCt:lAt(e),u=(l=l==CCt?LCt:l)==LCt,h=(c=c==CCt?LCt:c)==LCt,d=l==c;if(d&&ZEt(t)){if(!ZEt(e))return!1;a=!0,u=!1}if(d&&!u)return o||(o=new kEt),a||lTt(t)?vCt(t,e,n,i,r,o):(function p(t,e,n,i,r,o,a){switch(n){case"[object DataView]":if(t.byteLength!=e.byteLength||t.byteOffset!=e.byteOffset)return!1;t=t.buffer,e=e.buffer;case"[object ArrayBuffer]":return!(t.byteLength!=e.byteLength||!o(new uAt(t),new uAt(e)));case"[object Boolean]":case"[object Date]":case"[object Number]":return bMt(+t,+e);case"[object Error]":return t.name==e.name&&t.message==e.message;case"[object RegExp]":case"[object String]":return t==e+"";case"[object Map]":var s=xCt;case"[object Set]":if(s||(s=SCt),t.size!=e.size&&!(1&i))return!1;var l=a.get(t);if(l)return l==e;i|=2,a.set(t,e);var c=vCt(s(t),s(e),i,r,o,a);return a.delete(t),c;case"[object Symbol]":if(TCt)return TCt.call(t)==TCt.call(e)}return!1})(t,e,l,n,i,r,o);if(!(1&n)){var f=u&&PCt.call(t,"__wrapped__"),m=h&&PCt.call(e,"__wrapped__");if(f||m){var g=f?t.value():t,_=m?e.value():e;return o||(o=new kEt),r(g,_,n,i,o)}}return!!d&&(o||(o=new kEt),(function y(t,e,n,i,r,o){var a=1&n,s=UTt(t),l=s.length;if(l!=UTt(e).length&&!a)return!1;for(var c=l;c--;){var u=s[c];if(!(a?u in e:ACt.call(e,u)))return!1}var h=o.get(t);if(h&&o.get(e))return h==e;var d=!0;o.set(t,e),o.set(e,t);for(var p=a;++c<l;){var f=t[u=s[c]],m=e[u];if(i)var g=a?i(m,f,u,e,t,o):i(f,m,u,t,e,o);if(!(void 0===g?f===m||r(f,m,n,i,o):g)){d=!1;break}p||(p="constructor"==u)}if(d&&!p){var _=t.constructor,y=e.constructor;_==y||!("constructor"in t)||!("constructor"in e)||"function"==typeof _&&_ instanceof _&&"function"==typeof y&&y instanceof y||(d=!1)}return o.delete(t),o.delete(e),d})(t,e,n,i,r,o))})(e,n,i,r,t,o))},NCt=function OCt(t){return t==t&&!GMt(t)},RCt=function zCt(t,e){return function(n){return null!=n&&n[t]===e&&(void 0!==e||t in Object(n))}},DCt=function BCt(t){return"symbol"==typeof t||FEt(t)&&"[object Symbol]"==jMt(t)},HCt=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,FCt=/^\w*$/,VCt=function jCt(t,e){if(XEt(t))return!1;var n=typeof t;return!("number"!=n&&"symbol"!=n&&"boolean"!=n&&null!=t&&!DCt(t))||FCt.test(t)||!HCt.test(t)||null!=e&&t in Object(e)};function UCt(t,e){if("function"!=typeof t||null!=e&&"function"!=typeof e)throw new TypeError("Expected a function");var n=function(){var i=arguments,r=e?e.apply(this,i):i[0],o=n.cache;if(o.has(r))return o.get(r);var a=t.apply(this,i);return n.cache=o.set(r,a)||o,a};return n.cache=new(UCt.Cache||wEt),n}UCt.Cache=wEt;var GCt,WCt=UCt,qCt=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,YCt=/\\(\\)?/g,XCt=(function $Ct(t){var e=WCt(t,(function(t){return 500===n.size&&n.clear(),t})),n=e.cache;return e})((function(t){var e=[];return 46===t.charCodeAt(0)&&e.push(""),t.replace(qCt,(function(t,n,i,r){e.push(i?r.replace(YCt,"$1"):n||t)})),e})),KCt=function ZCt(t,e){for(var n=-1,i=null==t?0:t.length,r=Array(i);++n<i;)r[n]=e(t[n],n,t);return r},JCt=RMt?RMt.prototype:void 0,QCt=JCt?JCt.toString:void 0,tkt=function t(e){if("string"==typeof e)return e;if(XEt(e))return KCt(e,t)+"";if(DCt(e))return QCt?QCt.call(e):"";var n=e+"";return"0"==n&&1/e==-1/0?"-0":n},ekt=function nkt(t){return null==t?"":tkt(t)},ikt=function rkt(t,e){return XEt(t)?t:VCt(t,e)?[t]:XCt(ekt(t))},okt=function akt(t){if("string"==typeof t||DCt(t))return t;var e=t+"";return"0"==e&&1/t==-1/0?"-0":e},skt=function lkt(t,e){for(var n=0,i=(e=ikt(e,t)).length;null!=t&&n<i;)t=t[okt(e[n++])];return n&&n==i?t:void 0},ckt=function ukt(t,e){return null!=t&&e in Object(t)},hkt=function dkt(t,e,n){for(var i=-1,r=(e=ikt(e,t)).length,o=!1;++i<r;){var a=okt(e[i]);if(!(o=null!=t&&n(t,a)))break;t=t[a]}return o||++i!=r?o:!!(r=null==t?0:t.length)&&eTt(r)&&QEt(a,r)&&(XEt(t)||YEt(t))},pkt=function fkt(t,e){return null!=t&&hkt(t,e,ckt)},mkt=function gkt(t){return"function"==typeof t?t:null==t?RAt:"object"==typeof t?XEt(t)?(function e(t,n){return VCt(t)&&NCt(n)?RCt(okt(t),n):function(e){var i=(function r(t,e,n){var i=null==t?void 0:skt(t,e);return void 0===i?n:i})(e,t);return void 0===i&&i===n?pkt(e,t):ICt(n,i,3)}})(t[0],t[1]):(function n(t){var e=(function n(t){for(var e=wTt(t),n=e.length;n--;){var i=e[n],r=t[i];e[n]=[i,r,NCt(r)]}return e})(t);return 1==e.length&&e[0][2]?RCt(e[0][0],e[0][1]):function(n){return n===t||(function i(t,e,n,r){var o=n.length,a=o,s=!r;if(null==t)return!a;for(t=Object(t);o--;){var l=n[o];if(s&&l[2]?l[1]!==t[l[0]]:!(l[0]in t))return!1}for(;++o<a;){var c=(l=n[o])[0],u=t[c],h=l[1];if(s&&l[2]){if(void 0===u&&!(c in t))return!1}else{var d=new kEt;if(r)var p=r(u,h,c,t,e,d);if(!(void 0===p?ICt(h,u,3,r,d):p))return!1}}return!0})(n,t,e)}})(t):(function i(t){return VCt(t)?(function e(t){return function(e){return null==e?void 0:e[t]}})(okt(t)):(function n(t){return function(e){return skt(e,t)}})(t)})(t)},_kt=/^\s+|\s+$/g,ykt=/^[-+]0x[0-9a-f]+$/i,vkt=/^0b[01]+$/i,bkt=/^0o[0-7]+$/i,xkt=parseInt,wkt=function Skt(t){return t?1/0===(t=(function e(t){if("number"==typeof t)return t;if(DCt(t))return NaN;if(GMt(t)){var e="function"==typeof t.valueOf?t.valueOf():t;t=GMt(e)?e+"":e}if("string"!=typeof t)return 0===t?t:+t;t=t.replace(_kt,"");var n=vkt.test(t);return n||bkt.test(t)?xkt(t.slice(2),n?2:8):ykt.test(t)?NaN:+t})(t))||t===-1/0?17976931348623157e292*(t<0?-1:1):t==t?t:0:0===t?t:0},Mkt=Math.max,Ekt=(function Akt(t){return function(e,n,i){var r=Object(e);if(!bTt(e)){var o=mkt(n);e=wTt(e),n=function(t){return o(r[t],t,r)}}var a=t(e,n,i);return a>-1?r[o?e[a]:a]:void 0}})((function Tkt(t,e,n){var i=null==t?0:t.length;if(!i)return-1;var r=null==n?0:(function o(t){var e=wkt(t),n=e%1;return e==e?n?e-n:e:0})(n);return r<0&&(r=Mkt(i+r,0)),(function a(t,e,n,i){for(var r=t.length,o=n+(i?1:-1);i?o--:++o<r;)if(e(t[o],o,t))return o;return-1})(t,mkt(e),r)})),Ckt=RMt?RMt.isConcatSpreadable:void 0,kkt=function Lkt(t){return XEt(t)||YEt(t)||!!(Ckt&&t&&t[Ckt])},Pkt=function t(e,n,i,r,o){var a=-1,s=e.length;for(i||(i=kkt),o||(o=[]);++a<s;){var l=e[a];n>0&&i(l)?n>1?t(l,n-1,i,r,o):DTt(o,l):r||(o[o.length]=l)}return o},Ikt=function Nkt(t){return null!=t&&t.length?Pkt(t,1):[]},Okt=Object.prototype.hasOwnProperty,Rkt=function zkt(t,e){return null!=t&&Okt.call(t,e)},Dkt=function Bkt(t,e){var n=-1,i=bTt(t)?Array(t.length):[];return nCt(t,(function(t,r,o){i[++n]=e(t,r,o)})),i},Hkt=function Fkt(t,e,n){for(var i=-1,r=t.length;++i<r;){var o=t[i],a=e(o);if(null!=a&&(void 0===s?a==a&&!DCt(a):n(a,s)))var s=a,l=o}return l},Vkt=function jkt(t,e){return t>e},Ukt=function Gkt(t,e,n){(void 0!==n&&!bMt(t[e],n)||void 0===n&&!(e in t))&&NEt(t,e,n)},Wkt=Function.prototype.toString,qkt=Object.prototype.hasOwnProperty,Ykt=Wkt.call(Object),Xkt=function $kt(t,e){if(("constructor"!==e||"function"!=typeof t[e])&&"__proto__"!=e)return t[e]},Kkt=function t(e,n,i,r,o){e!==n&&JAt(n,(function(a,s){if(o||(o=new kEt),GMt(a))!(function l(t,e,n,i,r,o,a){var s=Xkt(t,n),l=Xkt(e,n),c=a.get(l);if(c)Ukt(t,n,c);else{var u=o?o(s,l,n+"",t,e,a):void 0,h=void 0===u;if(h){var d=XEt(l),p=!d&&ZEt(l),f=!d&&!p&&lTt(l);u=l,d||p||f?XEt(s)?u=s:(function m(t){return FEt(t)&&bTt(t)})(s)?u=CTt(s):p?(h=!1,u=ATt(l,!0)):f?(h=!1,u=gAt(l,!0)):u=[]:(function g(t){if(!FEt(t)||"[object Object]"!=jMt(t))return!1;var e=HTt(t);if(null===e)return!0;var n=qkt.call(e,"constructor")&&e.constructor;return"function"==typeof n&&n instanceof n&&Wkt.call(n)==Ykt})(l)||YEt(l)?(u=s,YEt(s)?u=(function _(t){return BEt(t,ETt(t))})(s):GMt(s)&&!qMt(s)||(u=bAt(l))):h=!1}h&&(a.set(l,u),r(u,l,i,o,a),a.delete(l)),Ukt(t,n,u)}})(e,n,s,i,t,r,o);else{var c=r?r(Xkt(e,s),a,s+"",e,n,o):void 0;void 0===c&&(c=a),Ukt(e,s,c)}}),ETt)},Zkt=(function Jkt(t){return WAt((function(e,n){var i=-1,r=n.length,o=r>1?n[r-1]:void 0,a=r>2?n[2]:void 0;for(o=t.length>3&&"function"==typeof o?(r--,o):void 0,a&&YAt(n[0],n[1],a)&&(o=r<3?void 0:o,r=1),e=Object(e);++i<r;){var s=n[i];s&&t(e,s,i,o)}return e}))})((function(t,e,n){Kkt(t,e,n)})),Qkt=function tLt(t,e){return t<e},eLt=function nLt(t,e,n,i){if(!GMt(t))return t;for(var r=-1,o=(e=ikt(e,t)).length,a=o-1,s=t;null!=s&&++r<o;){var l=okt(e[r]),c=n;if(r!=a){var u=s[l];void 0===(c=i?i(u,l,s):void 0)&&(c=GMt(u)?u:QEt(e[r+1])?[]:{})}zEt(s,l,c),s=s[l]}return t},iLt=(function rLt(t){return UAt(FAt(t,void 0,Ikt),t+"")})((function(t,e){return null==t?{}:(function n(t,e){return(function n(t,e,i){for(var r=-1,o=e.length,a={};++r<o;){var s=e[r],l=skt(t,s);i(l,s)&&eLt(a,ikt(s,t),l)}return a})(t,e,(function(e,n){return pkt(t,n)}))})(t,e)})),oLt=Math.ceil,aLt=Math.max,sLt=(function lLt(t){return function(e,n,i){return i&&"number"!=typeof i&&YAt(e,n,i)&&(n=i=void 0),e=wkt(e),void 0===n?(n=e,e=0):n=wkt(n),(function r(t,e,n,i){for(var r=-1,o=aLt(oLt((e-t)/(n||1)),0),a=Array(o);o--;)a[i?o:++r]=t,t+=n;return a})(e,n,i=void 0===i?e<n?1:-1:wkt(i),t)}})(),cLt=function uLt(t,e,n,i){var r=-1,o=null==t?0:t.length;for(i&&o&&(n=t[++r]);++r<o;)n=e(n,t[r],r,t);return n},hLt=function dLt(t,e,n,i,r){return r(t,(function(t,r,o){n=i?(i=!1,t):e(n,t,r,o)})),n},pLt=function fLt(t,e){if(t!==e){var n=void 0!==t,i=null===t,r=t==t,o=DCt(t),a=void 0!==e,s=null===e,l=e==e,c=DCt(e);if(!s&&!c&&!o&&t>e||o&&a&&l&&!s&&!c||i&&a&&l||!n&&l||!r)return 1;if(!i&&!o&&!c&&t<e||c&&n&&r&&!i&&!o||s&&n&&r||!a&&r||!l)return-1}return 0},mLt=WAt((function(t,e){if(null==t)return[];var n=e.length;return n>1&&YAt(t,e[0],e[1])?e=[]:n>2&&YAt(e[0],e[1],e[2])&&(e=[e[0]]),(function i(t,e,n){var i=-1;return e=KCt(e.length?e:[RAt],rTt(mkt)),(function r(t,e){var n=t.length;for(t.sort(e);n--;)t[n]=t[n].value;return t})(Dkt(t,(function(t,n,r){return{criteria:KCt(e,(function(e){return e(t)})),index:++i,value:t}})),(function(t,e){return(function i(t,e,n){for(var i=-1,r=t.criteria,o=e.criteria,a=r.length,s=n.length;++i<a;){var l=pLt(r[i],o[i]);if(l)return i>=s?l:l*("desc"==n[i]?-1:1)}return t.index-e.index})(t,e,n)}))})(t,Pkt(e,1),[])})),gLt=0;try{GCt={cloneDeep:function _Lt(t){return IAt(t,5)},constant:NAt,defaults:ZAt,each:lCt,filter:function yLt(t,e){return(XEt(t)?LTt:cCt)(t,mkt(e))},find:Ekt,flatten:Ikt,forEach:aCt,forIn:function vLt(t,e){return null==t?t:JAt(t,rCt(e),ETt)},has:function bLt(t,e){return null!=t&&hkt(t,e,Rkt)},isUndefined:function xLt(t){return void 0===t},last:function wLt(t){var e=null==t?0:t.length;return e?t[e-1]:void 0},map:function SLt(t,e){return(XEt(t)?KCt:Dkt)(t,mkt(e))},mapValues:function MLt(t,e){var n={};return e=mkt(e),tCt(t,(function(t,i,r){NEt(n,i,e(t,i,r))})),n},max:function ELt(t){return t&&t.length?Hkt(t,RAt,Vkt):void 0},merge:Zkt,min:function TLt(t){return t&&t.length?Hkt(t,RAt,Qkt):void 0},minBy:function ALt(t,e){return t&&t.length?Hkt(t,mkt(e),Qkt):void 0},now:function(){return OMt.Date.now()},pick:iLt,range:sLt,reduce:function CLt(t,e,n){var i=XEt(t)?cLt:hLt,r=arguments.length<3;return i(t,mkt(e),n,r,nCt)},sortBy:mLt,uniqueId:function kLt(t){var e=++gLt;return ekt(t)+e},values:function LLt(t){return null==t?[]:(function e(t,n){return KCt(n,(function(e){return t[e]}))})(t,wTt(t))},zipObject:function PLt(t,e){return(function n(t,e,i){for(var r=-1,o=t.length,a=e.length,s={};++r<o;)i(s,t[r],r<a?e[r]:void 0);return s})(t||[],e||[],zEt)}}}catch(t){}GCt||(GCt=window._);var ILt=GCt,NLt=OLt;function OLt(){var t={};t._next=t._prev=t,this._sentinel=t}function RLt(t){t._prev._next=t._next,t._next._prev=t._prev,delete t._next,delete t._prev}function zLt(t,e){if("_next"!==t&&"_prev"!==t)return e}OLt.prototype.dequeue=function(){var t=this._sentinel,e=t._prev;if(e!==t)return RLt(e),e},OLt.prototype.enqueue=function(t){var e=this._sentinel;t._prev&&t._next&&RLt(t),t._next=e._next,e._next._prev=t,e._next=t,t._prev=e},OLt.prototype.toString=function(){for(var t=[],e=this._sentinel,n=e._prev;n!==e;)t.push(JSON.stringify(n,zLt)),n=n._prev;return"["+t.join(", ")+"]"};var DLt=vMt.Graph,BLt=ILt.constant(1);function HLt(t,e,n,i,r){var o=r?[]:void 0;return ILt.forEach(t.inEdges(i.v),(function(i){var a=t.edge(i),s=t.node(i.v);r&&o.push({v:i.v,w:i.w}),s.out-=a,FLt(e,n,s)})),ILt.forEach(t.outEdges(i.v),(function(i){var r=t.edge(i),o=t.node(i.w);o.in-=r,FLt(e,n,o)})),t.removeNode(i.v),o}function FLt(t,e,n){n.out?n.in?t[n.out-n.in+e].enqueue(n):t[t.length-1].enqueue(n):t[0].enqueue(n)}var VLt=vMt.Graph,jLt={addDummyNode:ePt,simplify:function ULt(t){var e=(new VLt).setGraph(t.graph());return ILt.forEach(t.nodes(),(function(n){e.setNode(n,t.node(n))})),ILt.forEach(t.edges(),(function(n){var i=e.edge(n.v,n.w)||{weight:0,minlen:1},r=t.edge(n);e.setEdge(n.v,n.w,{weight:i.weight+r.weight,minlen:Math.max(i.minlen,r.minlen)})})),e},asNonCompoundGraph:function GLt(t){var e=new VLt({multigraph:t.isMultigraph()}).setGraph(t.graph());return ILt.forEach(t.nodes(),(function(n){t.children(n).length||e.setNode(n,t.node(n))})),ILt.forEach(t.edges(),(function(n){e.setEdge(n,t.edge(n))})),e},successorWeights:function WLt(t){var e=ILt.map(t.nodes(),(function(e){var n={};return ILt.forEach(t.outEdges(e),(function(e){n[e.w]=(n[e.w]||0)+t.edge(e).weight})),n}));return ILt.zipObject(t.nodes(),e)},predecessorWeights:function qLt(t){var e=ILt.map(t.nodes(),(function(e){var n={};return ILt.forEach(t.inEdges(e),(function(e){n[e.v]=(n[e.v]||0)+t.edge(e).weight})),n}));return ILt.zipObject(t.nodes(),e)},intersectRect:function YLt(t,e){var n,i,r=t.x,o=t.y,a=e.x-r,s=e.y-o,l=t.width/2,c=t.height/2;if(!a&&!s)throw new Error("Not possible to find intersection inside of the rectangle");return Math.abs(s)*l>Math.abs(a)*c?(s<0&&(c=-c),n=c*a/s,i=c):(a<0&&(l=-l),n=l,i=l*s/a),{x:r+n,y:o+i}},buildLayerMatrix:function XLt(t){var e=ILt.map(ILt.range(nPt(t)+1),(function(){return[]}));return ILt.forEach(t.nodes(),(function(n){var i=t.node(n),r=i.rank;ILt.isUndefined(r)||(e[r][i.order]=n)})),e},normalizeRanks:function $Lt(t){var e=ILt.min(ILt.map(t.nodes(),(function(e){return t.node(e).rank})));ILt.forEach(t.nodes(),(function(n){var i=t.node(n);ILt.has(i,"rank")&&(i.rank-=e)}))},removeEmptyRanks:function KLt(t){var e=ILt.min(ILt.map(t.nodes(),(function(e){return t.node(e).rank}))),n=[];ILt.forEach(t.nodes(),(function(i){var r=t.node(i).rank-e;n[r]||(n[r]=[]),n[r].push(i)}));var i=0,r=t.graph().nodeRankFactor;ILt.forEach(n,(function(e,n){ILt.isUndefined(e)&&n%r!=0?--i:i&&ILt.forEach(e,(function(e){t.node(e).rank+=i}))}))},addBorderNode:function ZLt(t,e,n,i){var r={width:0,height:0};return arguments.length>=4&&(r.rank=n,r.order=i),ePt(t,"border",r,e)},maxRank:nPt,partition:function JLt(t,e){var n={lhs:[],rhs:[]};return ILt.forEach(t,(function(t){e(t)?n.lhs.push(t):n.rhs.push(t)})),n},time:function QLt(t,e){var n=ILt.now();try{return e()}finally{console.log(t+" time: "+(ILt.now()-n)+"ms")}},notime:function tPt(t,e){return e()}};function ePt(t,e,n,i){var r;do{r=ILt.uniqueId(i)}while(t.hasNode(r));return n.dummy=e,t.setNode(r,n),r}function nPt(t){return ILt.max(ILt.map(t.nodes(),(function(e){var n=t.node(e).rank;if(!ILt.isUndefined(n))return n})))}var iPt=function rPt(t){var e={};ILt.forEach(t.sources(),(function n(i){var r=t.node(i);if(ILt.has(e,i))return r.rank;e[i]=!0;var o=ILt.min(ILt.map(t.outEdges(i),(function(e){return n(e.w)-t.edge(e).minlen})));return o!==Number.POSITIVE_INFINITY&&null!=o||(o=0),r.rank=o}))},oPt=function aPt(t,e){return t.node(e.w).rank-t.node(e.v).rank-t.edge(e).minlen},sPt=vMt.Graph,lPt=oPt,cPt=function uPt(t){var e,n,i=new sPt({directed:!1}),r=t.nodes()[0],o=t.nodeCount();for(i.setNode(r,{});hPt(i,t)<o;)e=dPt(i,t),n=i.hasNode(e.v)?lPt(t,e):-lPt(t,e),pPt(i,t,n);return i};function hPt(t,e){return ILt.forEach(t.nodes(),(function n(i){ILt.forEach(e.nodeEdges(i),(function(r){var o=r.v,a=i===o?r.w:o;t.hasNode(a)||lPt(e,r)||(t.setNode(a,{}),t.setEdge(i,a,{}),n(a))}))})),t.nodeCount()}function dPt(t,e){return ILt.minBy(e.edges(),(function(n){if(t.hasNode(n.v)!==t.hasNode(n.w))return lPt(e,n)}))}function pPt(t,e,n){ILt.forEach(t.nodes(),(function(t){e.node(t).rank+=n}))}var fPt=oPt,mPt=iPt,gPt=vMt.alg.preorder,_Pt=vMt.alg.postorder,yPt=jLt.simplify,vPt=bPt;function bPt(t){t=yPt(t),mPt(t);var e,n=cPt(t);for(SPt(n),xPt(n,t);e=EPt(n);)APt(n,t,e,TPt(n,t,e))}function xPt(t,e){var n=_Pt(t,t.nodes());n=n.slice(0,n.length-1),ILt.forEach(n,(function(n){!(function i(t,e,n){var i=t.node(n);t.edge(n,i.parent).cutvalue=wPt(t,e,n)})(t,e,n)}))}function wPt(t,e,n){var i=t.node(n).parent,r=!0,o=e.edge(n,i),a=0;return o||(r=!1,o=e.edge(i,n)),a=o.weight,ILt.forEach(e.nodeEdges(n),(function(o){var s=o.v===n,l=s?o.w:o.v;if(l!==i){var c=s===r,u=e.edge(o).weight;if(a+=c?u:-u,(function h(t,e,n){return t.hasEdge(e,n)})(t,n,l)){var d=t.edge(n,l).cutvalue;a+=c?-d:d}}})),a}function SPt(t,e){arguments.length<2&&(e=t.nodes()[0]),MPt(t,{},1,e)}function MPt(t,e,n,i,r){var o=n,a=t.node(i);return e[i]=!0,ILt.forEach(t.neighbors(i),(function(r){ILt.has(e,r)||(n=MPt(t,e,n,r,i))})),a.low=o,a.lim=n++,r?a.parent=r:delete a.parent,n}function EPt(t){return ILt.find(t.edges(),(function(e){return t.edge(e).cutvalue<0}))}function TPt(t,e,n){var i=n.v,r=n.w;e.hasEdge(i,r)||(i=n.w,r=n.v);var o=t.node(i),a=t.node(r),s=o,l=!1;o.lim>a.lim&&(s=a,l=!0);var c=ILt.filter(e.edges(),(function(e){return l===CPt(0,t.node(e.v),s)&&l!==CPt(0,t.node(e.w),s)}));return ILt.minBy(c,(function(t){return fPt(e,t)}))}function APt(t,e,n,i){t.removeEdge(n.v,n.w),t.setEdge(i.v,i.w,{}),SPt(t),xPt(t,e),(function r(t,e){var n=ILt.find(t.nodes(),(function(t){return!e.node(t).parent})),i=gPt(t,n);i=i.slice(1),ILt.forEach(i,(function(n){var i=t.node(n).parent,r=e.edge(n,i),o=!1;r||(r=e.edge(i,n),o=!0),e.node(n).rank=e.node(i).rank+(o?r.minlen:-r.minlen)}))})(t,e)}function CPt(t,e,n){return n.low<=e.lim&&e.lim<=n.lim}bPt.initLowLimValues=SPt,bPt.initCutValues=xPt,bPt.calcCutValue=wPt,bPt.leaveEdge=EPt,bPt.enterEdge=TPt,bPt.exchangeEdges=APt;var kPt=iPt,LPt=kPt;function PPt(t){vPt(t)}var IPt=function NPt(t){var e=jLt.addDummyNode(t,"root",{},"_root"),n=(function i(t){var e={};function n(i,r){var o=t.children(i);o&&o.length&&ILt.forEach(o,(function(t){n(t,r+1)})),e[i]=r}return ILt.forEach(t.children(),(function(t){n(t,1)})),e})(t),r=ILt.max(ILt.values(n))-1,o=2*r+1;t.graph().nestingRoot=e,ILt.forEach(t.edges(),(function(e){t.edge(e).minlen*=o}));var a=(function s(t){return ILt.reduce(t.edges(),(function(e,n){return e+t.edge(n).weight}),0)})(t)+1;ILt.forEach(t.children(),(function(i){OPt(t,e,o,a,r,n,i)})),t.graph().nodeRankFactor=o};function OPt(t,e,n,i,r,o,a){var s=t.children(a);if(s.length){var l=jLt.addBorderNode(t,"_bt"),c=jLt.addBorderNode(t,"_bb"),u=t.node(a);t.setParent(l,a),u.borderTop=l,t.setParent(c,a),u.borderBottom=c,ILt.forEach(s,(function(s){OPt(t,e,n,i,r,o,s);var u=t.node(s),h=u.borderTop?u.borderTop:s,d=u.borderBottom?u.borderBottom:s,p=u.borderTop?i:2*i,f=h!==d?1:r-o[a]+1;t.setEdge(l,h,{weight:p,minlen:f,nestingEdge:!0}),t.setEdge(d,c,{weight:p,minlen:f,nestingEdge:!0})})),t.parent(a)||t.setEdge(e,l,{weight:0,minlen:r+o[a]})}else a!==e&&t.setEdge(e,a,{weight:0,minlen:n})}function RPt(t,e,n,i,r,o){var a=r[e][o-1],s=jLt.addDummyNode(t,"border",{width:0,height:0,rank:o,borderType:e},n);r[e][o]=s,t.setParent(s,i),a&&t.setEdge(a,s,{weight:1})}function zPt(t){ILt.forEach(t.nodes(),(function(e){DPt(t.node(e))})),ILt.forEach(t.edges(),(function(e){DPt(t.edge(e))}))}function DPt(t){var e=t.width;t.width=t.height,t.height=e}function BPt(t){t.y=-t.y}function HPt(t){var e=t.x;t.x=t.y,t.y=e}var FPt=function VPt(t,e){for(var n=0,i=1;i<e.length;++i)n+=jPt(t,e[i-1],e[i]);return n};function jPt(t,e,n){for(var i=ILt.zipObject(n,ILt.map(n,(function(t,e){return e}))),r=ILt.flatten(ILt.map(e,(function(e){return ILt.sortBy(ILt.map(t.outEdges(e),(function(e){return{pos:i[e.w],weight:t.edge(e).weight}})),"pos")})),!0),o=1;o<n.length;)o<<=1;var a=2*o-1;o-=1;var s=ILt.map(new Array(a),(function(){return 0})),l=0;return ILt.forEach(r.forEach((function(t){var e=t.pos+o;s[e]+=t.weight;for(var n=0;e>0;)e%2&&(n+=s[e+1]),s[e=e-1>>1]+=t.weight;l+=t.weight*n}))),l}function UPt(t,e,n){for(var i;e.length&&(i=ILt.last(e)).i<=n;)e.pop(),t.push(i.vs),n++;return n}var GPt=function t(e,n,i,r){var o=e.children(n),a=e.node(n),s=a?a.borderLeft:void 0,l=a?a.borderRight:void 0,c={};s&&(o=ILt.filter(o,(function(t){return t!==s&&t!==l})));var u=(function h(t,e){return ILt.map(e,(function(e){var n=t.inEdges(e);if(n.length){var i=ILt.reduce(n,(function(e,n){var i=t.edge(n),r=t.node(n.v);return{sum:e.sum+i.weight*r.order,weight:e.weight+i.weight}}),{sum:0,weight:0});return{v:e,barycenter:i.sum/i.weight,weight:i.weight}}return{v:e}}))})(e,o);ILt.forEach(u,(function(n){if(e.children(n.v).length){var o=t(e,n.v,i,r);c[n.v]=o,ILt.has(o,"barycenter")&&(function a(t,e){ILt.isUndefined(t.barycenter)?(t.barycenter=e.barycenter,t.weight=e.weight):(t.barycenter=(t.barycenter*t.weight+e.barycenter*e.weight)/(t.weight+e.weight),t.weight+=e.weight)})(n,o)}}));var d=(function p(t,e){var n={};return ILt.forEach(t,(function(t,e){var i=n[t.v]={indegree:0,in:[],out:[],vs:[t.v],i:e};ILt.isUndefined(t.barycenter)||(i.barycenter=t.barycenter,i.weight=t.weight)})),ILt.forEach(e.edges(),(function(t){var e=n[t.v],i=n[t.w];ILt.isUndefined(e)||ILt.isUndefined(i)||(i.indegree++,e.out.push(n[t.w]))})),(function i(t){var e=[];function n(t){return function(e){e.merged||(ILt.isUndefined(e.barycenter)||ILt.isUndefined(t.barycenter)||e.barycenter>=t.barycenter)&&(function n(t,e){var n=0,i=0;t.weight&&(n+=t.barycenter*t.weight,i+=t.weight),e.weight&&(n+=e.barycenter*e.weight,i+=e.weight),t.vs=e.vs.concat(t.vs),t.barycenter=n/i,t.weight=i,t.i=Math.min(e.i,t.i),e.merged=!0})(t,e)}}function i(e){return function(n){n.in.push(e),0==--n.indegree&&t.push(n)}}for(;t.length;){var r=t.pop();e.push(r),ILt.forEach(r.in.reverse(),n(r)),ILt.forEach(r.out,i(r))}return ILt.map(ILt.filter(e,(function(t){return!t.merged})),(function(t){return ILt.pick(t,["vs","i","barycenter","weight"])}))})(ILt.filter(n,(function(t){return!t.indegree})))})(u,i);!(function f(t,e){ILt.forEach(t,(function(t){t.vs=ILt.flatten(t.vs.map((function(t){return e[t]?e[t].vs:t})),!0)}))})(d,c);var m=(function g(t,e){var n=jLt.partition(t,(function(t){return ILt.has(t,"barycenter")})),i=n.lhs,r=ILt.sortBy(n.rhs,(function(t){return-t.i})),o=[],a=0,s=0,l=0;i.sort((function c(t){return function(e,n){return e.barycenter<n.barycenter?-1:e.barycenter>n.barycenter?1:t?n.i-e.i:e.i-n.i}})(!!e)),l=UPt(o,r,l),ILt.forEach(i,(function(t){l+=t.vs.length,o.push(t.vs),a+=t.barycenter*t.weight,s+=t.weight,l=UPt(o,r,l)}));var u={vs:ILt.flatten(o,!0)};return s&&(u.barycenter=a/s,u.weight=s),u})(d,r);if(s&&(m.vs=ILt.flatten([s,m.vs,l],!0),e.predecessors(s).length)){var _=e.node(e.predecessors(s)[0]),y=e.node(e.predecessors(l)[0]);ILt.has(m,"barycenter")||(m.barycenter=0,m.weight=0),m.barycenter=(m.barycenter*m.weight+_.order+y.order)/(m.weight+2),m.weight+=2}return m},WPt=vMt.Graph,qPt=vMt.Graph;function YPt(t,e,n){return ILt.map(e,(function(e){return(function i(t,e,n){var i=(function r(t){for(var e;t.hasNode(e=ILt.uniqueId("_root")););return e})(t),o=new WPt({compound:!0}).setGraph({root:i}).setDefaultNodeLabel((function(e){return t.node(e)}));return ILt.forEach(t.nodes(),(function(r){var a=t.node(r),s=t.parent(r);(a.rank===e||a.minRank<=e&&e<=a.maxRank)&&(o.setNode(r),o.setParent(r,s||i),ILt.forEach(t[n](r),(function(e){var n=e.v===r?e.w:e.v,i=o.edge(n,r),a=ILt.isUndefined(i)?0:i.weight;o.setEdge(n,r,{weight:t.edge(e).weight+a})})),ILt.has(a,"minRank")&&o.setNode(r,{borderLeft:a.borderLeft[e],borderRight:a.borderRight[e]}))})),o})(t,e,n)}))}function XPt(t,e){var n=new qPt;ILt.forEach(t,(function(t){var i=t.graph().root,r=GPt(t,i,n,e);ILt.forEach(r.vs,(function(e,n){t.node(e).order=n})),(function o(t,e,n){var i,r={};ILt.forEach(n,(function(n){for(var o,a,s=t.parent(n);s;){if((o=t.parent(s))?(a=r[o],r[o]=s):(a=i,i=s),a&&a!==s)return void e.setEdge(a,s);s=o}}))})(t,n,r.vs)}))}function $Pt(t,e){ILt.forEach(e,(function(e){ILt.forEach(e,(function(e,n){t.node(e).order=n}))}))}var KPt=vMt.Graph;function ZPt(t,e,n){if(e>n){var i=e;e=n,n=i}var r=t[e];r||(t[e]=r={}),r[n]=!0}function JPt(t,e,n){if(e>n){var i=e;e=n,n=i}return ILt.has(t[e],n)}var QPt=jLt.normalizeRanks,tIt=jLt.removeEmptyRanks,eIt=jLt,nIt=vMt.Graph,iIt=["nodesep","edgesep","ranksep","marginx","marginy"],rIt={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},oIt=["acyclicer","ranker","rankdir","align"],aIt=["width","height"],sIt={width:0,height:0},lIt=["minlen","weight","width","height","labeloffset"],cIt={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},uIt=["labelpos"];function hIt(t,e){return ILt.mapValues(ILt.pick(t,e),Number)}function dIt(t){var e={};return ILt.forEach(t,(function(t,n){e[n.toLowerCase()]=t})),e}var pIt,fIt,mIt=vMt.Graph,gIt={graphlib:vMt,layout:function _It(t,e){var n=e&&e.debugTiming?eIt.time:eIt.notime;n("layout",(function(){var e=n("  buildLayoutGraph",(function(){return(function e(t){var e=new nIt({multigraph:!0,compound:!0}),n=dIt(t.graph());return e.setGraph(ILt.merge({},rIt,hIt(n,iIt),ILt.pick(n,oIt))),ILt.forEach(t.nodes(),(function(n){var i=dIt(t.node(n));e.setNode(n,ILt.defaults(hIt(i,aIt),sIt)),e.setParent(n,t.parent(n))})),ILt.forEach(t.edges(),(function(n){var i=dIt(t.edge(n));e.setEdge(n,ILt.merge({},cIt,hIt(i,lIt),ILt.pick(i,uIt)))})),e})(t)}));n("  runLayout",(function(){!(function t(e,n){n("    makeSpaceForEdgeLabels",(function(){!(function t(e){var n=e.graph();n.ranksep/=2,ILt.forEach(e.edges(),(function(t){var i=e.edge(t);i.minlen*=2,"c"!==i.labelpos.toLowerCase()&&("TB"===n.rankdir||"BT"===n.rankdir?i.width+=i.labeloffset:i.height+=i.labeloffset)}))})(e)})),n("    removeSelfEdges",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){if(t.v===t.w){var n=e.node(t.v);n.selfEdges||(n.selfEdges=[]),n.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}}))})(e)})),n("    acyclic",(function(){!(function t(e){var n="greedy"===e.graph().acyclicer?(function r(t,e){if(t.nodeCount()<=1)return[];var n=(function i(t,e){var n=new DLt,i=0,r=0;ILt.forEach(t.nodes(),(function(t){n.setNode(t,{v:t,in:0,out:0})})),ILt.forEach(t.edges(),(function(t){var o=n.edge(t.v,t.w)||0,a=e(t);n.setEdge(t.v,t.w,o+a),r=Math.max(r,n.node(t.v).out+=a),i=Math.max(i,n.node(t.w).in+=a)}));var o=ILt.range(r+i+3).map((function(){return new NLt})),a=i+1;return ILt.forEach(n.nodes(),(function(t){FLt(o,a,n.node(t))})),{graph:n,buckets:o,zeroIdx:a}})(t,e||BLt),r=(function o(t,e,n){for(var i,r=[],o=e[e.length-1],a=e[0];t.nodeCount();){for(;i=a.dequeue();)HLt(t,e,n,i);for(;i=o.dequeue();)HLt(t,e,n,i);if(t.nodeCount())for(var s=e.length-2;s>0;--s)if(i=e[s].dequeue()){r=r.concat(HLt(t,e,n,i,!0));break}}return r})(n.graph,n.buckets,n.zeroIdx);return ILt.flatten(ILt.map(r,(function(e){return t.outEdges(e.v,e.w)})),!0)})(e,(function i(t){return function(e){return t.edge(e).weight}})(e)):(function o(t){var e=[],n={},i={};return ILt.forEach(t.nodes(),(function r(o){ILt.has(i,o)||(i[o]=!0,n[o]=!0,ILt.forEach(t.outEdges(o),(function(t){ILt.has(n,t.w)?e.push(t):r(t.w)})),delete n[o])})),e})(e);ILt.forEach(n,(function(t){var n=e.edge(t);e.removeEdge(t),n.forwardName=t.name,n.reversed=!0,e.setEdge(t.w,t.v,n,ILt.uniqueId("rev"))}))})(e)})),n("    nestingGraph.run",(function(){IPt(e)})),n("    rank",(function(){!(function t(e){switch(e.graph().ranker){case"network-simplex":PPt(e);break;case"tight-tree":!(function n(t){kPt(t),cPt(t)})(e);break;case"longest-path":LPt(e);break;default:PPt(e)}})(eIt.asNonCompoundGraph(e))})),n("    injectEdgeLabelProxies",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){var n=e.edge(t);if(n.width&&n.height){var i=e.node(t.v),r=e.node(t.w);eIt.addDummyNode(e,"edge-proxy",{rank:(r.rank-i.rank)/2+i.rank,e:t},"_ep")}}))})(e)})),n("    removeEmptyRanks",(function(){tIt(e)})),n("    nestingGraph.cleanup",(function(){!(function t(e){var n=e.graph();e.removeNode(n.nestingRoot),delete n.nestingRoot,ILt.forEach(e.edges(),(function(t){e.edge(t).nestingEdge&&e.removeEdge(t)}))})(e)})),n("    normalizeRanks",(function(){QPt(e)})),n("    assignRankMinMax",(function(){!(function t(e){var n=0;ILt.forEach(e.nodes(),(function(t){var i=e.node(t);i.borderTop&&(i.minRank=e.node(i.borderTop).rank,i.maxRank=e.node(i.borderBottom).rank,n=ILt.max(n,i.maxRank))})),e.graph().maxRank=n})(e)})),n("    removeEdgeLabelProxies",(function(){!(function t(e){ILt.forEach(e.nodes(),(function(t){var n=e.node(t);"edge-proxy"===n.dummy&&(e.edge(n.e).labelRank=n.rank,e.removeNode(t))}))})(e)})),n("    normalize.run",(function(){!(function t(e){e.graph().dummyChains=[],ILt.forEach(e.edges(),(function(t){!(function n(t,e){var n,i,r,o=e.v,a=t.node(o).rank,s=e.w,l=t.node(s).rank,c=e.name,u=t.edge(e),h=u.labelRank;if(l!==a+1){for(t.removeEdge(e),r=0,++a;a<l;++r,++a)u.points=[],n=jLt.addDummyNode(t,"edge",i={width:0,height:0,edgeLabel:u,edgeObj:e,rank:a},"_d"),a===h&&(i.width=u.width,i.height=u.height,i.dummy="edge-label",i.labelpos=u.labelpos),t.setEdge(o,n,{weight:u.weight},c),0===r&&t.graph().dummyChains.push(n),o=n;t.setEdge(o,s,{weight:u.weight},c)}})(e,t)}))})(e)})),n("    parentDummyChains",(function(){!(function t(e){var n=(function i(t){var e={},n=0;return ILt.forEach(t.children(),(function i(r){var o=n;ILt.forEach(t.children(r),i),e[r]={low:o,lim:n++}})),e})(e);ILt.forEach(e.graph().dummyChains,(function(t){for(var i=e.node(t),r=i.edgeObj,o=(function a(t,e,n,i){var r,o,a=[],s=[],l=Math.min(e[n].low,e[i].low),c=Math.max(e[n].lim,e[i].lim);r=n;do{r=t.parent(r),a.push(r)}while(r&&(e[r].low>l||c>e[r].lim));for(o=r,r=i;(r=t.parent(r))!==o;)s.push(r);return{path:a.concat(s.reverse()),lca:o}})(e,n,r.v,r.w),s=o.path,l=o.lca,c=0,u=s[c],h=!0;t!==r.w;){if(i=e.node(t),h){for(;(u=s[c])!==l&&e.node(u).maxRank<i.rank;)c++;u===l&&(h=!1)}if(!h){for(;c<s.length-1&&e.node(u=s[c+1]).minRank<=i.rank;)c++;u=s[c]}e.setParent(t,u),t=e.successors(t)[0]}}))})(e)})),n("    addBorderSegments",(function(){!(function t(e){ILt.forEach(e.children(),(function t(n){var i=e.children(n),r=e.node(n);if(i.length&&ILt.forEach(i,t),ILt.has(r,"minRank")){r.borderLeft=[],r.borderRight=[];for(var o=r.minRank,a=r.maxRank+1;o<a;++o)RPt(e,"borderLeft","_bl",n,r,o),RPt(e,"borderRight","_br",n,r,o)}}))})(e)})),n("    order",(function(){!(function t(e){var n=jLt.maxRank(e),i=YPt(e,ILt.range(1,n+1),"inEdges"),r=YPt(e,ILt.range(n-1,-1,-1),"outEdges"),o=(function a(t){var e={},n=ILt.filter(t.nodes(),(function(e){return!t.children(e).length})),i=ILt.max(ILt.map(n,(function(e){return t.node(e).rank}))),r=ILt.map(ILt.range(i+1),(function(){return[]})),o=ILt.sortBy(n,(function(e){return t.node(e).rank}));return ILt.forEach(o,(function n(i){if(!ILt.has(e,i)){e[i]=!0;var o=t.node(i);r[o.rank].push(i),ILt.forEach(t.successors(i),n)}})),r})(e);$Pt(e,o);for(var s,l=Number.POSITIVE_INFINITY,c=0,u=0;u<4;++c,++u){XPt(c%2?i:r,c%4>=2),o=jLt.buildLayerMatrix(e);var h=FPt(e,o);h<l&&(u=0,s=ILt.cloneDeep(o),l=h)}$Pt(e,s)})(e)})),n("    insertSelfEdges",(function(){!(function t(e){var n=eIt.buildLayerMatrix(e);ILt.forEach(n,(function(t){var n=0;ILt.forEach(t,(function(t,i){var r=e.node(t);r.order=i+n,ILt.forEach(r.selfEdges,(function(t){eIt.addDummyNode(e,"selfedge",{width:t.label.width,height:t.label.height,rank:r.rank,order:i+ ++n,e:t.e,label:t.label},"_se")})),delete r.selfEdges}))}))})(e)})),n("    adjustCoordinateSystem",(function(){!(function t(e){var n=e.graph().rankdir.toLowerCase();"lr"!==n&&"rl"!==n||zPt(e)})(e)})),n("    position",(function(){!(function t(e){(function n(t){var e=jLt.buildLayerMatrix(t),n=t.graph().ranksep,i=0;ILt.forEach(e,(function(e){var r=ILt.max(ILt.map(e,(function(e){return t.node(e).height})));ILt.forEach(e,(function(e){t.node(e).y=i+r/2})),i+=r+n}))})(e=jLt.asNonCompoundGraph(e)),ILt.forEach((function i(t){var e,n=jLt.buildLayerMatrix(t),i=ILt.merge((function r(t,e){var n={};return ILt.reduce(e,(function i(e,r){var o=0,a=0,s=e.length,l=ILt.last(r);return ILt.forEach(r,(function(e,i){var c=(function u(t,e){if(t.node(e).dummy)return ILt.find(t.predecessors(e),(function(e){return t.node(e).dummy}))})(t,e),h=c?t.node(c).order:s;(c||e===l)&&(ILt.forEach(r.slice(a,i+1),(function(e){ILt.forEach(t.predecessors(e),(function(i){var r=t.node(i),a=r.order;!(a<o||h<a)||r.dummy&&t.node(e).dummy||ZPt(n,i,e)}))})),a=i+1,o=h)})),r})),n})(t,n),(function o(t,e){var n={};function i(e,i,r,o,a){var s;ILt.forEach(ILt.range(i,r),(function(i){t.node(s=e[i]).dummy&&ILt.forEach(t.predecessors(s),(function(e){var i=t.node(e);i.dummy&&(i.order<o||i.order>a)&&ZPt(n,e,s)}))}))}return ILt.reduce(e,(function r(e,n){var r,o=-1,a=0;return ILt.forEach(n,(function(s,l){if("border"===t.node(s).dummy){var c=t.predecessors(s);c.length&&(r=t.node(c[0]).order,i(n,a,l,o,r),a=l,o=r)}i(n,a,n.length,r,e.length)})),n})),n})(t,n)),a={};ILt.forEach(["u","d"],(function(r){e="u"===r?n:ILt.values(n).reverse(),ILt.forEach(["l","r"],(function(n){"r"===n&&(e=ILt.map(e,(function(t){return ILt.values(t).reverse()})));var o=("u"===r?t.predecessors:t.successors).bind(t),s=(function l(t,e,n,i){var r={},o={},a={};return ILt.forEach(e,(function(t){ILt.forEach(t,(function(t,e){r[t]=t,o[t]=t,a[t]=e}))})),ILt.forEach(e,(function(t){var e=-1;ILt.forEach(t,(function(t){var s=i(t);if(s.length)for(var l=((s=ILt.sortBy(s,(function(t){return a[t]}))).length-1)/2,c=Math.floor(l),u=Math.ceil(l);c<=u;++c){var h=s[c];o[t]===t&&e<a[h]&&!JPt(n,t,h)&&(o[h]=t,o[t]=r[t]=r[h],e=a[h])}}))})),{root:r,align:o}})(0,e,i,o),c=(function u(t,e,n,i,r){var o={},a=(function s(t,e,n,i){var r=new KPt,o=t.graph(),a=(function s(t,e,n){return function(i,r,o){var a,s=i.node(r),l=i.node(o),c=0;if(c+=s.width/2,ILt.has(s,"labelpos"))switch(s.labelpos.toLowerCase()){case"l":a=-s.width/2;break;case"r":a=s.width/2}if(a&&(c+=n?a:-a),a=0,c+=(s.dummy?e:t)/2,c+=(l.dummy?e:t)/2,c+=l.width/2,ILt.has(l,"labelpos"))switch(l.labelpos.toLowerCase()){case"l":a=l.width/2;break;case"r":a=-l.width/2}return a&&(c+=n?a:-a),a=0,c}})(o.nodesep,o.edgesep,i);return ILt.forEach(e,(function(e){var i;ILt.forEach(e,(function(e){var o=n[e];if(r.setNode(o),i){var s=n[i],l=r.edge(s,o);r.setEdge(s,o,Math.max(a(t,e,i),l||0))}i=e}))})),r})(t,e,n,r),l=r?"borderLeft":"borderRight";function c(t,e){for(var n=a.nodes(),i=n.pop(),r={};i;)r[i]?t(i):(r[i]=!0,n.push(i),n=n.concat(e(i))),i=n.pop()}return c((function u(t){o[t]=a.inEdges(t).reduce((function(t,e){return Math.max(t,o[e.v]+a.edge(e))}),0)}),a.predecessors.bind(a)),c((function h(e){var n=a.outEdges(e).reduce((function(t,e){return Math.min(t,o[e.w]-a.edge(e))}),Number.POSITIVE_INFINITY),i=t.node(e);n!==Number.POSITIVE_INFINITY&&i.borderType!==l&&(o[e]=Math.max(o[e],n))}),a.successors.bind(a)),ILt.forEach(i,(function(t){o[t]=o[n[t]]})),o})(t,e,s.root,s.align,"r"===n);"r"===n&&(c=ILt.mapValues(c,(function(t){return-t}))),a[r+n]=c}))}));var s=(function l(t,e){return ILt.minBy(ILt.values(e),(function(e){var n=Number.NEGATIVE_INFINITY,i=Number.POSITIVE_INFINITY;return ILt.forIn(e,(function(e,r){var o=(function a(t,e){return t.node(e).width})(t,r)/2;n=Math.max(e+o,n),i=Math.min(e-o,i)})),n-i}))})(t,a);return(function c(t,e){var n=ILt.values(e),i=ILt.min(n),r=ILt.max(n);ILt.forEach(["u","d"],(function(n){ILt.forEach(["l","r"],(function(o){var a,s=n+o,l=t[s];if(l!==e){var c=ILt.values(l);(a="l"===o?i-ILt.min(c):r-ILt.max(c))&&(t[s]=ILt.mapValues(l,(function(t){return t+a})))}}))}))})(a,s),(function u(t,e){return ILt.mapValues(t.ul,(function(n,i){if(e)return t[e.toLowerCase()][i];var r=ILt.sortBy(ILt.map(t,i));return(r[1]+r[2])/2}))})(a,t.graph().align)})(e),(function(t,n){e.node(n).x=t}))})(e)})),n("    positionSelfEdges",(function(){!(function t(e){ILt.forEach(e.nodes(),(function(t){var n=e.node(t);if("selfedge"===n.dummy){var i=e.node(n.e.v),r=i.x+i.width/2,o=i.y,a=n.x-r,s=i.height/2;e.setEdge(n.e,n.label),e.removeNode(t),n.label.points=[{x:r+2*a/3,y:o-s},{x:r+5*a/6,y:o-s},{x:r+a,y:o},{x:r+5*a/6,y:o+s},{x:r+2*a/3,y:o+s}],n.label.x=n.x,n.label.y=n.y}}))})(e)})),n("    removeBorderNodes",(function(){!(function t(e){ILt.forEach(e.nodes(),(function(t){if(e.children(t).length){var n=e.node(t),i=e.node(n.borderTop),r=e.node(n.borderBottom),o=e.node(ILt.last(n.borderLeft)),a=e.node(ILt.last(n.borderRight));n.width=Math.abs(a.x-o.x),n.height=Math.abs(r.y-i.y),n.x=o.x+n.width/2,n.y=i.y+n.height/2}})),ILt.forEach(e.nodes(),(function(t){"border"===e.node(t).dummy&&e.removeNode(t)}))})(e)})),n("    normalize.undo",(function(){!(function t(e){ILt.forEach(e.graph().dummyChains,(function(t){var n,i=e.node(t),r=i.edgeLabel;for(e.setEdge(i.edgeObj,r);i.dummy;)n=e.successors(t)[0],e.removeNode(t),r.points.push({x:i.x,y:i.y}),"edge-label"===i.dummy&&(r.x=i.x,r.y=i.y,r.width=i.width,r.height=i.height),i=e.node(t=n)}))})(e)})),n("    fixupEdgeLabelCoords",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){var n=e.edge(t);if(ILt.has(n,"x"))switch("l"!==n.labelpos&&"r"!==n.labelpos||(n.width-=n.labeloffset),n.labelpos){case"l":n.x-=n.width/2+n.labeloffset;break;case"r":n.x+=n.width/2+n.labeloffset}}))})(e)})),n("    undoCoordinateSystem",(function(){!(function t(e){var n=e.graph().rankdir.toLowerCase();"bt"!==n&&"rl"!==n||(function i(t){ILt.forEach(t.nodes(),(function(e){BPt(t.node(e))})),ILt.forEach(t.edges(),(function(e){var n=t.edge(e);ILt.forEach(n.points,BPt),ILt.has(n,"y")&&BPt(n)}))})(e),"lr"!==n&&"rl"!==n||((function r(t){ILt.forEach(t.nodes(),(function(e){HPt(t.node(e))})),ILt.forEach(t.edges(),(function(e){var n=t.edge(e);ILt.forEach(n.points,HPt),ILt.has(n,"x")&&HPt(n)}))})(e),zPt(e))})(e)})),n("    translateGraph",(function(){!(function t(e){var n=Number.POSITIVE_INFINITY,i=0,r=Number.POSITIVE_INFINITY,o=0,a=e.graph(),s=a.marginx||0,l=a.marginy||0;function c(t){var e=t.x,a=t.y,s=t.width,l=t.height;n=Math.min(n,e-s/2),i=Math.max(i,e+s/2),r=Math.min(r,a-l/2),o=Math.max(o,a+l/2)}ILt.forEach(e.nodes(),(function(t){c(e.node(t))})),ILt.forEach(e.edges(),(function(t){var n=e.edge(t);ILt.has(n,"x")&&c(n)})),n-=s,r-=l,ILt.forEach(e.nodes(),(function(t){var i=e.node(t);i.x-=n,i.y-=r})),ILt.forEach(e.edges(),(function(t){var i=e.edge(t);ILt.forEach(i.points,(function(t){t.x-=n,t.y-=r})),ILt.has(i,"x")&&(i.x-=n),ILt.has(i,"y")&&(i.y-=r)})),a.width=i-n+s,a.height=o-r+l})(e)})),n("    assignNodeIntersects",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){var n,i,r=e.edge(t),o=e.node(t.v),a=e.node(t.w);r.points?(n=r.points[0],i=r.points[r.points.length-1]):(r.points=[],n=a,i=o),r.points.unshift(eIt.intersectRect(o,n)),r.points.push(eIt.intersectRect(a,i))}))})(e)})),n("    reversePoints",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){var n=e.edge(t);n.reversed&&n.points.reverse()}))})(e)})),n("    acyclic.undo",(function(){!(function t(e){ILt.forEach(e.edges(),(function(t){var n=e.edge(t);if(n.reversed){e.removeEdge(t);var i=n.forwardName;delete n.reversed,delete n.forwardName,e.setEdge(t.w,t.v,n,i)}}))})(e)}))})(e,n)})),n("  updateInputGraph",(function(){!(function n(t,e){ILt.forEach(t.nodes(),(function(n){var i=t.node(n),r=e.node(n);i&&(i.x=r.x,i.y=r.y,e.children(n).length&&(i.width=r.width,i.height=r.height))})),ILt.forEach(t.edges(),(function(n){var i=t.edge(n),r=e.edge(n);i.points=r.points,ILt.has(r,"x")&&(i.x=r.x,i.y=r.y)})),t.graph().width=e.graph().width,t.graph().height=e.graph().height})(t,e)}))}))},debug:{debugOrdering:function yIt(t){var e=jLt.buildLayerMatrix(t),n=new mIt({compound:!0,multigraph:!0}).setGraph({});return ILt.forEach(t.nodes(),(function(e){n.setNode(e,{label:e}),n.setParent(e,"layer"+t.node(e).rank)})),ILt.forEach(t.edges(),(function(t){n.setEdge(t.v,t.w,{},t.name)})),ILt.forEach(e,(function(t,e){n.setNode("layer"+e,{rank:"same"}),ILt.reduce(t,(function(t,e){return n.setEdge(t,e,{style:"invis"}),e}))})),n}},util:{time:jLt.time,notime:jLt.notime},version:"0.8.5"};!(function(t){t.FETCH_PBTXT_BYTES="FETCH_PBTXT_BYTES",t.FETCH_PBTXT_BYTES_FROM_FILESYSTEM="FETCH_PBTXT_BYTES_FROM_FILESYSTEM",t.FETCH_PBTXT_BYTES_FROM_SERVER="FETCH_PBTXT_BYTES_FROM_SERVER",t.PARSE_PBTXT_INTO_OBJECT="PARSE_PBTXT_INTO_OBJECT",t.FETCH_METADATA_PBTXT_BYTES="FETCH_METADATA_PBTXT_BYTES",t.PARSE_METADATA_PBTXT_INTO_OBJECT="PARSE_METADATA_PBTXT_INTO_OBJECT",t.NORMALIZING_NAMES="NORMALIZING_NAMES",t.BUILD_SLIM_GRAPH="BUILD_SLIM_GRAPH",t.HIERARCHY_ADD_NODES="HIERARCHY_ADD_NODES",t.HIERARCHY_DETECT_SERIES="HIERARCHY_DETECT_SERIES",t.HIERARCHY_ADD_EDGES="HIERARCHY_ADD_EDGES",t.HIERARCHY_FIND_SIMILAR_SUBGRAPHS="HIERARCHY_FIND_SIMILAR_SUBGRAPHS",t.RENDER_BUILD_HIERARCHY="RENDER_BUILD_HIERARCHY",t.RENDER_SCENE_LAYOUT="RENDER_SCENE_LAYOUT",t.RENDER_SCENE_BUILD_SCENE="RENDER_SCENE_BUILD_SCENE",t.GRAPH_LOAD_SUCCEEDED="GRAPH_LOAD_SUCCEEDED",t.GRAPH_LOAD_FAILED="GRAPH_LOAD_FAILED"})(pIt||(pIt={})),(function(t){t.NODE_EXPANSION_TOGGLED="NODE_EXPANSION_TOGGLED",t.NODE_SEARCH_RESULT_FOCUSED="NODE_SEARCH_RESULT_FOCUSED",t.NODE_AUXILIARY_EXTRACTION_CHANGED="NODE_AUXILIARY_EXTRACTION_CHANGED",t.GRAPH_TYPE_CHANGED="GRAPH_TYPE_CHANGED",t.TRACE_INPUT_MODE_TOGGLED="TRACE_INPUT_MODE_TOGGLED",t.NODE_COLOR_MODE_CHANGED="NODE_COLOR_MODE_CHANGED",t.UPLOADED_GRAPH_FROM_FILESYSTEM="UPLOADED_GRAPH_FROM_FILESYSTEM"})(fIt||(fIt={}));const vIt=Object.assign(Object.assign({},pIt),fIt);var bIt;!(function(t){t.OP_GRAPH="op_graph",t.CONCEPTUAL_GRAPH="conceptual_graph",t.PROFILE="profile"})(bIt||(bIt={}));let xIt={Node:{CONTAINER:"nodes",GROUP:"node",SHAPE:"nodeshape",COLOR_TARGET:"nodecolortarget",LABEL:"nodelabel",BUTTON_CONTAINER:"buttoncontainer",BUTTON_CIRCLE:"buttoncircle",EXPAND_BUTTON:"expandbutton",COLLAPSE_BUTTON:"collapsebutton"},Edge:{CONTAINER:"edges",GROUP:"edge",LINE:"edgeline",REFERENCE_EDGE:"referenceedge",REF_LINE:"refline",SELECTABLE:"selectableedge",SELECTED:"selectededge",STRUCTURAL:"structural"},Annotation:{OUTBOX:"out-annotations",INBOX:"in-annotations",GROUP:"annotation",NODE:"annotation-node",EDGE:"annotation-edge",CONTROL_EDGE:"annotation-control-edge",LABEL:"annotation-label",ELLIPSIS:"annotation-ellipsis"},Scene:{GROUP:"scene",CORE:"core",FUNCTION_LIBRARY:"function-library",INEXTRACT:"in-extract",OUTEXTRACT:"out-extract"},Subscene:{GROUP:"subscene"},OPNODE:"op",METANODE:"meta",SERIESNODE:"series",BRIDGENODE:"bridge",ELLIPSISNODE:"ellipsis"};const wIt="http://www.w3.org/2000/svg";function SIt(t,e,n){let i=t.node().childNodes;for(let t=0;t<i.length;t++){let r=i[t];if(r.tagName===e)if(n instanceof Array){let t=!0;for(let e=0;e<n.length;e++)t=t&&r.classList.contains(n[e]);if(t)return Su(r)}else if(!n||r.classList.contains(n))return Su(r)}return Su(null)}function MIt(t,e,n,i){let r=SIt(t,e,n);if(!r.empty())return r;let o=document.createElementNS("http://www.w3.org/2000/svg",e);if(n instanceof Array)for(let t=0;t<n.length;t++)o.classList.add(n[t]);else o.classList.add(n);return i?t.node().insertBefore(o,i):t.node().appendChild(o),Su(o).datum(t.datum())}class EIt{constructor(t){this.totalBytes=0,this.outputSize=t}addExecutionTime(t,e){this.startTime=null!=this.startTime?Math.min(this.startTime,t):t,this.endTime=null!=this.endTime?Math.max(this.endTime,e):e}addBytesAllocation(t){this.totalBytes=null!=this.totalBytes?Math.max(this.totalBytes,t):t}combine(t){null!=t.totalBytes&&(this.totalBytes+=t.totalBytes),null!=t.getTotalMicros()&&this.addExecutionTime(t.startTime,t.endTime)}getTotalMicros(){return null==this.startTime||null==this.endTime?null:this.endTime-this.startTime}}const TIt=.75,AIt=QM().exponent(.3).domain([1,5e6]).range([TIt,12]).clamp(!0);function CIt(t){!(function e(t){t.hasOwnProperty("timingId")})(t)}function kIt(t,e,n){let i=Date.now(),r=e();const o=Date.now()-i;return console.log(t,":",o,"ms"),n&&CIt({timingId:n,eventValue:o}),r}function LIt(t){return{setMessage:function(e){t.set("progress",{value:t.progress.value,msg:e})},updateProgress:function(e){t.set("progress",{value:t.progress.value+e,msg:t.progress.msg})},reportError:function(e,n){console.error(n.stack),t.set("progress",{value:t.progress.value,msg:e,error:!0})}}}function PIt(t,e,n){return{setMessage:function(e){t.setMessage(n+": "+e)},updateProgress:function(n){t.updateProgress(n*e/100)},reportError:function(e,i){t.reportError(n+": "+e,i)}}}function IIt(t,e,n,i,r){return new Promise(((o,a)=>{i.setMessage(t),setTimeout((function(){try{let a=kIt(t,n,r);i.updateProgress(e),o(a)}catch(e){i.reportError("Failed "+t,e)}}),20)}))}function NIt(t,e,n,i,r){return new Promise(((o,a)=>{let s=function(e){i.reportError("Failed "+t,e),a(e)};i.setMessage(t),setTimeout((function(){try{let a=Date.now();n().then((function(n){const s=Date.now()-a;console.log(t,":",s,"ms"),i.updateProgress(e),CIt({timingId:r,eventValue:s}),o(n)})).catch(s)}catch(t){s(t)}}),20)}))}const OIt=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",numUnits:1024},{symbol:"PB",numUnits:1024}],RIt=[{symbol:"µs"},{symbol:"ms",numUnits:1e3},{symbol:"s",numUnits:1e3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];function zIt(t,e,n=0){return n+1<e.length&&t>=e[n+1].numUnits?zIt(t/e[n+1].numUnits,e,n+1):Number(t.toPrecision(3))+" "+e[n].symbol}function DIt(t){return!(!t||!(t.totalBytes>0||t.getTotalMicros()>0||t.outputSize))}function BIt(t){if(t.length<2)return t;let e=0,n=0,i=we.min(we.map(t,(t=>t.length)));for(;;){e++;let r=we.map(t,(t=>t.substring(0,e)));if(!r.every(((t,e)=>0===e||t===r[e-1])))break;if(e>=i)return t;n=e}return we.map(t,(t=>t.substring(n)))}const HIt=document.createElement("canvas").getContext("2d");function FIt(t,e){return HIt.font=`${e}px Roboto, sans-serif`,HIt.measureText(t).width}const VIt="/",jIt="__root__",UIt="__function_library__";var GIt,WIt,qIt,YIt;!(function(t){t[t.FULL=0]="FULL",t[t.EMBEDDED=1]="EMBEDDED",t[t.META=2]="META",t[t.SERIES=3]="SERIES",t[t.CORE=4]="CORE",t[t.SHADOW=5]="SHADOW",t[t.BRIDGE=6]="BRIDGE",t[t.EDGE=7]="EDGE"})(GIt||(GIt={})),(function(t){t[t.META=0]="META",t[t.OP=1]="OP",t[t.SERIES=2]="SERIES",t[t.BRIDGE=3]="BRIDGE",t[t.ELLIPSIS=4]="ELLIPSIS"})(WIt||(WIt={})),(function(t){t[t.INCLUDE=0]="INCLUDE",t[t.EXCLUDE=1]="EXCLUDE",t[t.UNSPECIFIED=2]="UNSPECIFIED"})(qIt||(qIt={})),(function(t){t[t.GROUP=0]="GROUP",t[t.UNGROUP=1]="UNGROUP"})(YIt||(YIt={}));class XIt{constructor(){this.nodes={},this.edges=[]}}class $It{constructor(t){this.type=WIt.ELLIPSIS,this.isGroupNode=!1,this.cardinality=1,this.parentNode=null,this.stats=null,this.setNumMoreNodes(t),this.include=qIt.UNSPECIFIED}setNumMoreNodes(t){this.numMoreNodes=t,this.name="... "+t+" more"}}class KIt{constructor(t){this.op=t.op,this.name=t.name,this.device=t.device,this.attr=t.attr,this.inputs=(function e(t){const e=[];let n=null;for(let i of t||[]){const t=i.startsWith("^");t&&(i=i.substring(1));let r=i,o="0";const a=i.includes(":")&&i.match(rNt);a&&(r=a[1],o=a[2]),n!==r&&(n=r,e.push({name:r,outputTensorKey:o,isControlDependency:t}))}return e})(t.input),this.outputShapes=(function n(t){if(!t)return null;for(let e=0;e<t.length;e++){let{key:n,value:i}=t[e];if("_output_shapes"===n){if(!i.list.shape)return null;let n=i.list.shape.map((t=>t.unknown_rank?null:null==t.dim||1===t.dim.length&&null==t.dim[0].size?[]:t.dim.map((t=>t.size))));return t.splice(e,1),n}}return null})(t.attr),this.xlaCluster=(function i(t){if(!t)return null;for(let e=0;e<t.length;e++)if("_XlaCluster"===t[e].key)return t[e].value.s||null;return null})(t.attr),this.compatible=!1,this.type=WIt.OP,this.isGroupNode=!1,this.cardinality=1,this.inEmbeddings=[],this.outEmbeddings=[],this.parentNode=null,this.include=qIt.UNSPECIFIED,this.owningSeries=null}}function ZIt(t,e={}){return new JIt(t,e)}class JIt{constructor(t,e={}){this.name=t,this.type=WIt.META,this.depth=1,this.isGroupNode=!0,this.cardinality=0,this.metagraph=sNt(t,GIt.META,e),this.bridgegraph=null,this.opHistogram={},this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.templateId=null,this.parentNode=null,this.hasNonControlEdges=!1,this.include=qIt.UNSPECIFIED,this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let t=this.name.split("/");return this.metagraph.node(this.name+"/("+t[t.length-1]+")")}leaves(){let t,e=[],n=[this];for(;n.length;){let i=n.shift();i.isGroupNode?(t=i.metagraph,we.each(t.nodes(),(e=>n.push(t.node(e))))):e.push(i.name)}return e}}function QIt(t,e){return new tNt(t,e)}class tNt{constructor(t,e){this.v=t,this.w=e,this.baseEdgeList=[],this.inbound=null,this.numRegularEdges=0,this.numControlEdges=0,this.numRefEdges=0,this.totalSize=0}addBaseEdge(t,e){this.baseEdgeList.push(t),t.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1,t.isReferenceEdge&&(this.numRefEdges+=1),this.totalSize+=tNt.computeSizeOfEdge(t,e),e.maxMetaEdgeSize=Math.max(e.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(t,e){let n=e.node(t.v);if(!n.outputShapes)return 1;e.hasShapeInfo=!0;const i=Object.keys(n.outputShapes).map((t=>n.outputShapes[t])).map((t=>null==t?1:t.reduce(((t,e)=>(-1===e&&(e=1),t*e)),1)));return we.sum(i)}}function eNt(t,e,n,i,r,o){return new iNt(t,e,n,i,r,o)}function nNt(t,e,n,i,r){return(n?n+"/":"")+t+(void 0!==i&&void 0!==r?"["+i+"-"+r+"]":"#")+e}class iNt{constructor(t,e,n,i,r,o){this.name=r||nNt(t,e,n),this.type=WIt.SERIES,this.hasLoop=!1,this.prefix=t,this.suffix=e,this.clusterId=i,this.ids=[],this.parent=n,this.isGroupNode=!0,this.cardinality=0,this.metagraph=sNt(r,GIt.SERIES,o),this.bridgegraph=null,this.parentNode=null,this.deviceHistogram={},this.xlaClusterHistogram={},this.compatibilityHistogram={compatible:0,incompatible:0},this.hasNonControlEdges=!1,this.include=qIt.UNSPECIFIED}}const rNt=/^([^:]+):((\w+:|)\d+)$/;function oNt(t,e,n,i,r,o){e!==n.name&&t.edges.push({v:e,w:n.name,outputTensorKey:i.outputTensorKey,isControlDependency:i.isControlDependency,isReferenceEdge:!0===r.refEdges[n.op+" "+o]})}const aNt={enableEmbedding:!0,inEmbeddingTypes:["Const"],outEmbeddingTypes:["^[a-zA-Z]+Summary$"],refEdges:{"Assign 0":!0,"AssignAdd 0":!0,"AssignSub 0":!0,"assign 0":!0,"assign_add 0":!0,"assign_sub 0":!0,"count_up_to 0":!0,"ScatterAdd 0":!0,"ScatterSub 0":!0,"ScatterUpdate 0":!0,"scatter_add 0":!0,"scatter_sub 0":!0,"scatter_update 0":!0}};function sNt(t,e,n={}){const i=new gIt.graphlib.Graph(n);return i.setGraph({name:t,rankdir:n.rankdir||"BT",type:e}),i}function lNt(t){return function(e){for(let n=0;n<t.length;n++){let i=new RegExp(t[n]);if("string"==typeof e.op&&e.op.match(i))return!0}return!1}}function cNt(t){let e=t.split(VIt);return t+VIt+"("+e[e.length-1]+")"}function uNt(t){let e=t.nodes().map((function(e){return t.neighbors(e).length}));return e.sort(),e}function hNt(t,e){let n=[],i=t.indexOf(VIt);for(;i>=0;)n.push(t.substring(0,i)),i=t.indexOf(VIt,i+1);if(e){let i=e[t];i&&n.push(i)}return n.push(t),n}function dNt(t){return t===qIt.EXCLUDE?"Add to main graph":"Remove from main graph"}let pNt="#0f9d58",fNt="#db4437",mNt={DEFAULT_FILL:"#d9d9d9",DEFAULT_STROKE:"#a6a6a6",SATURATION:.6,LIGHTNESS:.85,EXPANDED_COLOR:"#f0f0f0",HUES:[220,100,180,40,20,340,260,300,140,60],STRUCTURE_PALETTE(t,e){let n=mNt.HUES,i=n[t%n.length],r=Math.sin(i*Math.PI/360);return $h(i,.01*(e?30:90-60*r),.01*(e?95:80)).toString()},DEVICE_PALETTE:t=>mNt.STRUCTURE_PALETTE(t),XLA_CLUSTER_PALETTE:t=>mNt.STRUCTURE_PALETTE(t),UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"};const gNt=["NoOp"],_Nt=[],yNt=["#fff5f0","#fb6a4a"],vNt=new RegExp("^(?:__function_library__)?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$");class bNt{constructor(t,e,n){this.hierarchy=t,this.displayingStats=e,this.autoExtractNodes=n,this.index={},this.renderedOpNames=[],this.computeScales(),this.hasSubhierarchy={},this.root=new CNt(t.root,t.graphOptions),this.index[t.root.name]=this.root,this.renderedOpNames.push(t.root.name),this.buildSubhierarchy(t.root.name),this.root.expanded=!0,this.traceInputs=!1}computeScales(){this.deviceColorMap=bM().domain(this.hierarchy.devices).range(we.map(zl(this.hierarchy.devices.length),mNt.DEVICE_PALETTE)),this.xlaClusterColorMap=bM().domain(this.hierarchy.xlaClusters).range(we.map(zl(this.hierarchy.xlaClusters.length),mNt.XLA_CLUSTER_PALETTE));let t=this.hierarchy.root.metagraph,e=Wl(t.nodes(),((e,n)=>{let i=t.node(e);if(null!=i.stats)return i.stats.totalBytes}));this.memoryUsageScale=zM().domain([0,e]).range(yNt);let n=Wl(t.nodes(),((e,n)=>{let i=t.node(e);if(null!=i.stats)return i.stats.getTotalMicros()}));this.computeTimeScale=zM().domain([0,n]).range(yNt),this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?AIt:zM().domain([1,this.hierarchy.maxMetaEdgeSize]).range([TIt,12])}getRenderNodeByName(t){return this.index[t]}getNodeByName(t){return this.hierarchy.node(t)}colorHistogram(t,e){if(Object.keys(t).length>0){const n=we.sum(Object.keys(t).map((e=>t[e])));return Object.keys(t).map((i=>({color:e(i),proportion:t[i]/n})))}return null}getOrCreateRenderNodeByName(t){if(!t)return null;if(t in this.index)return this.index[t];let e=this.hierarchy.node(t);if(!e)return null;let n=e.isGroupNode?new CNt(e,this.hierarchy.graphOptions):new MNt(e);this.index[t]=n,this.renderedOpNames.push(t),e.stats&&(n.memoryColor=this.memoryUsageScale(e.stats.totalBytes),n.computeTimeColor=this.computeTimeScale(e.stats.getTotalMicros())),n.isFadedOut=this.displayingStats&&!DIt(e.stats);var i=null,r=null,o=null;if(e.isGroupNode){i=e.deviceHistogram,r=e.xlaClusterHistogram;let t=e.compatibilityHistogram.compatible,n=e.compatibilityHistogram.incompatible;0==t&&0==n||(o=t/(t+n))}else{let t=n.node.device;t&&(i={[t]:1});let e=n.node.xlaCluster;e&&(r={[e]:1}),n.node.type===WIt.OP&&(o=n.node.compatible?1:0)}return i&&(n.deviceColors=this.colorHistogram(i,this.deviceColorMap)),r&&(n.xlaClusterColors=this.colorHistogram(r,this.xlaClusterColorMap)),null!=o&&(n.compatibilityColors=[{color:pNt,proportion:o},{color:fNt,proportion:1-o}]),this.index[t]}getNearestVisibleAncestor(t){let e=hNt(t),n=0,i=null,r=t;for(;n<e.length&&(r=e[n],i=this.getRenderNodeByName(r),i.expanded);n++);if(n==e.length-2){let t=e[n+1];if(i.inAnnotations.nodeNames[t])return t;if(i.outAnnotations.nodeNames[t])return t}return r}setDepth(t){kNt(this.root,+t)}isNodeAuxiliary(t){let e=this.getRenderNodeByName(t.node.parentNode.name),n=we.find(e.isolatedInExtract,(e=>e.node.name===t.node.name));return!!n||(n=we.find(e.isolatedOutExtract,(e=>e.node.name===t.node.name)),!!n)}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(t,e,n,i){const r=n.name.replace(e,i);let o=t.metagraph.node(r);if(o)return o;o=new KIt({name:r,input:[],device:n.device,op:n.op,attr:we.cloneDeep(n.attr)}),o.cardinality=n.cardinality,o.include=n.include,o.outputShapes=we.cloneDeep(n.outputShapes),o.xlaCluster=n.xlaCluster,o.functionInputIndex=n.functionInputIndex,o.functionOutputIndex=n.functionOutputIndex,o.inputs=n.inputs.map((t=>{const n=we.clone(t);return n.name=t.name.replace(e,i),n})),o.parentNode=t,t.metagraph.setNode(o.name,o),this.hierarchy.setNode(o.name,o);const a=n=>this.cloneAndAddFunctionOpNode(t,e,n,i);return o.inEmbeddings=n.inEmbeddings.map(a),o.outEmbeddings=n.outEmbeddings.map(a),o}cloneFunctionLibraryMetanode(t,e,n,i,r){const o={},a=this.cloneFunctionLibraryMetanodeHelper(t,e,n,i,r,o);return we.isEmpty(o)||this.patchEdgesFromFunctionOutputs(e,o),a}cloneFunctionLibraryMetanodeHelper(t,e,n,i,r,o){const a=ZIt(n.name.replace(i,r));return a.depth=n.depth,a.cardinality=n.cardinality,a.templateId=n.templateId,a.opHistogram=we.clone(n.opHistogram),a.deviceHistogram=we.clone(n.deviceHistogram),a.xlaClusterHistogram=we.clone(n.xlaClusterHistogram),a.hasNonControlEdges=n.hasNonControlEdges,a.include=n.include,a.nodeAttributes=we.clone(n.nodeAttributes),a.associatedFunction=n.associatedFunction,we.each(n.metagraph.nodes(),(s=>{const l=n.metagraph.node(s);switch(l.type){case WIt.META:const n=this.cloneFunctionLibraryMetanodeHelper(t,e,l,i,r,o);n.parentNode=a,a.metagraph.setNode(n.name,n),this.hierarchy.setNode(n.name,n);break;case WIt.OP:const s=this.cloneAndAddFunctionOpNode(a,i,l,r);we.isNumber(s.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(e,s),we.isNumber(s.functionOutputIndex)&&(o[s.functionOutputIndex]=s);break;default:console.warn(l.name+" is oddly neither a metanode nor an opnode.")}})),this.cloneLibraryMetanodeEdges(n,a,i,r),a}cloneLibraryMetanodeEdges(t,e,n,i){we.each(t.metagraph.edges(),(r=>{const o=t.metagraph.edge(r),a=o.v.replace(n,i),s=o.w.replace(n,i),l=new tNt(a,s);l.inbound=o.inbound,l.numRegularEdges=o.numRegularEdges,l.numControlEdges=o.numControlEdges,l.numRefEdges=o.numRefEdges,l.totalSize=o.totalSize,o.baseEdgeList&&(l.baseEdgeList=o.baseEdgeList.map((t=>{const e=we.clone(t);return e.v=t.v.replace(n,i),e.w=t.w.replace(n,i),e}))),e.metagraph.node(s)?e.metagraph.setEdge(a,s,l):e.metagraph.setEdge(s,a,l)}))}patchEdgesIntoFunctionInputs(t,e){let n=Math.min(e.functionInputIndex,t.inputs.length-1),i=we.clone(t.inputs[n]);for(;i.isControlDependency;)n++,i=t.inputs[n];e.inputs.push(i);const r=this.hierarchy.getPredecessors(t.name);let o,a=0;we.each(r.regular,(t=>{if(a+=t.numRegularEdges,a>n)return o=t,!1})),we.each(o.baseEdgeList,(n=>{n.w===t.name&&(n.w=e.name),n.v===t.name&&(n.v=e.name)}))}patchEdgesFromFunctionOutputs(t,e){const n=this.hierarchy.getSuccessors(t.name);we.each(n.regular,(n=>{we.each(n.baseEdgeList,(n=>{const i=this.hierarchy.node(n.w);we.each(i.inputs,(i=>{i.name===t.name&&(i.name=e[i.outputTensorKey].name,i.outputTensorKey=n.outputTensorKey)}))})),we.each(n.baseEdgeList,(t=>{t.v=e[t.outputTensorKey].name,t.outputTensorKey="0"}))}))}buildSubhierarchy(t){if(t in this.hasSubhierarchy)return;this.hasSubhierarchy[t]=!0;let e=this.index[t];if(e.node.type!==WIt.META&&e.node.type!==WIt.SERIES)return;let n=e,i=n.node.metagraph,r=n.coreGraph;const o=[],a=[];we.isEmpty(this.hierarchy.libraryFunctions)||(we.each(i.nodes(),(t=>{const e=i.node(t),n=this.hierarchy.libraryFunctions[e.op];if(!n)return;if(0===t.indexOf(UIt))return;const r=this.cloneFunctionLibraryMetanode(i,e,n.node,n.node.name,e.name);o.push(e),a.push(r)})),we.each(a,((t,e)=>{const n=o[e];t.parentNode=n.parentNode,i.setNode(n.name,t),this.hierarchy.setNode(n.name,t)}))),we.each(i.nodes(),(t=>{let e=this.getOrCreateRenderNodeByName(t),n=e.node;r.setNode(t,e),n.isGroupNode||(we.each(n.inEmbeddings,(t=>{let n=new ENt(null),i=new MNt(t);TNt(e,t,i,n,wNt.CONSTANT),this.index[t.name]=i})),we.each(n.outEmbeddings,(t=>{let n=new ENt(null),i=new MNt(t);ANt(e,t,i,n,wNt.SUMMARY),this.index[t.name]=i})))})),we.each(i.edges(),(t=>{let e=i.edge(t),n=new ENt(e);n.isFadedOut=this.index[t.v].isFadedOut||this.index[t.w].isFadedOut,r.setEdge(t.v,t.w,n)})),n.node.type===WIt.META&&(function s(t,e){(function n(t){let e=t.coreGraph;we.each(e.nodes(),(n=>{e.node(n).node.include!==qIt.EXCLUDE||n.startsWith(UIt)||(t.coreGraph.outEdges(n).length>t.coreGraph.inEdges(n).length?PNt(t,n):INt(t,n))}))})(t),gNt.length&&(function i(t){let e=t.coreGraph;we.each(e.nodes(),(n=>{let i=e.node(n);i.node.include===qIt.UNSPECIFIED&&NNt(i.node,gNt)&&PNt(t,n)}))})(t),_Nt.length&&(function r(t){let e=t.coreGraph;we.each(e.nodes(),(n=>{let i=e.node(n);i.node.include===qIt.UNSPECIFIED&&NNt(i.node,_Nt)&&INt(t,n)}))})(t),e&&(function o(t){let e=t.coreGraph,n={},i={},r=0;if(we.each(e.nodes(),(t=>{if(e.node(t).node.include!==qIt.UNSPECIFIED)return;let o=we.reduce(e.predecessors(t),((n,i)=>n+(e.edge(i,t).metaedge.numRegularEdges?1:0)),0);0===o&&e.predecessors(t).length>0&&(o=e.predecessors(t).length);let a=we.reduce(e.successors(t),((n,i)=>n+(e.edge(t,i).metaedge.numRegularEdges?1:0)),0);0===a&&e.successors(t).length>0&&(a=e.successors(t).length),n[t]=o,i[t]=a,r++})),r<15)return;let o=Math.round(.75*r),a=Math.round(.25*r),s=Object.keys(n).sort(((t,e)=>n[t]-n[e])),l=n[s[o]],c=l+l-n[s[a]];c=Math.max(c,4);for(let e=r-1;n[s[e]]>c;e--)INt(t,s[e]);let u=Object.keys(i).sort(((t,e)=>i[t]-i[e])),h=i[u[o]],d=h+4*(h-i[u[a]]);d=Math.max(d,4);for(let n=r-1;i[u[n]]>d;n--){let i=e.node(u[n]);i&&!i.isInExtract&&PNt(t,u[n])}})(t),(function a(t){let e=t.coreGraph,n={};we.each(e.edges(),(t=>{e.edge(t).metaedge.numRegularEdges||((n[t.v]=n[t.v]||[]).push(t),(n[t.w]=n[t.w]||[]).push(t))})),we.each(n,((t,n)=>{t.length>4&&we.each(t,(t=>LNt(e,t.v,t.w)))}))})(t);let s=t.coreGraph;we.each(s.nodes(),(e=>{let n=s.node(e),i=s.neighbors(e).length;if(n.node.include===qIt.UNSPECIFIED&&0===i){let i=n.outAnnotations.list.length>0,r=n.inAnnotations.list.length>0;n.isInExtract?(t.isolatedInExtract.push(n),n.node.include=qIt.EXCLUDE,s.removeNode(e)):n.isOutExtract?(t.isolatedOutExtract.push(n),n.node.include=qIt.EXCLUDE,s.removeNode(e)):i&&!r?(n.isInExtract=!0,t.isolatedInExtract.push(n),n.node.include=qIt.EXCLUDE,s.removeNode(e)):r&&!i&&(n.isOutExtract=!0,t.isolatedOutExtract.push(n),n.node.include=qIt.EXCLUDE,s.removeNode(e))}}))})(n,this.autoExtractNodes),we.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(i),t===jIt&&we.forOwn(this.hierarchy.libraryFunctions,((t,e)=>{const i=t.node,o=this.getOrCreateRenderNodeByName(i.name);n.libraryFunctionsExtract.push(o),o.node.include=qIt.EXCLUDE,r.removeNode(i.name)}));let l=n.node.parentNode;if(!l)return;let c=this.index[l.name],u=(t,...e)=>e.concat([t?"IN":"OUT"]).join("~~"),h=this.hierarchy.getBridgegraph(t),d={in:{},out:{},control:{}};we.each(h.edges(),(t=>{let e=!!i.node(t.w),n=e?t.v:t.w;h.edge(t).numRegularEdges?e?d.out[n]=(d.out[n]||0)+1:d.in[n]=(d.in[n]||0)+1:d.control[n]=(d.control[n]||0)+1}));let p=this.hierarchy.getNodeMap();we.each(h.edges(),(n=>{let o=h.edge(n),a=!!i.node(n.w),[s,f]=a?[n.w,n.v]:[n.v,n.w],m=this.index[s],g=this.index[f],_=g?g.node:p[f],y=!o.numRegularEdges&&d.control[f]>4,[,v]=a?[e.inAnnotations,m.inAnnotations]:[e.outAnnotations,m.outAnnotations],b=null,x=!1;if(!((a?d.out:d.in)[f]>4)&&!y&&m.isInCore()){let e=e=>c.coreGraph.edge(a?{v:e,w:t}:{v:t,w:e});b=e(f),b||(b=e(u(a,f,l.name))),x=!!b}let w=!1;if(b&&!o.numRegularEdges){let t=b,e=c.node;for(;t.adjoiningMetaedge;)t=t.adjoiningMetaedge,e=e.parentNode;let n=this.hierarchy.getTopologicalOrdering(e.name),i=t.metaedge;w=n[i.v]>n[i.w]}if(x=x&&!w,!x)return void v.push(new xNt(_,g,new ENt(o),wNt.SHORTCUT,a));let S=u(a,t),M=u(a,f,t),E=r.node(M);if(!E){let t=r.node(S);t||(t=new MNt({name:S,type:WIt.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:qIt.UNSPECIFIED,inbound:a,nodeAttributes:{}}),this.index[S]=t,r.setNode(S,t)),E=new MNt({name:M,type:WIt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:qIt.UNSPECIFIED,inbound:a,nodeAttributes:{}}),this.index[M]=E,r.setNode(M,E),r.setParent(M,S),t.node.cardinality++}let T=new ENt(o);T.adjoiningMetaedge=b,a?r.setEdge(M,s,T):r.setEdge(s,M,T)})),we.each([!0,!1],(e=>{let n=u(e,t),i=r.node(n);i&&we.each(r.nodes(),(o=>{if(r.node(o).node.type===WIt.BRIDGE)return;if(!(e?!r.predecessors(o).length:!r.successors(o).length))return;let a=u(e,t,"STRUCTURAL_TARGET"),s=r.node(a);s||(s=new MNt({name:a,type:WIt.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:qIt.UNSPECIFIED,inbound:e,nodeAttributes:{}}),s.structural=!0,this.index[a]=s,r.setNode(a,s),i.node.cardinality++,r.setParent(a,n));let l=new ENt(null);l.structural=!0,l.weight--,e?r.setEdge(a,o,l):r.setEdge(o,a,l)}))}))}buildSubhierarchiesForNeededFunctions(t){we.each(t.edges(),(e=>{let n=t.edge(e),i=new ENt(n);we.forEach(i.metaedge.baseEdgeList,(t=>{const e=t.v.split(VIt);for(let t=e.length;t>=0;t--){const n=e.slice(0,t),i=this.hierarchy.node(n.join(VIt));if(i){if(i.type===WIt.OP&&this.hierarchy.libraryFunctions[i.op])for(let t=1;t<n.length;t++){const e=n.slice(0,t).join(VIt);e&&this.buildSubhierarchy(e)}break}}}))}))}}class xNt{constructor(t,e,n,i,r){this.node=t,this.renderNodeInfo=e,this.renderMetaedgeInfo=n,this.annotationType=i,this.dx=0,this.dy=0,this.width=0,this.height=0,n&&n.metaedge&&(this.v=n.metaedge.v,this.w=n.metaedge.w),this.isIn=r,this.points=[]}}var wNt;!(function(t){t[t.SHORTCUT=0]="SHORTCUT",t[t.CONSTANT=1]="CONSTANT",t[t.SUMMARY=2]="SUMMARY",t[t.ELLIPSIS=3]="ELLIPSIS"})(wNt||(wNt={}));class SNt{constructor(){this.list=[],this.nodeNames={}}push(t){if(t.node.name in this.nodeNames)return;if(this.nodeNames[t.node.name]=!0,this.list.length<5)return void this.list.push(t);let e=this.list[this.list.length-1];if(e.annotationType===wNt.ELLIPSIS){let t=e.node;return void t.setNumMoreNodes(++t.numMoreNodes)}let n=new $It(1);this.list.push(new xNt(n,new MNt(n),null,wNt.ELLIPSIS,t.isIn))}}class MNt{constructor(t){if(this.node=t,this.expanded=!1,this.inAnnotations=new SNt,this.outAnnotations=new SNt,this.x=0,this.y=0,this.width=0,this.height=0,this.inboxWidth=0,this.outboxWidth=0,this.excluded=!1,this.structural=!1,this.labelOffset=0,this.radius=0,this.labelHeight=0,this.paddingTop=0,this.paddingLeft=0,this.paddingRight=0,this.paddingBottom=0,this.isInExtract=!1,this.isOutExtract=!1,this.coreBox={width:0,height:0},this.isFadedOut=!1,this.displayName=t.name.substring(t.name.lastIndexOf(VIt)+1),t.type===WIt.META&&t.associatedFunction){const t=this.displayName.match(vNt);t?this.displayName=t[1]:we.startsWith(this.displayName,UIt)&&(this.displayName=this.displayName.substring(UIt.length))}}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}}class ENt{constructor(t){this.metaedge=t,this.adjoiningMetaedge=null,this.structural=!1,this.weight=1,this.isFadedOut=!1}}function TNt(t,e,n,i,r){let o=new xNt(e,n,i,r,!0);t.inAnnotations.push(o)}function ANt(t,e,n,i,r){let o=new xNt(e,n,i,r,!1);t.outAnnotations.push(o)}class CNt extends MNt{constructor(t,e){super(t);let n=t.metagraph.graph();this.coreGraph=sNt(n.name,GIt.CORE,e),this.inExtractBox={width:0,height:0},this.outExtractBox={width:0,height:0},this.libraryFunctionsBox={width:0,height:0},this.isolatedInExtract=[],this.isolatedOutExtract=[],this.libraryFunctionsExtract=[]}}function kNt(t,e){t.coreGraph&&(function n(t,e){we.each(t.nodes(),(n=>{let i=t.node(n);if(i.expanded=e>1,e>0)switch(i.node.type){case WIt.META:case WIt.SERIES:kNt(i,e-1)}}))})(t.coreGraph,e)}function LNt(t,e,n){let i=t.node(e),r=t.node(n),o=t.edge(e,n);(i.node.include!==qIt.INCLUDE&&r.node.include!==qIt.INCLUDE||i.node.include===qIt.EXCLUDE||r.node.include===qIt.EXCLUDE)&&(ANt(i,r.node,r,o,wNt.SHORTCUT),TNt(r,i.node,i,o,wNt.SHORTCUT),t.removeEdge(e,n))}function PNt(t,e,n){let i=t.coreGraph,r=i.node(e);r.isOutExtract=!0,we.each(i.predecessors(e),((t,n)=>{LNt(i,t,e)})),we.each(i.successors(e),((t,n)=>{LNt(i,e,t)})),0===i.neighbors(e).length&&(r.node.include=qIt.EXCLUDE,t.isolatedOutExtract.push(r),i.removeNode(e))}function INt(t,e,n){let i=t.coreGraph,r=i.node(e);r.isInExtract=!0,we.each(i.successors(e),((t,n)=>{LNt(i,e,t)})),we.each(i.predecessors(e),((t,n)=>{LNt(i,t,e)})),0===i.neighbors(e).length&&(r.node.include=qIt.EXCLUDE,t.isolatedInExtract.push(r),i.removeNode(e))}function NNt(t,e){if(t.type===WIt.OP){for(let n=0;n<e.length;n++)if(t.op===e[n])return!0}else if(t.type===WIt.META){let n=t.getRootOp();if(n)for(let t=0;t<e.length;t++)if(n.op===e[t])return!0}return!1}const ONt={animation:{duration:250},graph:{meta:{nodeSep:5,rankSep:25,edgeSep:5},series:{nodeSep:5,rankSep:25,edgeSep:5},padding:{paddingTop:40,paddingLeft:20}},subscene:{meta:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:20,extractXOffset:15,extractYOffset:20},series:{paddingTop:10,paddingBottom:10,paddingLeft:10,paddingRight:10,labelHeight:10}},nodeSize:{meta:{radius:5,width:60,maxLabelWidth:52,height:zM().domain([1,200]).range([15,60]).clamp(!0),expandButtonRadius:3},op:{width:15,height:6,radius:3,labelOffset:-8,maxLabelWidth:30},series:{expanded:{radius:10,labelOffset:0},vertical:{width:16,height:13,labelOffset:-13},horizontal:{width:24,height:8,radius:10,labelOffset:-10}},bridge:{width:20,height:20,radius:2,labelOffset:0}},shortcutSize:{op:{width:10,height:4},meta:{width:12,height:4,radius:1},series:{width:14,height:4}},annotations:{inboxWidth:50,outboxWidth:50,xOffset:10,yOffset:3,labelOffset:2,maxLabelWidth:40},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}},RNt=140;function zNt(t){t.node.isGroupNode&&(function e(t){let e=t.coreGraph.nodes().map((e=>t.coreGraph.node(e))).concat(t.isolatedInExtract,t.isolatedOutExtract,t.libraryFunctionsExtract);we.each(e,(t=>{switch(t.node.type){case WIt.OP:we.extend(t,ONt.nodeSize.op);break;case WIt.BRIDGE:we.extend(t,ONt.nodeSize.bridge);break;case WIt.META:t.expanded?zNt(t):(we.extend(t,ONt.nodeSize.meta),t.height=ONt.nodeSize.meta.height(t.node.cardinality));break;case WIt.SERIES:t.expanded?(we.extend(t,ONt.nodeSize.series.expanded),zNt(t)):we.extend(t,t.node.hasNonControlEdges?ONt.nodeSize.series.vertical:ONt.nodeSize.series.horizontal);break;default:throw Error("Unrecognized node type: "+t.node.type)}t.expanded||(function e(t){t.inboxWidth=t.inAnnotations.list.length>0?ONt.annotations.inboxWidth:0,t.outboxWidth=t.outAnnotations.list.length>0?ONt.annotations.outboxWidth:0,t.coreBox.width=t.width,t.coreBox.height=t.height,t.width=Math.max(t.coreBox.width+t.inboxWidth+t.outboxWidth,3*t.displayName.length)})(t),(function n(t){if(t.expanded)return;let e=t.inAnnotations.list,n=t.outAnnotations.list;we.each(e,(t=>BNt(t))),we.each(n,(t=>BNt(t)));let i=ONt.annotations,r=we.reduce(e,((e,n,r)=>{let o=r>0?i.yOffset:0;return n.dx=-(t.coreBox.width+n.width)/2-i.xOffset,n.dy=e+o+n.height/2,e+o+n.height}),0);we.each(e,(t=>{t.dy-=r/2,t.labelOffset=i.labelOffset}));let o=we.reduce(n,((e,n,r)=>{let o=r>0?i.yOffset:0;return n.dx=(t.coreBox.width+n.width)/2+i.xOffset,n.dy=e+o+n.height/2,e+o+n.height}),0);we.each(n,(t=>{t.dy-=o/2,t.labelOffset=i.labelOffset}));let a=Math.min(t.height/2-t.radius,r/2);a=a<0?0:a;let s=zM().domain([0,e.length-1]).range([-a,a]);we.each(e,((n,i)=>{n.points=[{dx:n.dx+n.width/2,dy:n.dy},{dx:-t.coreBox.width/2,dy:e.length>1?s(i):0}]}));let l=Math.min(t.height/2-t.radius,o/2);l=l<0?0:l;let c=zM().domain([0,n.length-1]).range([-l,l]);we.each(n,((e,i)=>{e.points=[{dx:t.coreBox.width/2,dy:n.length>1?c(i):0},{dx:e.dx-e.width/2,dy:e.dy}]})),t.height=Math.max(t.height,r,o)})(t)}))})(t),t.node.type===WIt.META?(function n(t){let e=ONt.subscene.meta;we.extend(t,e),we.extend(t.coreBox,DNt(t.coreGraph,ONt.graph.meta));let n=t.isolatedInExtract.length?we.maxBy(t.isolatedInExtract,(t=>t.width)).width:null;t.inExtractBox.width=null!=n?n:0,t.inExtractBox.height=we.reduce(t.isolatedInExtract,((t,n,i)=>{let r=i>0?e.extractYOffset:0;return n.x=0,n.y=t+r+n.height/2,t+r+n.height}),0);let i=t.isolatedOutExtract.length?we.maxBy(t.isolatedOutExtract,(t=>t.width)).width:null;t.outExtractBox.width=null!=i?i:0,t.outExtractBox.height=we.reduce(t.isolatedOutExtract,((t,n,i)=>{let r=i>0?e.extractYOffset:0;return n.x=0,n.y=t+r+n.height/2,t+r+n.height}),0);let r=t.libraryFunctionsExtract.length?we.maxBy(t.libraryFunctionsExtract,(t=>t.width)).width:null;t.libraryFunctionsBox.width=null!=r?r:0,t.libraryFunctionsBox.height=we.reduce(t.libraryFunctionsExtract,((t,n,i)=>{let r=i>0?e.extractYOffset:0;return n.x=0,n.y=t+r+n.height/2,t+r+n.height}),0);let o=0;t.isolatedInExtract.length>0&&o++,t.isolatedOutExtract.length>0&&o++,t.libraryFunctionsExtract.length>0&&o++,t.coreGraph.nodeCount()>0&&o++;let a=o<=1?0:o*ONt.subscene.meta.extractXOffset;const s=Math.max(RNt,t.inExtractBox.width+t.outExtractBox.width);t.coreBox.width+=s+a+t.libraryFunctionsBox.width+a,t.coreBox.height=e.labelHeight+Math.max(t.inExtractBox.height,t.coreBox.height,t.libraryFunctionsBox.height,t.outExtractBox.height),t.width=t.coreBox.width+e.paddingLeft+e.paddingRight,t.height=t.paddingTop+t.coreBox.height+t.paddingBottom})(t):t.node.type===WIt.SERIES&&(function i(t){let e=t.coreGraph,n=ONt.subscene.series;we.extend(t,n),we.extend(t.coreBox,DNt(t.coreGraph,ONt.graph.series)),we.each(e.nodes(),(t=>{e.node(t).excluded=!1})),t.width=t.coreBox.width+n.paddingLeft+n.paddingRight,t.height=t.coreBox.height+n.paddingTop+n.paddingBottom})(t)}function DNt(t,e){we.extend(t.graph(),{nodesep:e.nodeSep,ranksep:e.rankSep,edgesep:e.edgeSep});let n=[];if(we.each(t.nodes(),(e=>{t.node(e).node.type===WIt.BRIDGE||n.push(e)})),!n.length)return{width:0,height:0};gIt.layout(t);let i=1/0,r=1/0,o=-1/0,a=-1/0;return we.each(n,(e=>{let n=t.node(e),s=.5*n.width,l=n.x-s,c=n.x+s;i=l<i?l:i,o=c>o?c:o;let u=.5*n.height,h=n.y-u,d=n.y+u;r=h<r?h:r,a=d>a?d:a})),we.each(t.edges(),(e=>{let n=t.edge(e);if(n.structural)return;let s=t.node(n.metaedge.v),l=t.node(n.metaedge.w);if(3===n.points.length&&(function c(t){let e=FNt(t[0],t[1]);for(let n=1;n<t.length-1;n++){let i=FNt(t[n],t[n+1]);if(Math.abs(i-e)>1)return!1;e=i}return!0})(n.points)){if(null!=s){let t=s.expanded?s.x:HNt(s);n.points[0].x=t}if(null!=l){let t=l.expanded?l.x:HNt(l);n.points[2].x=t}n.points=[n.points[0],n.points[1]]}null!=l&&(n.points[n.points.length-1]=VNt(n.points[n.points.length-2],l)),null!=s&&(n.points[0]=VNt(n.points[1],s)),we.each(n.points,(t=>{i=t.x<i?t.x:i,o=t.x>o?t.x:o,r=t.y<r?t.y:r,a=t.y>a?t.y:a}))})),we.each(t.nodes(),(e=>{let n=t.node(e);n.x-=i,n.y-=r})),we.each(t.edges(),(e=>{we.each(t.edge(e).points,(t=>{t.x-=i,t.y-=r}))})),{width:o-i,height:a-r}}function BNt(t){switch(t.annotationType){case wNt.CONSTANT:we.extend(t,ONt.constant.size);break;case wNt.SHORTCUT:if(t.node.type===WIt.OP)we.extend(t,ONt.shortcutSize.op);else if(t.node.type===WIt.META)we.extend(t,ONt.shortcutSize.meta);else{if(t.node.type!==WIt.SERIES)throw Error("Invalid node type: "+t.node.type);we.extend(t,ONt.shortcutSize.series)}break;case wNt.SUMMARY:we.extend(t,ONt.constant.size)}}function HNt(t){return t.expanded?t.x:t.x-t.width/2+(t.inAnnotations.list.length?t.inboxWidth:0)+t.coreBox.width/2}function FNt(t,e){return 180*Math.atan((e.y-t.y)/(e.x-t.x))/Math.PI}function VNt(t,e){let n,i,r=e.expanded?e.x:HNt(e),o=e.y,a=t.x-r,s=t.y-o,l=e.expanded?e.width:e.coreBox.width,c=e.expanded?e.height:e.coreBox.height;return Math.abs(s)*l/2>Math.abs(a)*c/2?(s<0&&(c=-c),n=0===s?0:c/2*a/s,i=c/2):(a<0&&(l=-l),n=l/2,i=0===a?0:l/2*s/a),{x:r+n,y:o+i}}const jNt=SIt,UNt=xIt;let GNt=[{background_color:"#CC2F2C",label:"NaN"},{background_color:"#FF8D00",label:"-∞"},{background_color:"#EAEAEA",label:"-"},{background_color:"#A5A5A5",label:"0"},{background_color:"#262626",label:"+"},{background_color:"#003ED4",label:"+∞"}];function WNt(t,e,n){null!=t.attr("transform")&&(t=t.transition("position")),t.attr("transform","translate("+e+","+n+")")}function qNt(t,e,n,i,r){t.transition().attr("x",e-i/2).attr("y",n-r/2).attr("width",i).attr("height",r)}function YNt(t,e,n,i,r){t.transition().attr("cx",e).attr("cy",n).attr("rx",i/2).attr("ry",r/2)}function XNt(t,e){return e?t.toFixed(0):Math.abs(t)>=1?t.toFixed(1):t.toExponential(1)}let $Nt=class extends(tr(ye)){constructor(){super(...arguments),this.specificHealthPillStep=0,this.healthPillEntries=GNt}ready(){super.ready();var t=document.getElementById("mainContainer"),e=document.querySelector("tf-dashboard-layout .scrollbar");t&&e&&(t.style.overflow="hidden",e.style.overflow="hidden")}_healthPillsAvailable(t,e){return t&&e}_computeTensorCountString(t,e){return t?t[e].toFixed(0):""}get healthPillValuesForSelectedNode(){var t=this.selectedNode;if(this.areHealthPillsLoading)return null;if(!t)return null;const e=this.nodeNamesToHealthPills[t];if(!e)return null;const n=e[this.allStepsModeEnabled?0:this.healthPillStepIndex];return n?n.value.slice(2,8):null}get _currentStepDisplayValue(){var t=this.nodeNamesToHealthPills,e=this.healthPillStepIndex,n=this.areHealthPillsLoading;if(this.allStepsModeEnabled)return this.specificHealthPillStep.toFixed(0);if(n)return 0;for(let n in t)return t[n][e].step.toFixed(0);return 0}get _biggestStepEverSeen(){var t=this.nodeNamesToHealthPills;for(let n in t){var e=t[n];return Math.max(this._biggestStepEverSeen,e[e.length-1].step)}return this._biggestStepEverSeen||0}get _maxStepIndex(){var t=this.nodeNamesToHealthPills;for(let e in t)return t[e].length-1;return 0}_hasDebuggerNumericAlerts(t){return t&&t.length}_updateAlertsList(){var t=this.debuggerNumericAlerts,e=this.$$("#numeric-alerts-body");if(e){e.innerText="";for(var n=0;n<t.length;n++){var i=t[n],r=document.createElement("tr"),o=document.createElement("td");o.innerText=(f=i.first_timestamp,(m=+new Date-+new Date(f/1e3))<3e4?"just now":m<6e4?Math.floor(m/1e3)+" seconds ago":m<12e4?"a minute ago":m<36e5?Math.floor(m/6e4)+" minutes ago":1==Math.floor(m/36e5)?"an hour ago":m<864e5?Math.floor(m/36e5)+" hours ago":m<1728e5?"yesterday":Math.floor(m/864e5)+" days ago"),o.classList.add("first-offense-td"),r.appendChild(o);var a=document.createElement("td");a.classList.add("tensor-device-td");var s=document.createElement("div");s.classList.add("tensor-section-within-table"),s.innerText=i.tensor_name,this._addOpExpansionListener(s,i.tensor_name),a.appendChild(s);var l=document.createElement("div");l.classList.add("device-section-within-table"),l.innerText="("+i.device_name+")",a.appendChild(l),r.appendChild(a);var c=document.createElement("div");c.classList.add("mini-health-pill");var u=document.createElement("td");if(u.classList.add("mini-health-pill-td"),u.appendChild(c),r.appendChild(u),i.neg_inf_event_count){var h=document.createElement("div");h.classList.add("negative-inf-mini-health-pill-section"),h.innerText=i.neg_inf_event_count,h.setAttribute("title",i.neg_inf_event_count+" events with -∞"),c.appendChild(h)}if(i.pos_inf_event_count){var d=document.createElement("div");d.classList.add("positive-inf-mini-health-pill-section"),d.innerText=i.pos_inf_event_count,d.setAttribute("title",i.pos_inf_event_count+" events with +∞"),c.appendChild(d)}if(i.nan_event_count){var p=document.createElement("div");p.classList.add("nan-mini-health-pill-section"),p.innerText=i.nan_event_count,p.setAttribute("title",i.nan_event_count+" events with NaN"),c.appendChild(p)}qi(e).appendChild(r)}var f,m}}_addOpExpansionListener(t,e){t.addEventListener("click",(()=>{var t,n=(function i(t,e,n){const i=n.split("/"),r=i[i.length-1].match(/(.*):\w+/);2===r.length&&(i[i.length-1]=r[1]);let o=i[0],a=e.getRenderNodeByName(o);for(let n=1;n<i.length&&a.node.type!==WIt.OP;n++)e.buildSubhierarchy(o),a.expanded=!0,t.setNodeExpanded(a),o+="/"+i[n],a=e.getRenderNodeByName(o);return a.node.name})(document.getElementById("scene"),this.renderHierarchy,e),r=document.querySelector("tf-graph-info#graph-info");r&&(t=r.scrollHeight-r.scrollTop);var o=this.selectedNode;this.set("selectedNode",n);var a=()=>{r.scrollTop=r.scrollHeight-t};r&&(o?a():window.setTimeout(a,20))}))}};var KNt;$Nt.template=_e`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }

      .health-pill-legend {
        padding: 15px;
      }

      .health-pill-legend h2 {
        text-align: left;
      }

      .health-pill-entry {
        margin: 10px 10px 10px 0;
      }

      .health-pill-entry .color-preview {
        width: 26px;
        height: 26px;
        border-radius: 3px;
        display: inline-block;
        margin: 0 10px 0 0;
      }

      .health-pill-entry .color-label,
      .health-pill-entry .tensor-count {
        color: #777;
        display: inline-block;
        height: 26px;
        font-size: 22px;
        line-height: 26px;
        vertical-align: top;
      }

      .health-pill-entry .tensor-count {
        float: right;
      }

      #health-pill-step-slider {
        width: 100%;
        margin: 0 0 0 -15px;
        /* 31 comes from adding a padding of 15px from both sides of the paper-slider, subtracting
   * 1px so that the slider width aligns with the image (the last slider marker takes up 1px),
   * and adding 2px to account for a border of 1px on both sides of the image. 30 - 1 + 2.
   * Apparently, the paper-slider lacks a mixin for those padding values. */
        width: calc(100% + 31px);
      }

      #health-pills-loading-spinner {
        width: 20px;
        height: 20px;
        vertical-align: top;
      }

      #health-pill-step-number-input {
        text-align: center;
        vertical-align: top;
      }

      #numeric-alerts-table-container {
        max-height: 400px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      #numeric-alerts-table {
        text-align: left;
      }

      #numeric-alerts-table td {
        vertical-align: top;
      }

      #numeric-alerts-table .first-offense-td {
        display: inline-block;
      }

      .first-offense-td {
        width: 80px;
      }

      .tensor-device-td {
        max-width: 140px;
        word-wrap: break-word;
      }

      .tensor-section-within-table {
        color: #266236;
        cursor: pointer;
        opacity: 0.8;
        text-decoration: underline;
      }

      .tensor-section-within-table:hover {
        opacity: 1;
      }

      .device-section-within-table {
        color: #666;
      }

      .mini-health-pill {
        width: 130px;
      }

      .mini-health-pill > div {
        height: 100%;
        width: 60px;
        border-radius: 3px;
      }

      #event-counts-th {
        padding: 0 0 0 10px;
      }

      .negative-inf-mini-health-pill-section {
        background: rgb(255, 141, 0);
        width: 20px;
      }

      .positive-inf-mini-health-pill-section {
        background: rgb(0, 62, 212);
        width: 20px;
      }

      .nan-mini-health-pill-section {
        background: rgb(204, 47, 44);
        width: 20px;
      }

      .negative-inf-mini-health-pill-section,
      .positive-inf-mini-health-pill-section,
      .nan-mini-health-pill-section {
        color: #fff;
        display: inline-block;
        height: 100%;
        line-height: 20px;
        margin: 0 0 0 10px;
        text-align: center;
      }

      .no-numeric-alerts-notification {
        margin: 0;
      }
    </style>
    <paper-material elevation="1" class="card health-pill-legend">
      <div class="title">
        Enable all (not just sampled) steps. Requires slow disk read.
      </div>
      <paper-toggle-button
        id="enableAllStepsModeToggle"
        checked="{{allStepsModeEnabled}}"
      >
      </paper-toggle-button>
      <h2>
        Step of Health Pills:
        <template is="dom-if" if="[[allStepsModeEnabled]]">
          <input
            type="number"
            id="health-pill-step-number-input"
            min="0"
            max="[[_biggestStepEverSeen]]"
            value="{{specificHealthPillStep::input}}"
          />
        </template>
        <template is="dom-if" if="[[!allStepsModeEnabled]]">
          [[_currentStepDisplayValue]]
        </template>
        <paper-spinner-lite
          active
          hidden$="[[!areHealthPillsLoading]]"
          id="health-pills-loading-spinner"
        ></paper-spinner-lite>
      </h2>
      <template is="dom-if" if="[[allStepsModeEnabled]]">
        <paper-slider
          id="health-pill-step-slider"
          immediate-value="{{specificHealthPillStep}}"
          max="[[_biggestStepEverSeen]]"
          snaps
          step="1"
          value="{{specificHealthPillStep}}"
        ></paper-slider>
      </template>
      <template is="dom-if" if="[[!allStepsModeEnabled]]">
        <template is="dom-if" if="[[_maxStepIndex]]">
          <paper-slider
            id="health-pill-step-slider"
            immediate-value="{{healthPillStepIndex}}"
            max="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{healthPillStepIndex}}"
          ></paper-slider>
        </template>
      </template>
      <h2>
        Health Pill
        <template is="dom-if" if="[[healthPillValuesForSelectedNode]]">
          Counts for Selected Node
        </template>
        <template is="dom-if" if="[[!healthPillValuesForSelectedNode]]">
          Legend
        </template>
      </h2>
      <template is="dom-repeat" items="[[healthPillEntries]]">
        <div class="health-pill-entry">
          <div
            class="color-preview"
            style="background:[[item.background_color]]"
          ></div>
          <div class="color-label">[[item.label]]</div>
          <div class="tensor-count">
            [[_computeTensorCountString(healthPillValuesForSelectedNode,
            index)]]
          </div>
        </div>
      </template>
      <div hidden$="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]">
        <h2 id="numeric-alerts-header">Numeric Alerts</h2>
        <p>Alerts are sorted from top to bottom by increasing timestamp.</p>
        <div id="numeric-alerts-table-container">
          <table id="numeric-alerts-table">
            <thead>
              <tr>
                <th>First Offense</th>
                <th>Tensor (Device)</th>
                <th id="event-counts-th">Event Counts</th>
              </tr>
            </thead>
            <tbody id="numeric-alerts-body"></tbody>
          </table>
        </div>
      </div>
      <template
        is="dom-if"
        if="[[!_hasDebuggerNumericAlerts(debuggerNumericAlerts)]]"
      >
        <p class="no-numeric-alerts-notification">
          No numeric alerts so far. That is likely good. Alerts indicate the
          presence of NaN or (+/-) Infinity values, which may be concerning.
        </p>
      </template>
    </paper-material>
  `,t([o({type:Object}),e("design:type",bNt)],$Nt.prototype,"renderHierarchy",void 0),t([o({type:Array,notify:!0}),e("design:type",Object)],$Nt.prototype,"debuggerNumericAlerts",void 0),t([o({type:Object}),e("design:type",Object)],$Nt.prototype,"nodeNamesToHealthPills",void 0),t([o({type:Number,notify:!0}),e("design:type",Object)],$Nt.prototype,"healthPillStepIndex",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],$Nt.prototype,"specificHealthPillStep",void 0),t([o({type:String,notify:!0}),e("design:type",Object)],$Nt.prototype,"selectedNode",void 0),t([o({type:String,notify:!0}),e("design:type",Object)],$Nt.prototype,"highlightedNode",void 0),t([o({type:Number,notify:!0}),e("design:type",Object)],$Nt.prototype,"selectedNodeInclude",void 0),t([o({type:Boolean}),e("design:type",Object)],$Nt.prototype,"areHealthPillsLoading",void 0),t([o({type:Array}),e("design:type",Array)],$Nt.prototype,"healthPillEntries",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Object)],$Nt.prototype,"allStepsModeEnabled",void 0),t([s("nodeNamesToHealthPills","healthPillStepIndex","selectedNode","allStepsModeEnabled","areHealthPillsLoading"),e("design:type",Array),e("design:paramtypes",[])],$Nt.prototype,"healthPillValuesForSelectedNode",null),t([s("nodeNamesToHealthPills","healthPillStepIndex","allStepsModeEnabled","specificHealthPillStep","areHealthPillsLoading"),e("design:type",Object),e("design:paramtypes",[])],$Nt.prototype,"_currentStepDisplayValue",null),t([s("nodeNamesToHealthPills"),e("design:type",Number),e("design:paramtypes",[])],$Nt.prototype,"_biggestStepEverSeen",null),t([s("nodeNamesToHealthPills"),e("design:type",Number),e("design:paramtypes",[])],$Nt.prototype,"_maxStepIndex",null),t([a("debuggerNumericAlerts"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],$Nt.prototype,"_updateAlertsList",null),$Nt=t([i("tf-graph-debugger-data-card")],$Nt),(function(t){t.CONST="CONST",t.META="META",t.OP="OP",t.SERIES="SERIES",t.SUMMARY="SUMMARY"})(KNt||(KNt={}));let ZNt=class extends(tr(ye)){constructor(){super(...arguments),this.vertical=!1,this.fillOverride=null,this.strokeOverride=null,this.height=20,this.faded=!1}getSvgDefinableElement(){return this.$.svgDefs}get _fill(){var t=this.fillOverride;if(null!=t)return t;switch(this.type){case KNt.META:return mNt.DEFAULT_FILL;case KNt.SERIES:return"white";default:return"#ffffff"}}get _stroke(){var t=this.strokeOverride;if(null!=t)return t;switch(this.type){case KNt.META:return mNt.DEFAULT_STROKE;case KNt.SERIES:default:return"#b2b2b2"}}_isType(t,e){return t===e}_fadedClass(t,e){return t?"faded-"+e:""}};ZNt.template=_e`
    <style>
      :host {
        font-size: 0;
      }

      .faded-rect {
        fill: url(#rectHatch);
      }

      .faded-ellipse {
        fill: url(#ellipseHatch);
      }

      .faded-rect,
      .faded-ellipse,
      .faded-series {
        stroke: var(--tb-graph-faded) !important;
      }
      #rectHatch line,
      #ellipseHatch line {
        color: #e0d4b3 !important;
        fill: white;
        stroke: #e0d4b3 !important;
      }
    </style>
    <!-- SVG for definitions -->
    <svg height="0" width="0" id="svgDefs">
      <defs>
        <!-- Hatch patterns for faded out nodes. -->
        <pattern
          id="rectHatch"
          patternTransform="rotate(45 0 0)"
          width="5"
          height="5"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
        </pattern>
        <pattern
          id="ellipseHatch"
          patternTransform="rotate(45 0 0)"
          width="2"
          height="2"
          patternUnits="userSpaceOnUse"
        >
          <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
        </pattern>
        <!-- Template for an Op node ellipse. -->
        <ellipse
          id="op-node-stamp"
          rx="7.5"
          ry="3"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Template for an Op node annotation ellipse (smaller). -->
        <ellipse
          id="op-node-annotation-stamp"
          rx="5"
          ry="2"
          stroke="inherit"
          fill="inherit"
        ></ellipse>
        <!-- Vertically stacked series of Op nodes when unexpanded. -->
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9"></use>
          <use xlink:href="#op-node-stamp" x="8" y="6"></use>
          <use xlink:href="#op-node-stamp" x="8" y="3"></use>
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4"></use>
          <use xlink:href="#op-node-stamp" x="12" y="4"></use>
          <use xlink:href="#op-node-stamp" x="8" y="4"></use>
        </g>
        <g
          id="summary-icon"
          fill="#848484"
          height="12"
          viewBox="0 0 24 24"
          width="12"
        >
          <path
            d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
          ></path>
        </g>
      </defs>
    </svg>
    <template is="dom-if" if="[[_isType(type, 'CONST')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 10 10"
      >
        <circle
          cx="5"
          cy="5"
          r="3"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
        ></circle>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SUMMARY')]]">
      <svg
        width$="[[height]]"
        height$="[[height]]"
        viewBox="0 0 24 24"
        fill="#848484"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'OP')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 16 8"
      >
        <use
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xlink:href="#op-node-stamp"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'ellipse')}}"
          x="8"
          y="4"
        ></use>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'META')]]">
      <svg
        height$="[[height]]"
        preserveAspectRatio="xMinYMid meet"
        viewBox="0 0 37 16"
      >
        <rect
          x="1"
          y="1"
          fill$="[[_fill]]"
          stroke$="[[_stroke]]"
          class$="{{_fadedClass(faded, 'rect')}}"
          stroke-width="2px"
          height="14"
          width="35"
          rx="5"
          ry="5"
        ></rect>
      </svg>
    </template>
    <template is="dom-if" if="[[_isType(type, 'SERIES')]]">
      <template is="dom-if" if="[[vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 16 15"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-vertical-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="2"
          ></use>
        </svg>
      </template>
      <template is="dom-if" if="[[!vertical]]">
        <svg
          height$="[[height]]"
          preserveAspectRatio="xMinYMid meet"
          viewBox="0 0 24 10"
        >
          <use
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xlink:href="#op-series-horizontal-stamp"
            fill$="[[_fill]]"
            stroke$="[[_stroke]]"
            class$="{{_fadedClass(faded, 'series')}}"
            x="0"
            y="1"
          ></use>
        </svg>
      </template>
    </template>
  `,t([o({type:String}),e("design:type",String)],ZNt.prototype,"type",void 0),t([o({type:Boolean}),e("design:type",Boolean)],ZNt.prototype,"vertical",void 0),t([o({type:String}),e("design:type",String)],ZNt.prototype,"fillOverride",void 0),t([o({type:String}),e("design:type",String)],ZNt.prototype,"strokeOverride",void 0),t([o({type:Number}),e("design:type",Number)],ZNt.prototype,"height",void 0),t([o({type:Boolean}),e("design:type",Boolean)],ZNt.prototype,"faded",void 0),t([s("type","fillOverride"),e("design:type",String),e("design:paramtypes",[])],ZNt.prototype,"_fill",null),t([s("type","strokeOverride"),e("design:type",String),e("design:paramtypes",[])],ZNt.prototype,"_stroke",null),ZNt=t([i("tf-graph-icon")],ZNt);var JNt=Object.freeze({__proto__:null,get GraphIconType(){return KNt}});function QNt(t,e){const n=t.getContextMenu(),i=Su(t.getContextMenu());return function(r,o){let a=uu;const s=(function l(t){let e=0,n=0,i=t;for(;i&&i.offsetLeft>=0&&i.offsetTop>=0;)e+=i.offsetLeft-i.scrollLeft,n+=i.offsetTop-i.scrollTop,i=i.offsetParent;return{left:e,top:n}})(t);function c(t){t&&t.composedPath().includes(n)||(i.style("display","none"),document.body.removeEventListener("mousedown",c,{capture:!0}))}i.style("display","block").style("left",a.clientX-s.left+1+"px").style("top",a.clientY-s.top+1+"px"),a.preventDefault(),a.stopPropagation(),document.body.addEventListener("mousedown",c,{capture:!0}),i.html(""),i.append("ul").selectAll("li").data(e).enter().append("li").on("click",((t,e)=>{t.action(this,r,o),c()})).html((function(t){return t.title(r)}))}}let tOt=eE().domain([TIt,12]).range(["small","medium","large","xlarge"]);function eOt(t){return t.v+"--"+t.w}function nOt(t,e){let n=e.getNodeByName(t.v);if(null==n.outputShapes||we.isEmpty(n.outputShapes))return null;let i=n.outputShapes[t.outputTensorKey];return null==i?null:0===i.length?"scalar":i.map((t=>-1===t?"?":t)).join("×")}function iOt(t,e){return e.edgeLabelFunction?e.edgeLabelFunction(t,e):t.baseEdgeList.length>1?t.baseEdgeList.length+" tensors":nOt(t.baseEdgeList[0],e)}function rOt(t,e,n){const i=document.createElementNS(wIt,"path");for(let r=1;r<t.length;r++)if(i.setAttribute("d",n(t.slice(0,r))),i.getTotalLength()>e)return r-1;return t.length-1}function oOt(t,e,n){let i=Vk().x((t=>t.x)).y((t=>t.y)),r=Su(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",i(t)),o=+e.attr("markerWidth"),a=e.attr("viewBox").split(" ").map(Number),s=a[2]-a[0],l=+e.attr("refX"),c=r.node();if(n){const e=o*(1-l/s),n=c.getPointAtLength(e),r=rOt(t,e,i);return t[r-1]={x:n.x,y:n.y},t.slice(r-1)}{const e=1-l/s,n=c.getTotalLength()-o*e,r=c.getPointAtLength(n),a=rOt(t,n,i);return t[a]={x:r.x,y:r.y},t.slice(0,a+1)}}function aOt(t,e,n,i){i=i||xIt.Edge.LINE,e.label&&e.label.structural&&(i+=" "+xIt.Edge.STRUCTURAL),e.label&&e.label.metaedge&&e.label.metaedge.numRefEdges&&(i+=" "+xIt.Edge.REFERENCE_EDGE),n.handleEdgeSelected&&(i+=" "+xIt.Edge.SELECTABLE);let r,o="path_"+eOt(e);if(n.renderHierarchy.edgeWidthFunction)r=n.renderHierarchy.edgeWidthFunction(e,i);else{let t=1;null!=e.label&&null!=e.label.metaedge&&(t=e.label.metaedge.totalSize),r=n.renderHierarchy.edgeWidthSizedBasedScale(t)}let a=t.append("path").attr("id",o).attr("class",i).style("stroke-width",r+"px");if(e.label&&e.label.metaedge)if(e.label.metaedge.numRefEdges){const t=`reference-arrowhead-${tOt(r)}`;a.style("marker-start",`url(#${t})`),e.label.startMarkerId=t}else{const t=`dataflow-arrowhead-${tOt(r)}`;a.style("marker-end",`url(#${t})`),e.label.endMarkerId=t}if(null==e.label||null==e.label.metaedge)return;let s=iOt(e.label.metaedge,n.renderHierarchy);null!=s&&t.append("text").append("textPath").attr("xlink:href","#"+o).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(s)}let sOt=Vk().curve(TL).x((t=>t.x)).y((t=>t.y));var lOt;function cOt(t,e,n){let i=MIt(t,"g",xIt.Node.CONTAINER).selectAll((function(){return this.childNodes})).data(e,(t=>t.node.name+":"+t.node.type));return i.enter().append("g").attr("data-name",(t=>t.node.name)).each((function(t){let e=Su(this);n.addNodeGroup(t.node.name,e)})).merge(i).attr("class",(t=>xIt.Node.GROUP+" "+bOt(t))).each((function(t){let e=Su(this);LOt(MIt(e,"g",xIt.Annotation.INBOX),t.inAnnotations,t,n),LOt(MIt(e,"g",xIt.Annotation.OUTBOX),t.outAnnotations,t,n);let i=vOt(e,t,xIt.Node.SHAPE);t.node.isGroupNode&&(function r(t,e,n){let i=MIt(t,"g",xIt.Node.BUTTON_CONTAINER);MIt(i,"circle",xIt.Node.BUTTON_CIRCLE),MIt(i,"path",xIt.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2"),MIt(i,"path",xIt.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2"),i.on("click",(t=>{uu.stopPropagation(),n.fire("node-toggle-expand",{name:t.node.name})})),(function r(t,e){let n=HNt(e)+(e.expanded?e.width:e.coreBox.width)/2-6,i=e.y-(e.expanded?e.height:e.coreBox.height)/2+6;e.node.type!==WIt.SERIES||e.expanded||(n+=10,i-=2);let r="translate("+n+","+i+")";t.selectAll("path").transition().attr("transform",r),t.select("circle").transition().attr({cx:n,cy:i,r:ONt.nodeSize.meta.expandButtonRadius})})(i,e)})(i,t,n),hOt(i,t,n),(function o(t,e,n){if(e.node.isGroupNode){if(e.expanded)return IOt(t,e,n,xIt.Subscene.GROUP);jNt(t,"g",xIt.Subscene.GROUP).remove()}})(e,t,n),hOt((function a(t,e,n){let i=e.displayName,r=e.node.type===WIt.META&&!e.expanded,o=MIt(t,"text",xIt.Node.LABEL),a=o.node();a.parentNode.appendChild(a),o.attr("dy",".35em").attr("text-anchor","middle");let s=8;switch(e.node.type){case WIt.META:s=e.expanded?9:8;break;case WIt.OP:s=6}if(r){i.length>n.maxMetanodeLabelLength&&(i=i.substr(0,n.maxMetanodeLabelLength-2)+"…");let t=(function l(t){return _Ot||(_Ot=zM().domain([t.maxMetanodeLabelLengthLargeFont,t.maxMetanodeLabelLength]).range([t.maxMetanodeLabelLengthFontSize,t.minMetanodeLabelLengthFontSize]).clamp(!0)),_Ot})(n);o.attr("font-size",t(i.length)+"px"),s=t(i.length)}return gOt(o.text(i),e.node.type,s,e),o})(e,t,n),t,n,t.node.type===WIt.META),MOt(e,t,n),(function s(t,e){let n=jNt(t,"g",xIt.Node.SHAPE),i=HNt(e);switch(e.node.type){case WIt.OP:{const r=e.node;we.isNumber(r.functionInputIndex)||we.isNumber(r.functionOutputIndex)?(function r(t,e,n,i,o){const a=o/2,s=i/2,l=[[e,n-a],[e+s,n+a],[e-s,n+a]];t.transition().attr("points",l.map((t=>t.join(","))).join(" "))})(jNt(n,"polygon"),e.x,e.y,e.coreBox.width,e.coreBox.height):YNt(jNt(n,"ellipse"),i,e.y,e.coreBox.width,e.coreBox.height),yOt(t,i,e.y,e.labelOffset);break}case WIt.META:{let r=n.selectAll("rect");e.expanded?(qNt(r,e.x,e.y,e.width,e.height),uOt(t,e),yOt(t,i,e.y,-e.height/2+e.labelHeight/2)):(qNt(r,i,e.y,e.coreBox.width,e.coreBox.height),yOt(t,i,e.y,0));break}case WIt.SERIES:{let r=jNt(n,"use");e.expanded?(qNt(r,e.x,e.y,e.width,e.height),uOt(t,e),yOt(t,i,e.y,-e.height/2+e.labelHeight/2)):(qNt(r,i,e.y,e.coreBox.width,e.coreBox.height),yOt(t,i,e.y,e.labelOffset));break}case WIt.BRIDGE:qNt(jNt(n,"rect"),e.x,e.y,e.width,e.height);break;default:throw Error("Unrecognized node type: "+e.node.type)}})(e,t)})),i.exit().each((function(t){n.removeNodeGroup(t.node.name);let e=Su(this);t.inAnnotations.list.length>0&&e.select("."+xIt.Annotation.INBOX).selectAll("."+xIt.Annotation.GROUP).each((e=>{n.removeAnnotationGroup(e,t)})),t.outAnnotations.list.length>0&&e.select("."+xIt.Annotation.OUTBOX).selectAll("."+xIt.Annotation.GROUP).each((e=>{n.removeAnnotationGroup(e,t)}))})).remove(),i}function uOt(t,e){let n=e.x-e.width/2+e.paddingLeft,i=e.y-e.height/2+e.paddingTop;WNt(jNt(t,"g",xIt.Subscene.GROUP),n,i)}function hOt(t,e,n,i){if(i)return void t.attr("pointer-events","none");let r=QNt(n,dOt(e.node,n));t.on("dblclick",(t=>{n.fire("node-toggle-expand",{name:t.node.name})})).on("mouseover",(t=>{n.isNodeExpanded(t)||n.fire("node-highlight",{name:t.node.name})})).on("mouseout",(t=>{n.isNodeExpanded(t)||n.fire("node-unhighlight",{name:t.node.name})})).on("click",(t=>{uu.stopPropagation(),n.fire("node-select",{name:t.node.name})})).on("contextmenu",((t,e)=>{n.fire("node-select",{name:t.node.name}),r.call(t,e)}))}function dOt(t,e){let n=[{title:e=>dNt(t.include),action:(n,i,r)=>{e.fire("node-toggle-extract",{name:t.name})}}];return e.nodeContextMenuItems&&(n=n.concat(e.nodeContextMenuItems)),pOt(t)&&n.push({title:e=>mOt(t),action:(n,i,r)=>{e.fire("node-toggle-seriesgroup",{name:fOt(t)})}}),n}function pOt(t){return null!==fOt(t)}function fOt(t){return t?t.type===WIt.SERIES?t.name:t.type===WIt.OP?t.owningSeries:null:null}function mOt(t){return(function n(t){return t===YIt.GROUP?"Ungroup this series of nodes":"Group this series of nodes"})(null!==(function e(t){let e=null;return t?(t.type===WIt.SERIES?e=t:t.parentNode&&t.parentNode.type===WIt.SERIES&&(e=t.parentNode),e):null})(t)?YIt.GROUP:YIt.UNGROUP)}function gOt(t,e,n,i){let r=t.node(),o=r.textContent,a=null;switch(e){case WIt.META:i&&!i.expanded&&(a=ONt.nodeSize.meta.maxLabelWidth);break;case WIt.OP:a=ONt.nodeSize.op.maxLabelWidth;break;case-1:a=ONt.annotations.maxLabelWidth}if(null!==a)return r.textContent=(function s(t,e,n){if(!t)return"";if(FIt(t,e)<=n)return t;let i=0,r=t.length;for(;i<r;){const o=i+Math.round((r-i)/2);FIt(t.slice(0,o)+"…",e)<=n?i=o:r=o-1}return 0===i?t[0]:t.slice(0,i)+"…"})(r.textContent,n,a),t.append("title").text(o)}!(function(t){t.NONE="none",t.COMPUTE_TIME="compute_time",t.DEVICE="device",t.MEMORY="memory",t.OP_COMPATIBILITY="op_compatibility",t.STRUCTURE="structure",t.XLA_CLUSTER="xla_cluster"})(lOt||(lOt={}));let _Ot=null;function yOt(t,e,n,i){jNt(t,"text",xIt.Node.LABEL).transition().attr("x",e).attr("y",n+i)}function vOt(t,e,n){let i=MIt(t,"g",n);switch(e.node.type){case WIt.OP:const t=e.node;if(we.isNumber(t.functionInputIndex)||we.isNumber(t.functionOutputIndex)){MIt(i,"polygon",xIt.Node.COLOR_TARGET);break}MIt(i,"ellipse",xIt.Node.COLOR_TARGET);break;case WIt.SERIES:let n="annotation",r=e;r.coreGraph&&(n=r.node.hasNonControlEdges?"vertical":"horizontal");let o=[xIt.Node.COLOR_TARGET];r.isFadedOut&&o.push("faded-ellipse"),MIt(i,"use",o).attr("xlink:href","#op-series-"+n+"-stamp"),MIt(i,"rect",xIt.Node.COLOR_TARGET).attr("rx",e.radius).attr("ry",e.radius);break;case WIt.BRIDGE:case WIt.META:MIt(i,"rect",xIt.Node.COLOR_TARGET).attr("rx",e.radius).attr("ry",e.radius);break;default:throw Error("Unrecognized node type: "+e.node.type)}return i}function bOt(t){switch(t.node.type){case WIt.OP:return xIt.OPNODE;case WIt.META:return xIt.METANODE;case WIt.SERIES:return xIt.SERIESNODE;case WIt.BRIDGE:return xIt.BRIDGENODE;case WIt.ELLIPSIS:return xIt.ELLIPSISNODE}throw Error("Unrecognized node type: "+t.node.type)}function xOt(t,e,n){let i=(function r(t){return t.replace(/([:.\[\],/\\\(\)])/g,"\\$1")})(t);if(!n)return`url(#${i})`;let o=Su(n),a=o.select("defs#_graph-gradients");a.empty()&&(a=o.append("defs").attr("id","_graph-gradients"));let s=a.select("linearGradient#"+i);if(s.empty()){s=a.append("linearGradient").attr("id",t),s.selectAll("*").remove();let n=0;we.each(e,(t=>{let e=t.color;s.append("stop").attr("offset",n).attr("stop-color",e),s.append("stop").attr("offset",n+t.proportion).attr("stop-color",e),n+=t.proportion}))}return`url(#${i})`}function wOt(t){Su(t).select("defs#_graph-gradients").remove()}function SOt(t,e,n,i,r){let o=mNt;switch(t=t||(()=>0),e){case lOt.NONE:case lOt.STRUCTURE:if(n.node.type===WIt.META){let r=n.node.templateId;return e===lOt.STRUCTURE&&null!==r?o.STRUCTURE_PALETTE(t(r),i):o.UNKNOWN}return n.node.type===WIt.SERIES?i?o.EXPANDED_COLOR:"white":n.node.type===WIt.BRIDGE?n.structural?"#f0e":n.node.inbound?"#0ef":"#fe0":we.isNumber(n.node.functionInputIndex)?"#795548":we.isNumber(n.node.functionOutputIndex)?"#009688":"white";case lOt.DEVICE:return null==n.deviceColors?o.UNKNOWN:i?o.EXPANDED_COLOR:xOt("device-"+n.node.name,n.deviceColors,r);case lOt.XLA_CLUSTER:return null==n.xlaClusterColors?o.UNKNOWN:i?o.EXPANDED_COLOR:xOt("xla-"+n.node.name,n.xlaClusterColors,r);case lOt.COMPUTE_TIME:return i?o.EXPANDED_COLOR:n.computeTimeColor||o.UNKNOWN;case lOt.MEMORY:return i?o.EXPANDED_COLOR:n.memoryColor||o.UNKNOWN;case lOt.OP_COMPATIBILITY:return null==n.compatibilityColors?o.UNKNOWN:i?o.EXPANDED_COLOR:xOt("op-compat-"+n.node.name,n.compatibilityColors,r);default:throw new Error("Unknown case to color nodes by")}}function MOt(t,e,n,i){i=i||xIt.Node.SHAPE;const r=n.isNodeHighlighted(e.node.name),o=n.isNodeSelected(e.node.name),a=e.isInExtract||e.isOutExtract||e.isLibraryFunction,s=e.expanded&&i!==xIt.Annotation.NODE,l=e.isFadedOut;t.classed("highlighted",r),t.classed("selected",o),t.classed("extract",a),t.classed("expanded",s),t.classed("faded",l);const c=t.select("."+i+" ."+xIt.Node.COLOR_TARGET),u=SOt(n.templateIndex,n.colorBy,e,s,n.getGraphSvgRoot());c.style("fill",u),c.style("stroke",o?null:EOt(u))}function EOt(t){return"url"===t.substring(0,3)?mNt.GRADIENT_OUTLINE:jh(t).darker().toString()}function TOt(t,e,n,i){const r=Su(t);if(r.selectAll(".input-highlight").classed("input-highlight",!1),r.selectAll(".non-input").classed("non-input",!1),r.selectAll(".input-parent").classed("input-parent",!1),r.selectAll(".input-child").classed("input-child",!1),r.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1),r.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1),r.selectAll(".input-highlight-selected").classed("input-highlight-selected",!1),!e||!i||!n)return;let o=AOt(n,e),a={};we.each(o,(function(n){a=COt(t,e,n,a)}));let s=Object.keys(a),l=(function c(t,e){let n={};return we.each(e,(function(e){let i=t.getNodeByName(e),r=kOt(t,i);n[r.name]=r})),n})(e,s);!(function u(t,e){we.forOwn(e,(function(e){let n=e;for(;n.name!==jIt;){const e=Su(t).select(`.node[data-name="${n.name}"]`);!e.nodes().length||e.classed("input-highlight")||e.classed("selected")||e.classed("op")||e.classed("input-parent",!0),n=n.parentNode}}))})(t,l),r.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each((function(t){r.selectAll(`[data-name="${t.node.name}"]`).classed("non-input",!0)})),r.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}function AOt(t,e){let n=[],i=e.getNodeByName(t);if(i instanceof KIt)return[i].concat(i.inEmbeddings);let r=i.metagraph.nodes();return we.each(r,(function(t){n=n.concat(AOt(t,e))})),n}function COt(t,e,n,i){if(i[n.name])return i;i[n.name]=!0;let r=n.inputs,o=kOt(e,n);Su(t).select(`.node[data-name="${o.name}"]`).classed("input-highlight",!0);let a={};we.each(r,(function(t){let n=e.getNodeByName(t.name);if(void 0===n)return;if(n instanceof JIt){let t=cNt(n.name);n=e.getNodeByName(t)}let i=kOt(e,n),r=a[i.name];r?r.opNodes.push(n):a[i.name]={visibleParent:i,opNodes:[n]}}));let s={},l=[o];s[o.name]={traced:!1,index:0,connectionEndpoints:[]};let c=o;for(let t=1;c.name!==jIt;t++)c=c.parentNode,s[c.name]={traced:!1,index:t,connectionEndpoints:[]},l[t]=c;return we.forOwn(a,(function(n,r){let a=n.visibleParent;we.each(n.opNodes,(function(n){i=COt(t,e,n,i)})),a.name!==o.name&&(function c(t,e,n,i){let r=e,o=e,a=[];for(;!n[r.name];)o.name!==r.name&&a.push([o,r]),o=r,r=r.parentNode;let s=n[r.name].index,l=i[Math.max(s-1,0)].name,c=l,u=o.name,h=o.name;const d=Su(t);d.selectAll(`[data-edge="${h}--${l}"]`).classed("input-edge-highlight",!0),we.each(a,(function(t){d.selectAll(`[data-edge="${t[0].name}--${c}~~${t[1].name}~~OUT"]`).classed("input-edge-highlight",!0)}));for(let t=1;t<s;t++)d.selectAll(`[data-edge="${u}~~${i[t].name}~~IN--${i[t-1].name}"]`).classed("input-edge-highlight",!0)})(t,a,s,l)})),i}function kOt(t,e){let n=!1,i=e;for(;!n;)if(i=(e=i).parentNode,void 0===i)n=!0;else{let e=t.getRenderNodeByName(i.name);e&&(e.expanded||i instanceof KIt)&&(n=!0)}return e}function LOt(t,e,n,i){let r=t.selectAll((function(){return this.childNodes})).data(e.list,(t=>t.node.name));return r.enter().append("g").attr("data-name",(t=>t.node.name)).each((function(t){let e=Su(this);i.addAnnotationGroup(t,n,e);let r=xIt.Annotation.EDGE,o=t.renderMetaedgeInfo&&t.renderMetaedgeInfo.metaedge;o&&!o.numRegularEdges&&(r+=" "+xIt.Annotation.CONTROL_EDGE),o&&o.numRefEdges&&(r+=" "+xIt.Edge.REF_LINE),aOt(e,t,i,r),t.annotationType!==wNt.ELLIPSIS?((function a(t,e){let n=e.node.name.split("/");POt(t,n[n.length-1],e,null)})(e,t),(function s(t,e){e.annotationType===wNt.SUMMARY?MIt(t,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer"):MIt(vOt(t,e,xIt.Annotation.NODE),"title").text(e.node.name)})(e,t)):POt(e,t.node.name,t,xIt.Annotation.ELLIPSIS)})).merge(r).attr("class",(t=>xIt.Annotation.GROUP+" "+(function e(t){return(wNt[t]||"").toLowerCase()||null})(t.annotationType)+" "+bOt(t))).each((function(t){let e=Su(this);!(function r(t,e,n,i){let r=HNt(e);n.renderNodeInfo&&n.annotationType!==wNt.ELLIPSIS&&MOt(t,n.renderNodeInfo,i,xIt.Annotation.NODE),n.annotationType===wNt.SUMMARY&&(n.width+=10),t.select("text."+xIt.Annotation.LABEL).transition().attr("x",r+n.dx+(n.isIn?-1:1)*(n.width/2+n.labelOffset)).attr("y",e.y+n.dy),t.select("use.summary").transition().attr("x",r+n.dx-3).attr("y",e.y+n.dy-6),YNt(t.select("."+xIt.Annotation.NODE+" ellipse"),r+n.dx,e.y+n.dy,n.width,n.height),qNt(t.select("."+xIt.Annotation.NODE+" rect"),r+n.dx,e.y+n.dy,n.width,n.height),qNt(t.select("."+xIt.Annotation.NODE+" use"),r+n.dx,e.y+n.dy,n.width,n.height),t.select("path."+xIt.Annotation.EDGE).transition().attr("d",(t=>{let n=t.points.map((t=>({x:t.dx+r,y:t.dy+e.y})));return sOt(n)}))})(e,n,t,i),t.annotationType!==wNt.ELLIPSIS&&(function o(t,e,n,i){t.on("mouseover",(t=>{i.fire("annotation-highlight",{name:t.node.name,hostName:e.node.name})})).on("mouseout",(t=>{i.fire("annotation-unhighlight",{name:t.node.name,hostName:e.node.name})})).on("click",(t=>{uu.stopPropagation(),i.fire("annotation-select",{name:t.node.name,hostName:e.node.name})})),n.annotationType!==wNt.SUMMARY&&n.annotationType!==wNt.CONSTANT&&t.on("contextmenu",QNt(i,dOt(n.node,i)))})(e,n,t,i)})),r.exit().each((function(t){i.removeAnnotationGroup(t,n)})).remove(),r}function POt(t,e,n,i){let r=xIt.Annotation.LABEL;return i&&(r+=" "+i),gOt(t.append("text").attr("class",r).attr("dy",".35em").attr("text-anchor",n.isIn?"end":"start").text(e),-1,5)}function IOt(t,e,n,i){let r=SIt(t,"g",i=i||xIt.Scene.GROUP).empty(),o=MIt(t,"g",i),a=MIt(o,"g",xIt.Scene.CORE),s=we.reduce(e.coreGraph.nodes(),((t,n)=>{let i=e.coreGraph.node(n);return i.excluded||t.push(i),t}),[]);return e.node.type===WIt.SERIES&&s.reverse(),(function l(t,e,n){const i=n;let r=[];r=we.reduce(e.edges(),((t,n)=>{let i=e.edge(n);return t.push({v:n.v,w:n.w,label:i}),t}),r);let o=MIt(t,"g",xIt.Edge.CONTAINER).selectAll((function(){return this.childNodes})).data(r,eOt);o.enter().append("g").attr("class",xIt.Edge.GROUP).attr("data-edge",eOt).each((function(t){let e=Su(this);t.label.edgeGroup=e,i._edgeGroupIndex[eOt(t)]=e,i.handleEdgeSelected&&e.on("click",(t=>{uu.stopPropagation(),i.fire("edge-select",{edgeData:t,edgeGroup:e})})),aOt(e,t,i)})).merge(o).each((function(){!(function t(e,n){Su(n).select("path."+xIt.Edge.LINE).transition().attrTween("d",(function(t,n,i){return(function r(t,e,n,i,o){let a=n.label,s=a.adjoiningMetaedge,l=a.points;const{shadowRoot:c}=t;if(n.label.startMarkerId&&(l=oOt(l,Su(c.querySelector("#"+n.label.startMarkerId)),!0)),n.label.endMarkerId&&(l=oOt(l,Su(c.querySelector("#"+n.label.endMarkerId)),!1)),!s)return Ud(o,sOt(l));let u=s.edgeGroup.node().firstChild,h=a.metaedge.inbound;return function(t){let n=u.getPointAtLength(h?u.getTotalLength():0).matrixTransform(u.getCTM()).matrixTransform(e.getCTM().inverse()),i=h?0:l.length-1;return l[i].x=n.x,l[i].y=n.y,sOt(l)}})(e,this,t,0,i)}))})(n,this)})).each((function(t){!(function e(t,n,i){t.classed("faded",n.label.isFadedOut);let r=n.label.metaedge;t.select("path."+xIt.Edge.LINE).classed("control-dep",r&&!r.numRegularEdges)})(Su(this),t)})),o.exit().each((t=>{delete i._edgeGroupIndex[eOt(t)]})).remove()})(a,e.coreGraph,n),cOt(a,s,n),e.isolatedInExtract.length>0?cOt(MIt(o,"g",xIt.Scene.INEXTRACT),e.isolatedInExtract,n):SIt(o,"g",xIt.Scene.INEXTRACT).remove(),e.isolatedOutExtract.length>0?cOt(MIt(o,"g",xIt.Scene.OUTEXTRACT),e.isolatedOutExtract,n):SIt(o,"g",xIt.Scene.OUTEXTRACT).remove(),e.libraryFunctionsExtract.length>0?cOt(MIt(o,"g",xIt.Scene.FUNCTION_LIBRARY),e.libraryFunctionsExtract,n):SIt(o,"g",xIt.Scene.FUNCTION_LIBRARY).remove(),(function c(t,e){let n=e.node.type===WIt.SERIES?0:ONt.subscene.meta.labelHeight;WNt(jNt(t,"g",UNt.Scene.CORE),0,n);let i=e.isolatedInExtract.length>0,r=e.isolatedOutExtract.length>0,o=e.libraryFunctionsExtract.length>0,a=ONt.subscene.meta.extractXOffset,s=0;if(i&&(s+=e.outExtractBox.width),r&&(s+=e.outExtractBox.width),i){let i=e.coreBox.width;i=s<RNt?i-RNt+e.inExtractBox.width/2:i-e.inExtractBox.width/2-e.outExtractBox.width-(r?a:0),i=i-e.libraryFunctionsBox.width-(o?a:0),WNt(jNt(t,"g",UNt.Scene.INEXTRACT),i,n)}if(r){let i=e.coreBox.width;s<RNt?i=i-RNt+e.outExtractBox.width/2:i-=e.outExtractBox.width/2,i=i-e.libraryFunctionsBox.width-(o?a:0),WNt(jNt(t,"g",UNt.Scene.OUTEXTRACT),i,n)}if(o){let i=e.coreBox.width-e.libraryFunctionsBox.width/2;WNt(jNt(t,"g",UNt.Scene.FUNCTION_LIBRARY),i,n)}})(o,e),r&&o.attr("opacity",0).transition().attr("opacity",1),o}let NOt=class extends(tr(ye)){constructor(){super(...arguments),this.node=null,this.renderInfo=null,this.colorBy=lOt.STRUCTURE,this.templateIndex=null,this.type=null,this.vertical=!1,this.const=!1,this.summary=!1,this.fill=null,this.height=20}_computeFillOverride(t,e,n,i,r){return t&&e&&i?SOt(i,n,e,!1):r}_getStrokeOverride(t){return t?EOt(t):null}_getType(t,e,n,i){const{GraphIconType:r}=JNt;if(t)switch(t.type){case WIt.OP:{const i=t.op;return"string"!=typeof i?r.OP:"Const"===i||n?r.CONST:i.endsWith("Summary")||e?r.SUMMARY:r.OP}case WIt.META:return r.META;case WIt.SERIES:return r.SERIES}return i}_isVertical(t,e){return t?t.hasNonControlEdges:!!e}_getFaded(t){return t&&t.isFadedOut}_onFillOverrideChanged(t,e){const{node:n,renderInfo:i,colorBy:r,templateIndex:o}=this;t!==e&&wOt(this.$.icon.getSvgDefinableElement()),n&&i&&o&&SOt(o,r,i,!1,this.$.icon.getSvgDefinableElement())}};NOt.template=_e`
    <style>
      tf-graph-icon {
        --tb-graph-faded: var(--tb-graph-faded);
      }
    </style>
    <tf-graph-icon
      id="icon"
      type="[[_getType(node, summary, const, type)]]"
      height="[[height]]"
      fill-override="[[_fillOverride]]"
      stroke-override="[[_getStrokeOverride(_fillOverride)]]"
      faded="[[_getFaded(renderInfo)]]"
      vertical="[[_isVertical(node, vertical)]]"
    ></tf-graph-icon>
  `,t([o({type:Object}),e("design:type",Object)],NOt.prototype,"node",void 0),t([o({type:Object}),e("design:type",Object)],NOt.prototype,"renderInfo",void 0),t([o({type:Object}),e("design:type",String)],NOt.prototype,"colorBy",void 0),t([o({type:Object}),e("design:type",Function)],NOt.prototype,"templateIndex",void 0),t([o({type:String}),e("design:type",String)],NOt.prototype,"type",void 0),t([o({type:Boolean}),e("design:type",Boolean)],NOt.prototype,"vertical",void 0),t([o({type:Boolean}),e("design:type",Boolean)],NOt.prototype,"const",void 0),t([o({type:Boolean}),e("design:type",Boolean)],NOt.prototype,"summary",void 0),t([o({type:String}),e("design:type",String)],NOt.prototype,"fill",void 0),t([o({type:Number}),e("design:type",Number)],NOt.prototype,"height",void 0),t([o({type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}),e("design:type",String)],NOt.prototype,"_fillOverride",void 0),NOt=t([i("tf-node-icon")],NOt);let OOt=class extends(tr(ye)){_itemTypeChanged(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};function ROt(t,e,n){return we.sortBy(t,[t=>e.node(t).op,t=>e.node(t).templateId,t=>e.neighbors(t).length,t=>e.predecessors(t).length,t=>e.successors(t).length,t=>t.substr(n.length)])}function zOt(t,e){if(!(function n(t,e){let n=uNt(t),i=uNt(e);for(let t=0;t<n.length;t++)if(n[t]!==i[t])return!1;return!0})(t,e))return!1;let i=t.graph().name,r=e.graph().name,o={},a={},s=[];function l(t,e){let n=t.substr(i.length),l=e.substr(r.length);return o[n]^a[l]?(console.warn("different visit pattern","["+i+"]",n,"["+r+"]",l),!0):(o[n]||(o[n]=a[l]=!0,s.push({n1:t,n2:e})),!1)}let c=t.sources(),u=e.sources();if(c.length!==u.length)return console.log("different source length"),!1;c=ROt(c,t,i),u=ROt(u,e,r);for(let t=0;t<c.length;t++)if(l(c[t],u[t]))return!1;for(;s.length>0;){let n=s.pop();if(!DOt(t.node(n.n1),e.node(n.n2)))return!1;let o=t.successors(n.n1),a=e.successors(n.n2);if(o.length!==a.length)return console.log("# of successors mismatch",o,a),!1;o=ROt(o,t,i),a=ROt(a,e,r);for(let t=0;t<o.length;t++)if(l(o[t],a[t]))return!1}return!0}function DOt(t,e){if(t.type===WIt.META){let n=t,i=e;return n.templateId&&i.templateId&&n.templateId===i.templateId}if(t.type===WIt.OP&&e.type===WIt.OP)return t.op===e.op;if(t.type===WIt.SERIES&&e.type===WIt.SERIES){let n=t,i=e,r=n.metagraph.nodeCount();return r===i.metagraph.nodeCount()&&(0===r||n.metagraph.node(n.metagraph.nodes()[0]).op===i.metagraph.node(i.metagraph.nodes()[0]).op)}return!1}var BOt;OOt.template=_e`
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>

    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        >
        </tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
      </div>
    </div>
  `,t([o({type:Object}),e("design:type",Object)],OOt.prototype,"cardNode",void 0),t([o({type:Object}),e("design:type",Object)],OOt.prototype,"itemNode",void 0),t([o({type:String}),e("design:type",String)],OOt.prototype,"edgeLabel",void 0),t([o({type:Object}),e("design:type",Object)],OOt.prototype,"itemRenderInfo",void 0),t([o({type:String}),e("design:type",String)],OOt.prototype,"name",void 0),t([o({type:String,observer:"_itemTypeChanged"}),e("design:type",String)],OOt.prototype,"itemType",void 0),t([o({type:String}),e("design:type",String)],OOt.prototype,"colorBy",void 0),t([o({type:Object}),e("design:type",Object)],OOt.prototype,"colorByParams",void 0),t([o({type:Object}),e("design:type",Function)],OOt.prototype,"templateIndex",void 0),OOt=t([i("tf-graph-op-compat-list-item")],OOt),(function(t){t[t.TEMPLATES_UPDATED=0]="TEMPLATES_UPDATED"})(BOt||(BOt={}));class HOt extends class{constructor(){this.eventTypeToListeners=new Map}getListeners(t){return this.eventTypeToListeners.has(t)||this.eventTypeToListeners.set(t,[]),this.eventTypeToListeners.get(t)}addListener(t,e){this.getListeners(t).push(e)}removeListener(t,e){const n=this.getListeners(t).filter((t=>t!==e));this.eventTypeToListeners.set(t,n)}dispatchEvent(t,e){for(const n of this.getListeners(t))n(e)}}{constructor(t){super(),this.hasShapeInfo=!1,this.maxMetaEdgeSize=1,this.graphOptions={},this.templates=null,this.graphOptions.compound=!0,this.graphOptions.rankdir=t.rankDirection,this.root=ZIt(jIt,this.graphOptions),this.libraryFunctions={},this.seriesGroupMap=new Map(t.seriesMap),this.devices=null,this.xlaClusters=null,this.verifyTemplate=t.verifyTemplate,this.index={},this.index.__root__=this.root,this.orderings={}}getSeriesGroupType(t){var e;return null!==(e=this.seriesGroupMap.get(t))&&void 0!==e?e:YIt.GROUP}setSeriesGroupType(t,e){return this.seriesGroupMap.set(t,e)}buildSeriesGroupMapToggled(t){const e=this.getSeriesGroupType(t)===YIt.GROUP?YIt.UNGROUP:YIt.GROUP;return new Map([...this.seriesGroupMap,[t,e]])}getNodeMap(){return this.index}node(t){return this.index[t]}setNode(t,e){this.index[t]=e}getBridgegraph(t){let e=this.index[t];if(!e)throw Error("Could not find node in hierarchy: "+t);if(!("metagraph"in e))return null;if(e.bridgegraph)return e.bridgegraph;let n=e.bridgegraph=sNt("BRIDGEGRAPH",GIt.BRIDGE,this.graphOptions);if(!e.parentNode||!("metagraph"in e.parentNode))return n;let i=e.parentNode,r=i.metagraph,o=this.getBridgegraph(i.name);return we.each([r,o],(e=>{e.edges().filter((e=>e.v===t||e.w===t)).forEach((i=>{let r=i.w===t,o=e.edge(i);we.each(o.baseEdgeList,(e=>{let[o,a]=r?[e.w,i.v]:[e.v,i.w],s=this.getChildName(t,o),l={v:r?a:s,w:r?s:a},c=n.edge(l);c||(c=QIt(l.v,l.w),c.inbound=r,n.setEdge(l.v,l.w,c)),c.addBaseEdge(e,this)}))}))})),n}getChildName(t,e){let n=this.index[e];for(;n;){if(n.parentNode&&n.parentNode.name===t)return n.name;n=n.parentNode}throw Error("Could not find immediate child for descendant: "+e)}getPredecessors(t){let e=this.index[t];if(!e)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(e,!0);return e.isGroupNode||we.each(e.inEmbeddings,(i=>{we.each(e.inputs,(e=>{if(e.name===i.name){let r=new tNt(i.name,t);r.addBaseEdge({isControlDependency:e.isControlDependency,outputTensorKey:e.outputTensorKey,isReferenceEdge:!1,v:i.name,w:t},this),n.regular.push(r)}}))})),n}getSuccessors(t){let e=this.index[t];if(!e)throw Error("Could not find node with name: "+t);let n=this.getOneWayEdges(e,!1);return e.isGroupNode||we.each(e.outEmbeddings,(e=>{we.each(e.inputs,(i=>{if(i.name===t){let r=new tNt(t,e.name);r.addBaseEdge({isControlDependency:i.isControlDependency,outputTensorKey:i.outputTensorKey,isReferenceEdge:!1,v:t,w:e.name},this),n.regular.push(r)}}))})),n}getOneWayEdges(t,e){let n={control:[],regular:[]};if(!t.parentNode||!t.parentNode.isGroupNode)return n;let i=t.parentNode,r=i.metagraph,o=this.getBridgegraph(i.name);return FOt(r,t,e,n),FOt(o,t,e,n),n}getTopologicalOrdering(t){let e=this.index[t];if(!e)throw Error("Could not find node with name: "+t);if(!e.isGroupNode)return null;if(t in this.orderings)return this.orderings[t];let n={},i={},r=e.metagraph;we.each(r.edges(),(t=>{r.edge(t).numRegularEdges&&(t.v in n||(n[t.v]=[]),n[t.v].push(t.w),i[t.w]=!0)}));let o=we.difference(we.keys(n),we.keys(i)),a=this.orderings[t]={},s=0;for(;o.length;){let t=o.shift();a[t]=s++,we.each(n[t],(t=>o.push(t))),delete n[t]}return a}getTemplateIndex(){if(!this.templates)return null;let t=kg(this.templates);if(!t.length)return null;let e=bM().domain(t).range(zl(0,t.length));return t=>e(t)}updateTemplates(){kIt("Finding similar subgraphs",(()=>{this.templates=(function t(e,n){let i=(function o(t,e){return we.reduce(t,(function(t,n){let i=n[0],r=[];return n[1].nodes.forEach((function(t){for(let n=0;n<r.length;n++)if(!e||zOt(r[n].metanode.metagraph,t.metagraph))return t.templateId=r[n].metanode.templateId,void r[n].members.push(t.name);t.templateId=i+"["+r.length+"]",r.push({metanode:t,members:[t.name]})})),r.forEach((function(e){t[e.metanode.templateId]={level:n[1].level,nodes:e.members}})),t}),{})})((function r(t){const e=t.getNodeMap();let n=Object.keys(e).reduce(((t,n)=>{const i=e[n];if(i.type!==WIt.META)return t;let r=n.split("/").length-1,o=(function a(t){return we.map({depth:t.depth,"|V|":t.metagraph.nodes().length,"|E|":t.metagraph.edges().length},(function(t,e){return e+"="+t})).join(" ")+" [ops] "+we.map(t.opHistogram,(function(t,e){return e+"="+t})).join(",")})(i),s=t[o]||{nodes:[],level:r};return t[o]=s,s.nodes.push(i),s.level>r&&(s.level=r),t}),{});return Object.keys(n).map((t=>[t,n[t]])).filter((([t,e])=>{const{nodes:n}=e;if(n.length>1)return!0;const i=n[0];return i.type===WIt.META&&i.associatedFunction})).sort((([t,e])=>e.nodes[0].depth))})(e),n);return Object.keys(i).sort((t=>i[t].level)).reduce(((t,e)=>(t[e]=i[e],t)),{})})(this,this.verifyTemplate),this.dispatchEvent(BOt.TEMPLATES_UPDATED)}),vIt.HIERARCHY_FIND_SIMILAR_SUBGRAPHS)}}function FOt(t,e,n,i){let r=n?t.inEdges(e.name):t.outEdges(e.name);we.each(r,(e=>{let n=t.edge(e);(n.numRegularEdges?i.regular:i.control).push(n)}))}const VOt={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:new Map,rankDirection:"BT",useGeneralizedSeriesPatterns:!1};function jOt(t,e,n){const i=new HOt(e),r={};return IIt("Adding nodes",30,(()=>{let e={},n={};we.each(t.nodes,((t,i)=>{t.device&&(e[t.device]=!0),t.xlaCluster&&(n[t.xlaCluster]=!0)})),i.devices=we.keys(e),i.xlaClusters=we.keys(n),(function r(t,e){const n={};we.each(e.nodes,((e,i)=>{let r=hNt(e.name),o=t.root;o.depth=Math.max(r.length,o.depth),n[e.op]||(n[e.op]=[]),n[e.op].push(e);for(let i=0;i<r.length&&(o.depth=Math.max(o.depth,r.length-i),o.cardinality+=e.cardinality,o.opHistogram[e.op]=(o.opHistogram[e.op]||0)+1,null!=e.device&&(o.deviceHistogram[e.device]=(o.deviceHistogram[e.device]||0)+1),null!=e.xlaCluster&&(o.xlaClusterHistogram[e.xlaCluster]=(o.xlaClusterHistogram[e.xlaCluster]||0)+1),e.compatible?o.compatibilityHistogram.compatible=(o.compatibilityHistogram.compatible||0)+1:o.compatibilityHistogram.incompatible=(o.compatibilityHistogram.incompatible||0)+1,we.each(e.inEmbeddings,(t=>{t.compatible?o.compatibilityHistogram.compatible=(o.compatibilityHistogram.compatible||0)+1:o.compatibilityHistogram.incompatible=(o.compatibilityHistogram.incompatible||0)+1})),we.each(e.outEmbeddings,(t=>{t.compatible?o.compatibilityHistogram.compatible=(o.compatibilityHistogram.compatible||0)+1:o.compatibilityHistogram.incompatible=(o.compatibilityHistogram.incompatible||0)+1})),i!==r.length-1);i++){let e=r[i],a=t.node(e);if(!a&&(a=ZIt(e,t.graphOptions),a.parentNode=o,t.setNode(e,a),o.metagraph.setNode(e,a),0===e.indexOf(UIt)&&o.name===jIt)){const i=e.substring(UIt.length);n[i]||(n[i]=[]),t.libraryFunctions[i]={node:a,usages:n[i]},a.associatedFunction=i}o=a}t.setNode(e.name,e),e.parentNode=o,o.metagraph.setNode(e.name,e),we.each(e.inEmbeddings,(function(n){t.setNode(n.name,n),n.parentNode=e})),we.each(e.outEmbeddings,(function(n){t.setNode(n.name,n),n.parentNode=e}))}))})(i,t)}),n,vIt.HIERARCHY_ADD_NODES).then((()=>IIt("Detect series",30,(()=>{e.seriesNodeMinSize>0&&UOt(i.root,i,r,e.seriesNodeMinSize,e.seriesMap,e.useGeneralizedSeriesPatterns)}),n,vIt.HIERARCHY_DETECT_SERIES))).then((()=>IIt("Adding edges",40,(()=>{!(function e(t,n,i){let r=t.getNodeMap(),o=[],a=[],s=(t,e)=>{let n=0;for(;t;)e[n++]=t.name,t=t.parentNode;return n-1};we.each(n.edges,(e=>{let i=s(n.nodes[e.v],o),l=s(n.nodes[e.w],a);if(-1===i||-1===l)return;for(;o[i]===a[l];)if(i--,l--,i<0||l<0)throw Error("No difference found between ancestor paths.");let c=r[o[i+1]],u=o[i],h=a[l],d=c.metagraph.edge(u,h);d||(d=QIt(u,h),c.metagraph.setEdge(u,h,d)),c.hasNonControlEdges||e.isControlDependency||(c.hasNonControlEdges=!0),d.addBaseEdge(e,t)}))})(i,t)}),n,vIt.HIERARCHY_ADD_EDGES))).then((()=>i))}function UOt(t,e,n,i,r,o){let a=t.metagraph;we.each(a.nodes(),(t=>{let s=a.node(t);s.type===WIt.META&&UOt(s,e,n,i,r,o)}));let s=(function l(t){return we.reduce(t.nodes(),((e,n)=>{let i=t.node(n);if(i.type===WIt.META)return e;let r=i.op;return r&&(e[r]=e[r]||[],e[r].push(i.name)),e}),{})})(a),c=(o?WOt:GOt)(s,a,e.graphOptions);we.each(c,(function(t,r){let o=t.metagraph.nodes();we.each(o,(t=>{let e=a.node(t);e.owningSeries||(e.owningSeries=r)})),o.length<i&&e.getSeriesGroupType(t.name)===YIt.GROUP&&e.setSeriesGroupType(t.name,YIt.UNGROUP),e.getSeriesGroupType(t.name)!==YIt.UNGROUP&&(e.setNode(r,t),a.setNode(r,t),we.each(o,(e=>{let i=a.node(e);t.metagraph.setNode(e,i),t.parentNode=i.parentNode,t.cardinality++,null!=i.device&&(t.deviceHistogram[i.device]=(t.deviceHistogram[i.device]||0)+1),null!=i.xlaCluster&&(t.xlaClusterHistogram[i.xlaCluster]=(t.xlaClusterHistogram[i.xlaCluster]||0)+1),i.compatible?t.compatibilityHistogram.compatible=(t.compatibilityHistogram.compatible||0)+1:t.compatibilityHistogram.incompatible=(t.compatibilityHistogram.incompatible||0)+1,we.each(i.inEmbeddings,(e=>{e.compatible?t.compatibilityHistogram.compatible=(t.compatibilityHistogram.compatible||0)+1:t.compatibilityHistogram.incompatible=(t.compatibilityHistogram.incompatible||0)+1})),we.each(i.outEmbeddings,(e=>{e.compatible?t.compatibilityHistogram.compatible=(t.compatibilityHistogram.compatible||0)+1:t.compatibilityHistogram.incompatible=(t.compatibilityHistogram.incompatible||0)+1})),i.parentNode=t,n[e]=r,a.removeNode(e)})))}))}function GOt(t,e,n){let i={};return we.each(t,(function(t,r){if(t.length<=1)return;let o={};we.each(t,(function(t){const e="*"===t.charAt(t.length-1),i=t.split("/"),r=i[i.length-1],a=i.slice(0,i.length-1).join("/"),s=r.match(/^(\D*)(\d+)$/);let l,c,u="";s?(l=s[1],c=s[2]):(l=e?r.substr(0,r.length-1):r,c=0,u=e?"*":"");const h=nNt(l,u,a);o[h]=o[h]||[];const d=eNt(l,u,a,+c,t,n);o[h].push(d)})),we.each(o,(function(t,o){if(t.length<2)return;t.sort((function(t,e){return+t.clusterId-+e.clusterId}));let a=[t[0]];for(let o=1;o<t.length;o++){let s=t[o];s.clusterId!==a[a.length-1].clusterId+1?(qOt(a,i,+r,e,n),a=[s]):a.push(s)}qOt(a,i,+r,e,n)}))})),i}function WOt(t,e,n){let i={};return we.each(t,(function(t,r){if(t.length<=1)return;let o={},a={};we.each(t,(function(t){let e="*"===t.charAt(t.length-1),i=t.split("/"),r=i[i.length-1],s=i.slice(0,i.length-1).join("/");const l=/(\d+)/g;let c,u,h,d,p,f=0;for(;c=l.exec(r);)++f,u=r.slice(0,c.index),h=c[0],d=r.slice(c.index+c[0].length),p=nNt(u,d,s),o[p]=o[p],o[p]||(o[p]=eNt(u,d,s,+h,t,n)),o[p].ids.push(h),a[t]=a[t]||[],a[t].push([p,h]);f<1&&(u=e?r.substr(0,r.length-1):r,h=0,d=e?"*":"",p=nNt(u,d,s),o[p]=o[p],o[p]||(o[p]=eNt(u,d,s,+h,t,n)),o[p].ids.push(h),a[t]=a[t]||[],a[t].push([p,h]))}));var s={};we.each(a,(function(t,e){t.sort((function(t,e){return o[e[0]].ids.length-o[t[0]].ids.length}));var i=t[0][0],r=t[0][1];s[i]=s[i]||[];const a=e.split("/"),l=a.slice(0,a.length-1).join("/");var c=eNt(o[i].prefix,o[i].suffix,l,+r,e,n);s[i].push(c)})),we.each(s,(function(t,o){if(t.length<2)return;t.sort((function(t,e){return+t.clusterId-+e.clusterId}));let a=[t[0]];for(let o=1;o<t.length;o++){let s=t[o];s.clusterId!==a[a.length-1].clusterId+1?(qOt(a,i,+r,e,n),a=[s]):a.push(s)}qOt(a,i,+r,e,n)}))})),i}function qOt(t,e,n,i,r){if(t.length>1){let o=nNt(t[0].prefix,t[0].suffix,t[0].parent,t[0].clusterId,t[t.length-1].clusterId),a=eNt(t[0].prefix,t[0].suffix,t[0].parent,n,o,r);we.each(t,(function(t){a.ids.push(t.clusterId),a.metagraph.setNode(t.name,i.node(t.name))})),e[o]=a}}let YOt=class extends(tr(ye)){constructor(){super(...arguments),this._expanded=!0,this._opCompatColor=pNt,this._opIncompatColor=fNt,this._templateIndex=null}_getNode(t,e){return e.node(t)}_getRenderInfo(t,e){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resizeList(t){var e=document.querySelector(t);e&&e.fire("iron-resize")}get _incompatibleOpNodes(){const t=this.graphHierarchy;return t&&t.root?(this.async(this._resizeList.bind(this,"#incompatibleOpsList")),(function e(t){const e=[],n={};return we.each(t.root.leaves(),(i=>{let r=t.node(i);if(r.type==WIt.OP){let i=r;if(!i.compatible)if(i.owningSeries){if(t.getSeriesGroupType(i.owningSeries)===YIt.UNGROUP)e.push(i);else if(!n[i.owningSeries]){let r=t.node(i.owningSeries);r&&(n[i.owningSeries]=r,e.push(r))}}else e.push(i);we.each(i.inEmbeddings,(t=>{t.compatible||e.push(t)})),we.each(i.outEmbeddings,(t=>{t.compatible||e.push(t)}))}})),e})(t)):[]}get _opCompatScore(){var t=this.graphHierarchy;if(t&&t.root){var e=t.root,n=e.compatibilityHistogram.compatible,i=e.compatibilityHistogram.incompatible;return 0==n&&0==i?0:Math.floor(100*n/(n+i))/100}return 0}get _opCompatScoreLabel(){var t=this._opCompatScore;return py(".0%")(t)}get _totalIncompatOps(){var t=this.graphHierarchy;return t&&t.root?t.root.compatibilityHistogram.incompatible:0}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(BOt.TEMPLATES_UPDATED,(()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()}))}};YOt.template=_e`
    <style>
      :host {
        max-height: 500px;
      }

      .incompatible-ops-list {
        height: 350px;
        max-height: 400px;
        overflow-y: scroll;
        display: flex;
        flex-direction: column;
      }

      iron-list {
        flex: 1 1 auto;
      }

      paper-item {
        padding: 0;
        background: #e9e9e9;
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
        font-weight: 500;
        font-size: 12pt;
        width: 100%;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .subtitle {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .non-control-list-item {
        padding-left: 10px;
      }

      div.op-compat-display {
        margin-top: 10px;
        display: inline-block;
      }

      svg.op-compat {
        width: 250px;
        height: 25px;
        float: left;
      }

      div.op-compat-value {
        float: right;
        height: 100%;
        font-size: 14px;
        color: black;
        margin-left: 10px;
      }
    </style>

    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name" id="nodetitle">[[nodeTitle]]</div>
        </div>
        <div secondary>
          <div class="subtitle">
            <div class="op-compat-display">
              <svg
                class="op-compat"
                preserveAspectRatio="xMinYMid meet"
                viewBox="0 0 250 25"
              >
                <defs>
                  <linearGradient id="op-compat-fill">
                    <stop offset="0" stop-color$="[[_opCompatColor]]"></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opCompatColor]]"
                    ></stop>
                    <stop
                      offset$="[[_opCompatScore]]"
                      stop-color$="[[_opIncompatColor]]"
                    ></stop>
                    <stop offset="1" stop-color$="[[_opIncompatColor ]]"></stop>
                  </linearGradient>
                </defs>
                <rect
                  height="25"
                  width="250"
                  rx="5"
                  ry="5"
                  style="fill: url('#op-compat-fill');"
                ></rect>
              </svg>
              <div class="op-compat-value">[[_opCompatScoreLabel]]</div>
            </div>
          </div>
        </div>
      </paper-item-body>
    </paper-item>

    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          Incompatible Operations: (<span>[[_totalIncompatOps]]</span>)
          <iron-list
            class="incompatible-ops-list"
            id="incompatibleOpsList"
            items="[[_incompatibleOpNodes]]"
          >
            <template>
              <tf-graph-op-compat-list-item
                class="non-control-list-item"
                item-node="[[item]]"
                item-render-info="[[_getRenderInfo(item.name, renderHierarchy)]]"
                name="[[item.name]]"
                template-index="[[_templateIndex]]"
                color-by="[[colorBy]]"
                item-type="incompatible-ops"
              >
              </tf-graph-op-compat-list-item>
            </template>
          </iron-list>
        </div>
      </template>
    </iron-collapse>
  `,t([o({type:Object}),e("design:type",HOt)],YOt.prototype,"graphHierarchy",void 0),t([o({type:Object}),e("design:type",bNt)],YOt.prototype,"renderHierarchy",void 0),t([o({type:String}),e("design:type",String)],YOt.prototype,"nodeTitle",void 0),t([o({type:Boolean}),e("design:type",Boolean)],YOt.prototype,"_expanded",void 0),t([o({type:String}),e("design:type",String)],YOt.prototype,"_opCompatColor",void 0),t([o({type:String}),e("design:type",String)],YOt.prototype,"_opIncompatColor",void 0),t([o({type:Object}),e("design:type",Function)],YOt.prototype,"_templateIndex",void 0),t([s("graphHierarchy"),e("design:type",Array),e("design:paramtypes",[])],YOt.prototype,"_incompatibleOpNodes",null),t([s("graphHierarchy"),e("design:type",Number),e("design:paramtypes",[])],YOt.prototype,"_opCompatScore",null),t([s("_opCompatScore"),e("design:type",String),e("design:paramtypes",[])],YOt.prototype,"_opCompatScoreLabel",null),t([s("graphHierarchy"),e("design:type",Number),e("design:paramtypes",[])],YOt.prototype,"_totalIncompatOps",null),t([a("graphHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],YOt.prototype,"_graphHierarchyChanged",null),YOt=t([i("tf-graph-op-compat-card")],YOt);let XOt=class extends(tr(ye)){_itemTypeChanged(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")}_nodeListener(t){this.fire("node-list-item-"+t.type,{cardNode:this.cardNode.name,nodeName:this.name,type:this.itemType})}_fadedClass(t){return t&&t.isFadedOut?"faded":""}};XOt.template=_e`
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        font-size: 11pt;
        font-weight: 400;
        position: relative;
        display: inline-block;
      }

      #list-item:hover {
        background-color: var(--google-yellow-100);
      }

      .clickable {
        cursor: pointer;
      }

      #list-item span {
        margin-left: 40px;
      }

      #list-item.excluded span {
        color: #999;
      }

      #list-item span.edge-label {
        float: right;
        font-size: 10px;
        margin-left: 3px;
        margin-right: 5px;
      }

      .node-icon {
        position: absolute;
        top: 1px;
        left: 2px;
      }

      .faded span {
        color: var(--tb-graph-faded);
      }
    </style>
    <div
      id="list-item"
      on-mouseover="_nodeListener"
      on-mouseout="_nodeListener"
      on-click="_nodeListener"
    >
      <div class$="{{_fadedClass(itemRenderInfo)}}">
        <tf-node-icon
          class="node-icon"
          height="12"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          node="[[itemNode]]"
          render-info="[[itemRenderInfo]]"
          template-index="[[templateIndex]]"
        ></tf-node-icon>
        <span title$="[[name]]">[[name]]</span>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  `,t([o({type:Object}),e("design:type",Object)],XOt.prototype,"cardNode",void 0),t([o({type:Object}),e("design:type",Object)],XOt.prototype,"itemNode",void 0),t([o({type:String}),e("design:type",String)],XOt.prototype,"edgeLabel",void 0),t([o({type:Object}),e("design:type",Object)],XOt.prototype,"itemRenderInfo",void 0),t([o({type:String}),e("design:type",String)],XOt.prototype,"name",void 0),t([o({type:String,observer:"_itemTypeChanged"}),e("design:type",String)],XOt.prototype,"itemType",void 0),t([o({type:String}),e("design:type",String)],XOt.prototype,"colorBy",void 0),t([o({type:Object}),e("design:type",Object)],XOt.prototype,"colorByParams",void 0),t([o({type:Object}),e("design:type",Object)],XOt.prototype,"templateIndex",void 0),XOt=t([i("tf-node-list-item")],XOt);let $Ot=class extends(tr(ye)){constructor(){super(...arguments),this._expanded=!0,this._openedControlPred=!1,this._openedControlSucc=!1,this._templateIndex=null}expandNode(){this.fire("_node.expand",this.node)}_getNode(t,e){return e.node(t)}_getNodeStats(t,e){var n=this._getNode(t,e);return n?n.stats:null}_getTotalMicros(t){return t?t.getTotalMicros():0}get _hasDisplayableNodeStats(){return DIt(this._nodeStats)}get _nodeStatsFormattedBytes(){var t=this._nodeStats;if(t&&t.totalBytes)return zIt(t.totalBytes,OIt)}get _nodeStatsFormattedComputeTime(){var t=this._nodeStats;if(t&&t.getTotalMicros())return zIt(t.getTotalMicros(),RIt)}get _nodeStatsFormattedOutputSizes(){var t=this._nodeStats;if(t&&t.outputSize&&t.outputSize.length)return we.map(t.outputSize,(function(t){return 0===t.length?"scalar":"["+t.join(", ")+"]"}))}_getRenderInfo(t,e){return this.renderHierarchy.getOrCreateRenderNodeByName(t)}get _attributes(){var t=this._node;if(this.async(this._resizeList.bind(this,"#attributesList")),!t||!t.attr)return[];var e=[];return we.each(t.attr,(function(t){"_too_large_attrs"===t.key?e=e.concat(t.value.list.s.map((function(t){return{key:t,value:"Too large to show..."}}))):e.push({key:t.key,value:JSON.stringify(t.value)})})),e}get _device(){var t=this._node;return t?t.device:null}get _successors(){var t=this._node,e=this.graphHierarchy;return this._refreshNodeItemList("inputsList"),t?this._convertEdgeListToEdgeInfoList(e.getSuccessors(t.name),!1,t.isGroupNode):{regular:[],control:[]}}get _predecessors(){var t=this._node,e=this.graphHierarchy;return this._refreshNodeItemList("outputsList"),t?this._convertEdgeListToEdgeInfoList(e.getPredecessors(t.name),!0,t.isGroupNode):{regular:[],control:[]}}get _functionUsages(){var t=this._node,e=this.graphHierarchy;if(this._refreshNodeItemList("functionUsagesList"),!t||t.type!==WIt.META)return[];const n=e.libraryFunctions[t.associatedFunction];return n?n.usages:[]}_refreshNodeItemList(t){this.async(this._resizeList.bind(this,`#${t}`))}_convertEdgeListToEdgeInfoList(t,e,n){var i=t=>we.map(t.baseEdgeList,(t=>{var n=e?t.v:t.w;return{name:n,node:this._getNode(n,this.graphHierarchy),edgeLabel:nOt(t,this.renderHierarchy),renderInfo:this._getRenderInfo(n,this.renderHierarchy)}})),r=function(t){var r=[];return we.each(t,(t=>{var o=e?t.v:t.w;n&&1!=t.baseEdgeList.length?r.push({name:o,node:this._getNode(o,this.graphHierarchy),edgeLabel:iOt(t,this.renderHierarchy),renderInfo:this._getRenderInfo(o,this.renderHierarchy)}):r=r.concat(i(t))})),r}.bind(this);return{regular:r(t.regular),control:r(t.control)}}get _subnodes(){var t=this._node;return t&&t.metagraph?t.metagraph.nodes():null}get _totalPredecessors(){var t=this._predecessors;return t.regular.length+t.control.length}get _totalSuccessors(){var t=this._successors;return t.regular.length+t.control.length}_toggleControlPred(){this._openedControlPred=!this._openedControlPred}_toggleControlSucc(){this._openedControlSucc=!this._openedControlSucc}_toggleExpanded(){this._expanded=!this._expanded}_getToggleIcon(t){return t?"expand-less":"expand-more"}_resetState(){this._openedControlPred=!1,this._openedControlSucc=!1,this.set("_groupButtonText",mOt(this._node))}_resizeList(t){var e=document.querySelector(t);e&&e.fire("iron-resize")}_toggleInclude(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})}_nodeIncludeStateChanged(t,e){this.set("_auxButtonText",dNt(t))}_toggleGroup(){var t=fOt(this._node);this.fire("node-toggle-seriesgroup",{name:t})}_isLibraryFunction(t){return t&&t.name.startsWith(UIt)}_isInSeries(t){return pOt(t)}_graphHierarchyChanged(){this._templateIndex=this.graphHierarchy.getTemplateIndex(),this.graphHierarchy.addListener(BOt.TEMPLATES_UPDATED,(()=>{this._templateIndex=this.graphHierarchy.getTemplateIndex()}))}};$Ot.template=_e`
    <style>
      .sub-list-group {
        font-weight: 500;
        font-size: 12pt;
        padding-bottom: 8px;
        width: 100%;
      }

      .sub-list {
        max-height: 300px;
        overflow-y: scroll;
      }

      .attr-left {
        float: left;
        width: 30%;
        word-wrap: break-word;
        color: #565656;
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: #565656;
        font-weight: 400;
      }

      .sub-list-table {
        display: table;
        width: 100%;
      }

      .sub-list-table-row {
        display: table-row;
      }

      .sub-list-table-row .sub-list-table-cell:last-child {
        text-align: right;
      }

      .sub-list-table-cell {
        color: #565656;
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: #e9e9e9;
      }

      paper-item-body[two-line] {
        min-height: 0;
        padding: 8px 12px 4px;
      }

      .expandedInfo {
        padding: 8px 12px;
      }

      .controlDeps {
        padding: 0 0 0 8px;
      }

      .node-name {
        white-space: normal;
        word-wrap: break-word;
        font-size: 14pt;
        font-weight: 500;
      }

      .node-icon {
        float: right;
      }

      .subtitle {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .controlLine {
        font-size: 11pt;
        font-weight: 400;
      }

      .toggle-button {
        float: right;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .control-toggle-button {
        float: left;
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-include-group {
        padding-top: 4px;
      }

      .toggle-include {
        margin: 5px 6px;
        text-transform: none;
        padding: 4px 6px;
        font-size: 10pt;
        background-color: #fafafa;
        color: #666;
      }

      .toggle-include:hover {
        background-color: var(--google-yellow-100);
      }

      .non-control-list-item {
        padding-left: 10px;
      }
    </style>
    <paper-item>
      <paper-item-body two-line>
        <div>
          <paper-icon-button
            icon="{{_getToggleIcon(_expanded)}}"
            on-click="_toggleExpanded"
            class="toggle-button"
          >
          </paper-icon-button>
          <div class="node-name">
            <tf-wbr-string value="[[_node.name]]" delimiter-pattern="/">
            </tf-wbr-string>
          </div>
        </div>
        <div secondary>
          <tf-node-icon
            class="node-icon"
            node="[[_node]]"
            render-info="[[_getRenderInfo(graphNodeName, renderHierarchy)]]"
            color-by="[[colorBy]]"
            template-index="[[_templateIndex]]"
          ></tf-node-icon>
          <template is="dom-if" if="{{_node.op}}">
            <div class="subtitle">
              Operation:
              <span>[[_node.op]]</span>
            </div>
          </template>
          <template is="dom-if" if="{{_node.metagraph}}">
            <div class="subtitle">
              Subgraph:
              <span>[[_node.cardinality]]</span> nodes
            </div>
          </template>
        </div>
      </paper-item-body>
    </paper-item>
    <iron-collapse opened="{{_expanded}}">
      <template is="dom-if" if="{{_expanded}}" restamp="true">
        <div class="expandedInfo">
          <div class="sub-list-group attributes">
            Attributes (<span>[[_attributes.length]]</span>)
            <iron-list
              class="sub-list"
              id="attributesList"
              items="[[_attributes]]"
            >
              <template>
                <div>
                  <div class="attr-left">[[item.key]]</div>
                  <div class="attr-right">[[item.value]]</div>
                </div>
              </template>
            </iron-list>
          </div>

          <template is="dom-if" if="{{_device}}">
            <div class="sub-list-group device">
              <div class="attr-left">Device</div>
              <div class="attr-right">[[_device]]</div>
            </div>
          </template>

          <div class="sub-list-group predecessors">
            Inputs (<span>[[_totalPredecessors]]</span>)
            <iron-list
              class="sub-list"
              id="inputsList"
              items="[[_predecessors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="predecessors"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_predecessors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlPred)}}"
                    on-click="_toggleControlPred"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlPred}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlPred}}"
                    restamp="true"
                  >
                    <iron-list
                      class="sub-list"
                      items="[[_predecessors.control]]"
                    >
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="predecessors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>

          <div class="sub-list-group successors">
            Outputs (<span>[[_totalSuccessors]]</span>)
            <iron-list
              class="sub-list"
              id="outputsList"
              items="[[_successors.regular]]"
            >
              <template>
                <tf-node-list-item
                  class="non-control-list-item"
                  card-node="[[_node]]"
                  item-node="[[item.node]]"
                  edge-label="[[item.edgeLabel]]"
                  item-render-info="[[item.renderInfo]]"
                  name="[[item.name]]"
                  item-type="successor"
                  color-by="[[colorBy]]"
                  template-index="[[_templateIndex]]"
                >
                </tf-node-list-item>
              </template>
            </iron-list>
            <template is="dom-if" if="[[_successors.control.length]]">
              <div class="controlDeps">
                <div class="controlLine">
                  <paper-icon-button
                    icon="{{_getToggleIcon(_openedControlSucc)}}"
                    on-click="_toggleControlSucc"
                    class="control-toggle-button"
                  >
                  </paper-icon-button>
                  Control dependencies
                </div>
                <iron-collapse opened="{{_openedControlSucc}}" no-animation>
                  <template
                    is="dom-if"
                    if="{{_openedControlSucc}}"
                    restamp="true"
                  >
                    <iron-list class="sub-list" items="[[_successors.control]]">
                      <template>
                        <tf-node-list-item
                          card-node="[[_node]]"
                          item-node="[[item.node]]"
                          item-render-info="[[item.renderInfo]]"
                          name="[[item.name]]"
                          item-type="successors"
                          color-by="[[colorBy]]"
                          template-index="[[_templateIndex]]"
                        >
                        </tf-node-list-item>
                      </template>
                    </iron-list>
                  </template>
                </iron-collapse>
              </div>
            </template>
          </div>
          <template is="dom-if" if="{{_hasDisplayableNodeStats}}">
            <div class="sub-list-group node-stats">
              Node Stats
              <div class="sub-list-table">
                <template is="dom-if" if="{{_nodeStats.totalBytes}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Memory</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedBytes]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_getTotalMicros(_nodeStats)}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Compute Time</div>
                    <div class="sub-list-table-cell">
                      [[_nodeStatsFormattedComputeTime]]
                    </div>
                  </div>
                </template>
                <template is="dom-if" if="{{_nodeStats.outputSize}}">
                  <div class="sub-list-table-row">
                    <div class="sub-list-table-cell">Tensor Output Sizes</div>
                    <div class="sub-list-table-cell">
                      <template
                        is="dom-repeat"
                        items="{{_nodeStatsFormattedOutputSizes}}"
                      >
                        [[item]] <br />
                      </template>
                    </div>
                  </div>
                </template>
              </div>
            </div>
          </template>

          <template is="dom-if" if="[[_functionUsages.length]]">
            <div class="sub-list-group predecessors">
              Usages of the Function (<span>[[_functionUsages.length]]</span>)
              <iron-list
                class="sub-list"
                id="functionUsagesList"
                items="[[_functionUsages]]"
              >
                <template>
                  <tf-node-list-item
                    class="non-control-list-item"
                    card-node="[[_node]]"
                    item-node="[[item]]"
                    name="[[item.name]]"
                    item-type="functionUsages"
                    color-by="[[colorBy]]"
                    template-index="[[_templateIndex]]"
                  >
                  </tf-node-list-item>
                </template>
              </iron-list>
            </div>
          </template>

          <template is="dom-if" if="[[!_isLibraryFunction(_node)]]">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleInclude"
              >
                <span>[[_auxButtonText]]</span>
              </paper-button>
            </div>
          </template>

          <template is="dom-if" if="{{_isInSeries(_node)}}">
            <div class="toggle-include-group">
              <paper-button
                raised
                class="toggle-include"
                on-click="_toggleGroup"
              >
                <span>[[_groupButtonText]]</span>
              </paper-button>
            </div>
          </template>
        </div>
      </template>
    </iron-collapse>
  `,t([o({type:String}),e("design:type",String)],$Ot.prototype,"graphNodeName",void 0),t([o({type:Object}),e("design:type",HOt)],$Ot.prototype,"graphHierarchy",void 0),t([o({type:Object}),e("design:type",Object)],$Ot.prototype,"renderHierarchy",void 0),t([o({type:String}),e("design:type",String)],$Ot.prototype,"colorBy",void 0),t([o({type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"}),e("design:type",Object)],$Ot.prototype,"_node",void 0),t([o({type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"}),e("design:type",Object)],$Ot.prototype,"_nodeStats",void 0),t([o({type:Number,observer:"_nodeIncludeStateChanged"}),e("design:type",Number)],$Ot.prototype,"nodeInclude",void 0),t([o({type:Boolean}),e("design:type",Boolean)],$Ot.prototype,"_expanded",void 0),t([o({type:Boolean}),e("design:type",Boolean)],$Ot.prototype,"_openedControlPred",void 0),t([o({type:Boolean}),e("design:type",Boolean)],$Ot.prototype,"_openedControlSucc",void 0),t([o({type:String}),e("design:type",String)],$Ot.prototype,"_auxButtonText",void 0),t([o({type:String}),e("design:type",String)],$Ot.prototype,"_groupButtonText",void 0),t([o({type:Object}),e("design:type",Function)],$Ot.prototype,"_templateIndex",void 0),t([s("_nodeStats"),e("design:type",Boolean),e("design:paramtypes",[])],$Ot.prototype,"_hasDisplayableNodeStats",null),t([s("_nodeStats"),e("design:type",String),e("design:paramtypes",[])],$Ot.prototype,"_nodeStatsFormattedBytes",null),t([s("_nodeStats"),e("design:type",String),e("design:paramtypes",[])],$Ot.prototype,"_nodeStatsFormattedComputeTime",null),t([s("_nodeStats"),e("design:type",Array),e("design:paramtypes",[])],$Ot.prototype,"_nodeStatsFormattedOutputSizes",null),t([s("_node"),e("design:type",Array),e("design:paramtypes",[])],$Ot.prototype,"_attributes",null),t([s("_node"),e("design:type",String),e("design:paramtypes",[])],$Ot.prototype,"_device",null),t([s("_node","graphHierarchy"),e("design:type",Object),e("design:paramtypes",[])],$Ot.prototype,"_successors",null),t([s("_node","graphHierarchy"),e("design:type",Object),e("design:paramtypes",[])],$Ot.prototype,"_predecessors",null),t([s("_node","graphHierarchy"),e("design:type",Array),e("design:paramtypes",[])],$Ot.prototype,"_functionUsages",null),t([s("_node"),e("design:type",Array),e("design:paramtypes",[])],$Ot.prototype,"_subnodes",null),t([s("_predecessors"),e("design:type",Number),e("design:paramtypes",[])],$Ot.prototype,"_totalPredecessors",null),t([s("_successors"),e("design:type",Number),e("design:paramtypes",[])],$Ot.prototype,"_totalSuccessors",null),t([a("graphHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],$Ot.prototype,"_graphHierarchyChanged",null),$Ot=t([i("tf-node-info")],$Ot);let KOt=class extends(tr(ye)){ready(){super.ready(),this.addEventListener("node-list-item-click",this._nodeListItemClicked.bind(this)),this.addEventListener("node-list-item-mouseover",this._nodeListItemMouseover.bind(this)),this.addEventListener("node-list-item-mouseout",this._nodeListItemMouseout.bind(this))}_nodeListItemClicked(t){this.selectedNode=t.detail.nodeName}_nodeListItemMouseover(t){this.highlightedNode=t.detail.nodeName}_nodeListItemMouseout(){this.highlightedNode=null}_healthPillsAvailable(t,e){return t&&e&&Object.keys(e).length>0}_equals(t,e){return t===e}};KOt.template=_e`
    <style>
      :host {
        font-size: 12px;
        margin: 0;
        padding: 0;
        display: block;
        max-height: 650px;
        overflow-x: hidden;
        overflow-y: auto;
      }

      h2 {
        padding: 0;
        text-align: center;
        margin: 0;
      }
    </style>
    <template is="dom-if" if="{{selectedNode}}">
      <paper-material elevation="1" class="card">
        <tf-node-info
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          flat-graph="[[graph]]"
          graph-node-name="[[selectedNode]]"
          node-include="[[selectedNodeInclude]]"
          highlighted-node="{{highlightedNode}}"
          color-by="[[colorBy]]"
        >
        </tf-node-info>
      </paper-material>
    </template>
    <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
      <tf-graph-op-compat-card
        graph-hierarchy="[[graphHierarchy]]"
        render-hierarchy="[[renderHierarchy]]"
        color-by="[[colorBy]]"
        node-title="[[compatNodeTitle]]"
      >
      </tf-graph-op-compat-card>
    </template>
    <template
      is="dom-if"
      if="[[_healthPillsAvailable(debuggerDataEnabled, nodeNamesToHealthPills)]]"
    >
      <tf-graph-debugger-data-card
        render-hierarchy="[[renderHierarchy]]"
        debugger-numeric-alerts="[[debuggerNumericAlerts]]"
        node-names-to-health-pills="[[nodeNamesToHealthPills]]"
        selected-node="{{selectedNode}}"
        highlighted-node="{{highlightedNode}}"
        are-health-pills-loading="[[areHealthPillsLoading]]"
        all-steps-mode-enabled="{{allStepsModeEnabled}}"
        specific-health-pill-step="{{specificHealthPillStep}}"
        health-pill-step-index="{{healthPillStepIndex}}"
      >
      </tf-graph-debugger-data-card>
    </template>
  `,t([o({type:String}),e("design:type",String)],KOt.prototype,"title",void 0),t([o({type:Object}),e("design:type",HOt)],KOt.prototype,"graphHierarchy",void 0),t([o({type:Object}),e("design:type",XIt)],KOt.prototype,"graph",void 0),t([o({type:Object}),e("design:type",bNt)],KOt.prototype,"renderHierarchy",void 0),t([o({type:Object}),e("design:type",Object)],KOt.prototype,"nodeNamesToHealthPills",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],KOt.prototype,"healthPillStepIndex",void 0),t([o({type:String}),e("design:type",String)],KOt.prototype,"colorBy",void 0),t([o({type:String}),e("design:type",String)],KOt.prototype,"compatNodeTitle",void 0),t([o({type:String,notify:!0}),e("design:type",String)],KOt.prototype,"selectedNode",void 0),t([o({type:String,notify:!0}),e("design:type",String)],KOt.prototype,"highlightedNode",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],KOt.prototype,"selectedNodeInclude",void 0),t([o({type:Boolean}),e("design:type",Boolean)],KOt.prototype,"debuggerDataEnabled",void 0),KOt=t([i("tf-graph-info")],KOt);class ZOt{constructor(t,e,n,i,r,o){this.svg=t,this.labelPadding=o,this.zoomG=e,this.mainZoom=n,this.maxWandH=r;let a=Su(i.shadowRoot),s=a.select("svg"),l=s.select("rect");this.viewpointCoord={x:0,y:0};let c=vh().subject(Object).on("drag",(t=>{this.viewpointCoord.x=uu.x,this.viewpointCoord.y=uu.y,this.updateViewpoint()}));l.datum(this.viewpointCoord).call(c),s.on("click",(()=>{if(uu.defaultPrevented)return;let t=Number(l.attr("width")),e=Number(l.attr("height")),n=ah(s.node());this.viewpointCoord.x=n[0]-t/2,this.viewpointCoord.y=n[1]-e/2,this.updateViewpoint()})),this.viewpoint=l.node(),this.minimapSvg=s.node(),this.minimap=i,this.canvas=a.select("canvas.first").node(),this.canvasBuffer=a.select("canvas.second").node(),this.downloadCanvas=a.select("canvas.download").node(),Su(this.downloadCanvas).style("display","none"),this.update()}updateViewpoint(){Su(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let t=-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,e=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;Su(this.svg).call(this.mainZoom.transform,KP.translate(t,e).scale(this.scaleMain))}getImageBlob(){return new Promise((t=>{this.downloadCanvas.toBlob((e=>{t(e)}),"image/png")}))}update(){let t=null;try{if(t=this.zoomG.getBBox(),0===t.width)return}catch(t){return}let e=Su(this.svg),n="";const i=this.svg,r=(i.getRootNode?i.getRootNode():this.svg.parentNode).styleSheets;for(let t=0;t<r.length;t++)try{let e=r[t].cssRules||r[t].rules;if(null==e)continue;for(let t=0;t<e.length;t++)n+=e[t].cssText.replace(/ ?tf-[\w-]+ ?/g,"")+"\n"}catch(t){if("SecurityError"!==t.name)throw t}let o=e.append("style");o.text(n);let a=Su(this.zoomG),s=a.attr("transform");a.attr("transform",null),t.height+=t.y,t.width+=t.x,t.height+=2*this.labelPadding,t.width+=2*this.labelPadding,e.attr("width",t.width).attr("height",t.height),this.scaleMinimap=this.maxWandH/Math.max(t.width,t.height),this.minimapSize={width:t.width*this.scaleMinimap,height:t.height*this.scaleMinimap},Su(this.minimapSvg).attr(this.minimapSize),Su(this.canvasBuffer).attr(this.minimapSize);const l=Su(this.downloadCanvas);l.style("width",t.width),l.style("height",t.height),l.attr("width",3*t.width),l.attr("height",3*t.height),null!=this.translate&&null!=this.zoom&&requestAnimationFrame((()=>this.zoom()));let c=(new XMLSerializer).serializeToString(this.svg);o.remove(),e.attr("width",null).attr("height",null),a.attr("transform",s);let u=new Image;u.onload=()=>{let t=this.canvasBuffer.getContext("2d");t.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height),t.drawImage(u,0,0,this.minimapSize.width,this.minimapSize.height),requestAnimationFrame((()=>{Su(this.canvasBuffer).style("display",null),Su(this.canvas).style("display","none"),[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]}));let e=this.downloadCanvas.getContext("2d");e.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height),e.drawImage(u,0,0,this.downloadCanvas.width,this.downloadCanvas.height)},u.onerror=()=>{let t=new Blob([c],{type:"image/svg+xml;charset=utf-8"});u.src=URL.createObjectURL(t)},u.src="data:image/svg+xml;charset=utf-8,"+encodeURIComponent(c)}zoom(t){if(null==this.scaleMinimap)return;t&&(this.translate=[t.x,t.y],this.scaleMain=t.k);let e=this.svg.getBoundingClientRect(),n=Su(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain,this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;let i=e.width*this.scaleMinimap/this.scaleMain,r=e.height*this.scaleMinimap/this.scaleMain;n.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",i).attr("height",r);let o=this.minimapSize.width,a=this.minimapSize.height,s=this.viewpointCoord.x,l=this.viewpointCoord.y;(Math.min(Math.max(0,s+i),o)-Math.min(Math.max(0,s),o))*(Math.min(Math.max(0,l+r),a)-Math.min(Math.max(0,l),a))/(o*a)<.8?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}}let JOt=class extends ye{init(t,e,n,i,r){return new ZOt(t,e,n,this,i,r)}};JOt.template=_e`
    <style>
      :host {
        background-color: white;
        transition: opacity 0.3s linear;
        pointer-events: auto;
      }

      :host(.hidden) {
        opacity: 0;
        pointer-events: none;
      }

      canvas {
        border: 1px solid #999;
      }

      rect {
        fill: white;
        stroke: #111111;
        stroke-width: 1px;
        fill-opacity: 0;
        filter: url(#minimapDropShadow);
        cursor: move;
      }

      svg {
        position: absolute;
      }
    </style>
    <svg>
      <defs>
        <filter
          id="minimapDropShadow"
          x="-20%"
          y="-20%"
          width="150%"
          height="150%"
        >
          <feOffset result="offOut" in="SourceGraphic" dx="1" dy="1"></feOffset>
          <feColorMatrix
            result="matrixOut"
            in="offOut"
            type="matrix"
            values="0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.1 0 0 0 0 0 0.5 0"
          ></feColorMatrix>
          <feGaussianBlur
            result="blurOut"
            in="matrixOut"
            stdDeviation="2"
          ></feGaussianBlur>
          <feBlend in="SourceGraphic" in2="blurOut" mode="normal"></feBlend>
        </filter>
      </defs>
      <rect></rect>
    </svg>
    <canvas class="first"></canvas>
    <!-- Additional canvas to use as buffer to avoid flickering between updates -->
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  `,JOt=t([i("tf-graph-minimap")],JOt);const QOt=_e`
  <style>
    :host {
      display: flex;
      font-size: 20px;
      height: 100%;
      width: 100%;
    }

    #svg {
      flex: 1;
      font-family: Roboto, sans-serif;
      height: 100%;
      overflow: hidden;
      width: 100%;
    }

    #hidden {
      position: fixed;
      top: 0px;
      visibility: hidden;
    }

    text {
      user-select: none;
    }

    /* --- Node and annotation-node for Metanode --- */

    .meta > .nodeshape > rect,
    .meta > .annotation-node > rect {
      cursor: pointer;
      fill: hsl(0, 0%, 70%);
    }
    .node.meta.highlighted > .nodeshape > rect,
    .node.meta.highlighted > .annotation-node > rect {
      stroke-width: 2;
    }
    .annotation.meta.highlighted > .nodeshape > rect,
    .annotation.meta.highlighted > .annotation-node > rect {
      stroke-width: 1;
    }
    .meta.selected > .nodeshape > rect,
    .meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded > .nodeshape > rect,
    .node.meta.selected.expanded > .annotation-node > rect {
      stroke: red;
      stroke-width: 3;
    }
    .annotation.meta.selected > .nodeshape > rect,
    .annotation.meta.selected > .annotation-node > rect {
      stroke: red;
      stroke-width: 2;
    }
    .node.meta.selected.expanded.highlighted > .nodeshape > rect,
    .node.meta.selected.expanded.highlighted > .annotation-node > rect {
      stroke: red;
      stroke-width: 4;
    }

    .faded,
    .faded rect,
    .faded ellipse,
    .faded path,
    .faded use,
    #rectHatch line,
    #ellipseHatch line {
      color: #e0d4b3 !important;
      fill: white;
      stroke: #e0d4b3 !important;
    }

    .faded path {
      stroke-width: 1px !important;
    }

    .faded rect {
      fill: url(#rectHatch) !important;
    }

    .faded ellipse,
    .faded use {
      fill: url(#ellipseHatch) !important;
    }

    .faded text {
      opacity: 0;
    }

    /* Rules used for input-tracing. */
    .input-highlight > * > rect,
    .input-highlight > * > ellipse,
    .input-highlight > * > use {
      fill: white;
      stroke: #ff9800 !important;
    }

    /*  - Faded non-input styling */
    .non-input > * > rect,
.non-input > * > ellipse,
.non-input > * > use,
/* For Const nodes. */
.non-input > * > .constant:not([class*="input-highlight"]) >
  .annotation-node > ellipse,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      stroke: #e0d4b3 !important;
      stroke-width: inherit;
      stroke-dasharray: inherit;
    }

    .non-input path {
      visibility: hidden;
    }

    .non-input > .nodeshape > rect,
.non-input > .annotation-node > rect,
/* For styling of annotation nodes of non-input nodes. */
.non-input > g > .annotation > .annotation-node > rect {
      fill: url(#rectHatch) !important;
    }

    .non-input ellipse,
    .non-input use {
      fill: url(#ellipseHatch) !important;
    }

    .non-input > text {
      opacity: 0;
    }

    .non-input .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .non-input .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    /* Input edges. */
    .input-edge-highlight > text {
      fill: black !important;
    }
    .input-highlight > .in-annotations > .annotation > .annotation-edge,
    .input-highlight-selected
      > .in-annotations
      > .annotation
      > .annotation-edge {
      stroke: #999 !important;
    }

    /* Non-input edges. */
    .non-input-edge-highlight,
.non-input > g > .annotation > path,
/* Annotation styles (label and edges respectively). */
.non-input > g >
.annotation:not(.input-highlight):not(.input-highlight-selected) >
.annotation-label
/*.annotation-edge*/ {
      visibility: hidden;
    }

    /* --- Op Node --- */

    .op > .nodeshape > .nodecolortarget,
    .op > .annotation-node > .nodecolortarget {
      cursor: pointer;
      fill: #fff;
      stroke: #ccc;
    }

    .op.selected > .nodeshape > .nodecolortarget,
    .op.selected > .annotation-node > .nodecolortarget {
      stroke: red;
      stroke-width: 2;
    }

    .op.highlighted > .nodeshape > .nodecolortarget,
    .op.highlighted > .annotation-node > .nodecolortarget {
      stroke-width: 2;
    }

    /* --- Series Node --- */

    /* By default, don't show the series background <rect>. */
    .series > .nodeshape > rect {
      fill: hsl(0, 0%, 70%);
      fill-opacity: 0;
      stroke-dasharray: 5, 5;
      stroke-opacity: 0;
      cursor: pointer;
    }

    /* Once expanded, show the series background <rect> and hide the <use>. */
    .series.expanded > .nodeshape > rect {
      fill-opacity: 0.15;
      stroke: hsl(0, 0%, 70%);
      stroke-opacity: 1;
    }
    .series.expanded > .nodeshape > use {
      visibility: hidden;
    }

    /**
 * TODO: Simplify this by applying a stable class name to all <g>
 * elements that currently have either the nodeshape or annotation-node classes.
 */
    .series > .nodeshape > use,
    .series > .annotation-node > use {
      stroke: #ccc;
    }
    .series.highlighted > .nodeshape > use,
    .series.highlighted > .annotation-node > use {
      stroke-width: 2;
    }
    .series.selected > .nodeshape > use,
    .series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    .series.selected > .nodeshape > rect {
      stroke: red;
      stroke-width: 2;
    }

    .annotation.series.selected > .annotation-node > use {
      stroke: red;
      stroke-width: 2;
    }

    /* --- Bridge Node --- */
    .bridge > .nodeshape > rect {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* --- Structural Elements --- */
    .edge > path.edgeline.structural {
      stroke: #f0f;
      opacity: 0.2;
      display: none;
    }

    /* Reference Edge */
    .edge > path.edgeline.referenceedge {
      stroke: #ffb74d;
      opacity: 1;
    }

    /* --- Series Nodes --- */

    /* Hide the rect for a series' annotation. */
    .series > .annotation-node > rect {
      display: none;
    }

    /* --- Node label --- */

    .node {
      /* Provide a hint to browsers to avoid using their static rasterization
      at initial scale, which looks very pixelated on Chromium when zoomed in.
      Note that we intentionally do *not* use 'will-change: transform' and
      'translateZ(0) here, which introduce blurriness on Firefox.
      See https://github.com/tensorflow/tensorboard/issues/4744 */
      transform: translateZ(1px);
    }

    .node > text.nodelabel {
      cursor: pointer;
      fill: #444;
    }

    .meta.expanded > text.nodelabel {
      font-size: 9px;
    }

    .series > text.nodelabel {
      font-size: 8px;
    }

    .op > text.nodelabel {
      font-size: 6px;
    }

    .bridge > text.nodelabel {
      display: none;
    }

    .node.meta.expanded > text.nodelabel {
      cursor: normal;
    }

    .annotation.meta.highlighted > text.annotation-label {
      fill: #50a3f7;
    }

    .annotation.meta.selected > text.annotation-label {
      fill: #4285f4;
    }

    /* --- Annotation --- */

    /* only applied for annotations that are not summary or constant.
(.summary, .constant gets overridden below) */
    .annotation > .annotation-node > * {
      stroke-width: 0.5;
      stroke-dasharray: 1, 1;
    }

    .annotation.summary > .annotation-node > *,
    .annotation.constant > .annotation-node > * {
      stroke-width: 1;
      stroke-dasharray: none;
    }

    .annotation > .annotation-edge {
      fill: none;
      stroke: #aaa;
      stroke-width: 0.5;
      marker-end: url(#annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge {
      marker-end: url(#annotation-arrowhead-faded);
    }

    .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead);
    }

    .faded .annotation > .annotation-edge.refline {
      marker-start: url(#ref-annotation-arrowhead-faded);
    }

    .annotation > .annotation-control-edge {
      stroke-dasharray: 1, 1;
    }

    #annotation-arrowhead {
      fill: #aaa;
    }

    #annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    #ref-annotation-arrowhead {
      fill: #aaa;
    }

    #ref-annotation-arrowhead-faded {
      fill: #e0d4b3;
    }

    .annotation > .annotation-label {
      font-size: 5px;
      cursor: pointer;
    }
    .annotation > .annotation-label.annotation-ellipsis {
      cursor: default;
    }

    /* Hide annotations on expanded meta nodes since they're redundant. */
    .expanded > .in-annotations,
    .expanded > .out-annotations {
      display: none;
    }

    /* --- Annotation: Constant --- */

    .constant > .annotation-node > ellipse {
      cursor: pointer;
      fill: white;
      stroke: #848484;
    }

    .constant.selected > .annotation-node > ellipse {
      fill: white;
      stroke: red;
    }

    .constant.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Annotation: Summary --- */

    .summary > .annotation-node > ellipse {
      cursor: pointer;
      fill: #db4437;
      stroke: #db4437;
    }

    .summary.selected > .annotation-node > ellipse {
      fill: #a52714;
      stroke: #a52714;
    }

    .summary.highlighted > .annotation-node > ellipse {
      stroke-width: 1.5;
    }

    /* --- Edge --- */

    .edge > path.edgeline {
      fill: none;
      stroke: #bbb;
      stroke-linecap: round;
      stroke-width: 0.75;
    }

    .edge .selectableedge {
      cursor: pointer;
    }

    .selectededge > path.edgeline {
      cursor: default;
      stroke: #f00;
    }

    .edge.selectededge text {
      fill: #000;
    }

    /* Labels showing tensor shapes on edges */
    .edge > text {
      font-size: 3.5px;
      fill: #666;
    }

    .dataflow-arrowhead {
      fill: #bbb;
    }

    .reference-arrowhead {
      fill: #ffb74d;
    }

    .selected-arrowhead {
      fill: #f00;
    }

    .edge .control-dep {
      stroke-dasharray: 2, 2;
    }

    /* --- Group node expand/collapse button --- */

    /* Hides expand/collapse buttons when a node isn't expanded or highlighted. Using
   incredibly small opacity so that the bounding box of the <g> parent still takes
   this container into account even when it isn't visible */
    .node:not(.highlighted):not(.expanded) > .nodeshape > .buttoncontainer {
      opacity: 0.01;
    }
    .node.highlighted > .nodeshape > .buttoncontainer {
      cursor: pointer;
    }
    .buttoncircle {
      fill: #e7811d;
    }
    .buttoncircle:hover {
      fill: #b96717;
    }
    .expandbutton,
    .collapsebutton {
      stroke: white;
    }
    /* Do not let the path elements in the button take pointer focus */
    .node > .nodeshape > .buttoncontainer > .expandbutton,
    .node > .nodeshape > .buttoncontainer > .collapsebutton {
      pointer-events: none;
    }
    /* Only show the expand button when a node is collapsed and only show the
   collapse button when a node is expanded. */
    .node.expanded > .nodeshape > .buttoncontainer > .expandbutton {
      display: none;
    }
    .node:not(.expanded) > .nodeshape > .buttoncontainer > .collapsebutton {
      display: none;
    }

    .health-pill-stats {
      font-size: 4px;
      text-anchor: middle;
    }

    .health-pill rect {
      filter: url(#health-pill-shadow);
      rx: 3;
      ry: 3;
    }

    .titleContainer {
      position: relative;
      top: 20px;
    }

    .title,
    .auxTitle,
    .functionLibraryTitle {
      position: absolute;
    }

    #minimap {
      position: absolute;
      right: 20px;
      bottom: 20px;
    }

    .context-menu {
      position: absolute;
      display: none;
      background-color: #e2e2e2;
      border-radius: 2px;
      font-size: 14px;
      min-width: 150px;
      border: 1px solid #d4d4d4;
    }

    .context-menu ul {
      list-style-type: none;
      margin: 0;
      padding: 0;
      cursor: default;
    }

    .context-menu ul li {
      padding: 4px 16px;
    }

    .context-menu ul li:hover {
      background-color: #f3913e;
      color: white;
    }
  </style>
  <div class="titleContainer">
    <div id="title" class="title">Main Graph</div>
    <div id="auxTitle" class="auxTitle">Auxiliary Nodes</div>
    <div id="functionLibraryTitle" class="functionLibraryTitle">Functions</div>
  </div>
  <svg id="svg">
    <defs>
      <!-- Arrow heads for reference edge paths of different predefined sizes per color. -->
      <path
        id="reference-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>
      <marker
        class="reference-arrowhead"
        id="reference-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#reference-arrowhead-path"></use>
      </marker>

      <!-- Arrow heads for dataflow edge paths of different predefined sizes per color. -->
      <path
        id="dataflow-arrowhead-path"
        d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"
      ></path>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-small"
        viewBox="0 0 10 10"
        markerWidth="5"
        markerHeight="5"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-medium"
        viewBox="0 0 10 10"
        markerWidth="13"
        markerHeight="13"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-large"
        viewBox="0 0 10 10"
        markerWidth="16"
        markerHeight="16"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>
      <marker
        class="dataflow-arrowhead"
        id="dataflow-arrowhead-xlarge"
        viewBox="0 0 10 10"
        markerWidth="20"
        markerHeight="20"
        refX="2"
        refY="5"
        orient="auto-start-reverse"
        markerUnits="userSpaceOnUse"
      >
        <use xlink:href="#dataflow-arrowhead-path"></use>
      </marker>

      <!-- Arrow head for annotation edge paths. -->
      <marker
        id="annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="5"
        refY="2.5"
        orient="auto"
      >
        <path d="M 0,0 L 5,2.5 L 0,5 L 0,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <marker
        id="ref-annotation-arrowhead-faded"
        markerWidth="5"
        markerHeight="5"
        refX="0"
        refY="2.5"
        orient="auto"
      >
        <path d="M 5,0 L 0,2.5 L 5,5 L 5,0"></path>
      </marker>
      <!-- Template for an Op node ellipse. -->
      <ellipse
        id="op-node-stamp"
        rx="7.5"
        ry="3"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Template for an Op node annotation ellipse (smaller). -->
      <ellipse
        id="op-node-annotation-stamp"
        rx="5"
        ry="2"
        stroke="inherit"
        fill="inherit"
      ></ellipse>
      <!-- Vertically stacked series of Op nodes when unexpanded. -->
      <g id="op-series-vertical-stamp">
        <use xlink:href="#op-node-stamp" x="8" y="9"></use>
        <use xlink:href="#op-node-stamp" x="8" y="6"></use>
        <use xlink:href="#op-node-stamp" x="8" y="3"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes when unexpanded. -->
      <g id="op-series-horizontal-stamp">
        <use xlink:href="#op-node-stamp" x="16" y="4"></use>
        <use xlink:href="#op-node-stamp" x="12" y="4"></use>
        <use xlink:href="#op-node-stamp" x="8" y="4"></use>
      </g>
      <!-- Horizontally stacked series of Op nodes for annotation. -->
      <g id="op-series-annotation-stamp">
        <use xlink:href="#op-node-annotation-stamp" x="9" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="7" y="2"></use>
        <use xlink:href="#op-node-annotation-stamp" x="5" y="2"></use>
      </g>
      <svg
        id="summary-icon"
        fill="#848484"
        height="12"
        viewBox="0 0 24 24"
        width="12"
      >
        <path
          d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z"
        ></path>
      </svg>

      <!-- Hatch patterns for faded out nodes. -->
      <pattern
        id="rectHatch"
        patternTransform="rotate(45 0 0)"
        width="5"
        height="5"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="5" style="stroke-width: 1"></line>
      </pattern>
      <pattern
        id="ellipseHatch"
        patternTransform="rotate(45 0 0)"
        width="2"
        height="2"
        patternUnits="userSpaceOnUse"
      >
        <line x1="0" y1="0" x2="0" y2="2" style="stroke-width: 1"></line>
      </pattern>

      <!-- A shadow for health pills. -->
      <filter
        id="health-pill-shadow"
        x="-40%"
        y="-40%"
        width="180%"
        height="180%"
      >
        <feGaussianBlur in="SourceAlpha" stdDeviation="0.8"></feGaussianBlur>
        <feOffset dx="0" dy="0" result="offsetblur"></feOffset>
        <feFlood flood-color="#000000"></feFlood>
        <feComposite in2="offsetblur" operator="in"></feComposite>
        <feMerge>
          <feMergeNode></feMergeNode>
          <feMergeNode in="SourceGraphic"></feMergeNode>
        </feMerge>
      </filter>
    </defs>
    <!-- Make a large rectangle that fills the svg space so that
  zoom events get captured on safari -->
    <rect fill="white" width="10000" height="10000"></rect>
    <g id="root"></g>
  </svg>
  <tf-graph-minimap id="minimap"></tf-graph-minimap>
  <div id="contextMenu" class="context-menu"></div>
`;let tRt=class extends(tr(ye)){constructor(){super(...arguments),this._zoomed=!1,this._zoomStartCoords=null,this._zoomTransform=null,this._maxZoomDistanceForClick=20,this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this.maxMetanodeLabelLengthFontSize=9,this.minMetanodeLabelLengthFontSize=6,this.maxMetanodeLabelLengthLargeFont=11,this.maxMetanodeLabelLength=18}getNode(t){return this.renderHierarchy.getRenderNodeByName(t)}isNodeExpanded(t){return t.expanded}setNodeExpanded(t){this._build(this.renderHierarchy),this._updateLabels(!this._zoomed)}panToNode(t){(function e(t,n,i,r){const o=Su(n).select(`[data-name="${t}"]`).node();if(!o)return console.warn(`panToNode() failed for node name "${t}"`),!1;let a=o.getBBox(),s=o.getScreenCTM(),l=n.createSVGPoint(),c=n.createSVGPoint();l.x=a.x,l.y=a.y,c.x=a.x+a.width,c.y=a.y+a.height,l=l.matrixTransform(s),c=c.matrixTransform(s);let u=(t,e,n,i)=>!(t>n&&e<i),h=n.getBoundingClientRect();const d=h.top+h.height-150;if(u(l.x,c.x,h.left,h.left+h.width-320)||u(l.y,c.y,h.top,d)){let t=h.left+h.width/2-(l.x+c.x)/2,e=h.top+h.height/2-(l.y+c.y)/2;const i=ZP(n);return Su(n).transition().duration(500).call(r.translateBy,t/i.k,e/i.k),!0}return!1})(t,this.$.svg,0,this._zoom)&&(this._zoomed=!0)}getGraphSvgRoot(){return this.$.svg}getContextMenu(){return this.$.contextMenu}_resetState(){this._nodeGroupIndex={},this._annotationGroupIndex={},this._edgeGroupIndex={},this._updateLabels(!1),Su(this.$.svg).select("#root").selectAll("*").remove(),wOt(this.$.svg)}_build(t){this.templateIndex=t.hierarchy.getTemplateIndex(),kIt("tf-graph-scene (layout):",function(){zNt(t.root)}.bind(this),vIt.RENDER_SCENE_LAYOUT),kIt("tf-graph-scene (build scene):",function(){IOt(Su(this.$.root),t.root,this),(function e(t,n){Su(t).on("click",(()=>{n.fire("graph-select")}))})(this.$.svg,this),this._updateInputTrace()}.bind(this),vIt.RENDER_SCENE_BUILD_SCENE),setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex),this.minimap.update()}.bind(this),ONt.animation.duration)}ready(){super.ready(),this._zoom=aI().on("end",function(){this._zoomStartCoords&&(Math.sqrt(Math.pow(this._zoomStartCoords.x-this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2))<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50)),this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=uu.transform,this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click")),this._zoomed=!0,Su(this.$.root).attr("transform",uu.transform),this.minimap.zoom(uu.transform)}.bind(this)),Su(this.$.svg).call(this._zoom).on("dblclick.zoom",null),Su(window).on("resize",function(){this.minimap.zoom()}.bind(this)),this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,ONt.minimap.size,ONt.subscene.meta.labelHeight)}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}_renderHierarchyChanged(){var t=this.renderHierarchy;this._hasRenderHierarchyBeenFitOnce=!1,this._resetState(),this._build(t)}_animateAndFit(){!this._hasRenderHierarchyBeenFitOnce&&this._isAttached&&setTimeout(this.fit.bind(this),ONt.animation.duration)}_updateLabels(t){var e=this.$$(".title"),n=e.style,i=this.$$(".auxTitle"),r=i.style,o=this.$$(".functionLibraryTitle").style;const a=Su(this.$.svg);var s=a.select("."+UNt.Scene.GROUP+">."+UNt.Scene.CORE).node();if(t&&s&&this.progress&&100===this.progress.value){var l=a.select("."+UNt.Scene.GROUP+">."+UNt.Scene.INEXTRACT).node()||a.select("."+UNt.Scene.GROUP+">."+UNt.Scene.OUTEXTRACT).node(),c=s.getCTM().e,u=l?l.getCTM().e:null;n.display="inline",n.left=c+"px",null!==u&&u!==c?(r.display="inline",u=Math.max(c+e.getBoundingClientRect().width,u),r.left=u+"px"):r.display="none";let t=a.select("."+UNt.Scene.GROUP+">."+UNt.Scene.FUNCTION_LIBRARY).node(),h=t?t.getCTM().e:null;null!==h&&h!==u?(o.display="inline",h=Math.max(u+i.getBoundingClientRect().width,h),o.left=h+"px"):o.display="none"}else n.display="none",r.display="none",o.display="none"}nodeColorsChanged(){null!=this.renderHierarchy&&(this.templateIndex=this.renderHierarchy.hierarchy.getTemplateIndex(),we.each(this._nodeGroupIndex,((t,e)=>{this._updateNodeState(e)})),this.minimap.update())}fit(){this._hasRenderHierarchyBeenFitOnce=!0,(function t(e,n,i,r){let o=e.getBoundingClientRect(),a=null;try{if(a=n.getBBox(),0===a.width)return}catch(t){return}let s=.9*Math.min(o.width/a.width,o.height/a.height,2),l=ONt.graph;const c=KP.scale(s).translate(l.padding.paddingLeft,l.padding.paddingTop);Su(e).transition().duration(500).call(i.transform,c).on("end.fitted",(()=>{i.on("end.fitted",null),r()}))})(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))}getImageBlob(){return this.minimap.getImageBlob()}isNodeSelected(t){return t===this.selectedNode}isNodeHighlighted(t){return t===this.highlightedNode}addAnnotationGroup(t,e,n){var i=t.node.name;this._annotationGroupIndex[i]=this._annotationGroupIndex[i]||{},this._annotationGroupIndex[i][e.node.name]=n}getAnnotationGroupsIndex(t){return this._annotationGroupIndex[t]}removeAnnotationGroup(t,e){delete this._annotationGroupIndex[t.node.name][e.node.name]}addNodeGroup(t,e){this._nodeGroupIndex[t]=e}getNodeGroup(t){return this._nodeGroupIndex[t]}removeNodeGroup(t){delete this._nodeGroupIndex[t]}addEdgeGroup(t,e){this._edgeGroupIndex[t]=e}getEdgeGroup(t){return this._edgeGroupIndex[t]}_updateHealthPills(){!(function t(e,n,i){if(!n)return;let r=1;Su(e).selectAll("g.nodeshape").each((function(t){const e=n[t.node.name];!(function o(t,e,n,i,r=60,a=10,s=0,l){if(Su(t.parentNode).selectAll(".health-pill").remove(),!e)return;const c=e.value,u=c.slice(2,8),h=u[0],d=u[1],p=u[5];let f=c[1];const m={min:c[8],max:c[9],mean:c[10],stddev:Math.sqrt(c[11])};null==r&&(r=60),null==a&&(a=10),null==s&&(s=0),null!=n&&n.node.type===WIt.OP&&(r/=2,a/=2);let g=document.createElementNS(wIt,"g");g.classList.add("health-pill");let _=document.createElementNS(wIt,"defs");g.appendChild(_);let y=document.createElementNS(wIt,"linearGradient");const v="health-pill-gradient-"+i;y.setAttribute("id",v);let b=0,x="0%";for(let t=0;t<u.length;t++){if(!u[t])continue;b+=u[t];let e=document.createElementNS(wIt,"stop");e.setAttribute("offset",x),e.setAttribute("stop-color",GNt[t].background_color),y.appendChild(e);let n=document.createElementNS(wIt,"stop"),i=100*b/f+"%";n.setAttribute("offset",i),n.setAttribute("stop-color",GNt[t].background_color),y.appendChild(n),x=i}_.appendChild(y);let w=document.createElementNS(wIt,"rect");w.setAttribute("fill","url(#"+v+")"),w.setAttribute("width",String(r)),w.setAttribute("height",String(a)),w.setAttribute("y",String(s)),g.appendChild(w);let S=document.createElementNS(wIt,"title");S.textContent=(function M(t,e,n,i){let r="Device: "+t.device_name+"\n";r+="dtype: "+t.dtype+"\n";let o="(scalar)";t.shape.length>0&&(o="("+t.shape.join(",")+")"),r+="\nshape: "+o+"\n\n",r+="#(elements): "+e+"\n";const a=[];for(let t=0;t<n.length;t++)n[t]>0&&a.push("#("+GNt[t].label+"): "+n[t]);return r+=a.join(", ")+"\n\n",i.max>=i.min&&(r+="min: "+i.min+", max: "+i.max+"\n",r+="mean: "+i.mean+", stddev: "+i.stddev),r})(e,f,u,m),g.appendChild(S);let E=!1;if(null!=n){let t=n.y-a-n.height/2-2;if(n.labelOffset<0&&(t+=n.labelOffset),g.setAttribute("transform","translate("+(n.x-r/2)+", "+t+")"),u[2]||u[3]||u[4]){let t=n.node.attr;if(t&&t.length)for(let e=0;e<t.length;e++)if("T"===t[e].key){let n=t[e].value.type;E=n&&/^DT_(BOOL|INT|UINT)/.test(n);break}}}let T=document.createElementNS(wIt,"text");if(Number.isFinite(m.min)&&Number.isFinite(m.max)){const t=XNt(m.min,E),e=XNt(m.max,E);if(T.textContent=f>1?t+" ~ "+e:t,h>0||d>0||p>0){T.textContent+=" (";const t=[];h>0&&t.push(`NaN×${h}`),d>0&&t.push(`-∞×${d}`),p>0&&t.push(`+∞×${p}`),T.textContent+=t.join("; ")+")"}}else T.textContent="(No finite elements)";T.classList.add("health-pill-stats"),null==l&&(l=r/2),T.setAttribute("x",String(l)),T.setAttribute("y",String(s-2)),g.appendChild(T),qi(t.parentNode).appendChild(g)})(this,e?e[i]:null,t,r++)}))})(this.$.svg,this.nodeNamesToHealthPills,this.healthPillStepIndex)}_updateNodeState(t){var e=this.getNode(t),n=this.getNodeGroup(t);n&&MOt(n,e,this),e.node.type===WIt.META&&e.node.associatedFunction&&!e.isLibraryFunction&&MOt(Su("."+UNt.Scene.GROUP+">."+UNt.Scene.FUNCTION_LIBRARY+' g[data-name="'+(UIt+e.node.associatedFunction)+'"]'),e,this);var i=this.getAnnotationGroupsIndex(t);we.each(i,((t,n)=>{MOt(t,e,this,UNt.Annotation.NODE)}))}_selectedNodeChanged(t,e){if(t!==e&&(e&&this._updateNodeState(e),t)){this.minimap.update();for(var n,i=this.renderHierarchy.hierarchy.node(t),r=[];null!=i.parentNode&&i.parentNode.name!=jIt;)r.push((i=i.parentNode).name);we.forEachRight(r,(t=>{this.renderHierarchy.buildSubhierarchy(t);var e=this.renderHierarchy.getRenderNodeByName(t);e.node.isGroupNode&&!e.expanded&&(e.expanded=!0,n||(n=e))})),n&&(this.setNodeExpanded(n),this._zoomed=!0),t&&this._updateNodeState(t),setTimeout((()=>{this.panToNode(t)}),ONt.animation.duration)}}_highlightedNodeChanged(t,e){t!==e&&(t&&this._updateNodeState(t),e&&this._updateNodeState(e))}_onZoomChanged(){this._updateLabels(!this._zoomed)}_fireEnableClick(){this.fire("enable-click")}_updateInputTrace(){TOt(this.getGraphSvgRoot(),this.renderHierarchy,this.selectedNode,this.traceInputs)}};tRt.template=QOt,t([o({type:Object}),e("design:type",bNt)],tRt.prototype,"renderHierarchy",void 0),t([o({type:String}),e("design:type",String)],tRt.prototype,"name",void 0),t([o({type:String}),e("design:type",String)],tRt.prototype,"colorBy",void 0),t([o({type:Boolean}),e("design:type",Boolean)],tRt.prototype,"traceInputs",void 0),t([o({type:Boolean}),e("design:type",Boolean)],tRt.prototype,"_hasRenderHierarchyBeenFitOnce",void 0),t([o({type:Boolean}),e("design:type",Boolean)],tRt.prototype,"_isAttached",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_zoom",void 0),t([o({type:String,observer:"_highlightedNodeChanged"}),e("design:type",String)],tRt.prototype,"highlightedNode",void 0),t([o({type:String,observer:"_selectedNodeChanged"}),e("design:type",String)],tRt.prototype,"selectedNode",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"handleEdgeSelected",void 0),t([o({type:Boolean,observer:"_onZoomChanged"}),e("design:type",Boolean)],tRt.prototype,"_zoomed",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_zoomStartCoords",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_zoomTransform",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"_maxZoomDistanceForClick",void 0),t([o({type:Object}),e("design:type",Function)],tRt.prototype,"templateIndex",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_nodeGroupIndex",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_annotationGroupIndex",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"_edgeGroupIndex",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"maxMetanodeLabelLengthFontSize",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"minMetanodeLabelLengthFontSize",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"maxMetanodeLabelLengthLargeFont",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"maxMetanodeLabelLength",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"progress",void 0),t([o({type:Array}),e("design:type",Array)],tRt.prototype,"nodeContextMenuItems",void 0),t([o({type:Object}),e("design:type",Object)],tRt.prototype,"nodeNamesToHealthPills",void 0),t([o({type:Number}),e("design:type",Number)],tRt.prototype,"healthPillStepIndex",void 0),t([a("renderHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tRt.prototype,"_renderHierarchyChanged",null),t([a("_isAttached","renderHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tRt.prototype,"_animateAndFit",null),t([a("colorBy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tRt.prototype,"nodeColorsChanged",null),t([a("nodeNamesToHealthPills","healthPillStepIndex"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tRt.prototype,"_updateHealthPills",null),t([a("traceInputs","selectedNode"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],tRt.prototype,"_updateInputTrace",null),tRt=t([i("tf-graph-scene")],tRt);let eRt=class extends(tr(ye)){constructor(){super(...arguments),this._renderDepth=1,this._allowGraphSelect=!0,this.edgeWidthFunction="",this.handleNodeSelected="",this.edgeLabelFunction="",this.handleEdgeSelected=""}panToNode(t){this.$$("tf-graph-scene").panToNode(t)}_autoExtractNodesChanged(){var t=this.graphHierarchy;if(t){for(const e of Object.values(t.getNodeMap()))e.include=qIt.UNSPECIFIED;this._buildRenderHierarchy(t)}}_buildNewRenderHierarchy(){var t=this.graphHierarchy;t&&this._buildRenderHierarchy(t)}_statsChanged(){var t=this.stats,e=this.devicesForStats;this.graphHierarchy&&(t&&e&&((function n(t,e,i){we.each(t.nodes,(t=>{t.stats=null})),we.each(e.dev_stats,(e=>{i&&!i[e.device]||we.each(e.node_stats,(n=>{let i=n.node_name in t.nodes?n.node_name:cNt(n.node_name);if(!(i in t.nodes))return;let r=0;n.memory&&we.each(n.memory,(t=>{t.total_bytes&&(t.total_bytes>0?r+=Number(t.total_bytes):console.log("ignoring negative memory allocation for "+i))}));let o=null;n.output&&(o=we.map(n.output,(t=>we.map(t.tensor_description.shape.dim,(t=>Number(t.size)))))),t.nodes[i].device=e.device,null==t.nodes[i].stats&&(t.nodes[i].stats=new EIt(o)),t.nodes[i].stats.addBytesAllocation(r),n.all_end_rel_micros&&(n.all_end_rel_micros>0?t.nodes[i].stats.addExecutionTime(n.all_start_micros,n.all_start_micros+n.all_end_rel_micros):console.log("ignoring negative runtime for "+i))}))}))})(this.basicGraph,t,e),(function i(t,e){let n={},i={};we.each(t.root.leaves(),(e=>{let r=t.node(e);null!=r.device&&(n[r.device]=!0),null!=r.xlaCluster&&(i[r.xlaCluster]=!0)})),t.devices=we.keys(n),t.xlaClusters=we.keys(i),we.each(t.getNodeMap(),((t,e)=>{t.isGroupNode&&(t.stats=new EIt(null),t.deviceHistogram={})})),we.each(t.root.leaves(),(e=>{let n=t.node(e),i=n;for(;null!=i.parentNode;){if(null!=n.device){let t=i.parentNode.deviceHistogram;t[n.device]=(t[n.device]||0)+1}if(null!=n.xlaCluster){let t=i.parentNode.xlaClusterHistogram;t[n.xlaCluster]=(t[n.xlaCluster]||0)+1}null!=n.stats&&i.parentNode.stats.combine(n.stats),i=i.parentNode}}))})(this.graphHierarchy)),this._buildRenderHierarchy(this.graphHierarchy))}ready(){super.ready(),this.addEventListener("graph-select",this._graphSelected.bind(this)),this.addEventListener("disable-click",this._disableClick.bind(this)),this.addEventListener("enable-click",this._enableClick.bind(this)),this.addEventListener("node-toggle-expand",this._nodeToggleExpand.bind(this)),this.addEventListener("node-select",this._nodeSelected.bind(this)),this.addEventListener("node-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("node-unhighlight",this._nodeUnhighlighted.bind(this)),this.addEventListener("node-toggle-extract",this._nodeToggleExtract.bind(this)),this.addEventListener("node-toggle-seriesgroup",this._nodeToggleSeriesGroup.bind(this)),this.addEventListener("edge-select",this._edgeSelected.bind(this)),this.addEventListener("annotation-select",this._nodeSelected.bind(this)),this.addEventListener("annotation-highlight",this._nodeHighlighted.bind(this)),this.addEventListener("annotation-unhighlight",this._nodeUnhighlighted.bind(this))}_buildRenderHierarchy(t){if(t.root.type!==WIt.META)return;const e=this,n=kIt("new tf_graph_render.Hierarchy",(()=>{const n=new bNt(t,!!this.stats,this.autoExtractNodes);function i(t){return{minValue:t.domain()[0],maxValue:t.domain()[1],startColor:t.range()[0],endColor:t.range()[1]}}return n.edgeLabelFunction=this.edgeLabelFunction,n.edgeWidthFunction=this.edgeWidthFunction,e._setColorByParams({compute_time:i(n.computeTimeScale),memory:i(n.memoryUsageScale),device:we.map(n.deviceColorMap.domain(),(function(t){return{device:t,color:n.deviceColorMap(t)}})),xla_cluster:we.map(n.xlaClusterColorMap.domain(),(function(t){return{xla_cluster:t,color:n.xlaClusterColorMap(t)}}))}),n}),vIt.RENDER_BUILD_HIERARCHY);e._setRenderHierarchy(n)}_getVisible(t){return t?this.renderHierarchy.getNearestVisibleAncestor(t):t}fit(){this.$.scene.fit()}getImageBlob(){return this.$.scene.getImageBlob()}_graphChanged(){this.graphHierarchy&&(this.graphHierarchy.addListener(BOt.TEMPLATES_UPDATED,(()=>{this.$.scene.nodeColorsChanged()})),this.fire("graph-select"))}_graphSelected(t){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null)),this._allowGraphSelect=!0}_disableClick(t){this._allowGraphSelect=!1}_enableClick(t){this._allowGraphSelect=!0}_selectedNodeChanged(){this.handleNodeSelected&&this.handleNodeSelected(this.selectedNode)}_selectedEdgeChanged(){var t=this.selectedEdge;this._deselectPreviousEdge(),t&&(this._lastSelectedEdgeGroup.classed(UNt.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(t)),this.handleEdgeSelected&&this.handleEdgeSelected(t)}_nodeSelected(t){this._allowGraphSelect&&this.set("selectedNode",t.detail.name),this._allowGraphSelect=!0}_edgeSelected(t){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",t.detail.edgeGroup),this.set("selectedEdge",t.detail.edgeData)),this._allowGraphSelect=!0}_nodeHighlighted(t){this.set("highlightedNode",t.detail.name)}_nodeUnhighlighted(t){this.set("highlightedNode",null)}_nodeToggleExpand(t){this._nodeSelected(t);var e=t.detail.name,n=this.renderHierarchy.getRenderNodeByName(e);n.node.type!==WIt.OP&&(this.renderHierarchy.buildSubhierarchy(e),n.expanded=!n.expanded,this.async((function(){this.$.scene.setNodeExpanded(n)}),75),CIt({actionId:vIt.NODE_EXPANSION_TOGGLED,eventLabel:n.expanded?"expanded":"collapsed"}))}_nodeToggleExtract(t){this.nodeToggleExtract(t.detail.name)}nodeToggleExtract(t){const e=this.renderHierarchy.getRenderNodeByName(t);e.node.include=e.node.include==qIt.INCLUDE?qIt.EXCLUDE:e.node.include==qIt.EXCLUDE||this.renderHierarchy.isNodeAuxiliary(e)?qIt.INCLUDE:qIt.EXCLUDE,this._buildRenderHierarchy(this.graphHierarchy),CIt({actionId:vIt.NODE_AUXILIARY_EXTRACTION_CHANGED,eventLabel:e.node.include===qIt.INCLUDE?"Auxiliary to Main":"Main to Auxiliary"})}_nodeToggleSeriesGroup(t){this.nodeToggleSeriesGroup(t.detail.name)}nodeToggleSeriesGroup(t){this.set("progress",{value:0,msg:""});var e=PIt(LIt(this),100,"Namespace hierarchy");const n=Object.assign(Object.assign({},this.hierarchyParams),{seriesMap:this.graphHierarchy.buildSeriesGroupMapToggled(t)});jOt(this.basicGraph,n,e).then(function(t){this.set("graphHierarchy",t),this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))}_deselectPreviousEdge(){Su("."+UNt.Edge.SELECTED).classed(UNt.Edge.SELECTED,!1).each(((t,e)=>{if(t.label){const e=Su(this).selectAll("path.edgeline");t.label.startMarkerId&&e.style("marker-start",`url(#${t.label.startMarkerId})`),t.label.endMarkerId&&e.style("marker-end",`url(#${t.label.endMarkerId})`)}}))}_updateMarkerOfSelectedEdge(t){if(t.label){const e=t.label.startMarkerId||t.label.endMarkerId;if(e){const n=e.replace("dataflow-","selected-");let i=this.$$("#"+n);if(!i){const t=this.$.scene.querySelector("#"+e);i=t.cloneNode(!0),i.setAttribute("id",n),i.classList.add("selected-arrowhead"),t.parentNode.appendChild(i)}const r=t.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(r,`url(#${n})`)}}}not(t){return!t}};eRt.template=_e`
    <style>
      .container {
        width: 100%;
        height: 100%;
        background: white;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
      }

      .vertical {
        width: 100%;
        height: 100%;
        @apply --layout-vertical;
      }

      .auto {
        @apply --layout-flex-auto;
        @apply --layout-vertical;
      }

      h2 {
        text-align: center;
      }

      paper-button {
        text-transform: none;
      }
    </style>
    <div class="container">
      <div class="vertical">
        <template is="dom-if" if="[[title]]">
          <h2>[[title]]</h2>
        </template>
        <tf-graph-scene
          id="scene"
          class="auto"
          render-hierarchy="[[renderHierarchy]]"
          highlighted-node="[[_getVisible(highlightedNode)]]"
          selected-node="{{selectedNode}}"
          selected-edge="{{selectedEdge}}"
          color-by="[[colorBy]]"
          progress="[[progress]]"
          node-context-menu-items="[[nodeContextMenuItems]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="{{healthPillStepIndex}}"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
        ></tf-graph-scene>
      </div>
    </div>
  `,t([o({type:Object,notify:!0,observer:"_graphChanged"}),e("design:type",HOt)],eRt.prototype,"graphHierarchy",void 0),t([o({type:Object}),e("design:type",XIt)],eRt.prototype,"basicGraph",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"stats",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"devicesForStats",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"hierarchyParams",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],eRt.prototype,"progress",void 0),t([o({type:String}),e("design:type",String)],eRt.prototype,"title",void 0),t([o({type:String,notify:!0}),e("design:type",String)],eRt.prototype,"selectedNode",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],eRt.prototype,"selectedEdge",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"_lastSelectedEdgeGroup",void 0),t([o({type:String,notify:!0}),e("design:type",String)],eRt.prototype,"highlightedNode",void 0),t([o({type:String}),e("design:type",String)],eRt.prototype,"colorBy",void 0),t([o({type:Object,notify:!0,readOnly:!0}),e("design:type",Object)],eRt.prototype,"colorByParams",void 0),t([o({type:Object,readOnly:!0,notify:!0}),e("design:type",bNt)],eRt.prototype,"renderHierarchy",void 0),t([o({type:Boolean}),e("design:type",Boolean)],eRt.prototype,"traceInputs",void 0),t([o({type:Boolean}),e("design:type",Boolean)],eRt.prototype,"autoExtractNodes",void 0),t([o({type:Array}),e("design:type",Array)],eRt.prototype,"nodeContextMenuItems",void 0),t([o({type:Number}),e("design:type",Number)],eRt.prototype,"_renderDepth",void 0),t([o({type:Boolean}),e("design:type",Boolean)],eRt.prototype,"_allowGraphSelect",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"nodeNamesToHealthPills",void 0),t([o({type:Number}),e("design:type",Number)],eRt.prototype,"healthPillStepIndex",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"edgeWidthFunction",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"handleNodeSelected",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"edgeLabelFunction",void 0),t([o({type:Object}),e("design:type",Object)],eRt.prototype,"handleEdgeSelected",void 0),t([a("autoExtractNodes"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eRt.prototype,"_autoExtractNodesChanged",null),t([a("graphHierarchy","edgeWidthFunction","handleNodeSelected","edgeLabelFunction","handleEdgeSelected"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eRt.prototype,"_buildNewRenderHierarchy",null),t([a("stats","devicesForStats"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eRt.prototype,"_statsChanged",null),t([a("selectedNode"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eRt.prototype,"_selectedNodeChanged",null),t([a("selectedEdge"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],eRt.prototype,"_selectedEdgeChanged",null),eRt=t([i("tf-graph")],eRt);const nRt={MAX_NODE_COUNT:1e4,MAX_EDGE_COUNT:1e4};let iRt=class extends(tr(ye)){constructor(){super(...arguments),this.hierarchyParams=VOt,this.allStepsModeEnabled=!1,this.specificHealthPillStep=0,this.compatNodeTitle="TPU Compatibility"}fit(){this.$.graph.fit()}downloadAsImage(t){return n(this,void 0,void 0,(function*(){const e=yield this.$.graph.getImageBlob(),n=document.createElement("a");n.href=URL.createObjectURL(e),n.download=t,n.click(),URL.revokeObjectURL(n.href)}))}_isNotComplete(t){return t.value<100}_getContainerClass(t){var e="container";return t.error&&(e+=" error"),this._isNotComplete(t)&&(e+=" loading"),e}_onNodeInclusionToggled(t){this.$.graph.nodeToggleExtract(t.detail.name)}_onNodeSeriesGroupToggled(t){this.$.graph.nodeToggleSeriesGroup(t.detail.name)}_updateNodeInclude(){const t=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=t?t.include:qIt.UNSPECIFIED}_slimGraphChanged(){if(!this.graph)return;const{MAX_NODE_COUNT:t,MAX_EDGE_COUNT:e}=nRt;Object.keys(this.graph.nodes).length>t&&this.graph.edges.length>e&&this.colorBy===lOt.STRUCTURE&&(this.colorBy=lOt.NONE)}_ensureTemplates(){this.graphHierarchy&&this.colorBy===lOt.STRUCTURE&&(this.graphHierarchy.getTemplateIndex()||this.graphHierarchy.updateTemplates())}};iRt.template=_e`
    <style>
      ::host {
        display: block;
      }

      /deep/ .close {
        position: absolute;
        cursor: pointer;
        left: 15px;
        bottom: 15px;
      }

      .container {
        width: 100%;
        height: 100%;
        opacity: 1;
      }

      .container.loading {
        cursor: progress;
        opacity: 0.1;
      }

      .container.loading.error {
        cursor: auto;
      }

      #info {
        position: absolute;
        right: 5px;
        top: 5px;
        padding: 0px;
        max-width: 380px;
        min-width: 320px;
        background-color: rgba(255, 255, 255, 0.9);
        @apply --shadow-elevation-2dp;
      }

      #main {
        width: 100%;
        height: 100%;
      }

      #progress-bar {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: 100%;
        position: absolute;
        top: 40px;
        left: 0;
        font-size: 13px;
      }

      #progress-msg {
        margin-bottom: 5px;
        white-space: pre-wrap;
        width: 400px;
      }

      paper-progress {
        width: 400px;
        --paper-progress-height: 6px;
        --paper-progress-active-color: #f3913e;
      }

      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }

      /deep/ .context-menu ul {
        list-style-type: none;
        margin: 0;
        padding: 0;
        cursor: default;
      }

      /deep/ .context-menu ul li {
        padding: 4px 16px;
      }

      /deep/ .context-menu ul li:hover {
        background-color: #f3913e;
        color: white;
      }
    </style>
    <template is="dom-if" if="[[_isNotComplete(progress)]]">
      <div id="progress-bar">
        <div id="progress-msg">[[progress.msg]]</div>
        <paper-progress value="[[progress.value]]"></paper-progress>
      </div>
    </template>
    <div class$="[[_getContainerClass(progress)]]">
      <div id="main">
        <tf-graph
          id="graph"
          graph-hierarchy="{{graphHierarchy}}"
          basic-graph="[[graph]]"
          hierarchy-params="[[hierarchyParams]]"
          render-hierarchy="{{renderHierarchy}}"
          devices-for-stats="[[devicesForStats]]"
          stats="[[stats]]"
          selected-node="{{selectedNode}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="{{colorByParams}}"
          progress="{{progress}}"
          edge-label-function="[[edgeLabelFunction]]"
          edge-width-function="[[edgeWidthFunction]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          health-pill-step-index="[[healthPillStepIndex]]"
          handle-node-selected="[[handleNodeSelected]]"
          handle-edge-selected="[[handleEdgeSelected]]"
          trace-inputs="[[traceInputs]]"
          auto-extract-nodes="[[autoExtractNodes]]"
        ></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info
          id="graph-info"
          title="selected"
          graph-hierarchy="[[graphHierarchy]]"
          render-hierarchy="[[renderHierarchy]]"
          graph="[[graph]]"
          selected-node="{{selectedNode}}"
          selected-node-include="{{_selectedNodeInclude}}"
          highlighted-node="{{_highlightedNode}}"
          color-by="[[colorBy]]"
          color-by-params="[[colorByParams]]"
          debugger-data-enabled="[[debuggerDataEnabled]]"
          are-health-pills-loading="[[areHealthPillsLoading]]"
          debugger-numeric-alerts="[[debuggerNumericAlerts]]"
          node-names-to-health-pills="[[nodeNamesToHealthPills]]"
          all-steps-mode-enabled="{{allStepsModeEnabled}}"
          specific-health-pill-step="{{specificHealthPillStep}}"
          health-pill-step-index="{{healthPillStepIndex}}"
          compat-node-title="[[compatNodeTitle]]"
          on-node-toggle-inclusion="_onNodeInclusionToggled"
          on-node-toggle-seriesgroup="_onNodeSeriesGroupToggled"
        ></tf-graph-info>
      </div>
    </div>
  `,t([o({type:Object}),e("design:type",HOt)],iRt.prototype,"graphHierarchy",void 0),t([o({type:Object}),e("design:type",XIt)],iRt.prototype,"graph",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"hierarchyParams",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"stats",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"progress",void 0),t([o({type:Boolean}),e("design:type",Boolean)],iRt.prototype,"traceInputs",void 0),t([o({type:Boolean}),e("design:type",Boolean)],iRt.prototype,"autoExtractNodes",void 0),t([o({type:String,notify:!0}),e("design:type",String)],iRt.prototype,"colorBy",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],iRt.prototype,"colorByParams",void 0),t([o({type:Object,notify:!0}),e("design:type",bNt)],iRt.prototype,"renderHierarchy",void 0),t([o({type:Boolean}),e("design:type",Boolean)],iRt.prototype,"debuggerDataEnabled",void 0),t([o({type:Boolean}),e("design:type",Boolean)],iRt.prototype,"areHealthPillsLoading",void 0),t([o({type:Array,notify:!0}),e("design:type",Array)],iRt.prototype,"debuggerNumericAlerts",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"nodeNamesToHealthPills",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],iRt.prototype,"allStepsModeEnabled",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],iRt.prototype,"specificHealthPillStep",void 0),t([o({type:Number}),e("design:type",Number)],iRt.prototype,"healthPillStepIndex",void 0),t([o({type:String,notify:!0}),e("design:type",String)],iRt.prototype,"selectedNode",void 0),t([o({type:String}),e("design:type",String)],iRt.prototype,"compatNodeTitle",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"edgeWidthFunction",void 0),t([o({type:Number}),e("design:type",Number)],iRt.prototype,"_selectedNodeInclude",void 0),t([o({type:String}),e("design:type",String)],iRt.prototype,"_highlightedNode",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"handleNodeSelected",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"edgeLabelFunction",void 0),t([o({type:Object}),e("design:type",Object)],iRt.prototype,"handleEdgeSelected",void 0),t([a("selectedNode","renderHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],iRt.prototype,"_updateNodeInclude",null),t([a("graph"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],iRt.prototype,"_slimGraphChanged",null),t([a("colorBy","graphHierarchy"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],iRt.prototype,"_ensureTemplates",null),iRt=t([i("tf-graph-board")],iRt);let rRt=class extends(tr(ye)){constructor(){super(...arguments),this._rawRegexInput="",this._previousRegexInput="",this._searchTimeoutDelay=150,this._maxRegexResults=42}get _regexInput(){return this._rawRegexInput.trim()}_regexInputChanged(){this._requestSearch()}_clearSearchResults(){this.set("_regexMatches",[])}_requestSearch(){this._searchPending||(this._regexInput!==this._previousRegexInput?(this._searchPending=!0,this._executeSearch(),this.async((()=>{this._searchPending=!1,this._requestSearch()}),this._searchTimeoutDelay)):this._searchPending=!1)}_executeSearch(){if(this._previousRegexInput=this._regexInput,!this._regexInput)return void this._clearSearchResults();try{var t=new RegExp(this._regexInput)}catch(t){return void this._clearSearchResults()}const e=[],n=this.renderHierarchy.hierarchy.getNodeMap();we.each(n,((n,i)=>{if(e.length>=this._maxRegexResults)return!1;t.test(i)&&e.push(i)})),this.set("_regexMatches",e)}_matchClicked(t){this.set("selectedNode",t.model.item),CIt({actionId:vIt.NODE_SEARCH_RESULT_FOCUSED})}};rRt.template=_e`
    <div id="search-container">
      <paper-input
        id="runs-regex"
        label="Search nodes (regex)"
        value="{{_rawRegexInput}}"
      >
      </paper-input>
      <div id="search-results-anchor">
        <div id="search-results">
          <template is="dom-repeat" items="[[_regexMatches]]">
            <div id="search-match" on-click="_matchClicked">[[item]]</div>
          </template>
        </div>
      </div>
    </div>
    <style>
      #search-container {
        width: 100%;
        overflow: visible;
      }

      #runs-regex {
        width: 100%;
      }

      #search-results-anchor {
        position: relative;
      }

      #search-results {
        color: #fff;
        position: absolute;
        max-height: 200px;
        overflow-x: hidden;
        overflow-y: auto;
        text-align: right;
        max-width: 100%;
        box-sizing: border-box;
      }

      #search-match {
        background: var(--tb-orange-strong);
        padding: 3px;
        float: right;
        width: 100%;
        box-sizing: border-box;
        direction: rtl;
      }

      #search-match:hover {
        background: var(--tb-orange-weak);
        cursor: pointer;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],rRt.prototype,"renderHierarchy",void 0),t([o({type:String,notify:!0}),e("design:type",String)],rRt.prototype,"selectedNode",void 0),t([o({type:String}),e("design:type",String)],rRt.prototype,"_rawRegexInput",void 0),t([o({type:String}),e("design:type",String)],rRt.prototype,"_previousRegexInput",void 0),t([o({type:Number}),e("design:type",Number)],rRt.prototype,"_searchTimeoutDelay",void 0),t([o({type:Boolean}),e("design:type",Boolean)],rRt.prototype,"_searchPending",void 0),t([o({type:Number}),e("design:type",Number)],rRt.prototype,"_maxRegexResults",void 0),t([o({type:Array}),e("design:type",Array)],rRt.prototype,"_regexMatches",void 0),t([s("renderHierarchy","_rawRegexInput"),e("design:type",String),e("design:paramtypes",[])],rRt.prototype,"_regexInput",null),t([a("_regexInput"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],rRt.prototype,"_regexInputChanged",null),rRt=t([i("tf-graph-node-search")],rRt);const oRt=/device:([^:]+:[0-9]+)$/,aRt=[{regex:oRt}],sRt=[],lRt=new Set([lOt.COMPUTE_TIME,lOt.MEMORY]);let cRt=class extends(tr(ye)){constructor(){super(...arguments),this.ColorBy=lOt,this.stats=null,this.devicesForStats=null,this.colorBy=lOt.STRUCTURE,this.datasets=[],this._selectedRunIndex=0,this.traceInputs=!1,this.autoExtractNodes=!0,this._selectedTagIndex=0,this._selectedGraphType=bIt.OP_GRAPH,this.showSessionRunsDropdown=!0,this.showUploadButton=!0,this._legendOpened=!0,this._downloadFilename="graph.png"}_onGraphTypeChangedByUserGesture(){CIt({actionId:vIt.GRAPH_TYPE_CHANGED,eventLabel:this._selectedGraphType})}_onColorByChangedByUserGesture(){CIt({actionId:vIt.NODE_COLOR_MODE_CHANGED,eventLabel:this.colorBy})}_onTraceInputsChangedByUserGesture(){CIt({actionId:vIt.TRACE_INPUT_MODE_TOGGLED})}_xlaClustersProvided(t){return t&&t.hierarchy&&t.hierarchy.xlaClusters.length>0}_statsChanged(t){if(null!=t){var e={};we.each(t.dev_stats,(function(t){var n=we.some(aRt,(function(e){return e.regex.test(t.device)})),i=we.some(sRt,(function(e){return e.regex.test(t.device)}));n&&!i&&(e[t.device]=!0)})),this.set("devicesForStats",e)}}get _currentDevices(){var t=this.devicesForStats;const e=this.stats,n=(e?e.dev_stats:[]).map((t=>t.device)).filter((t=>aRt.some((e=>e.regex.test(t))))),i=BIt(n);if(1==i.length){const t=i[0].match(oRt);t&&(i[0]=t[1])}return n.map(((e,n)=>{let r=null;return sRt.forEach((t=>{t.regex.test(e)&&(r=t.msg)})),{device:e,suffix:i[n],used:t[e],ignoredMsg:r}}))}_deviceCheckboxClicked(t){const e=t.target,n=Object.assign({},this.devicesForStats),i=e.value;e.checked?n[i]=!0:delete n[i],this.set("devicesForStats",n)}_numTags(t,e){return this._getTags(t,e).length}_getTags(t,e){return t&&t[e]?t[e].tags:[]}_fit(){this.fire("fit-tap")}_isGradientColoring(t,e){return lRt.has(e)&&null!=t}_equals(t,e){return t===e}get _currentDeviceParams(){const t=this.colorByParams.device.filter((t=>aRt.some((e=>e.regex.test(t.device))))),e=BIt(t.map((t=>t.device)));if(1==e.length){var n=e[0].match(oRt);n&&(e[0]=n[1])}return t.map(((t,n)=>({device:e[n],color:t.color})))}get _currentXlaClusterParams(){return this.colorByParams.xla_cluster}get _currentGradientParams(){var t=this.colorByParams,e=this.colorBy;if(!this._isGradientColoring(this.stats,e))return;const n=t[e];let i=n.minValue,r=n.maxValue;return e===lOt.MEMORY?(i=zIt(i,OIt),r=zIt(r,OIt)):e===lOt.COMPUTE_TIME&&(i=zIt(i,RIt),r=zIt(r,RIt)),{minValue:i,maxValue:r,startColor:n.startColor,endColor:n.endColor}}download(){this.fire("download-image-requested",this._downloadFilename)}_updateFileInput(t){const e=t.target.files[0];if(!e)return;let n=e.name;const i=n.lastIndexOf(".");i>=0&&(n=n.substring(0,i));const r=n.lastIndexOf("/");r>=0&&(n=n.substring(r+1)),this._setDownloadFilename(n),this.set("selectedFile",t),CIt({actionId:vIt.UPLOADED_GRAPH_FROM_FILESYSTEM})}_datasetsChanged(t,e){var n;null!=e&&(this._selectedRunIndex=0),this._setDownloadFilename(null===(n=this.datasets[this._selectedRunIndex])||void 0===n?void 0:n.name)}_computeSelection(t,e,n,i){return t[e]&&t[e].tags[n]?{run:t[e].name,tag:t[e].tags[n].tag,type:i}:null}_selectedRunIndexChanged(t){var e;this.datasets&&(this.colorBy=lOt.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename(null===(e=this.datasets[t])||void 0===e?void 0:e.name))}_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()}_getDefaultSelectionType(){const{datasets:t,_selectedRunIndex:e,_selectedTagIndex:n}=this;if(!t||!t[e]||!t[e].tags[n]||t[e].tags[n].opGraph)return bIt.OP_GRAPH;const i=t[e];return i.tags[n].profile?bIt.PROFILE:i.tags[n].conceptualGraph?bIt.CONCEPTUAL_GRAPH:bIt.OP_GRAPH}_getFile(){this.$$("#file").click()}_setDownloadFilename(t){this._downloadFilename=(t||"graph")+".png"}_statsNotNull(t){return null!==t}_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)}_getToggleLegendIcon(t){return t?"expand-more":"expand-less"}_getSelectionOpGraphDisabled(t,e,n){return!t[e]||!t[e].tags[n]||!t[e].tags[n].opGraph}_getSelectionProfileDisabled(t,e,n){return!t[e]||!t[e].tags[n]||!t[e].tags[n].profile}_getSelectionConceptualGraphDisabled(t,e,n){return!t[e]||!t[e].tags[n]||!t[e].tags[n].conceptualGraph}};cRt.template=_e`
    <style>
      :host {
        color: gray;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
        --tb-graph-controls-text-color: #555;
        --tb-graph-controls-title-font-size: 14px;
        --tb-graph-controls-subtitle-font-size: 14px;
        --paper-input-container-shared-input-style_-_font-size: 14px;
        --paper-font-subhead_-_font-size: 14px;
      }

      paper-dropdown-menu {
        --paper-dropdown-menu-input: {
          padding: 0;
          color: gray;
        }
        --iron-icon-width: 15px;
        --iron-icon-height: 15px;
        --primary-text-color: gray;
        --paper-item-min-height: 30px;
      }

      paper-button[raised].keyboard-focus {
        font-weight: normal;
      }

      .run-dropdown {
        --paper-input-container: {
          padding: 5px 0 5px 5px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table tr {
        height: 20px;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: #e9e9e9;
        box-sizing: border-box;
        color: var(--tb-graph-controls-text-color);
        width: 100%;
      }

      .legend-toolbar {
        appearance: none;
        background-color: inherit;
        border-top: 1px solid #ccc;
        border-bottom: 1px solid #ccc;
        border-right: none;
        border-left: none;
        cursor: pointer;
        font: inherit;
        display: flex;
        align-items: center;
        justify-content: space-between;
        width: 100%;
      }

      .legend-toolbar,
      .legend-content {
        padding: 8px 20px;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        font-size: var(--tb-graph-controls-subtitle-font-size);
      }

      paper-radio-button {
        display: block;
        padding: 5px;
      }
      svg.icon,
      tf-graph-icon {
        width: 60px;
        height: 18px;
      }
      .domainValues {
        margin-bottom: 10px;
        width: 165px;
      }
      .domainStart {
        float: left;
      }
      .domainEnd {
        float: right;
      }
      .colorBox {
        width: 20px;
      }

      .image-icon {
        width: 24px;
        height: 24px;
      }

      .help-icon {
        height: 15px;
        margin: 0;
        padding: 0;
      }

      .gray {
        color: #666;
      }

      .title {
        font-size: var(--tb-graph-controls-title-font-size);
        margin: 8px 5px 8px 0;
        color: black;
      }
      .title small {
        font-weight: normal;
      }
      .deviceList,
      .xlaClusterList {
        max-height: 200px;
        overflow-y: auto;
      }

      #file {
        padding: 8px 0;
      }

      .color-legend-row {
        align-items: center;
        clear: both;
        display: flex;
        height: 20px;
        margin-top: 5px;
      }

      .color-legend-row .label,
      .color-legend-row svg,
      .color-legend-row tf-graph-icon {
        flex: 0 0 40px;
        margin-right: 20px;
      }

      .devices-checkbox input {
        text-align: left;
        vertical-align: middle;
      }

      .control-holder .icon-button {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        margin: 0 -5px;
        padding: 5px;
        display: flex;
        justify-content: flex-start;
        color: var(--tb-graph-controls-text-color);
      }

      .button-text {
        padding-left: 20px;
        text-transform: none;
      }

      .upload-button {
        width: 165px;
        height: 25px;
        text-transform: none;
        margin-top: 4px;
      }

      .button-icon {
        width: 26px;
        height: 26px;
        color: var(--paper-orange-500);
      }

      .hidden-input {
        display: none;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder.control-options {
        padding: 0 0 15px 15px;
        flex-direction: column;
      }

      .allcontrols .control-holder paper-toggle-button {
        margin-bottom: 5px;
      }

      span.counter {
        font-size: var(--tb-graph-controls-subtitle-font-size);
        color: gray;
        margin-left: 4px;
      }

      .runs-row .title,
      .tags-row .title {
        display: flex;
        align-items: baseline;
      }

      .runs-row paper-item,
      .tags-row paper-item {
        --paper-item: {
          white-space: nowrap;
        }
      }

      table.control-holder {
        border: 0;
        border-collapse: collapse;
      }

      table.tf-graph-controls td.input-element-table-data {
        padding: 0 0 0 20px;
      }

      .spacer {
        flex-grow: 1;
      }

      .color-text {
        overflow: hidden;
      }

      .color-text.gradient-container {
        margin: 0 5px;
      }

      /** Override inline styles that suppress pointer events for disabled buttons. Otherwise, the */
      /*  tooltips do not appear. */
      paper-radio-group paper-radio-button {
        pointer-events: auto !important;
      }

      .legend-clarifier {
        color: #266236;
        cursor: help;
        display: inline-block;
        text-decoration: underline;
      }

      .legend-clarifier paper-tooltip {
        width: 150px;
      }

      /** Otherwise, polymer UI controls appear atop node search. */
      tf-graph-node-search {
        z-index: 1;
        width: 100%;
      }

      paper-dropdown-menu {
        flex-grow: 1;
      }
    </style>

    <div class="allcontrols">
      <div class="control-holder">
        <tf-graph-node-search
          selected-node="{{selectedNode}}"
          render-hierarchy="[[renderHierarchy]]"
        ></tf-graph-node-search>
      </div>
      <div class="control-holder">
        <paper-button class="icon-button" on-tap="_fit" alt="Fit to screen">
          <iron-icon icon="aspect-ratio" class="button-icon"></iron-icon>
          <span class="button-text">Fit to screen</span>
        </paper-button>
      </div>
      <div class="control-holder">
        <paper-button
          class="icon-button"
          on-click="download"
          alt="Download PNG"
        >
          <iron-icon icon="file-download" class="button-icon"></iron-icon>
          <span class="button-text">Download PNG</span>
        </paper-button>
      </div>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <paper-button
            class="icon-button"
            on-click="_getFile"
            alt="Upload file"
            title="Upload a pbtxt file to view a graph from the local filesystem"
          >
            <iron-icon icon="file-upload" class="button-icon"></iron-icon>
            <span class="button-text">Upload file</span>
          </paper-button>

          <div class="hidden-input">
            <input
              type="file"
              id="file"
              name="file"
              on-change="_updateFileInput"
              accept=".pbtxt"
            />
          </div>
        </div>
      </template>
      <div class="control-holder runs-row">
        <div class="title">
          Run <span class="counter">([[datasets.length]])</span>
        </div>
        <paper-dropdown-menu
          no-label-float
          no-animations
          noink
          horizontal-align="left"
          class="run-dropdown"
        >
          <paper-listbox
            class="dropdown-content"
            selected="{{_selectedRunIndex}}"
            slot="dropdown-content"
          >
            <template is="dom-repeat" items="[[datasets]]">
              <paper-item>[[item.name]]</paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <template is="dom-if" if="[[showSessionRunsDropdown]]">
        <div class="control-holder tags-row">
          <div class="title">
            Tag
            <span class="counter"
              >([[_numTags(datasets, _selectedRunIndex)]])</span
            >
          </div>
          <paper-dropdown-menu
            no-label-float
            no-animations
            horizontal-align="left"
            noink
            class="run-dropdown"
          >
            <paper-listbox
              class="dropdown-content"
              selected="{{_selectedTagIndex}}"
              slot="dropdown-content"
            >
              <template
                is="dom-repeat"
                items="[[_getTags(datasets, _selectedRunIndex)]]"
              >
                <paper-item>[[item.displayName]]</paper-item>
              </template>
            </paper-listbox>
          </paper-dropdown-menu>
        </div>
      </template>
      <div class="title">Graph type</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{_selectedGraphType}}"
          on-paper-radio-group-changed="_onGraphTypeChangedByUserGesture"
        >
          <!-- Note that the name has to match that of tf_graph_common.SelectionType. -->
          <paper-radio-button
            name="op_graph"
            disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Op graph</paper-radio-button
          >
          <paper-radio-button
            name="conceptual_graph"
            disabled="[[_getSelectionConceptualGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Conceptual graph</paper-radio-button
          >
          <paper-radio-button
            name="profile"
            disabled="[[_getSelectionProfileDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]"
            >Profile</paper-radio-button
          >
        </paper-radio-group>
      </div>
      <div class="title">Node options</div>
      <div class="control-holder control-options">
        <paper-toggle-button
          checked="{{traceInputs}}"
          on-change="_onTraceInputsChangedByUserGesture"
        >
          Trace inputs
        </paper-toggle-button>
        <paper-toggle-button checked="{{autoExtractNodes}}">
          Auto-extract high-degree nodes
        </paper-toggle-button>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}"
            >Show health pills</paper-toggle-button
          >
        </div>
      </template>
      <div class="title">Color by</div>
      <div class="control-holder control-options">
        <paper-radio-group
          selected="{{colorBy}}"
          on-paper-radio-group-changed="_onColorByChangedByUserGesture"
        >
          <paper-radio-button name="[[ColorBy.NONE]]">None</paper-radio-button>

          <paper-radio-button name="[[ColorBy.STRUCTURE]]"
            >Structure</paper-radio-button
          >

          <paper-radio-button name="[[ColorBy.DEVICE]]"
            >Device</paper-radio-button
          >

          <paper-radio-button
            id="xla-cluster-radio-button"
            name="[[ColorBy.XLA_CLUSTER]]"
            disabled="[[!_xlaClustersProvided(renderHierarchy)]]"
          >
            XLA cluster
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="xla-cluster-radio-button"
            position="right"
            offset="0"
          >
            Coloring by XLA cluster is only enabled if at least 1 op specifies
            an XLA cluster.
          </paper-tooltip>

          <paper-radio-button
            id="compute-time-radio-button"
            name="[[ColorBy.COMPUTE_TIME]]"
            disabled="[[!stats]]"
          >
            Compute time
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="compute-time-radio-button"
            position="right"
            offset="0"
          >
            Coloring by compute time is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="memory-radio-button"
            name="[[ColorBy.MEMORY]]"
            disabled="[[!stats]]"
          >
            Memory
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="memory-radio-button"
            position="right"
            offset="0"
          >
            Coloring by memory is only enabled if the RunMetadata proto is
            passed to the FileWriter when a specific session is run.
          </paper-tooltip>

          <paper-radio-button
            id="tpu-compatibility-radio-button"
            name="[[ColorBy.OP_COMPATIBILITY]]"
          >
            TPU compatibility
          </paper-radio-button>
          <paper-tooltip
            animation-delay="0"
            for="tpu-compatibility-radio-button"
            position="right"
            offset="0"
          >
            Coloring by whether an operation is compatible for the TPU device.
          </paper-tooltip>
        </paper-radio-group>
        <span class="spacer"></span>
      </div>
    </div>
    <div class="legend-holder">
      <button class="legend-toolbar" on-click="_toggleLegendOpen">
        <span class="toggle-legend-text">Legend</span>
        <iron-icon
          icon="[[_getToggleLegendIcon(_legendOpened)]]"
          class="toggle-legend-button"
        >
        </iron-icon>
      </button>
      <iron-collapse opened="[[_legendOpened]]" class="legend-content">
        <!-- Color-mode-specific legend items -->
        <div>
          <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
            <svg width="140" height="20" class="color-text gradient-container">
              <defs>
                <linearGradient
                  id="linearGradient"
                  x1="0%"
                  y1="0%"
                  x2="100%"
                  y2="0%"
                >
                  <stop
                    class="start"
                    offset="0%"
                    stop-color$="[[_currentGradientParams.startColor]]"
                  ></stop>
                  <stop
                    class="end"
                    offset="100%"
                    stop-color$="[[_currentGradientParams.endColor]]"
                  ></stop>
                </linearGradient>
              </defs>
              <rect
                x="0"
                y="0"
                width="135"
                height="20"
                fill="url(#linearGradient)"
                stroke="black"
              ></rect>
            </svg>
            <div class="domainValues color-text">
              <div class="domainStart">[[_currentGradientParams.minValue]]</div>
              <div class="domainEnd">[[_currentGradientParams.maxValue]]</div>
            </div>
            <br style="clear: both" />
            <div>Devices included in stats:</div>
            <div class="deviceList">
              <template is="dom-repeat" items="[[_currentDevices]]">
                <div class="color-legend-row devices-checkbox">
                  <span
                    ><input
                      type="checkbox"
                      value$="[[item.device]]"
                      checked$="[[item.used]]"
                      on-click="_deviceCheckboxClicked"
                  /></span>
                  <span>[[item.suffix]]</span>
                  <template is="dom-if" if="[[item.ignoredMsg]]">
                    <paper-icon-button
                      icon="help"
                      class="help-icon"
                    ></paper-icon-button>
                    <paper-tooltip
                      position="right"
                      offset="0"
                      animation-delay="0"
                      >[[item.ignoredMsg]]</paper-tooltip
                    >
                  </template>
                </div>
              </template>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'structure')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <span class="label"> colors </span>
                <span class="color-legend-value">same substructure</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unique substructure</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'device')]]">
            <div>
              <template is="dom-repeat" items="[[_currentDeviceParams]]">
                <div class="color-legend-row">
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="[[item.color]]"
                    stroke-override="#a6a6a6"
                  ></tf-graph-icon>
                  <span class="color-legend-value">[[item.device]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="META"
                  height="16"
                  fill-override="#eee"
                  stroke-override="#a6a6a6"
                ></tf-graph-icon>
                <span class="color-legend-value">unknown device</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'xla_cluster')]]">
            <div>
              <template is="dom-repeat" items="[[_currentXlaClusterParams]]">
                <div class="color-legend-row">
                  <svg>
                    <use
                      xmlns:xlink="http://www.w3.org/1999/xlink"
                      xlink:href="#unfilled-rect"
                      x="0"
                      y="0"
                      style="fill:[[item.color]]"
                    ></use>
                  </svg>
                  <span class="color-legend-value">[[item.xla_cluster]]</span>
                </div>
              </template>
              <div class="color-legend-row">
                <svg>
                  <use
                    xmlns:xlink="http://www.w3.org/1999/xlink"
                    xlink:href="#grey-rect"
                    x="0"
                    y="0"
                  ></use>
                </svg>
                <span class="color-legend-value">unknown XLA cluster</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_equals(colorBy, 'op_compatibility')]]">
            <div class="color-text">
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#0f9d58"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Valid Op</span>
              </div>
              <div class="color-legend-row">
                <tf-graph-icon
                  type="OP"
                  height="16"
                  fill-override="#db4437"
                  stroke-override="#ccc"
                ></tf-graph-icon>
                <span class="color-legend-value">Invalid Op</span>
              </div>
            </div>
          </template>
          <template is="dom-if" if="[[_statsNotNull(stats)]]">
            <div class="color-legend-row">
              <tf-graph-icon type="META" height="16" faded></tf-graph-icon>
              <span class="color-legend-value">unused substructure</span>
            </div>
          </template>
        </div>

        <!-- Common legend items -->
        <div>
          <table>
            <tbody>
              <tr>
                <td></td>
                <td>(* = expandable)</td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="META"
                    height="16"
                    fill-override="#d9d9d9"
                    stroke-override="#ccc"
                  ></tf-graph-icon>
                </td>
                <td>
                  Namespace<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Encapsulates a set of nodes. Namespace is hierarchical and
                      based on scope.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="OP" height="16"></tf-graph-icon>
                </td>
                <td>
                  OpNode
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that performs an operation. These nodes cannot
                      expand.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SERIES" height="16"></tf-graph-icon>
                </td>
                <td>
                  Unconnected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are not connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon
                    type="SERIES"
                    height="16"
                    vertical
                  ></tf-graph-icon>
                </td>
                <td>
                  Connected series<span class="gray">*</span>
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Sequence of numbered nodes that are connected to each
                      other.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg class="icon">
                    <circle
                      fill="white"
                      stroke="#848484"
                      cx="10"
                      cy="10"
                      r="5"
                    ></circle>
                  </svg>
                </td>
                <td>
                  Constant
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that outputs a constant value.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <tf-graph-icon type="SUMMARY" height="20"></tf-graph-icon>
                </td>
                <td>
                  Summary
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Node that collects data for visualization within
                      TensorBoard.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="dataflow-arrowhead-legend"
                        fill="#bbb"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#dataflow-arrowhead-legend)"
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Dataflow edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the data flow between operations. Edges flow
                      upwards unless arrowheads specify otherwise.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <path
                      stroke="#bbb"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                      stroke-dasharray="2, 2"
                    ></path>
                  </svg>
                </td>
                <td>
                  Control dependency edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing the control dependency between operations.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
              <tr>
                <td>
                  <svg
                    class="icon"
                    height="15px"
                    preserveAspectRatio="xMinYMid meet"
                    viewBox="0 0 15 15"
                  >
                    <defs>
                      <marker
                        id="reference-arrowhead-legend"
                        fill="#FFB74D"
                        markerWidth="10"
                        markerHeight="10"
                        refX="9"
                        refY="5"
                        orient="auto-start-reverse"
                      >
                        <path d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0"></path>
                      </marker>
                    </defs>
                    <path
                      marker-end="url(#reference-arrowhead-legend)"
                      stroke="#FFB74D"
                      d="M2 9 l 29 0"
                      stroke-linecap="round"
                    ></path>
                  </svg>
                </td>
                <td>
                  Reference edge
                  <div class="legend-clarifier">
                    <span>?</span>
                    <paper-tooltip
                      animation-delay="0"
                      position="right"
                      offset="0"
                    >
                      Edge showing that the outgoing operation node can mutate
                      the incoming tensor.
                    </paper-tooltip>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </div>
      </iron-collapse>
    </div>
  `,t([o({type:Object,observer:"_statsChanged"}),e("design:type",Object)],cRt.prototype,"stats",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],cRt.prototype,"devicesForStats",void 0),t([o({type:String,notify:!0}),e("design:type",String)],cRt.prototype,"colorBy",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],cRt.prototype,"colorByParams",void 0),t([o({type:Array,observer:"_datasetsChanged"}),e("design:type",Object)],cRt.prototype,"datasets",void 0),t([o({type:Object}),e("design:type",bNt)],cRt.prototype,"renderHierarchy",void 0),t([o({type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"}),e("design:type",Object)],cRt.prototype,"selection",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],cRt.prototype,"selectedFile",void 0),t([o({type:Number,observer:"_selectedRunIndexChanged"}),e("design:type",Number)],cRt.prototype,"_selectedRunIndex",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],cRt.prototype,"traceInputs",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],cRt.prototype,"autoExtractNodes",void 0),t([o({type:Number,observer:"_selectedTagIndexChanged"}),e("design:type",Number)],cRt.prototype,"_selectedTagIndex",void 0),t([o({type:String}),e("design:type",String)],cRt.prototype,"_selectedGraphType",void 0),t([o({type:String,notify:!0}),e("design:type",String)],cRt.prototype,"selectedNode",void 0),t([o({type:Boolean}),e("design:type",Boolean)],cRt.prototype,"showSessionRunsDropdown",void 0),t([o({type:Boolean}),e("design:type",Boolean)],cRt.prototype,"showUploadButton",void 0),t([o({type:Boolean}),e("design:type",Boolean)],cRt.prototype,"healthPillsFeatureEnabled",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],cRt.prototype,"healthPillsToggledOn",void 0),t([o({type:Boolean}),e("design:type",Boolean)],cRt.prototype,"_legendOpened",void 0),t([s("devicesForStats"),e("design:type",Array),e("design:paramtypes",[])],cRt.prototype,"_currentDevices",null),t([s("colorByParams"),e("design:type",Array),e("design:paramtypes",[])],cRt.prototype,"_currentDeviceParams",null),t([s("colorByParams"),e("design:type",Array),e("design:paramtypes",[])],cRt.prototype,"_currentXlaClusterParams",null),t([s("colorByParams","colorBy"),e("design:type",Object),e("design:paramtypes",[])],cRt.prototype,"_currentGradientParams",null),cRt=t([i("tf-graph-controls")],cRt);class uRt{isNotTpuOp(t){return-1!=t.toLowerCase().search("cpu:")||-1!=t.toLowerCase().search("gpu:")||-1==t.toLowerCase().search("tpu")}opValid(t){return 0==t.name.search(UIt)||!t.op||!(!t.device||!this.isNotTpuOp(t.device))||!(!t.device||-1==t.device.search("TPU_SYSTEM"))||we.includes(uRt.WHITELIST,t.op)}}function hRt(t){return new Promise(((e,n)=>{fetch(t).then((t=>{t.ok?t.arrayBuffer().then(e,n):t.text().then(n,n)}))}))}uRt.WHITELIST=["Abs","Acos","Acosh","Add","AddN","AddV2","AdjustContrastv2","AdjustHue","AdjustSaturation","All","AllToAll","Angle","Any","ApproximateEqual","ArgMax","ArgMin","Asin","Asinh","Assert","AssignAddVariableOp","AssignSubVariableOp","AssignVariableOp","Atan","Atan2","Atanh","AvgPool","AvgPool3D","AvgPool3DGrad","AvgPoolGrad","BatchMatMul","BatchMatMulV2","BatchToSpace","BatchToSpaceND","BesselI0e","BesselI1e","Betainc","BiasAdd","BiasAddGrad","BiasAddV1","Bitcast","BitwiseAnd","BitwiseOr","BitwiseXor","BroadcastArgs","BroadcastGradientArgs","BroadcastTo","Bucketize","Case","Cast","Ceil","CheckNumerics","Cholesky","ClipByValue","CollectivePermute","CollectiveReduceV2","Complex","ComplexAbs","Concat","ConcatOffset","ConcatV2","Conj","ConjugateTranspose","Const","ControlTrigger","Conv2D","Conv2DBackpropFilter","Conv2DBackpropInput","Conv3D","Conv3DBackpropFilterV2","Conv3DBackpropInputV2","Cos","Cosh","Cross","CrossReplicaSum","Cumprod","Cumsum","DataFormatDimMap","DataFormatVecPermute","DepthToSpace","DepthwiseConv2dNative","DepthwiseConv2dNativeBackpropFilter","DepthwiseConv2dNativeBackpropInput","Dequantize","DeviceIndex","Diag","DiagPart","Digamma","Div","DivNoNan","DynamicStitch","Einsum","Elu","EluGrad","Empty","EmptyTensorList","EnsureShape","Equal","Erf","Erfc","Erfinv","Exp","ExpandDims","Expm1","ExtractImagePatches","FFT","FFT2D","FFT3D","FakeParam","FakeQuantWithMinMaxArgs","FakeQuantWithMinMaxArgsGradient","FakeQuantWithMinMaxVars","FakeQuantWithMinMaxVarsGradient","Fill","Floor","FloorDiv","FloorMod","FusedBatchNorm","FusedBatchNormGrad","FusedBatchNormGradV2","FusedBatchNormGradV3","FusedBatchNormV2","FusedBatchNormV3","Gather","GatherNd","GatherV2","GetItem","Greater","GreaterEqual","HSVToRGB","IFFT","IFFT2D","IFFT3D","IRFFT","IRFFT2D","IRFFT3D","Identity","IdentityN","If","Igamma","IgammaGradA","Igammac","Imag","InTopKV2","InfeedDequeue","InfeedDequeueTuple","InplaceAdd","InplaceUpdate","Inv","Invert","InvertPermutation","IsFinite","IsInf","IsNan","KthOrderStatistic","L2Loss","LRN","LRNGrad","LeakyRelu","LeakyReluGrad","LeftShift","Less","LessEqual","Lgamma","LinSpace","ListDiff","Log","Log1p","LogSoftmax","LogicalAnd","LogicalNot","LogicalOr","LowerBound","MakeUnique","MatMul","MatrixBandPart","MatrixDiag","MatrixDiagPart","MatrixDiagPartV2","MatrixDiagPartV3","MatrixDiagV2","MatrixDiagV3","MatrixInverse","MatrixSetDiag","MatrixSetDiagV2","MatrixSetDiagV3","MatrixSolve","MatrixTriangularSolve","Max","MaxPool","MaxPool3D","MaxPool3DGrad","MaxPool3DGradGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Maximum","Mean","Min","Minimum","MirrorPad","MirrorPadGrad","Mod","Mul","MulNoNan","Multinomial","Ndtri","Neg","NextAfter","NoOp","NonMaxSuppressionV4","NotEqual","OneHot","OnesLike","OutfeedEnqueue","OutfeedEnqueueTuple","Pack","Pad","PadV2","ParallelDynamicStitch","ParameterizedTruncatedNormal","PartitionedCall","PlaceholderWithDefault","Polygamma","PopulationCount","Pow","PreventGradient","Prod","Qr","QuantizeAndDequantizeV2","QuantizeAndDequantizeV3","RFFT","RFFT2D","RFFT3D","RGBToHSV","RandomGammaGrad","RandomShuffle","RandomStandardNormal","RandomUniform","RandomUniformInt","Range","Rank","ReadVariableOp","Real","RealDiv","Reciprocal","ReciprocalGrad","Relu","Relu6","Relu6Grad","ReluGrad","Reshape","ResizeBilinear","ResizeBilinearGrad","ResizeNearestNeighbor","ResizeNearestNeighborGrad","ResourceApplyAdaMax","ResourceApplyAdadelta","ResourceApplyAdagrad","ResourceApplyAdagradDA","ResourceApplyAdagradV2","ResourceApplyAdam","ResourceApplyAddSign","ResourceApplyCenteredRMSProp","ResourceApplyFtrl","ResourceApplyFtrlV2","ResourceApplyGradientDescent","ResourceApplyKerasMomentum","ResourceApplyMomentum","ResourceApplyPowerSign","ResourceApplyProximalAdagrad","ResourceApplyProximalGradientDescent","ResourceApplyRMSProp","ResourceGather","ResourceScatterAdd","ResourceScatterDiv","ResourceScatterMax","ResourceScatterMin","ResourceScatterMul","ResourceScatterNdAdd","ResourceScatterNdSub","ResourceScatterNdUpdate","ResourceScatterSub","ResourceScatterUpdate","ResourceStridedSliceAssign","Reverse","ReverseSequence","ReverseV2","RightShift","Rint","RngReadAndSkip","RngSkip","Roll","Round","Rsqrt","RsqrtGrad","ScatterNd","Select","SelectV2","SelfAdjointEigV2","Selu","SeluGrad","Shape","ShapeN","Sigmoid","SigmoidGrad","Sign","Sin","Sinh","Size","Slice","Snapshot","Softmax","SoftmaxCrossEntropyWithLogits","Softplus","SoftplusGrad","Softsign","SoftsignGrad","SpaceToBatch","SpaceToBatchND","SpaceToDepth","SparseMatMul","SparseSoftmaxCrossEntropyWithLogits","SparseToDense","Split","SplitV","Sqrt","SqrtGrad","Square","SquaredDifference","Squeeze","StackCloseV2","StackPopV2","StackPushV2","StackV2","StatefulPartitionedCall","StatefulStandardNormalV2","StatefulTruncatedNormal","StatefulUniform","StatefulUniformFullInt","StatefulUniformInt","StatelessCase","StatelessIf","StatelessMultinomial","StatelessRandomGetAlg","StatelessRandomGetKeyCounter","StatelessRandomGetKeyCounterAlg","StatelessRandomNormal","StatelessRandomNormalV2","StatelessRandomUniform","StatelessRandomUniformFullInt","StatelessRandomUniformFullIntV2","StatelessRandomUniformInt","StatelessRandomUniformIntV2","StatelessRandomUniformV2","StatelessTruncatedNormal","StatelessTruncatedNormalV2","StatelessWhile","StopGradient","StridedSlice","StridedSliceGrad","Sub","Sum","Svd","SymbolicGradient","TPUEmbeddingActivations","Tan","Tanh","TanhGrad","TensorArrayCloseV3","TensorArrayConcatV3","TensorArrayGatherV3","TensorArrayGradV3","TensorArrayReadV3","TensorArrayScatterV3","TensorArraySizeV3","TensorArraySplitV3","TensorArrayV3","TensorArrayWriteV3","TensorListConcatV2","TensorListElementShape","TensorListFromTensor","TensorListGather","TensorListGetItem","TensorListLength","TensorListPopBack","TensorListPushBack","TensorListReserve","TensorListSetItem","TensorListSplit","TensorListStack","TensorScatterAdd","TensorScatterMax","TensorScatterMin","TensorScatterSub","TensorScatterUpdate","TensorStridedSliceUpdate","Tile","TopKUnique","TopKV2","TopKWithUnique","Transpose","TridiagonalSolve","TruncateDiv","TruncateMod","TruncatedNormal","Unique","Unpack","UnsortedSegmentMax","UnsortedSegmentMin","UnsortedSegmentProd","UnsortedSegmentSum","UpperBound","VarIsInitializedOp","VariableShape","Where","While","Xdivy","XlaBroadcastHelper","XlaConv","XlaConvV2","XlaDequantize","XlaDot","XlaDotV2","XlaDynamicSlice","XlaDynamicUpdateSlice","XlaEinsum","XlaGather","XlaHostCompute","XlaIf","XlaKeyValueSort","XlaPad","XlaRecv","XlaRecvFromHost","XlaReduce","XlaReduceWindow","XlaReplicaId","XlaScatter","XlaSelectAndScatter","XlaSelfAdjointEig","XlaSend","XlaSendToHost","XlaSetBound","XlaSetDynamicDimensionSize","XlaSharding","XlaSort","XlaSpmdFullToShardShape","XlaSpmdShardToFullShape","XlaSvd","XlaVariadicReduce","XlaVariadicSort","XlaWhile","Xlog1py","Xlogy","ZerosLike","Zeta","Enter","Exit","LoopCond","Merge","NextIteration","Switch","_Arg","_ArrayToList","_FusedBatchNormEx","_ListToArray","_ParallelConcatUpdate","_RecvTPUEmbeddingActivations","_RecvTPUEmbeddingDeduplicationData","_Retval","_SendTPUEmbeddingGradients","_TPUCompile","_TPUExecute","_UnaryOpsComposition","TPUCompilationResult","TPUReplicatedInput","TPUReplicatedOutput","TPUReplicateMetadata","MergeV2Checkpoints","RestoreV2","SaveV2","Abort","Assert","Assign","Placeholder","PlaceholderV2","ShardedFilename","StringJoin","Variable","VariableV2","VarHandleOp","AudioSummary","AudioSummaryV2","DebugNumericSummary","HistogramSummary","ImageSummary","MergeSummary","ScalarSummary","StatsAggregatorSummary"];const dRt={"library.function":!0,"library.function.node_def":!0,"library.function.node_def.input":!0,"library.function.node_def.attr":!0,"library.function.node_def.attr.value.list.b":!0,"library.function.node_def.attr.value.list.f":!0,"library.function.node_def.attr.value.list.func":!0,"library.function.node_def.attr.value.list.i":!0,"library.function.node_def.attr.value.list.s":!0,"library.function.node_def.attr.value.list.shape":!0,"library.function.node_def.attr.value.list.shape.dim":!0,"library.function.node_def.attr.value.list.tensor":!0,"library.function.node_def.attr.value.list.type":!0,"library.function.node_def.attr.value.shape.dim":!0,"library.function.node_def.attr.value.tensor.string_val":!0,"library.function.node_def.attr.value.tensor.tensor_shape.dim":!0,"library.function.signature.input_arg":!0,"library.function.signature.output_arg":!0,"library.versions":!0,node:!0,"node.input":!0,"node.attr":!0,"node.attr.value.list.b":!0,"node.attr.value.list.f":!0,"node.attr.value.list.func":!0,"node.attr.value.list.i":!0,"node.attr.value.list.s":!0,"node.attr.value.list.shape":!0,"node.attr.value.list.shape.dim":!0,"node.attr.value.list.tensor":!0,"node.attr.value.list.type":!0,"node.attr.value.shape.dim":!0,"node.attr.value.tensor.string_val":!0,"node.attr.value.tensor.tensor_shape.dim":!0},pRt={"step_stats.dev_stats":!0,"step_stats.dev_stats.node_stats":!0,"step_stats.dev_stats.node_stats.output":!0,"step_stats.dev_stats.node_stats.memory":!0,"step_stats.dev_stats.node_stats.output.tensor_description.shape.dim":!0};function fRt(t,e){let n={},i=[],r=[],o=n;function a(t,n,i,r){let o=t[n];null==o?t[n]=r.join(".")in e?[i]:i:Array.isArray(o)?o.push(i):t[n]=[o,i]}return(function s(t,e,n=1e6,i="\n"){return new Promise((function(r,o){!(function a(s,l,c){const u=c>=t.byteLength,h=l.split(i);h[0]=s+h[0];const d=u?"":h.pop();for(let t of h)try{e(t)}catch(t){return void o(t)}if(u)return void r(!0);const p=new Blob([t.slice(c,c+n)]),f=new FileReader;f.onload=function(t){a(d,t.target.result,c+n)},f.readAsText(p)})("","",0)}))})(t,(function(t){if(t=t.trim())switch(t[t.length-1]){case"{":let e=t.substring(0,t.length-2).trim(),n={};i.push(o),r.push(e),a(o,e,n,r),o=n;break;case"}":o=i.pop(),r.pop();break;default:let s=(function e(t){let e=t.indexOf(":");return{name:t.substring(0,e).trim(),value:(function n(t){if("true"===t)return!0;if("false"===t)return!1;if('"'===t[0])return t.substring(1,t.length-1);let e=parseFloat(t);return isNaN(e)?t:e})(t.substring(e+2).trim())}})(t);a(o,s.name,s.value,r.concat(s.name))}})).then((function(){return n}))}let mRt=class extends(tr(ye)){constructor(){super(...arguments),this.compatibilityProvider=new uRt,this.hierarchyParams=VOt,this._template=null}_selectionChanged(){this.selection&&this.debounce("selectionchange",(()=>{this._load(this.selection)}))}_load(t){const{run:e,tag:n,type:i}=t;switch(i){case bIt.OP_GRAPH:case bIt.CONCEPTUAL_GRAPH:{(function(){this._setOutStats(null)}).bind(this)();const t=new URLSearchParams;t.set("run",e),t.set("conceptual",String(i===bIt.CONCEPTUAL_GRAPH)),n&&t.set("tag",n);const r=gr().pluginRoute("graphs","/graph",t);return this._fetchAndConstructHierarchicalGraph(r).then((()=>{this._graphRunTag={run:e,tag:n}}))}case bIt.PROFILE:{const{tags:t}=this.datasets.find((({name:t})=>t===e)),i=t.find((t=>t.tag===n)).opGraph?n:null;console.assert(t.find((t=>t.tag===i)),`Required tag (${i}) is missing.`);const r=this._graphRunTag&&this._graphRunTag.run===e&&this._graphRunTag.tag===i?Promise.resolve():this._load({run:e,tag:i,type:bIt.OP_GRAPH}),o=new URLSearchParams;o.set("tag",n),o.set("run",e);const a=gr().pluginRoute("graphs","/run_metadata",o);return r.then((()=>this._readAndParseMetadata(a)))}default:return Promise.reject(new Error(`Unknown selection type: ${i}`))}}_readAndParseMetadata(t){this.set("progress",{value:0,msg:""}),(function e(t,n){return(function i(t,e,n,r,o){r.setMessage(t);try{let i=kIt(t,n,o);return r.updateProgress(e),i}catch(e){r.reportError("Failed "+t,e)}})("Reading metadata pbtxt",40,(()=>null==t?Promise.resolve(null):hRt(t)),n,vIt.FETCH_METADATA_PBTXT_BYTES).then((t=>NIt("Parsing metadata.pbtxt",60,(()=>null!=t?(function e(t){return fRt(t,pRt).then((t=>t.step_stats))})(t):Promise.resolve(null)),n,vIt.PARSE_METADATA_PBTXT_INTO_OBJECT)))})(t,LIt(this)).then(function(t){this._setOutStats(t)}.bind(this))}_fetchAndConstructHierarchicalGraph(t,e){return this.set("progress",{value:0,msg:""}),(function i(t,e,r,o=new uRt,a=VOt){const s=PIt(t,30,"Data"),l=PIt(t,20,"Graph"),c=PIt(t,50,"Namespace hierarchy"),u=Date.now();return(function h(t,e,i){return NIt("Reading graph pbtxt",40,(()=>n(this,void 0,void 0,(function*(){const n=Date.now();if(e){const t=yield new Promise((function(t,n){let i=new FileReader;i.onload=()=>t(i.result),i.onerror=()=>n(i.error),i.readAsArrayBuffer(e)}));return CIt({timingId:vIt.FETCH_PBTXT_BYTES_FROM_FILESYSTEM,eventValue:Date.now()-n}),t}const i=yield hRt(t);return CIt({timingId:vIt.FETCH_PBTXT_BYTES_FROM_SERVER,eventValue:Date.now()-n}),i}))),i,vIt.FETCH_PBTXT_BYTES).then((t=>NIt("Parsing graph.pbtxt",60,(()=>(function e(t){return fRt(t,dRt)})(t)),i,vIt.PARSE_PBTXT_INTO_OBJECT)))})(e,r,s).then((function(t){if(!t.node)throw new Error("The graph is empty. This can happen when TensorFlow could not trace any graph. Please refer to https://github.com/tensorflow/tensorboard/issues/1961 for more information.");return(function e(t,n,i){let r={},o={},a={},s=lNt(n.inEmbeddingTypes),l=lNt(n.outEmbeddingTypes),c=[],u=t.node,h=new Array(u.length);return IIt("Normalizing names",30,(()=>{let e=new Array(u.length),n=0;const i=t=>{let i=new KIt(t);return s(i)?(c.push(i.name),r[i.name]=i,i):l(i)?(c.push(i.name),o[i.name]=i,we.each(i.inputs,(t=>{let e=t.name;a[e]=a[e]||[],a[e].push(i)})),i):(e[n]=i,h[n]=i.name,n++,i)};return we.each(u,i),t.library&&t.library.function&&we.each(t.library.function,(t=>{const e=UIt+t.signature.name;if(i({name:e,input:[],device:"",op:"",attr:[]}),t.signature.input_arg){let n=0;const r=t=>{i({name:e+VIt+t.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:t.type}}]}).functionInputIndex=n,n++};t.signature.input_arg.name?r(t.signature.input_arg):we.each(t.signature.input_arg,r)}let n=0;const r={};if(t.signature.output_arg){const i=t=>{r[e+VIt+t.name]=n,n++};t.signature.output_arg.name?i(t.signature.output_arg):we.each(t.signature.output_arg,i)}we.each(t.node_def,(t=>{t.name=e+"/"+t.name,"string"==typeof t.input&&(t.input=[t.input]);const n=i(t);we.isNumber(r[t.name])&&(n.functionOutputIndex=r[t.name]),we.each(n.inputs,(t=>{t.name=e+VIt+t.name}))}))})),e.splice(n),h.splice(n),e}),i,vIt.NORMALIZING_NAMES).then((t=>IIt("Building the data structure",70,(()=>{let e=(function i(t,e){let n={},i={};t.sort();for(let e=0;e<t.length-1;++e){let r=t[e];we.each(hNt(r).slice(0,-1),(t=>{i[t]=!0}));for(let i=e+1;i<t.length;++i){let e=t[i];if(!we.startsWith(e,r))break;if(e.length>r.length&&e.charAt(r.length)===VIt){n[r]=cNt(r);break}}}return we.each(e,(t=>{t in i&&(n[t]=cNt(t))})),n})(h,c),s=new XIt;return we.each(t,(t=>{let n=e[t.name]||t.name;s.nodes[n]=t,t.name in a&&(t.outEmbeddings=a[t.name],we.each(t.outEmbeddings,(t=>{t.name=e[t.name]||t.name}))),t.name=n})),we.each(t,(t=>{we.each(t.inputs,((i,a)=>{let l=i.name;if(l in r){let i=r[l];t.inEmbeddings.push(i);for(let r of i.inputs)oNt(s,e[r.name]||r.name,t,r,n,a)}else if(l in o){let r=o[l];for(let o of r.inputs)oNt(s,e[o.name]||o.name,t,i,n,a)}else oNt(s,e[l]||l,t,i,n,a)}))})),we.each(r,((t,n)=>{t.name=e[t.name]||t.name})),s}),i,vIt.BUILD_SLIM_GRAPH)))})(t,aNt,l)}),(()=>{throw new Error("Malformed GraphDef. This can sometimes be caused by a bad network connection or difficulty reconciling multiple GraphDefs; for the latter case, please refer to https://github.com/tensorflow/tensorboard/issues/1929.")})).then((t=>n(this,void 0,void 0,(function*(){!(function e(t,n){if(null===n)throw new Error("Compatibility provider required, but got: "+n);we.each(t.nodes,(t=>{t.compatible=n.opValid(t),we.each(t.inEmbeddings,(t=>{t.compatible=n.opValid(t)})),we.each(t.outEmbeddings,(t=>{t.compatible=n.opValid(t)}))}))})(t,o);const n=yield jOt(t,a,c);return CIt({timingId:vIt.GRAPH_LOAD_SUCCEEDED,eventValue:Date.now()-u}),{graph:t,graphHierarchy:n}})))).catch((e=>{throw t.reportError(`Graph visualization failed.\n\n${e}`,e),CIt({timingId:vIt.GRAPH_LOAD_FAILED,eventValue:Date.now()-u}),e}))})(LIt(this),t,e,this.compatibilityProvider,this.hierarchyParams).then(function({graph:t,graphHierarchy:e}){this._setOutGraph(t),this._setOutGraphHierarchy(e)}.bind(this))}_selectedFileChanged(){var t=this.selectedFile;if(!t)return;const e=t.target,n=e.files[0];n&&(e.value="",this._fetchAndConstructHierarchicalGraph(null,n))}};t([o({type:Array}),e("design:type",Array)],mRt.prototype,"datasets",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],mRt.prototype,"progress",void 0),t([o({type:Object}),e("design:type",Object)],mRt.prototype,"selection",void 0),t([o({type:Object}),e("design:type",Object)],mRt.prototype,"selectedFile",void 0),t([o({type:Object}),e("design:type",Object)],mRt.prototype,"compatibilityProvider",void 0),t([o({type:Object}),e("design:type",Object)],mRt.prototype,"hierarchyParams",void 0),t([o({type:Object,readOnly:!0,notify:!0}),e("design:type",HOt)],mRt.prototype,"outGraphHierarchy",void 0),t([o({type:Object,readOnly:!0,notify:!0}),e("design:type",XIt)],mRt.prototype,"outGraph",void 0),t([o({type:Object,readOnly:!0,notify:!0}),e("design:type",Object)],mRt.prototype,"outStats",void 0),t([o({type:Object}),e("design:type",Object)],mRt.prototype,"_graphRunTag",void 0),t([a("selection","compatibilityProvider"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mRt.prototype,"_selectionChanged",null),t([a("selectedFile","compatibilityProvider"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mRt.prototype,"_selectedFileChanged",null),mRt=t([i("tf-graph-dashboard-loader")],mRt);let gRt=class extends(tr(ye)){constructor(){super(...arguments),this._datasets=[],this._datasetsFetched=!1,this._selectedDataset=0,this._requestManager=new hr,this._canceller=new EO,this.specificHealthPillStep=0,this.healthPillsToggledOn=!1,this._debuggerNumericAlerts=[],this._nodeNamesToHealthPills={},this._healthPillRequestId=1,this._healthPillStepRequestTimerDelay=500,this.run=Ps("run",{defaultValue:"",useLocalStorage:!1}).call(this),this._runObserver=Is("run",{defaultValue:"",polymerProperty:"run",useLocalStorage:!1})}attached(){this.set("_isAttached",!0)}detached(){this.set("_isAttached",!1)}ready(){super.ready(),this.addEventListener("node-toggle-expand",this._handleNodeToggleExpand.bind(this))}reload(){this._debuggerDataEnabled||this._requestManager.request(gr().pluginsListing()).then(this._canceller.cancellable((t=>{t.cancelled||t.value.debugger&&this.set("_debuggerDataEnabled",!0)}))),this._maybeFetchHealthPills()}_fit(){this.$$("#graphboard").fit()}_onDownloadImageRequested(t){this.$$("#graphboard").downloadAsImage(t.detail)}_getGraphDisplayClassName(t,e){return t||e.length?"":"no-graph"}_fetchDataset(){return this._requestManager.request(gr().pluginRoute("graphs","/info"))}_fetchHealthPills(t,e){const n={node_names:JSON.stringify(t),run:"__debugger_data__"};void 0!==e&&(n.step=e);const i=gr().pluginRoute("debugger","/health_pills");return this._requestManager.request(i,n)}_fetchDebuggerNumericsAlerts(){return this._requestManager.request(gr().pluginRoute("debugger","/numerics_alert_report"))}_graphUrl(t,e,n){return gr().pluginRoute("graphs","/graph",new URLSearchParams({run:t,limit_attr_size:e,large_attrs_key:n}))}_shouldRequestHealthPills(){return this._debuggerDataEnabled&&this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")}_maybeInitializeDashboard(){!this._initialized&&this._isAttached&&(this.set("_compatibilityProvider",new uRt),this._initialized=!0,this._fetchDataset().then((t=>{const e=Object.keys(t);this._datasets=e.sort(er).map((e=>{const n=t[e],i=Object.keys(n.tags).sort(er).map((t=>n.tags[t])).map((({tag:t,conceptual_graph:e,op_graph:n,profile:i})=>({tag:t,displayName:t,conceptualGraph:e,opGraph:n,profile:i})));return{name:e,tags:n.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...i]:i}})),this._datasetsFetched=!0})))}_determineSelectedDataset(){var t=this._datasetsFetched,e=this._datasets,n=this.run;if(!n)return void this.set("_selectedDataset",0);const i=e.findIndex((t=>t.name===n));if(-1!==i)this.set("_selectedDataset",i);else if(t){const t=this.$$("#error-dialog");t.textContent=`No dataset named "${n}" could be found.`,t.open()}}_updateSelectedDatasetName(){var t=this._datasets,e=this._selectedDataset;this._datasetsFetched&&(t.length<=e||this.set("run",t[e].name))}_requestHealthPills(){this.set("_areHealthPillsLoading",!0);var t=++this._healthPillRequestId;null!==this._healthPillStepRequestTimerId&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null),this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null,this._initiateNetworkRequestForHealthPills(t)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(t)}_initiateNetworkRequestForHealthPills(t){if(this._healthPillRequestId!==t)return;const e=this.allStepsModeEnabled?this.specificHealthPillStep:void 0,n=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),e),i=this._fetchDebuggerNumericsAlerts();Promise.all([n,i]).then(function(e){var n=e[0],i=e[1];if(this.healthPillsToggledOn&&t===this._healthPillRequestId){for(var r in n){this.set("_healthPillStepIndex",n[r].length-1);break}this.set("_debuggerNumericAlerts",i),this.set("_nodeNamesToHealthPills",n),this.set("_areHealthPillsLoading",!1),this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}_datasetsState(t,e,n){return t?e&&e.length?"PRESENT"===n:"EMPTY"===n:"NOT_LOADED"===n}_renderHierarchyChanged(t){this.reload()}_handleNodeToggleExpand(){this._maybeFetchHealthPills()}_healthPillsToggledOnChanged(t){t?this.reload():this.set("_nodeNamesToHealthPills",{})}_maybeFetchHealthPills(){this._shouldRequestHealthPills()&&this._requestHealthPills()}};gRt.template=_e`
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <tf-dashboard-layout>
      <tf-graph-controls
        id="controls"
        class="sidebar"
        slot="sidebar"
        devices-for-stats="{{_devicesForStats}}"
        color-by-params="[[_colorByParams]]"
        stats="[[_stats]]"
        color-by="{{_colorBy}}"
        datasets="[[_datasets]]"
        render-hierarchy="[[_renderHierarchy]]"
        selection="{{_selection}}"
        selected-file="{{_selectedFile}}"
        selected-node="{{_selectedNode}}"
        health-pills-feature-enabled="[[_debuggerDataEnabled]]"
        health-pills-toggled-on="{{healthPillsToggledOn}}"
        on-fit-tap="_fit"
        trace-inputs="{{_traceInputs}}"
        auto-extract-nodes="{{_autoExtractNodes}}"
        on-download-image-requested="_onDownloadImageRequested"
      ></tf-graph-controls>
      <div
        class$="center [[_getGraphDisplayClassName(_selectedFile, _datasets)]]"
        slot="center"
      >
        <tf-graph-dashboard-loader
          id="loader"
          datasets="[[_datasets]]"
          selection="[[_selection]]"
          selected-file="[[_selectedFile]]"
          out-graph-hierarchy="{{_graphHierarchy}}"
          out-graph="{{_graph}}"
          out-stats="{{_stats}}"
          progress="{{_progress}}"
          hierarchy-params="[[_hierarchyParams]]"
          compatibility-provider="[[_compatibilityProvider]]"
        ></tf-graph-dashboard-loader>
        <div class="no-data-message">
          <h3>No graph definition files were found.</h3>
          <p>
            To store a graph, create a
            <code>tf.summary.FileWriter</code>
            and pass the graph either via the constructor, or by calling its
            <code>add_graph()</code> method. You may want to check out the
            <a href="https://www.tensorflow.org/tensorboard/graphs"
              >examining the TensorFlow graph tutorial</a
            >.
          </p>

          <p>
            If you’re new to using TensorBoard, and want to find out how to add
            data and set up your event files, check out the
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
              >README</a
            >
            and perhaps the
            <a
              href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
              >TensorBoard tutorial</a
            >.
          </p>

          <p>
            If you think TensorBoard is configured properly, please see
            <a
              href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
              >the section of the README devoted to missing data problems</a
            >
            and consider filing an issue on GitHub.
          </p>
        </div>
        <div class="graphboard">
          <tf-graph-board
            id="graphboard"
            devices-for-stats="[[_devicesForStats]]"
            color-by="{{_colorBy}}"
            color-by-params="{{_colorByParams}}"
            graph-hierarchy="[[_graphHierarchy]]"
            graph="[[_graph]]"
            hierarchy-params="[[_hierarchyParams]]"
            progress="[[_progress]]"
            debugger-data-enabled="[[_debuggerDataEnabled]]"
            are-health-pills-loading="[[_areHealthPillsLoading]]"
            debugger-numeric-alerts="[[_debuggerNumericAlerts]]"
            node-names-to-health-pills="[[_nodeNamesToHealthPills]]"
            all-steps-mode-enabled="{{allStepsModeEnabled}}"
            specific-health-pill-step="{{specificHealthPillStep}}"
            health-pill-step-index="[[_healthPillStepIndex]]"
            render-hierarchy="{{_renderHierarchy}}"
            selected-node="{{_selectedNode}}"
            stats="[[_stats]]"
            trace-inputs="[[_traceInputs]]"
            auto-extract-nodes="[[_autoExtractNodes]]"
          ></tf-graph-board>
        </div>
      </div>
    </tf-dashboard-layout>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }

      .no-data-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      .graphboard {
        height: 100%;
      }

      .no-graph .graphboard {
        display: none;
      }

      .center:not(.no-graph) .no-data-message {
        display: none;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],gRt.prototype,"_datasets",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_datasetsFetched",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"_selectedDataset",void 0),t([o({type:Object,observer:"_renderHierarchyChanged"}),e("design:type",bNt)],gRt.prototype,"_renderHierarchy",void 0),t([o({type:Object}),e("design:type",hr)],gRt.prototype,"_requestManager",void 0),t([o({type:Object}),e("design:type",EO)],gRt.prototype,"_canceller",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_debuggerDataEnabled",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"allStepsModeEnabled",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"specificHealthPillStep",void 0),t([o({type:Boolean,observer:"_healthPillsToggledOnChanged"}),e("design:type",Boolean)],gRt.prototype,"healthPillsToggledOn",void 0),t([o({type:String,notify:!0}),e("design:type",String)],gRt.prototype,"selectedNode",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_isAttached",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_initialized",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_areHealthPillsLoading",void 0),t([o({type:Array,notify:!0}),e("design:type",Array)],gRt.prototype,"_debuggerNumericAlerts",void 0),t([o({type:Object}),e("design:type",Object)],gRt.prototype,"_nodeNamesToHealthPills",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"_healthPillStepIndex",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"_healthPillRequestId",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"_healthPillStepRequestTimerId",void 0),t([o({type:Number}),e("design:type",Number)],gRt.prototype,"_healthPillStepRequestTimerDelay",void 0),t([o({type:Array}),e("design:type",Array)],gRt.prototype,"runs",void 0),t([o({type:String,notify:!0,observer:"_runObserver"}),e("design:type",String)],gRt.prototype,"run",void 0),t([o({type:Object}),e("design:type",Object)],gRt.prototype,"_selection",void 0),t([o({type:Object}),e("design:type",Object)],gRt.prototype,"_compatibilityProvider",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_traceInputs",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gRt.prototype,"_autoExtractNodes",void 0),t([o({type:Object}),e("design:type",Object)],gRt.prototype,"_selectedFile",void 0),t([a("_isAttached"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],gRt.prototype,"_maybeInitializeDashboard",null),t([a("_datasetsFetched","_datasets","run"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],gRt.prototype,"_determineSelectedDataset",null),t([a("_datasetsFetched","_datasets","_selectedDataset"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],gRt.prototype,"_updateSelectedDatasetName",null),gRt=t([i("tf-graph-dashboard")],gRt);const _Rt=sI;let yRt=class extends(tr(ye)){constructor(){super(...arguments),this.mode="offset",this.timeProperty="step",this.bins="bins",this.x="x",this.dx="dx",this.y="y",this.colorScale=_Rt.scaleOrdinal(_Rt.schemeCategory10),this.modeTransitionDuration=500,this._name=null,this._data=null}ready(){super.ready(),this.scopeSubtree(this.$.svg,!0)}attached(){this._attached=!0}detached(){this._attached=!1}setSeriesData(t,e){this._name=t,this._data=e,this.redraw()}_redrawOnChange(){this.redraw()}redraw(){this._draw(0)}_modeRedraw(){this._draw(this.modeTransitionDuration)}_draw(t){if(!this._attached||!this._data)return;if(void 0===t)throw new Error("vz-histogram-timeseries _draw needs duration");if(this._data.length<=0)throw new Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw new Error("No bins property of '"+this.bins+"' in data");if(this._data[0][this.bins].length<=0)throw new Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw new Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw new Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw new Error("No y property '"+this.y+"' on bins data");var e=this.timeProperty,n=this.x,i=this.bins,r=this.dx,o=this.y,a=this._data,s=this.mode,l=_Rt.hcl(this.colorScale(this._name)),c=_Rt.select(this.$.tooltip),u=function(t){return t[n]},h=function(t){return t[o]},d=function(t){return t[n]+t[r]},p=function(t){return t[e]};"relative"===e&&(p=function(t){return t.wall_time-a[0].wall_time});var f,m=this.$.svg.getBoundingClientRect(),g=m.width,_=m.height,y={top:5,right:60,bottom:20,left:24};"offset"===s?y.top=5+(f=_/2.5):f=_-y.top-y.bottom;var v=g-y.left-y.right,b=_-y.top-y.bottom;_Rt.min(a,u),_Rt.max(a,d);var x=_Rt.format(".3n"),w=_Rt.format(".0f");"wall_time"===e?w=_Rt.timeFormat("%m/%d %X"):"relative"===e&&(w=function(t){return _Rt.format(".1r")(t/36e5)+"h"});var S=a.map((function(t,e){return[_Rt.min(t[i],u),_Rt.max(t[i],d)]})),M=a.map((function(t){return _Rt.extent(t[i],h)})),E=500,T=_Rt.extent(a,p),A=("wall_time"===e?_Rt.scaleTime():_Rt.scaleLinear()).domain(T).range([0,"offset"===s?b:0]),C=_Rt.scaleLinear().domain([0,_Rt.max(a,(function(t,e){return M[e][1]}))]).range([f,0]),k=_Rt.scaleLinear().domain(C.domain()).range([E,0]),L=_Rt.scaleLinear().domain([_Rt.min(a,(function(t,e){return S[e][0]})),_Rt.max(a,(function(t,e){return S[e][1]}))]).nice().range([0,v]),P=_Rt.scaleLinear().domain(L.domain()).range([0,E]);const I=_Rt.scaleLinear().domain(_Rt.extent(a,p)).range([l.brighter(),l.darker()]).interpolate(_Rt.interpolateHcl);var N=_Rt.axisBottom(L).ticks(Math.max(2,v/20)),O=_Rt.axisRight(A).ticks(Math.max(2,b/15)).tickFormat(w),R=_Rt.axisRight(C).ticks(Math.max(2,b/15)).tickSize(v+5).tickFormat(x),z=function(t){return t[n]+t[r]/2},D=_Rt.line().x((function(t){return P(z(t))})).y((function(t){return k(t[o])})),B=this.$.svg,H=_Rt.select(B),F=H.transition().duration(t),V=H.select("g").classed("small",(function(){return v>0&&v<=150})).classed("medium",(function(){return v>150&&v<=300})).classed("large",(function(){return v>300})),j=F.select("g").attr("transform","translate("+y.left+","+y.top+")"),U=_Rt.bisector(d).left,G=V.select(".stage").on("mouseover",(function(){J.style("opacity",1),et.style("opacity",1),rt.style("opacity",1),st.style("opacity",1),c.style("opacity",1)})).on("mouseout",(function(){J.style("opacity",0),et.style("opacity",0),rt.style("opacity",0),st.style("opacity",0),J.classed("hover-closest",!1),K.classed("outline-hover",!1),c.style("opacity",0)})).on("mousemove",(function W(){var t,a=_Rt.mouse(this),l=L.invert(a[0]);function u(t){return Math.min(t[i].length-1,U(t[i],l))}A.invert(a[1]);var h,d=1/0;J.attr("transform",(function(e,l){var c=u(e);h=e;var m=L(e[i][c][n]+e[i][c][r]/2),g=C(e[i][c][o]),_="offset"===s?A(p(e))-(f-g):g,y=Math.abs(a[1]-_);return y<d&&(d=y,t=e),"translate("+m+","+g+")"})),J.select("text").text((function(t){var e=u(t);return t[i][e][o]})),J.classed("hover-closest",(function(e){return e===t})),K.classed("outline-hover",(function(e){return e===t}));var m=u(h);et.attr("transform",(function(t){return"translate("+L(h[i][m][n]+h[i][m][r]/2)+", "+b+")"})).select("text").text((function(t){return x(h[i][m][n]+h[i][m][r]/2)}));var g=O.tickFormat();rt.attr("transform",(function(e){return"translate("+v+", "+("offset"===s?A(p(t)):0)+")"})).style("display","offset"===s?"":"none").select("text").text((function(e){return g(p(t))}));var _=R.tickFormat();st.attr("transform",(function(e){return"translate("+v+", "+("offset"===s?0:C(t[i][m][o]))+")"})).style("display","offset"===s?"none":"").select("text").text((function(e){return _(t[i][m][o])}));var y=_Rt.mouse(B);c.style("transform","translate("+(y[0]+15)+"px,"+(y[1]-15)+"px)").select("span").text("offset"===s?_(t[i][m][o]):("step"===e?"step ":"")+g(p(t)))}));G.select(".background").attr("transform","translate("+-y.left+","+-y.top+")").attr("width",g).attr("height",_);var q=G.selectAll(".histogram").data(a);q.exit().remove();var Y=q.enter().append("g").attr("class","histogram"),X=Y.merge(q).sort((function(t,e){return p(t)-p(e)})),$=j.selectAll(".histogram").attr("transform",(function(t){return"translate(0, "+("offset"===s?A(p(t))-f:0)+")"}));Y.append("line").attr("class","baseline"),$.select(".baseline").style("stroke-opacity",(function(t){return"offset"===s?.1:0})).attr("y1",f).attr("y2",f).attr("x2",v),Y.append("path").attr("class","outline");var K=X.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",(function(t){return(function(t){return"M"+P(z(t[0]))+","+k(0)+"L"+D(t).slice(1)+"L"+P(z(t[t.length-1]))+","+k(0)})(t[i])})).style("stroke-width",1);$.select(".outline").attr("transform","scale("+v/E+", "+f/E+")").style("stroke",(function(t){return"offset"===s?"white":I(p(t))})).style("fill-opacity",(function(t){return"offset"===s?1:0})).style("fill",(function(t){return I(p(t))}));var Z=Y.append("g").attr("class","hover"),J=X.select(".hover").style("fill",(function(t){return I(p(t))}));Z.append("circle").attr("r",2),Z.append("text").style("display","none").attr("dx",4);var Q=V.select(".x-axis-hover").selectAll(".label").data(["x"]),tt=Q.enter().append("g").attr("class","label"),et=Q.merge(tt);tt.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14),tt.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6),tt.append("text").attr("dy",18);var nt=V.select(".y-axis-hover").selectAll(".label").data(["y"]),it=nt.enter().append("g").attr("class","label"),rt=nt.merge(it);it.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),it.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),it.append("text").attr("dx",8).attr("dy",4);var ot=V.select(".y-slice-axis-hover").selectAll(".label").data(["y"]),at=ot.enter().append("g").attr("class","label"),st=ot.merge(at);at.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14),at.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0),at.append("text").attr("dx",8).attr("dy",4),j.select(".y.axis.slice").style("opacity","offset"===s?0:1).attr("transform","translate(0, "+("offset"===s?-f:0)+")").call(R),j.select(".x.axis").attr("transform","translate(0, "+b+")").call(N),j.select(".y.axis").style("opacity","offset"===s?1:0).attr("transform","translate("+v+", "+("offset"===s?0:b)+")").call(O),j.selectAll(".tick text").attr("fill","#aaa"),j.selectAll(".axis path.domain").attr("stroke","none")}};function vRt(t){const[e,n,i]=t;return{wall_time:e,step:n,min:Yl(i.map((([t,,])=>t))),max:Wl(i.map((([,t])=>t))),buckets:i.map((([t,e,n])=>({left:t,right:e,count:n})))}}function bRt(t,e,n,i=30){n===e&&(n=1.1*e+1,e=e/1.1-1);const r=(n-e)/i;let o=0;return zl(e,n,r).map((i=>{const a=i+r;let s=0;for(;o<t.buckets.length;){const r=Math.min(n,t.buckets[o].right),l=Math.max(e,t.buckets[o].left),c=Math.min(r,a)-Math.max(l,i),u=c/(r-l)*t.buckets[o].count;if(s+=c>0?u:0,r>a)break;o++}return{x:i,dx:r,y:s}}))}yRt.template=_e`
    <div id="tooltip"><span></span></div>
    <svg id="svg">
      <g>
        <g class="axis x"></g>
        <g class="axis y"></g>
        <g class="axis y slice"></g>
        <g class="stage">
          <rect class="background"></rect>
        </g>
        <g class="x-axis-hover"></g>
        <g class="y-axis-hover"></g>
        <g class="y-slice-axis-hover"></g>
      </g>
    </svg>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #tooltip {
        position: absolute;
        display: block;
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
      }

      .background {
        fill-opacity: 0;
        fill: red;
      }

      .histogram {
        pointer-events: none;
      }

      .hover {
        font-size: 9px;
        dominant-baseline: middle;
        opacity: 0;
      }

      .hover circle {
        stroke: white;
        stroke-opacity: 0.5;
        stroke-width: 1px;
      }

      .hover text {
        fill: black;
        opacity: 0;
      }

      .hover.hover-closest circle {
        fill: black !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: white;
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: black !important;
        stroke-opacity: 1;
      }

      .x-axis-hover,
      .y-axis-hover,
      .y-slice-axis-hover {
        pointer-events: none;
      }

      .x-axis-hover .label,
      .y-axis-hover .label,
      .y-slice-axis-hover .label {
        opacity: 0;
        font-weight: bold;
        font-size: 11px;
        text-anchor: end;
      }

      .x-axis-hover text {
        text-anchor: middle;
      }

      .y-axis-hover text,
      .y-slice-axis-hover text {
        text-anchor: start;
      }

      .x-axis-hover line,
      .y-axis-hover line,
      .y-slice-axis-hover line {
        stroke: black;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: white;
      }

      .axis {
        font-size: 11px;
      }

      .axis path.domain {
        fill: none;
      }

      .axis .tick line {
        stroke: #ddd;
      }

      .axis.slice {
        opacity: 0;
      }

      .axis.slice .tick line {
        stroke-dasharray: 2;
      }

      .small .axis text {
        display: none;
      }
      .small .axis .tick:first-of-type text {
        display: block;
      }
      .small .axis .tick:last-of-type text {
        display: block;
      }
      .medium .axis text {
        display: none;
      }
      .medium .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
      .large .axis text {
        display: none;
      }
      .large .axis .tick:nth-child(2n + 1) text {
        display: block;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],yRt.prototype,"mode",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"timeProperty",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"bins",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"x",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"dx",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"y",void 0),t([o({type:Object}),e("design:type",Object)],yRt.prototype,"colorScale",void 0),t([o({type:Number}),e("design:type",Number)],yRt.prototype,"modeTransitionDuration",void 0),t([o({type:Boolean}),e("design:type",Boolean)],yRt.prototype,"_attached",void 0),t([o({type:String}),e("design:type",String)],yRt.prototype,"_name",void 0),t([o({type:Array}),e("design:type",Array)],yRt.prototype,"_data",void 0),t([a("timeProperty","colorScale","_attached"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],yRt.prototype,"_redrawOnChange",null),t([a("mode"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],yRt.prototype,"_modeRedraw",null),yRt=t([i("vz-histogram-timeseries")],yRt);let xRt=class extends(t_t(tr(ye))){constructor(){super(...arguments),this.getDataLoadName=({run:t})=>t,this.requestData=(t,e,n)=>{const i=gr().pluginRoute("histograms","/histograms");Promise.all(t.map((t=>{const n=OO(i,{tag:t.tag,run:t.run});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this.loadDataCallback=(t,e,n)=>{const i=(function r(t){const e=t.map(vRt),n=Yl(e,(t=>t.min)),i=Wl(e,(t=>t.max));return e.map((t=>({wall_time:t.wall_time,step:t.step,bins:bRt(t,n,i)})))})(n),o=this.getDataLoadName(e);this.$.chart.setSeriesData(o,i)},this._colorScaleFunction=xO,this._expanded=!1}_reloadOnRunTagRequestManagerChange(){this.reload()}_updateDataToLoad(){this.dataToLoad=[{run:this.run,tag:this.tag}]}get _runColor(){return this._colorScaleFunction(this.run)}redraw(){this.$.chart.redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}};xRt.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    ></tf-card-heading>
    <!--
      The main histogram that we render. Data is set directly with
      \`setSeriesData\`, not with a bound property.
    -->
    <vz-histogram-timeseries
      id="chart"
      time-property="[[timeProperty]]"
      mode="[[histogramMode]]"
      color-scale="[[_colorScaleFunction]]"
    ></vz-histogram-timeseries>
    <div style="display: flex; flex-direction: row;">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
    </div>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 330px;
        height: 235px;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      :host([_expanded]) {
        width: 700px;
        height: 500px;
      }

      vz-histogram-timeseries {
        -moz-user-select: none;
        -webkit-user-select: none;
        will-change: transform;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      tf-card-heading {
        margin-bottom: 10px;
        width: 90%;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],xRt.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],xRt.prototype,"tag",void 0),t([o({type:Object}),e("design:type",Object)],xRt.prototype,"getDataLoadName",void 0),t([o({type:Object}),e("design:type",hr)],xRt.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",Object)],xRt.prototype,"loadDataCallback",void 0),t([o({type:Object}),e("design:type",Object)],xRt.prototype,"tagMetadata",void 0),t([o({type:String}),e("design:type",String)],xRt.prototype,"timeProperty",void 0),t([o({type:String}),e("design:type",String)],xRt.prototype,"histogramMode",void 0),t([o({type:Object}),e("design:type",Function)],xRt.prototype,"_colorScaleFunction",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],xRt.prototype,"_expanded",void 0),t([a("run","tag","requestManager"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],xRt.prototype,"_reloadOnRunTagRequestManagerChange",null),t([a("run","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],xRt.prototype,"_updateDataToLoad",null),t([s("run"),e("design:type",String),e("design:paramtypes",[])],xRt.prototype,"_runColor",null),xRt=t([i("tf-histogram-loader")],xRt);let wRt=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._histogramMode="offset",this._timeProperty="step",this._restamp=!1,this._requestManager=new hr}_redrawCategoryPane(t,e){e&&t.target.querySelectorAll("tf-histogram-loader").forEach((t=>t.redraw()))}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadHistograms()}))}_fetchTags(){const t=gr().pluginRoute("histograms","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=we.mapValues(t,(t=>Object.keys(t))),n=or(e);this.set("_dataNotFound",0===n.length),this.set("_runToTag",e),this.set("_runToTagInfo",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadHistograms(){this.root.querySelectorAll("tf-histogram-loader").forEach((t=>{t.reload()}))}_shouldOpen(t){return t<=2}get _categories(){return Sr(this._runToTag,this._selectedRuns,this._tagFilter)}_tagMetadata(t,e,n){return t[e][n]}};function SRt(t){return""!==t.displayName&&void 0!==t.displayName?t.displayName:t.name}function MRt(t){if(""!==t.displayName&&void 0!==t.displayName)return t.displayName;let e=t.name.group,n=t.name.tag;return void 0===e&&(e=""),void 0===n&&(n=""),""===e?n:e+"."+n}function ERt(t,e){return e<t.hparamColumns.length?SRt(t.hparamColumns[e].hparamInfo):MRt(t.metricColumns[e-t.hparamColumns.length].metricInfo)}function TRt(t){return t.hparamColumns.length}function ARt(t){return t.metricColumns.length}function CRt(t){return TRt(t)+ARt(t)}function kRt(t,e){return t[e]}function LRt(t,e){return t.find((t=>we.isEqual(t.name,e)))}function PRt(t,e,n){return e.hparams[t.hparamColumns[n].hparamInfo.name]}function IRt(t,e,n){const i=LRt(e.metricValues,t.metricColumns[n].metricInfo.name);return void 0===i?void 0:i.value}function NRt(t,e,n){return n<t.hparamColumns.length?PRt(t,e,n):IRt(t,e,n-t.hparamColumns.length)}function ORt(t,e,n){return Ll(e,(e=>NRt(t,e,n)))}function RRt(t,e,n){let i;if(n<e.hparamInfos.length)i=t.hparamColumns.findIndex((t=>t.hparamInfo.name===e.hparamInfos[n].name));else{const r=e.metricInfos[n-e.hparamInfos.length].name;i=t.hparamColumns.length+t.metricColumns.findIndex((t=>t.metricInfo.name===r))}return console.assert(-1!==i),i}function zRt(t){return t.hparamInfos.length}function DRt(t){return t.metricInfos.length}function BRt(t,e,n){return Ll(e,(e=>jRt(t,e,n)))}function HRt(t,e){return t.find((t=>t.name===e))}function FRt(t,e,n){return e.hparams[t.hparamInfos[n].name]}function VRt(t,e,n){const i=LRt(e.metricValues,t.metricInfos[n].name);return void 0===i?void 0:i.value}function jRt(t,e,n){return n<t.hparamInfos.length?FRt(t,e,n):VRt(t,e,n-t.hparamInfos.length)}function URt(t){return we.isNumber(t)?t.toPrecision(5):void 0===t?"":t.toString()}function GRt(t,e){return t*t+e*e}function WRt(t,e,n,i){return Math.sqrt(GRt(t-n,e-i))}function qRt(t,e,n,i,r,o){if(t<n&&e<i)return WRt(t,e,n,i);if(n<=t&&t<r&&e<i)return i-e;if(r<=t&&e<i)return WRt(t,e,r,i);if(t<n&&i<=e&&e<o)return n-t;if(n<=t&&t<r&&i<=e&&e<o)return 0;if(r<=t&&i<=e&&e<o)return t-r;if(t<n&&o<=e)return WRt(t,e,n,o);if(n<=t&&t<r&&o<=e)return e-o;if(r<=t&&o<=e)return WRt(t,e,r,o);throw"Point (x,y) must be in one of the regions defined above."}function YRt(t,e){return void 0===e?"translate("+t+")":"translate("+t+","+e+")"}function XRt(t,e,n){const i=t.get(e,t);Array.isArray(i)?t.splice.apply(t,[e,0,i.length].concat(n)):t.set(e,n)}function $Rt(t){let e=0;for(let n=0;n<t.length;++n)e=31*e+t.charCodeAt(n)&4294967295;return e+Math.pow(2,31)}wRt.template=_e`
    <tf-dashboard-layout>
      <div slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="histogramModeSelector"
              name="Histogram mode"
              selected-id="{{_histogramMode}}"
            >
              <paper-button id="overlay">overlay</paper-button>
              <paper-button id="offset">offset</paper-button>
            </tf-option-selector>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="timePropertySelector"
              name="Offset time axis"
              selected-id="{{_timeProperty}}"
            >
              <paper-button id="step">step</paper-button>
              <paper-button id="relative">relative</paper-button>
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No histogram data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any histogram data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-histogram-loader
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  active="[[active]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  time-property="[[_timeProperty]]"
                  histogram-mode="[[_histogramMode]]"
                  request-manager="[[_requestManager]]"
                ></tf-histogram-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],wRt.prototype,"reloadOnReady",void 0),t([o({type:String}),e("design:type",String)],wRt.prototype,"_histogramMode",void 0),t([o({type:String}),e("design:type",String)],wRt.prototype,"_timeProperty",void 0),t([o({type:Array}),e("design:type",Array)],wRt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],wRt.prototype,"_runToTag",void 0),t([o({type:Object}),e("design:type",Object)],wRt.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],wRt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],wRt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],wRt.prototype,"_restamp",void 0),t([o({type:Boolean}),e("design:type",Boolean)],wRt.prototype,"_categoriesDomReady",void 0),t([o({type:Object}),e("design:type",hr)],wRt.prototype,"_requestManager",void 0),t([s("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Array),e("design:paramtypes",[])],wRt.prototype,"_categories",null),wRt=t([i("tf-histogram-dashboard")],wRt);var KRt=Object.freeze({__proto__:null,hparamName:SRt,metricName:MRt,schemaColumnName:ERt,numHParams:TRt,numMetrics:ARt,numColumns:CRt,hparamValueByName:kRt,metricValueByName:LRt,hparamValueByIndex:PRt,metricValueByIndex:IRt,columnValueByIndex:NRt,numericColumnExtent:ORt,getAbsoluteColumnIndex:RRt,schemaVisibleColumnName:function ZRt(t,e){return e<t.hparamInfos.length?SRt(t.hparamInfos[e]):MRt(t.metricInfos[e-t.hparamInfos.length])},numVisibleHParams:zRt,numVisibleMetrics:DRt,numVisibleColumns:function JRt(t){return zRt(t)+DRt(t)},visibleNumericColumnExtent:BRt,prettyPrintHParamValueByName:function QRt(t,e){return URt(kRt(t,e))},prettyPrintMetricValueByName:function tzt(t,e){return URt(LRt(t,e))},sessionGroupWithName:HRt,hparamValueByVisibleIndex:FRt,metricValueByVisibleIndex:VRt,columnValueByVisibleIndex:jRt,prettyPrint:URt,l2NormSquared:GRt,euclideanDist:WRt,pointToRectangleDist:qRt,translateStr:YRt,rotateStr:function ezt(t,e,n){let i="rotate("+t;return void 0!==e&&void 0!==n&&(i=i+","+e+","+n),i+=")",i},isNullOrUndefined:function nzt(t){return null==t},quadTreeVisitPointsInRect:function izt(t,e,n,i,r,o){t.visit(((a,s,l,c,u)=>{if(void 0===a.length){do{const s=t.x()(a.data),l=t.y()(a.data);e<=s&&s<i&&n<=l&&l<r&&o(a.data)}while(a=a.next);return!0}return s>=i||c<=e||l>=r||u<=n}))},quadTreeVisitPointsInDisk:function rzt(t,e,n,i,r){t.visit(((o,a,s,l,c)=>{if(void 0===o.length){do{const a=t.x()(o.data),s=t.y()(o.data),l=WRt(e,n,a,s);l<=i&&r(o.data,l)}while(o=o.next);return!0}return qRt(e,n,a,s,l,c)>i}))},filterSet:function ozt(t,e){const n=new Set;return t.forEach((t=>{e(t)&&n.add(t)})),n},setArrayObservably:XRt,hashOfString:$Rt});let azt=class extends ye{constructor(){super(...arguments),this.orientation="horizontal"}};azt.template=_e`
    <slot name="content"></slot>

    <style>
      :host {
        display: block;
      }

      :host slot {
        display: flex;
        height: 100%;
        width: 100%;
      }

      :host ::slotted(*) {
        flex: 0 0 auto;
      }

      :host([orientation='horizontal']) slot {
        flex-direction: row;
        overflow-x: auto;
      }

      :host([orientation='vertical']) slot {
        flex-direction: column;
        overflow-y: auto;
      }

      :host ::slotted(*:not(:last-child)) {
        border: 0 solid var(--divider-color, #ccc);
      }

      :host([orientation='vertical']) ::slotted(*:not(:last-child)) {
        border-bottom-width: 5px;
      }

      :host([orientation='horizontal']) ::slotted(*:not(:last-child)) {
        border-right-width: 5px;
      }
    </style>
  `,t([o({type:String,reflectToAttribute:!0}),e("design:type",String)],azt.prototype,"orientation",void 0),azt=t([i("hparams-split-layout")],azt);let szt=class extends(tr(ye)){constructor(){super(...arguments),this.configuration={schema:{hparamColumns:[],metricColumns:[]},columnsVisibility:[],visibleSchema:{hparamInfos:[],metricInfos:[]}},this.sessionGroups=[],this.dataLoadedWithNonEmptyHparams=!1,this.dataLoadedWithEmptyHparams=!1,this._statuses=[{value:"STATUS_UNKNOWN",displayName:"Unknown",allowed:!0},{value:"STATUS_SUCCESS",displayName:"Success",allowed:!0},{value:"STATUS_FAILURE",displayName:"Failure",allowed:!0},{value:"STATUS_RUNNING",displayName:"Running",allowed:!0}],this._getExperimentResolved=new Promise((t=>{this._resolveGetExperiment=t})),this._listSessionGroupsCanceller=new EO,this._pageSizeInput={value:"100",invalid:!1},this._pageNumberInput={value:"1",invalid:!1},this._pageCountStr="?",this._hparamName=SRt,this._metricName=MRt,this._prettyPrint=URt}reload(){this._queryServer()}_csvUrl(t,e){return this._downloadDataUrl(t,e,"csv")}_jsonUrl(t,e){return this._downloadDataUrl(t,e,"json")}_latexUrl(t,e){return this._downloadDataUrl(t,e,"latex")}_downloadDataUrl(t,e,n){return this.backend.getDownloadUrl(n,t,e.columnsVisibility)}_computeExperimentAndRelatedProps(){const t=KRt;t.isNullOrUndefined(this.backend)||t.isNullOrUndefined(this.experimentName)||this.backend.getExperiment({experimentName:this.experimentName}).then((t=>{we.isEqual(t,this._experiment)||(this.set("_experiment",t),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())})).finally((()=>{this._computeDataFound()}))}_computeDataFound(){const t=Boolean(this._experiment&&this._experiment.hparamInfos&&this._experiment.hparamInfos.length>0&&this._experiment.metricInfos&&this._experiment.metricInfos.length>0);this.set("dataLoadedWithNonEmptyHparams",t),this.set("dataLoadedWithEmptyHparams",!t)}_computeHParams(){const t=[];this._experiment.hparamInfos.forEach(((e,n)=>{const i={info:e,displayed:n<5,filter:{}};i.info.hasOwnProperty("domainDiscrete")?(i.filter.domainDiscrete=[],i.info.domainDiscrete.forEach((t=>{i.filter.domainDiscrete.push({value:t,checked:!0})}))):"DATA_TYPE_BOOL"===i.info.type?i.filter.domainDiscrete=[{value:!1,checked:!0},{value:!0,checked:!0}]:"DATA_TYPE_FLOAT64"===i.info.type?i.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:"DATA_TYPE_STRING"===i.info.type?i.filter.regexp="":console.warn("unknown hparam.info.type: %s",i.info.type),t.push(i)})),this.set("_hparams",t)}_computeMetrics(){const t=[];this._experiment.metricInfos.forEach(((e,n)=>{t.push({info:e,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:n<5})})),this.set("_metrics",t)}_computeSchema(){return this._hparams&&this._metrics?{hparamColumns:this._hparams.map((t=>({hparamInfo:t.info}))),metricColumns:this._metrics.map((t=>({metricInfo:t.info})))}:{hparamColumns:[],metricColumns:[]}}_updateConfiguration(){this.debounce("_updateConfiguration",(()=>{this.configuration={schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),visibleSchema:this._computeVisibleSchema()}}))}_computeColumnsVisibility(){return this._hparams&&this._metrics?this._hparams.map((t=>t.displayed)).concat(this._metrics.map((t=>t.displayed))):[]}_computeVisibleSchema(){return this._hparams&&this._metrics?{hparamInfos:this._hparams.filter((t=>t.displayed)).map((t=>t.info)),metricInfos:this._metrics.filter((t=>t.displayed)).map((t=>t.info))}:{hparamInfos:[],metricInfos:[]}}_queryServer(){this.debounce("queryServer",(()=>this._queryServerNoDebounce()),100)}_queryServerNoDebounce(){if(this._hparams&&this._metrics)return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable((({value:t,cancelled:e})=>{e||(t.totalSize>=0?(this.set("_pageCountStr",String(Math.ceil(t.totalSize/+this._pageSizeInput.value))),this.set("_totalSessionGroupsCountStr",t.totalSize)):(this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown")),XRt(this,"sessionGroups",t.sessionGroups))})))}_sendListSessionGroupsRequest(){const t=this._buildListSessionGroupsRequest();if(null!==t)return this.set("_sessionGroupsRequest",t),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(t)}_buildListSessionGroupsRequest(){const t=this;let e=!0;function n(n){const i=t.get(n+".min.value");console.assert(void 0!==i);const r=""===i?"-Infinity":+i;t.set(n+".min.invalid",isNaN(r)),e=e&&!isNaN(r);const o=t.get(n+".max.value");console.assert(void 0!==o);const a=""===o?"Infinity":+o;return t.set(n+".max.invalid",isNaN(a)),e=e&&!isNaN(a),isNaN(r)||isNaN(a)?null:{minValue:r,maxValue:a}}function i(n){const i=t.get(n+".value");console.assert(void 0!==i);const r=+i,o=Number.isInteger(r)&&r>0;return t.set(n+".invalid",!o),e=e&&o,o?r:null}const r=this._statuses.filter((t=>t.allowed)).map((t=>t.value));let o=[];if(this._hparams.forEach(((t,e)=>{let i={hparam:t.info.name};if(t.filter.domainDiscrete)i.filterDiscrete=[],t.filter.domainDiscrete.forEach((t=>{t.checked&&i.filterDiscrete.push(t.value)}));else if(t.filter.interval)i.filterInterval=n("_hparams."+e+".filter.interval");else{if(!t.filter.regexp)return console.error("hparam.filter with no domainDiscrete, interval or regexp properties set: %s",t),null;i.filterRegexp=t.filter.regexp}o.push(i)})),this._metrics.forEach(((t,e)=>{let i={metric:t.info.name,filterInterval:n("_metrics."+e+".filter.interval")};o.push(i)})),void 0!==this._sortByIndex&&void 0!==this._sortDirection){if(!(this._sortByIndex in o))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;o[this._sortByIndex].order=0===this._sortDirection?"ORDER_ASC":"ORDER_DESC"}const a=i("_pageNumberInput"),s=i("_pageSizeInput");return e?{experimentName:this.experimentName,allowedStatuses:r,colParams:o,startIndex:s*(a-1),sliceSize:s}:null}_metricSortByIndex(t){return t+this._hparams.length}};szt.template=_e`
    <hparams-split-layout orientation="vertical">
      <div slot="content" class="section hyperparameters">
        <div class="section-title">Hyperparameters</div>
        <template is="dom-repeat" items="{{_hparams}}" as="hparam">
          <div class="hparam">
            <paper-checkbox
              checked="{{hparam.displayed}}"
              class="hparam-checkbox"
            >
              [[_hparamName(hparam.info)]]
            </paper-checkbox>
            <!-- Precisely one of the templates below will be stamped.-->
            <!-- 1. A list of checkboxes -->
            <template is="dom-if" if="[[hparam.filter.domainDiscrete]]">
              <template
                is="dom-repeat"
                items="[[hparam.filter.domainDiscrete]]"
              >
                <paper-checkbox
                  checked="{{item.checked}}"
                  class="discrete-value-checkbox"
                  on-change="_queryServer"
                >
                  [[_prettyPrint(item.value)]]
                </paper-checkbox>
              </template>
            </template>
            <!-- 2. A numeric interval -->
            <template is="dom-if" if="[[hparam.filter.interval]]">
              <paper-input
                label="Min"
                value="{{hparam.filter.interval.min.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.min.invalid]]"
                placeholder="-infinity"
              >
              </paper-input>
              <paper-input
                label="Max"
                value="{{hparam.filter.interval.max.value}}"
                allowed_pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="[[hparam.filter.interval.max.invalid]]"
                placeholder="+infinity"
              >
              </paper-input>
            </template>
            <!-- 3. A regexp -->
            <template is="dom-if" if="[[hparam.filter.regexp]]">
              <paper-input
                label="Regular expression"
                value="{{hparam.filter.regexp}}"
                on-value-changed="_queryServer"
              >
              </paper-input>
            </template>
          </div>
        </template>
      </div>
      <div slot="content" class="section metrics">
        <div class="section-title">Metrics</div>
        <template is="dom-repeat" items="{{_metrics}}" as="metric">
          <div class="metric">
            <!-- TODO(erez): Make it easier to handle a large number of
                  metrics:
                  1. Add an 'isolator' radio-button to select just one
                  metric and
                  hide all the rest
                  2. Add a 'toggle-all' button that will hide/unhide
                    all the
                  metrics.
                  Use similar logic/appearance to the run-selector of
                  scalars.-->
            <paper-checkbox
              checked="{{metric.displayed}}"
              class="metric-checkbox"
            >
              [[_metricName(metric.info)]]
            </paper-checkbox>
            <div class="inline-element">
              <paper-input
                label="Min"
                value="{{metric.filter.interval.min.value}}"
                allowed-pattern="[0-9.e\\-]"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.min.invalid}}"
                placeholder="-infinity"
              >
              </paper-input>
            </div>
            <div class="inline-element">
              <paper-input
                label="Max"
                allowed-pattern="[0-9.e\\-]"
                value="{{metric.filter.interval.max.value}}"
                on-value-changed="_queryServer"
                error-message="Invalid input"
                invalid="{{metric.filter.interval.max.invalid}}"
                placeholder="+infinity"
              >
              </paper-input>
            </div>
          </div>
        </template>
      </div>
      <div slot="content" class="section status">
        <div class="section-title">Status</div>
        <template is="dom-repeat" items="[[_statuses]]" as="status">
          <paper-checkbox checked="{{status.allowed}}" on-change="_queryServer">
            [[status.displayName]]
          </paper-checkbox>
        </template>
      </div>
      <div slot="content" class="section sorting">
        <div class="section-title">Sorting</div>
        <paper-dropdown-menu
          label="Sort by"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortByIndex}}"
            on-selected-item-changed="_queryServer"
          >
            <template is="dom-repeat" items="[[_hparams]]" as="hparam">
              <paper-item> [[_hparamName(hparam.info)]] </paper-item>
            </template>
            <template is="dom-repeat" items="[[_metrics]]" as="metric">
              <paper-item> [[_metricName(metric.info)]] </paper-item>
            </template>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-dropdown-menu
          label="Direction"
          on-selected-item-changed="_queryServer"
          horizontal-align="left"
        >
          <paper-listbox
            class="dropdown-content"
            slot="dropdown-content"
            selected="{{_sortDirection}}"
          >
            <paper-item>Ascending</paper-item>
            <paper-item>Descending</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
      </div>
      <div slot="content" class="section paging">
        <div class="section-title">Paging</div>
        <div>
          Number of matching session groups: [[_totalSessionGroupsCountStr]]
        </div>
        <div class="inline-element page-number-input">
          <paper-input
            label="Page #"
            value="{{_pageNumberInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageNumberInput.invalid]]"
            on-value-changed="_queryServer"
          >
            <div slot="suffix" class="page-suffix">/ [[_pageCountStr]]</div>
          </paper-input>
        </div>
        <div class="inline-element page-size-input">
          <paper-input
            label="Max # of session groups per page:"
            value="{{_pageSizeInput.value}}"
            allowed-pattern="[0-9]"
            error-message="Invalid input"
            invalid="[[_pageSizeInput.invalid]]"
            on-value-changed="_queryServer"
          >
          </paper-input>
        </div>
      </div>
      <div slot="content" class="section download">
        <template is="dom-if" if="[[_sessionGroupsRequest]]">
          Download data as
          <span>
            <a
              id="csvLink"
              download="hparams_table.csv"
              href="[[_csvUrl(_sessionGroupsRequest, configuration)]]"
              >CSV</a
            >
            <a
              id="jsonLink"
              download="hparams_table.json"
              href="[[_jsonUrl(_sessionGroupsRequest, configuration)]]"
              >JSON</a
            >
            <a
              id="latexLink"
              download="hparams_table.tex"
              href="[[_latexUrl(_sessionGroupsRequest, configuration)]]"
              >LaTeX</a
            >
          </span>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      .discrete-value-checkbox,
      .metric-checkbox,
      .hparam-checkbox {
        display: block;
      }
      .discrete-value-checkbox {
        margin-left: 20px;
      }
      .hparam,
      .metric {
        display: block;
      }
      .inline-element {
        display: inline-block;
        width: 40%;
        margin-left: 10px;
      }
      .page-number-input {
        width: 20%;
      }
      .page-size-input {
        width: 60%;
      }
      vaadin-split-layout {
        height: 100%;
      }
      paper-listbox {
        max-height: 15em;
      }
      .page-suffix {
        white-space: nowrap;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],szt.prototype,"experimentName",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],szt.prototype,"configuration",void 0),t([o({type:Array,notify:!0}),e("design:type",Object)],szt.prototype,"sessionGroups",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],szt.prototype,"dataLoadedWithNonEmptyHparams",void 0),t([o({type:Boolean,notify:!0}),e("design:type",Boolean)],szt.prototype,"dataLoadedWithEmptyHparams",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_experiment",void 0),t([o({type:Array}),e("design:type",Array)],szt.prototype,"_hparams",void 0),t([o({type:Array}),e("design:type",Array)],szt.prototype,"_metrics",void 0),t([o({type:Array}),e("design:type",Object)],szt.prototype,"_statuses",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_getExperimentResolved",void 0),t([o({type:Object}),e("design:type",Function)],szt.prototype,"_resolveGetExperiment",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_listSessionGroupsCanceller",void 0),t([o({type:Number}),e("design:type",Number)],szt.prototype,"_sortByIndex",void 0),t([o({type:Number}),e("design:type",Number)],szt.prototype,"_sortDirection",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_pageSizeInput",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_pageNumberInput",void 0),t([o({type:String}),e("design:type",String)],szt.prototype,"_pageCountStr",void 0),t([o({type:String}),e("design:type",String)],szt.prototype,"_totalSessionGroupsCountStr",void 0),t([o({type:Object}),e("design:type",Object)],szt.prototype,"_sessionGroupsRequest",void 0),t([a("backend","experimentName"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],szt.prototype,"_computeExperimentAndRelatedProps",null),t([a("_hparams.*","_metrics.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],szt.prototype,"_updateConfiguration",null),szt=t([i("tf-hparams-query-pane")],szt);let lzt=class extends ye{constructor(){super(...arguments),this.options=null}_configurationChanged(){const t=this.configuration.visibleSchema,e=this.configuration.schema,n={columns:t.hparamInfos.map(((n,i)=>({name:SRt(n),index:i,absoluteIndex:RRt(e,t,i),scale:this._isNumericColumn(i)?"LINEAR":"NON_NUMERIC"}))).concat(t.metricInfos.map(((n,i)=>{const r=i+t.hparamInfos.length;return{scale:"LINEAR",name:MRt(n),index:r,absoluteIndex:RRt(e,t,r)}}))),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",n),zi(),this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())}_unselectDisabledLogScales(){null!==this.options&&this.options.columns.forEach((t=>{const e="options.columns."+t.index;this._allowLogScale(t)||"LOG"!==t.scale||this.set(e+".scale","LINEAR")}))}_allowLogScale(t){if(!this._isNumericColumn(t.index)||!this.sessionGroups)return!1;const[e,n]=BRt(this.configuration.visibleSchema,this.sessionGroups,t.index);return e>0||n<0}_isNumericColumn(t){return t>=this.configuration.visibleSchema.hparamInfos.length||"DATA_TYPE_FLOAT64"===this.configuration.visibleSchema.hparamInfos[t].type}_defaultColorByColumnIndex(){if(this.configuration.visibleSchema.metricInfos.length>0)return this.configuration.visibleSchema.hparamInfos.length;const t=this.configuration.visibleSchema.hparamInfos.findIndex((t=>"DATA_TYPE_FLOAT64"===t.type));return-1!==t?t:void 0}};lzt.template=_e`
    <div class="control-panel">
      <!-- 'Color by' drop down menu -->
      <paper-dropdown-menu
        label="Color by"
        id="colorByDropDownMenu"
        horizontal-align="left"
      >
        <paper-listbox
          class="dropdown-content"
          slot="dropdown-content"
          selected="{{options.colorByColumnIndex}}"
          id="colorByListBox"
        >
          <template
            is="dom-repeat"
            items="[[options.columns]]"
            as="column"
            id="colorByColumnTemplate"
          >
            <paper-item disabled="[[!_isNumericColumn(column.index)]]">
              [[column.name]]
            </paper-item>
          </template>
        </paper-listbox>
      </paper-dropdown-menu>

      <!-- Columns scales -->
      <div class="columns-container">
        <!-- Scale options for each numeric feature -->
        <template is="dom-repeat" items="{{options.columns}}" as="column">
          <template is="dom-if" if="[[_isNumericColumn(column.index)]]">
            <div class="column">
              <div class="column-title">[[column.name]]</div>
              <div>
                <paper-radio-group
                  class="scale-radio-group"
                  selected="{{column.scale}}"
                >
                  <paper-radio-button name="LINEAR">
                    Linear
                  </paper-radio-button>
                  <!-- The id here is used to access this button in unit
                       tests.-->
                  <paper-radio-button
                    id="logScaleButton_[[column.name]]"
                    name="LOG"
                    disabled="[[!_allowLogScale(column, sessionGroups.*)]]"
                  >
                    Logarithmic
                  </paper-radio-button>
                  <paper-radio-button name="QUANTILE">
                    Quantile
                  </paper-radio-button>
                </paper-radio-group>
              </div>
            </div>
          </template>
        </template>
      </div>
    </div>

    <style>
      :host {
        display: block;
      }
      .control-panel {
        overflow: auto;
      }
      .column {
        flex-grow: 1;
        flex-shrink: 1;
        margin-right: 5px;
        border: solid 1px darkgray;
        padding: 3px;
      }
      .column-title {
        /* Fit every title in one line so the radio boxes align vertically. */
        white-space: nowrap;
        text-decoration: underline;
      }
      .columns-container {
        display: flex;
        flex-direction: row;
      }
      .scale-radio-group paper-radio-button {
        padding: 2px;
        display: block;
      }
      paper-listbox {
        max-height: 15em;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],lzt.prototype,"configuration",void 0),t([o({type:Array}),e("design:type",Array)],lzt.prototype,"sessionGroups",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],lzt.prototype,"options",void 0),t([a("configuration.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],lzt.prototype,"_configurationChanged",null),t([a("sessionGroups.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],lzt.prototype,"_unselectDisabledLogScales",null),lzt=t([i("tf-hparams-scale-and-color-controls")],lzt);class czt extends HTMLElement{static get version(){return"1.6.1"}}customElements.define("vaadin-lumo-styles",czt);const uzt=document.createElement("template");uzt.innerHTML='<custom-style>\n  <style>\n    html {\n      /* Base (background) */\n      --lumo-base-color: #FFF;\n\n      /* Tint */\n      --lumo-tint-5pct: hsla(0, 0%, 100%, 0.3);\n      --lumo-tint-10pct: hsla(0, 0%, 100%, 0.37);\n      --lumo-tint-20pct: hsla(0, 0%, 100%, 0.44);\n      --lumo-tint-30pct: hsla(0, 0%, 100%, 0.5);\n      --lumo-tint-40pct: hsla(0, 0%, 100%, 0.57);\n      --lumo-tint-50pct: hsla(0, 0%, 100%, 0.64);\n      --lumo-tint-60pct: hsla(0, 0%, 100%, 0.7);\n      --lumo-tint-70pct: hsla(0, 0%, 100%, 0.77);\n      --lumo-tint-80pct: hsla(0, 0%, 100%, 0.84);\n      --lumo-tint-90pct: hsla(0, 0%, 100%, 0.9);\n      --lumo-tint: #FFF;\n\n      /* Shade */\n      --lumo-shade-5pct: hsla(214, 61%, 25%, 0.05);\n      --lumo-shade-10pct: hsla(214, 57%, 24%, 0.1);\n      --lumo-shade-20pct: hsla(214, 53%, 23%, 0.16);\n      --lumo-shade-30pct: hsla(214, 50%, 22%, 0.26);\n      --lumo-shade-40pct: hsla(214, 47%, 21%, 0.38);\n      --lumo-shade-50pct: hsla(214, 45%, 20%, 0.5);\n      --lumo-shade-60pct: hsla(214, 43%, 19%, 0.61);\n      --lumo-shade-70pct: hsla(214, 42%, 18%, 0.72);\n      --lumo-shade-80pct: hsla(214, 41%, 17%, 0.83);\n      --lumo-shade-90pct: hsla(214, 40%, 16%, 0.94);\n      --lumo-shade: hsl(214, 35%, 15%);\n\n      /* Contrast */\n      --lumo-contrast-5pct: var(--lumo-shade-5pct);\n      --lumo-contrast-10pct: var(--lumo-shade-10pct);\n      --lumo-contrast-20pct: var(--lumo-shade-20pct);\n      --lumo-contrast-30pct: var(--lumo-shade-30pct);\n      --lumo-contrast-40pct: var(--lumo-shade-40pct);\n      --lumo-contrast-50pct: var(--lumo-shade-50pct);\n      --lumo-contrast-60pct: var(--lumo-shade-60pct);\n      --lumo-contrast-70pct: var(--lumo-shade-70pct);\n      --lumo-contrast-80pct: var(--lumo-shade-80pct);\n      --lumo-contrast-90pct: var(--lumo-shade-90pct);\n      --lumo-contrast: var(--lumo-shade);\n\n      /* Text */\n      --lumo-header-text-color: var(--lumo-contrast);\n      --lumo-body-text-color: var(--lumo-contrast-90pct);\n      --lumo-secondary-text-color: var(--lumo-contrast-70pct);\n      --lumo-tertiary-text-color: var(--lumo-contrast-50pct);\n      --lumo-disabled-text-color: var(--lumo-contrast-30pct);\n\n      /* Primary */\n      --lumo-primary-color: hsl(214, 90%, 52%);\n      --lumo-primary-color-50pct: hsla(214, 90%, 52%, 0.5);\n      --lumo-primary-color-10pct: hsla(214, 90%, 52%, 0.1);\n      --lumo-primary-text-color: var(--lumo-primary-color);\n      --lumo-primary-contrast-color: #FFF;\n\n      /* Error */\n      --lumo-error-color: hsl(3, 100%, 61%);\n      --lumo-error-color-50pct: hsla(3, 100%, 60%, 0.5);\n      --lumo-error-color-10pct: hsla(3, 100%, 60%, 0.1);\n      --lumo-error-text-color: hsl(3, 92%, 53%);\n      --lumo-error-contrast-color: #FFF;\n\n      /* Success */\n      --lumo-success-color: hsl(145, 80%, 42%); /* hsl(144,82%,37%); */\n      --lumo-success-color-50pct: hsla(145, 76%, 44%, 0.55);\n      --lumo-success-color-10pct: hsla(145, 76%, 44%, 0.12);\n      --lumo-success-text-color: hsl(145, 100%, 32%);\n      --lumo-success-contrast-color: #FFF;\n    }\n  </style>\n</custom-style><dom-module id="lumo-color">\n  <template>\n    <style>\n      [theme~="dark"] {\n        /* Base (background) */\n        --lumo-base-color: hsl(214, 35%, 21%);\n\n        /* Tint */\n        --lumo-tint-5pct: hsla(214, 65%, 85%, 0.06);\n        --lumo-tint-10pct: hsla(214, 60%, 80%, 0.14);\n        --lumo-tint-20pct: hsla(214, 64%, 82%, 0.23);\n        --lumo-tint-30pct: hsla(214, 69%, 84%, 0.32);\n        --lumo-tint-40pct: hsla(214, 73%, 86%, 0.41);\n        --lumo-tint-50pct: hsla(214, 78%, 88%, 0.5);\n        --lumo-tint-60pct: hsla(214, 82%, 90%, 0.6);\n        --lumo-tint-70pct: hsla(214, 87%, 92%, 0.7);\n        --lumo-tint-80pct: hsla(214, 91%, 94%, 0.8);\n        --lumo-tint-90pct: hsla(214, 96%, 96%, 0.9);\n        --lumo-tint: hsl(214, 100%, 98%);\n\n        /* Shade */\n        --lumo-shade-5pct: hsla(214, 0%, 0%, 0.07);\n        --lumo-shade-10pct: hsla(214, 4%, 2%, 0.15);\n        --lumo-shade-20pct: hsla(214, 8%, 4%, 0.23);\n        --lumo-shade-30pct: hsla(214, 12%, 6%, 0.32);\n        --lumo-shade-40pct: hsla(214, 16%, 8%, 0.41);\n        --lumo-shade-50pct: hsla(214, 20%, 10%, 0.5);\n        --lumo-shade-60pct: hsla(214, 24%, 12%, 0.6);\n        --lumo-shade-70pct: hsla(214, 28%, 13%, 0.7);\n        --lumo-shade-80pct: hsla(214, 32%, 13%, 0.8);\n        --lumo-shade-90pct: hsla(214, 33%, 13%, 0.9);\n        --lumo-shade: hsl(214, 33%, 13%);\n\n        /* Contrast */\n        --lumo-contrast-5pct: var(--lumo-tint-5pct);\n        --lumo-contrast-10pct: var(--lumo-tint-10pct);\n        --lumo-contrast-20pct: var(--lumo-tint-20pct);\n        --lumo-contrast-30pct: var(--lumo-tint-30pct);\n        --lumo-contrast-40pct: var(--lumo-tint-40pct);\n        --lumo-contrast-50pct: var(--lumo-tint-50pct);\n        --lumo-contrast-60pct: var(--lumo-tint-60pct);\n        --lumo-contrast-70pct: var(--lumo-tint-70pct);\n        --lumo-contrast-80pct: var(--lumo-tint-80pct);\n        --lumo-contrast-90pct: var(--lumo-tint-90pct);\n        --lumo-contrast: var(--lumo-tint);\n\n        /* Text */\n        --lumo-header-text-color: var(--lumo-contrast);\n        --lumo-body-text-color: var(--lumo-contrast-90pct);\n        --lumo-secondary-text-color: var(--lumo-contrast-70pct);\n        --lumo-tertiary-text-color: var(--lumo-contrast-50pct);\n        --lumo-disabled-text-color: var(--lumo-contrast-30pct);\n\n        /* Primary */\n        --lumo-primary-color: hsl(214, 86%, 55%);\n        --lumo-primary-color-50pct: hsla(214, 86%, 55%, 0.5);\n        --lumo-primary-color-10pct: hsla(214, 90%, 63%, 0.1);\n        --lumo-primary-text-color: hsl(214, 100%, 70%);\n        --lumo-primary-contrast-color: #FFF;\n\n        /* Error */\n        --lumo-error-color: hsl(3, 90%, 63%);\n        --lumo-error-color-50pct: hsla(3, 90%, 63%, 0.5);\n        --lumo-error-color-10pct: hsla(3, 90%, 63%, 0.1);\n        --lumo-error-text-color: hsl(3, 100%, 67%);\n\n        /* Success */\n        --lumo-success-color: hsl(145, 65%, 42%);\n        --lumo-success-color-50pct: hsla(145, 65%, 42%, 0.5);\n        --lumo-success-color-10pct: hsla(145, 65%, 42%, 0.1);\n        --lumo-success-text-color: hsl(145, 85%, 47%);\n      }\n\n      html {\n        color: var(--lumo-body-text-color);\n        background-color: var(--lumo-base-color);\n      }\n\n      [theme~="dark"] {\n        color: var(--lumo-body-text-color);\n        background-color: var(--lumo-base-color);\n      }\n\n      h1,\n      h2,\n      h3,\n      h4,\n      h5,\n      h6 {\n        color: var(--lumo-header-text-color);\n      }\n\n      a {\n        color: var(--lumo-primary-text-color);\n      }\n\n      blockquote {\n        color: var(--lumo-secondary-text-color);\n      }\n\n      code,\n      pre {\n        background-color: var(--lumo-contrast-10pct);\n        border-radius: var(--lumo-border-radius-m);\n      }\n    </style>\n  </template>\n</dom-module><dom-module id="lumo-color-legacy">\n  <template>\n    <style include="lumo-color">\n      :host {\n        color: var(--lumo-body-text-color) !important;\n        background-color: var(--lumo-base-color) !important;\n      }\n    </style>\n  </template>\n</dom-module>',document.head.appendChild(uzt.content);const hzt=document.createElement("template");hzt.innerHTML='<custom-style>\n  <style>\n    @font-face {\n      font-family: \'lumo-icons\';\n      src: url(data:application/font-woff;charset=utf-8;base64,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) format(\'woff\');\n      font-weight: normal;\n      font-style: normal;\n    }\n\n    html {\n      --lumo-icons-align-center: "\\ea01";\n      --lumo-icons-align-left: "\\ea02";\n      --lumo-icons-align-right: "\\ea03";\n      --lumo-icons-angle-down: "\\ea04";\n      --lumo-icons-angle-left: "\\ea05";\n      --lumo-icons-angle-right: "\\ea06";\n      --lumo-icons-angle-up: "\\ea07";\n      --lumo-icons-arrow-down: "\\ea08";\n      --lumo-icons-arrow-left: "\\ea09";\n      --lumo-icons-arrow-right: "\\ea0a";\n      --lumo-icons-arrow-up: "\\ea0b";\n      --lumo-icons-bar-chart: "\\ea0c";\n      --lumo-icons-bell: "\\ea0d";\n      --lumo-icons-calendar: "\\ea0e";\n      --lumo-icons-checkmark: "\\ea0f";\n      --lumo-icons-chevron-down: "\\ea10";\n      --lumo-icons-chevron-left: "\\ea11";\n      --lumo-icons-chevron-right: "\\ea12";\n      --lumo-icons-chevron-up: "\\ea13";\n      --lumo-icons-clock: "\\ea14";\n      --lumo-icons-cog: "\\ea15";\n      --lumo-icons-cross: "\\ea16";\n      --lumo-icons-download: "\\ea17";\n      --lumo-icons-dropdown: "\\ea18";\n      --lumo-icons-edit: "\\ea19";\n      --lumo-icons-error: "\\ea1a";\n      --lumo-icons-eye: "\\ea1b";\n      --lumo-icons-eye-disabled: "\\ea1c";\n      --lumo-icons-menu: "\\ea1d";\n      --lumo-icons-minus: "\\ea1e";\n      --lumo-icons-ordered-list: "\\ea1f";\n      --lumo-icons-phone: "\\ea20";\n      --lumo-icons-photo: "\\ea21";\n      --lumo-icons-play: "\\ea22";\n      --lumo-icons-plus: "\\ea23";\n      --lumo-icons-redo: "\\ea24";\n      --lumo-icons-reload: "\\ea25";\n      --lumo-icons-search: "\\ea26";\n      --lumo-icons-undo: "\\ea27";\n      --lumo-icons-unordered-list: "\\ea28";\n      --lumo-icons-upload: "\\ea29";\n      --lumo-icons-user: "\\ea2a";\n    }\n  </style>\n</custom-style>',document.head.appendChild(hzt.content);const dzt=document.createElement("template");dzt.innerHTML="<custom-style>\n  <style>\n    html {\n      --lumo-size-xs: 1.625rem;\n      --lumo-size-s: 1.875rem;\n      --lumo-size-m: 2.25rem;\n      --lumo-size-l: 2.75rem;\n      --lumo-size-xl: 3.5rem;\n\n      /* Icons */\n      --lumo-icon-size-s: 1.25em;\n      --lumo-icon-size-m: 1.5em;\n      --lumo-icon-size-l: 2.25em;\n      /* For backwards compatibility */\n      --lumo-icon-size: var(--lumo-icon-size-m);\n    }\n  </style>\n</custom-style>",document.head.appendChild(dzt.content);const pzt=document.createElement("template");pzt.innerHTML="<custom-style>\n  <style>\n    html {\n      /* Square */\n      --lumo-space-xs: 0.25rem;\n      --lumo-space-s: 0.5rem;\n      --lumo-space-m: 1rem;\n      --lumo-space-l: 1.5rem;\n      --lumo-space-xl: 2.5rem;\n\n      /* Wide */\n      --lumo-space-wide-xs: calc(var(--lumo-space-xs) / 2) var(--lumo-space-xs);\n      --lumo-space-wide-s: calc(var(--lumo-space-s) / 2) var(--lumo-space-s);\n      --lumo-space-wide-m: calc(var(--lumo-space-m) / 2) var(--lumo-space-m);\n      --lumo-space-wide-l: calc(var(--lumo-space-l) / 2) var(--lumo-space-l);\n      --lumo-space-wide-xl: calc(var(--lumo-space-xl) / 2) var(--lumo-space-xl);\n\n      /* Tall */\n      --lumo-space-tall-xs: var(--lumo-space-xs) calc(var(--lumo-space-xs) / 2);\n      --lumo-space-tall-s: var(--lumo-space-s) calc(var(--lumo-space-s) / 2);\n      --lumo-space-tall-m: var(--lumo-space-m) calc(var(--lumo-space-m) / 2);\n      --lumo-space-tall-l: var(--lumo-space-l) calc(var(--lumo-space-l) / 2);\n      --lumo-space-tall-xl: var(--lumo-space-xl) calc(var(--lumo-space-xl) / 2);\n    }\n  </style>\n</custom-style>",document.head.appendChild(pzt.content);const fzt=document.createElement("template");fzt.innerHTML="<custom-style>\n  <style>\n    html {\n      /* Border radius */\n      --lumo-border-radius-s: 0.25em; /* Checkbox, badge, date-picker year indicator, etc */\n      --lumo-border-radius-m: var(--lumo-border-radius, 0.25em); /* Button, text field, menu overlay, etc */\n      --lumo-border-radius-l: 0.5em; /* Dialog, notification, etc */\n      --lumo-border-radius: 0.25em; /* Deprecated */\n\n      /* Shadow */\n      --lumo-box-shadow-xs: 0 1px 4px -1px var(--lumo-shade-50pct);\n      --lumo-box-shadow-s: 0 2px 4px -1px var(--lumo-shade-20pct), 0 3px 12px -1px var(--lumo-shade-30pct);\n      --lumo-box-shadow-m: 0 2px 6px -1px var(--lumo-shade-20pct), 0 8px 24px -4px var(--lumo-shade-40pct);\n      --lumo-box-shadow-l: 0 3px 18px -2px var(--lumo-shade-20pct), 0 12px 48px -6px var(--lumo-shade-40pct);\n      --lumo-box-shadow-xl: 0 4px 24px -3px var(--lumo-shade-20pct), 0 18px 64px -8px var(--lumo-shade-40pct);\n\n      /* Clickable element cursor */\n      --lumo-clickable-cursor: default;\n    }\n  </style>\n</custom-style>",document.head.appendChild(fzt.content);const mzt=document.createElement("template");mzt.innerHTML='<custom-style>\n  <style>\n    html {\n      /* Font families */\n      --lumo-font-family: -apple-system, BlinkMacSystemFont, "Roboto", "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";\n\n      /* Font sizes */\n      --lumo-font-size-xxs: .75rem;\n      --lumo-font-size-xs: .8125rem;\n      --lumo-font-size-s: .875rem;\n      --lumo-font-size-m: 1rem;\n      --lumo-font-size-l: 1.125rem;\n      --lumo-font-size-xl: 1.375rem;\n      --lumo-font-size-xxl: 1.75rem;\n      --lumo-font-size-xxxl: 2.5rem;\n\n      /* Line heights */\n      --lumo-line-height-xs: 1.25;\n      --lumo-line-height-s: 1.375;\n      --lumo-line-height-m: 1.625;\n    }\n\n  </style>\n</custom-style><dom-module id="lumo-typography">\n  <template>\n    <style>\n      html {\n        font-family: var(--lumo-font-family);\n        font-size: var(--lumo-font-size, var(--lumo-font-size-m));\n        line-height: var(--lumo-line-height-m);\n        -webkit-text-size-adjust: 100%;\n        -webkit-font-smoothing: antialiased;\n        -moz-osx-font-smoothing: grayscale;\n      }\n\n      /* Can’t combine with the above selector because that doesn’t work in browsers without native shadow dom */\n      :host {\n        font-family: var(--lumo-font-family);\n        font-size: var(--lumo-font-size, var(--lumo-font-size-m));\n        line-height: var(--lumo-line-height-m);\n        -webkit-text-size-adjust: 100%;\n        -webkit-font-smoothing: antialiased;\n        -moz-osx-font-smoothing: grayscale;\n      }\n\n      small,\n      [theme~="font-size-s"] {\n        font-size: var(--lumo-font-size-s);\n        line-height: var(--lumo-line-height-s);\n      }\n\n      [theme~="font-size-xs"] {\n        font-size: var(--lumo-font-size-xs);\n        line-height: var(--lumo-line-height-xs);\n      }\n\n      h1,\n      h2,\n      h3,\n      h4,\n      h5,\n      h6 {\n        font-weight: 600;\n        line-height: var(--lumo-line-height-xs);\n        margin-top: 1.25em;\n      }\n\n      h1 {\n        font-size: var(--lumo-font-size-xxxl);\n        margin-bottom: 0.75em;\n      }\n\n      h2 {\n        font-size: var(--lumo-font-size-xxl);\n        margin-bottom: 0.5em;\n      }\n\n      h3 {\n        font-size: var(--lumo-font-size-xl);\n        margin-bottom: 0.5em;\n      }\n\n      h4 {\n        font-size: var(--lumo-font-size-l);\n        margin-bottom: 0.5em;\n      }\n\n      h5 {\n        font-size: var(--lumo-font-size-m);\n        margin-bottom: 0.25em;\n      }\n\n      h6 {\n        font-size: var(--lumo-font-size-xs);\n        margin-bottom: 0;\n        text-transform: uppercase;\n        letter-spacing: 0.03em;\n      }\n\n      p,\n      blockquote {\n        margin-top: 0.5em;\n        margin-bottom: 0.75em;\n      }\n\n      a {\n        text-decoration: none;\n      }\n\n      a:hover {\n        text-decoration: underline;\n      }\n\n      hr {\n        display: block;\n        align-self: stretch;\n        height: 1px;\n        border: 0;\n        padding: 0;\n        margin: var(--lumo-space-s) calc(var(--lumo-border-radius-m) / 2);\n        background-color: var(--lumo-contrast-10pct);\n      }\n\n      blockquote {\n        border-left: 2px solid var(--lumo-contrast-30pct);\n      }\n\n      b,\n      strong {\n        font-weight: 600;\n      }\n\n      /* RTL specific styles */\n\n      blockquote[dir="rtl"] {\n        border-left: none;\n        border-right: 2px solid var(--lumo-contrast-30pct);\n      }\n\n    </style>\n  </template>\n</dom-module>',document.head.appendChild(mzt.content);const gzt=_e`<dom-module id="lumo-checkbox" theme-for="vaadin-checkbox">
  <template>
    <style include="lumo-checkbox-style lumo-checkbox-effects">
      /* IE11 only */
      ::-ms-backdrop,
      [part="checkbox"] {
        line-height: 1;
      }
    </style>
  </template>
</dom-module><dom-module id="lumo-checkbox-style">
  <template>
    <style>
      :host {
        -webkit-tap-highlight-color: transparent;
        -webkit-user-select: none;
        -moz-user-select: none;
        -ms-user-select: none;
        user-select: none;
        cursor: default;
        outline: none;
      }

      [part="label"]:not([empty]) {
        margin: 0.1875em 0.875em 0.1875em 0.375em;
      }

      [part="checkbox"] {
        width: calc(1em + 2px);
        height: calc(1em + 2px);
        margin: 0.1875em;
        position: relative;
        border-radius: var(--lumo-border-radius-s);
        background-color: var(--lumo-contrast-20pct);
        transition: transform 0.2s cubic-bezier(.12, .32, .54, 2), background-color 0.15s;
        pointer-events: none;
        line-height: 1.2;
      }

      :host([indeterminate]) [part="checkbox"],
      :host([checked]) [part="checkbox"] {
        background-color: var(--lumo-primary-color);
      }

      /* Needed to align the checkbox nicely on the baseline */
      [part="checkbox"]::before {
        content: "\\2003";
      }

      /* Checkmark */
      [part="checkbox"]::after {
        content: "";
        display: inline-block;
        width: 0;
        height: 0;
        border: 0 solid var(--lumo-primary-contrast-color);
        border-width: 0.1875em 0 0 0.1875em;
        box-sizing: border-box;
        transform-origin: 0 0;
        position: absolute;
        top: 0.8125em;
        left: 0.5em;
        transform: scale(0.55) rotate(-135deg);
        opacity: 0;
      }

      :host([checked]) [part="checkbox"]::after {
        opacity: 1;
        width: 0.625em;
        height: 1.0625em;
      }

      /* Indeterminate checkmark */

      :host([indeterminate]) [part="checkbox"]::after {
        transform: none;
        opacity: 1;
        top: 45%;
        height: 10%;
        left: 22%;
        right: 22%;
        width: auto;
        border: 0;
        background-color: var(--lumo-primary-contrast-color);
        transition: opacity 0.25s;
      }

      /* Focus ring */

      :host([focus-ring]) [part="checkbox"] {
        box-shadow: 0 0 0 3px var(--lumo-primary-color-50pct);
      }

      /* Disabled */

      :host([disabled]) {
        pointer-events: none;
        color: var(--lumo-disabled-text-color);
      }

      :host([disabled]) [part="label"] ::slotted(*) {
        color: inherit;
      }

      :host([disabled]) [part="checkbox"] {
        background-color: var(--lumo-contrast-10pct);
      }

      :host([disabled]) [part="checkbox"]::after {
        border-color: var(--lumo-contrast-30pct);
      }

      :host([indeterminate][disabled]) [part="checkbox"]::after {
        background-color: var(--lumo-contrast-30pct);
      }

      /* RTL specific styles */

      :host([dir="rtl"]) [part="label"]:not([empty]) {
        margin: 0.1875em 0.375em 0.1875em 0.875em;
      }
    </style>
  </template>
</dom-module><dom-module id="lumo-checkbox-effects">
  <template>
    <style>
      /* Transition the checkmark if activated with the mouse (disabled for grid select-all this way) */
      :host(:hover) [part="checkbox"]::after {
        transition: width 0.1s, height 0.25s;
      }

      /* Used for activation "halo" */
      [part="checkbox"]::before {
        color: transparent;
        display: inline-block;
        width: 100%;
        height: 100%;
        border-radius: inherit;
        background-color: inherit;
        transform: scale(1.4);
        opacity: 0;
        transition: transform 0.1s, opacity 0.8s;
      }

      /* Hover */

      :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part="checkbox"] {
        background-color: var(--lumo-contrast-30pct);
      }

      /* Disable hover for touch devices */
      @media (pointer: coarse) {
        :host(:not([checked]):not([indeterminate]):not([disabled]):hover) [part="checkbox"] {
          background-color: var(--lumo-contrast-20pct);
        }
      }

      /* Active */

      :host([active]) [part="checkbox"] {
        transform: scale(0.9);
        transition-duration: 0.05s;
      }

      :host([active][checked]) [part="checkbox"] {
        transform: scale(1.1);
      }

      :host([active]:not([checked])) [part="checkbox"]::before {
        transition-duration: 0.01s, 0.01s;
        transform: scale(0);
        opacity: 0.4;
      }
    </style>
  </template>
</dom-module>`;document.head.appendChild(gzt.content);const _zt=t=>class extends t{static get properties(){return{theme:{type:String,readOnly:!0}}}attributeChangedCallback(t,e,n){super.attributeChangedCallback(t,e,n),"theme"===t&&this._setTheme(n)}},yzt=t=>class extends(_zt(t)){static finalize(){super.finalize();const t=this.prototype._template,e=this.template&&this.template.parentElement&&this.template.parentElement.id===this.is,n=Object.getPrototypeOf(this.prototype)._template;n&&!e&&Array.from(n.content.querySelectorAll("style[include]")).forEach((e=>{this._includeStyle(e.getAttribute("include"),t)})),this._includeMatchingThemes(t)}static _includeMatchingThemes(t){const e=B.prototype.modules;let n=!1;const i=this.is+"-default-theme";Object.keys(e).sort(((t,e)=>{const n=0===t.indexOf("vaadin-"),i=0===e.indexOf("vaadin-"),r=["lumo-","material-"],o=r.filter((e=>0===t.indexOf(e))).length>0,a=r.filter((t=>0===e.indexOf(t))).length>0;return n!==i?n?-1:1:o!==a?o?-1:1:0})).forEach((r=>{if(r!==i){const i=e[r].getAttribute("theme-for");i&&i.split(" ").forEach((e=>{new RegExp("^"+e.split("*").join(".*")+"$").test(this.is)&&(n=!0,this._includeStyle(r,t))}))}})),!n&&e[i]&&this._includeStyle(i,t)}static _includeStyle(t,e){if(e&&!e.content.querySelector(`style[include="${t}"]`)){const n=document.createElement("style");n.setAttribute("include",t),e.content.appendChild(n)}}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */;let vzt=!1;window.addEventListener("keydown",(()=>{vzt=!0}),{capture:!0}),window.addEventListener("mousedown",(()=>{vzt=!1}),{capture:!0});const bzt=t=>class extends((t=>class extends t{static get properties(){var t={tabindex:{type:Number,value:0,reflectToAttribute:!0,observer:"_tabindexChanged"}};return window.ShadyDOM&&(t.tabIndex=t.tabindex),t}})(t)){static get properties(){return{autofocus:{type:Boolean},_previousTabIndex:{type:Number},disabled:{type:Boolean,observer:"_disabledChanged",reflectToAttribute:!0},_isShiftTabbing:{type:Boolean}}}ready(){this.addEventListener("focusin",(t=>{t.composedPath()[0]===this?this.contains(t.relatedTarget)||this._focus():-1===t.composedPath().indexOf(this.focusElement)||this.disabled||this._setFocused(!0)})),this.addEventListener("focusout",(t=>this._setFocused(!1))),super.ready();const t=t=>{t.composed||t.target.dispatchEvent(new CustomEvent(t.type,{bubbles:!0,composed:!0,cancelable:!1}))};this.shadowRoot.addEventListener("focusin",t),this.shadowRoot.addEventListener("focusout",t),this.addEventListener("keydown",(t=>{if(!t.defaultPrevented&&9===t.keyCode)if(t.shiftKey)this._isShiftTabbing=!0,HTMLElement.prototype.focus.apply(this),this._setFocused(!1),setTimeout((()=>this._isShiftTabbing=!1),0);else{const t=window.navigator.userAgent.match(/Firefox\/(\d\d\.\d)/);if(t&&parseFloat(t[1])>=63&&parseFloat(t[1])<66&&this.parentNode&&this.nextSibling){const t=document.createElement("input");t.style.position="absolute",t.style.opacity="0",t.tabIndex=this.tabIndex,this.parentNode.insertBefore(t,this.nextSibling),t.focus(),t.addEventListener("focusout",(()=>this.parentNode.removeChild(t)))}}})),this.autofocus&&!this.disabled&&window.requestAnimationFrame((()=>{this._focus(),this._setFocused(!0),this.setAttribute("focus-ring","")}))}disconnectedCallback(){super.disconnectedCallback(),this.hasAttribute("focused")&&this._setFocused(!1)}_setFocused(t){t?this.setAttribute("focused",""):this.removeAttribute("focused"),t&&vzt?this.setAttribute("focus-ring",""):this.removeAttribute("focus-ring")}get focusElement(){return window.console.warn(`Please implement the 'focusElement' property in <${this.localName}>`),this}_focus(){this.focusElement&&!this._isShiftTabbing&&(this.focusElement.focus(),this._setFocused(!0))}focus(){this.focusElement&&!this.disabled&&(this.focusElement.focus(),this._setFocused(!0))}blur(){this.focusElement&&(this.focusElement.blur(),this._setFocused(!1))}_disabledChanged(t){this.focusElement.disabled=t,t?(this.blur(),this._previousTabIndex=this.tabindex,this.tabindex=-1,this.setAttribute("aria-disabled","true")):(void 0!==this._previousTabIndex&&(this.tabindex=this._previousTabIndex),this.removeAttribute("aria-disabled"))}_tabindexChanged(t){void 0!==t&&(this.focusElement.tabIndex=t),this.disabled&&this.tabindex&&(-1!==this.tabindex&&(this._previousTabIndex=this.tabindex),this.tabindex=t=void 0),window.ShadyDOM&&this.setProperties({tabIndex:t,tabindex:t})}click(){this.disabled||super.click()}}
/**
    @license
    Copyright (c) 2020 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */;class xzt{static detectScrollType(){const t=document.createElement("div");t.textContent="ABCD",t.dir="rtl",t.style.fontSize="14px",t.style.width="4px",t.style.height="1px",t.style.position="absolute",t.style.top="-1000px",t.style.overflow="scroll",document.body.appendChild(t);let e="reverse";return t.scrollLeft>0?e="default":(t.scrollLeft=2,t.scrollLeft<2&&(e="negative")),document.body.removeChild(t),e}static getNormalizedScrollLeft(t,e,n){const{scrollLeft:i}=n;if("rtl"!==e||!t)return i;switch(t){case"negative":return n.scrollWidth-n.clientWidth+i;case"reverse":return n.scrollWidth-n.clientWidth-i}return i}static setNormalizedScrollLeft(t,e,n,i){if("rtl"===e&&t)switch(t){case"negative":n.scrollLeft=n.clientWidth-n.scrollWidth+i;break;case"reverse":n.scrollLeft=n.scrollWidth-n.clientWidth-i;break;default:n.scrollLeft=i}else n.scrollLeft=i}}const wzt=[];let Szt;new MutationObserver((function(){const t=Ezt();wzt.forEach((e=>{Mzt(e,t)}))})).observe(document.documentElement,{attributes:!0,attributeFilter:["dir"]});const Mzt=function(t,e){e?t.setAttribute("dir",e):t.removeAttribute("dir")},Ezt=function(){return document.documentElement.getAttribute("dir")},Tzt=t=>class extends t{static get properties(){return{dir:{type:String,readOnly:!0}}}static finalize(){super.finalize(),Szt||(Szt=xzt.detectScrollType())}connectedCallback(){super.connectedCallback(),this.hasAttribute("dir")||(this.__subscribe(),Mzt(this,Ezt()))}attributeChangedCallback(t,e,n){if(super.attributeChangedCallback(t,e,n),"dir"!==t)return;const i=n===Ezt()&&-1===wzt.indexOf(this),r=!n&&e&&-1===wzt.indexOf(this),o=n!==Ezt()&&e===Ezt();i||r?(this.__subscribe(),Mzt(this,Ezt())):o&&this.__subscribe(!1)}disconnectedCallback(){super.disconnectedCallback(),this.__subscribe(!1),this.removeAttribute("dir")}__subscribe(t=!0){t?-1===wzt.indexOf(this)&&wzt.push(this):wzt.indexOf(this)>-1&&wzt.splice(wzt.indexOf(this),1)}__getNormalizedScrollLeft(t){return xzt.getNormalizedScrollLeft(Szt,this.getAttribute("dir")||"ltr",t)}__setNormalizedScrollLeft(t,e){return xzt.setNormalizedScrollLeft(Szt,this.getAttribute("dir")||"ltr",t,e)}},Azt=/\/\*\*\s+vaadin-dev-mode:start([\s\S]*)vaadin-dev-mode:end\s+\*\*\//i,Czt=window.Vaadin&&window.Vaadin.Flow&&window.Vaadin.Flow.clients;function kzt(t,e){if("function"!=typeof t)return;const n=Azt.exec(t.toString());if(n)try{t=new Function(n[1])}catch(t){console.log("vaadin-development-mode-detector: uncommentAndRun() failed",t)}return t(e)}function Lzt(){}window.Vaadin=window.Vaadin||{},void 0===window.Vaadin.developmentMode&&(window.Vaadin.developmentMode=(function Pzt(){try{return!!(function t(){return localStorage.getItem("vaadin.developmentmode.force")})()||!!(function e(){return["localhost","127.0.0.1"].indexOf(window.location.hostname)>=0})()&&(Czt?!(function n(){return!!(Czt&&Object.keys(Czt).map((t=>Czt[t])).filter((t=>t.productionMode)).length>0)})():!(function i(){return kzt((function t(){return!0}))})())}catch(t){return!1}})());const Izt=function(){return(function(t,e){if(window.Vaadin.developmentMode)return kzt(t,void 0)})(Lzt)};let Nzt;window.Vaadin||(window.Vaadin={}),window.Vaadin.registrations=window.Vaadin.registrations||[],window.Vaadin.developmentModeCallback=window.Vaadin.developmentModeCallback||{},window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]=function(){Izt&&Izt()};const Ozt=new Set,Rzt=t=>class extends(Tzt(t)){static finalize(){super.finalize();const{is:t}=this;t&&!Ozt.has(t)&&(window.Vaadin.registrations.push(this),Ozt.add(t),window.Vaadin.developmentModeCallback&&(Nzt=En.debounce(Nzt,yt,(()=>{window.Vaadin.developmentModeCallback["vaadin-usage-statistics"]()})),An(Nzt)))}constructor(){super(),null===document.doctype&&console.warn('Vaadin components require the "standards mode" declaration. Please add <!DOCTYPE html> to the HTML document.')}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */;class zzt extends(Rzt(bzt(yzt(di(ye))))){static get template(){return _e`
    <style>
      :host {
        display: inline-block;
      }

      :host([hidden]) {
        display: none !important;
      }

      label {
        display: inline-flex;
        align-items: baseline;
        outline: none;
      }

      [part="checkbox"] {
        position: relative;
        display: inline-block;
        flex: none;
      }

      input[type="checkbox"] {
        position: absolute;
        top: 0;
        left: 0;
        right: 0;
        width: 100%;
        height: 100%;
        opacity: 0;
        cursor: inherit;
        margin: 0;
      }

      :host([disabled]) {
        -webkit-tap-highlight-color: transparent;
      }
    </style>

    <label>
      <span part="checkbox">
        <input type="checkbox" checked="{{checked::change}}" disabled\$="[[disabled]]" indeterminate="{{indeterminate::change}}" role="presentation" tabindex="-1">
      </span>

      <span part="label">
        <slot></slot>
      </span>
    </label>
`}static get is(){return"vaadin-checkbox"}static get version(){return"2.5.0"}static get properties(){return{checked:{type:Boolean,value:!1,notify:!0,observer:"_checkedChanged",reflectToAttribute:!0},indeterminate:{type:Boolean,notify:!0,observer:"_indeterminateChanged",reflectToAttribute:!0,value:!1},value:{type:String,value:"on"},_nativeCheckbox:{type:Object}}}constructor(){super()}get name(){return this.checked?this._storedName:""}set name(t){this._storedName=t}ready(){super.ready(),this.setAttribute("role","checkbox"),this._nativeCheckbox=this.shadowRoot.querySelector('input[type="checkbox"]'),this.addEventListener("click",this._handleClick.bind(this)),this._addActiveListeners();const t=this.getAttribute("name");t&&(this.name=t),this.shadowRoot.querySelector('[part~="label"]').querySelector("slot").addEventListener("slotchange",this._updateLabelAttribute.bind(this)),this._updateLabelAttribute()}_updateLabelAttribute(){const t=this.shadowRoot.querySelector('[part~="label"]'),e=t.firstElementChild.assignedNodes();this._isAssignedNodesEmpty(e)?t.setAttribute("empty",""):t.removeAttribute("empty")}_isAssignedNodesEmpty(t){return 0===t.length||1==t.length&&t[0].nodeType==Node.TEXT_NODE&&""===t[0].textContent.trim()}_checkedChanged(t){this.setAttribute("aria-checked",this.indeterminate?"mixed":Boolean(t))}_indeterminateChanged(t){this.setAttribute("aria-checked",t?"mixed":this.checked)}_addActiveListeners(){this._addEventListenerToNode(this,"down",(t=>{this.__interactionsAllowed(t)&&this.setAttribute("active","")})),this._addEventListenerToNode(this,"up",(()=>this.removeAttribute("active"))),this.addEventListener("keydown",(t=>{this.__interactionsAllowed(t)&&32===t.keyCode&&(t.preventDefault(),this.setAttribute("active",""))})),this.addEventListener("keyup",(t=>{this.__interactionsAllowed(t)&&32===t.keyCode&&(t.preventDefault(),this._toggleChecked(),this.removeAttribute("active"),this.indeterminate&&(this.indeterminate=!1))}))}get focusElement(){return this.shadowRoot.querySelector("input")}__interactionsAllowed(t){return!this.disabled&&"a"!==t.target.localName}_handleClick(t){this.__interactionsAllowed(t)&&(this.indeterminate?(this.indeterminate=!1,t.preventDefault(),this._toggleChecked()):t.composedPath()[0]!==this._nativeCheckbox&&(t.preventDefault(),this._toggleChecked()))}_toggleChecked(){this.checked=!this.checked,this.dispatchEvent(new CustomEvent("change",{composed:!1,bubbles:!0}))}}customElements.define(zzt.is,zzt);const Dzt=_e`<dom-module id="lumo-grid" theme-for="vaadin-grid">
  <template>
    <style>
      :host {
        font-family: var(--lumo-font-family);
        font-size: var(--lumo-font-size-m);
        line-height: var(--lumo-line-height-s);
        color: var(--lumo-body-text-color);
        background-color: var(--lumo-base-color);
        box-sizing: border-box;
        -webkit-text-size-adjust: 100%;
        -webkit-tap-highlight-color: transparent;
        -webkit-font-smoothing: antialiased;
        -moz-osx-font-smoothing: grayscale;

        /* For internal use only */
        --_lumo-grid-border-color: var(--lumo-contrast-20pct);
        --_lumo-grid-secondary-border-color: var(--lumo-contrast-10pct);
        --_lumo-grid-border-width: 1px;
        --_lumo-grid-selected-row-color: var(--lumo-primary-color-10pct);
      }

      /* No (outer) border */

      :host(:not([theme~="no-border"])) {
        border: var(--_lumo-grid-border-width) solid var(--_lumo-grid-border-color);
      }

      /* Cell styles */

      [part~="cell"] {
        min-height: var(--lumo-size-m);
        background-color: var(--lumo-base-color);
      }

      [part~="cell"] ::slotted(vaadin-grid-cell-content) {
        cursor: default;
        padding: var(--lumo-space-xs) var(--lumo-space-m);
      }

      /* Apply row borders by default and introduce the "no-row-borders" variant */
      :host(:not([theme~="no-row-borders"])) [part~="cell"]:not([part~="details-cell"]) {
        border-top: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
      }

      /* Hide first body row top border */
      :host(:not([theme~="no-row-borders"])) [part="row"][first] [part~="cell"]:not([part~="details-cell"]) {
        border-top: 0;
        min-height: calc(var(--lumo-size-m) - var(--_lumo-grid-border-width));
      }

      /* Focus-ring */

      [part~="cell"]:focus {
        outline: none;
      }

      :host([navigating]) [part~="cell"]:focus::before {
        content: "";
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        pointer-events: none;
        box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
      }

      /* Drag and Drop styles */
      :host([dragover])::after {
        content: "";
        position: absolute;
        z-index: 100;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        pointer-events: none;
        box-shadow: inset 0 0 0 2px var(--lumo-primary-color-50pct);
      }

      [part~="row"][dragover] {
        z-index: 100 !important;
      }

      [part~="row"][dragover] [part~="cell"] {
        overflow: visible;
      }

      [part~="row"][dragover] [part~="cell"]::after {
        content: "";
        position: absolute;
        top: 0;
        right: 0;
        bottom: 0;
        left: 0;
        height: calc(var(--_lumo-grid-border-width) + 2px);
        pointer-events: none;
        background: var(--lumo-primary-color-50pct);
      }

      :host([theme~="no-row-borders"]) [dragover] [part~="cell"]::after {
        height: 2px;
      }

      [part~="row"][dragover="below"] [part~="cell"]::after {
        top: 100%;
        bottom: auto;
        margin-top: -1px;
      }

      [part~="row"][dragover="above"] [part~="cell"]::after {
        top: auto;
        bottom: 100%;
        margin-bottom: -1px;
      }

      [part~="row"][details-opened][dragover="below"] [part~="cell"]:not([part~="details-cell"])::after,
      [part~="row"][details-opened][dragover="above"] [part~="details-cell"]::after {
        display: none;
      }

      [part~="row"][dragover][dragover="on-top"] [part~="cell"]::after {
        height: 100%;
      }

      [part~="row"][dragstart] {
        /* Add bottom-space to the row so the drag number doesn't get clipped. Needed for IE/Edge */
        border-bottom: 100px solid transparent;
        z-index: 100 !important;
        opacity: 0.9;
      }

      [part~="row"][dragstart] [part~="cell"] {
        border: none !important;
        box-shadow: none !important;
      }

      [part~="row"][dragstart] [part~="cell"][last-column] {
        border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
      }

      [part~="row"][dragstart] [part~="cell"][first-column] {
        border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
      }

      [ios] [part~="row"][dragstart] [part~="cell"] {
        background: var(--lumo-primary-color-50pct);
      }

      #scroller:not([ios]) [part~="row"][dragstart]:not([dragstart=""])::after {
        display: block;
        position: absolute;
        left: var(--_grid-drag-start-x);
        top: var(--_grid-drag-start-y);
        z-index: 100;
        content: attr(dragstart);
        align-items: center;
        justify-content: center;
        box-sizing: border-box;
        padding: calc(var(--lumo-space-xs) * 0.8);
        color: var(--lumo-error-contrast-color);
        background-color: var(--lumo-error-color);
        border-radius: var(--lumo-border-radius-m);
        font-family: var(--lumo-font-family);
        font-size: var(--lumo-font-size-xxs);
        line-height: 1;
        font-weight: 500;
        text-transform: initial;
        letter-spacing: initial;
        min-width: calc(var(--lumo-size-s) * 0.7);
        text-align: center;
      }

      /* Headers and footers */

      [part~="header-cell"] ::slotted(vaadin-grid-cell-content),
      [part~="footer-cell"] ::slotted(vaadin-grid-cell-content),
      [part~="reorder-ghost"] {
        font-size: var(--lumo-font-size-s);
        font-weight: 500;
      }

      [part~="footer-cell"] ::slotted(vaadin-grid-cell-content) {
        font-weight: 400;
      }

      [part="row"]:only-child [part~="header-cell"] {
        min-height: var(--lumo-size-xl);
      }

      /* Header borders */

      /* Hide first header row top border */
      :host(:not([theme~="no-row-borders"])) [part="row"]:first-child [part~="header-cell"] {
        border-top: 0;
      }

      [part="row"]:last-child [part~="header-cell"] {
        border-bottom: var(--_lumo-grid-border-width) solid transparent;
      }

      :host(:not([theme~="no-row-borders"])) [part="row"]:last-child [part~="header-cell"] {
        border-bottom-color: var(--_lumo-grid-secondary-border-color);
      }

      /* Overflow uses a stronger border color */
      :host([overflow~="top"]) [part="row"]:last-child [part~="header-cell"] {
        border-bottom-color: var(--_lumo-grid-border-color);
      }

      /* Footer borders */

      [part="row"]:first-child [part~="footer-cell"] {
        border-top: var(--_lumo-grid-border-width) solid transparent;
      }

      :host(:not([theme~="no-row-borders"])) [part="row"]:first-child [part~="footer-cell"] {
        border-top-color: var(--_lumo-grid-secondary-border-color);
      }

      /* Overflow uses a stronger border color */
      :host([overflow~="bottom"]) [part="row"]:first-child [part~="footer-cell"] {
        border-top-color: var(--_lumo-grid-border-color);
      }

      /* Column reordering */

      :host([reordering]) [part~="cell"] {
        background: linear-gradient(var(--lumo-shade-20pct), var(--lumo-shade-20pct)) var(--lumo-base-color);
      }

      :host([reordering]) [part~="cell"][reorder-status="allowed"] {
        background: var(--lumo-base-color);
      }

      :host([reordering]) [part~="cell"][reorder-status="dragging"] {
        background: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct)) var(--lumo-base-color);
      }

      [part~="reorder-ghost"] {
        opacity: 0.85;
        box-shadow: var(--lumo-box-shadow-s);
        /* TODO Use the same styles as for the cell element (reorder-ghost copies styles from the cell element) */
        padding: var(--lumo-space-s) var(--lumo-space-m) !important;
      }

      /* Column resizing */

      [part="resize-handle"] {
        width: 3px;
        background-color: var(--lumo-primary-color-50pct);
        opacity: 0;
        transition: opacity 0.2s;
      }

      :host(:not([reordering])) *:not([column-resizing]) [part~="cell"]:hover [part="resize-handle"],
      [part="resize-handle"]:active {
        opacity: 1;
        transition-delay: 0.15s;
      }

      /* Column borders */

      :host([theme~="column-borders"]) [part~="cell"]:not([last-column]):not([part~="details-cell"]) {
        border-right: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
      }

      /* Frozen columns */

      [last-frozen] {
        border-right: var(--_lumo-grid-border-width) solid transparent;
        overflow: hidden;
      }

      :host([overflow~="left"]) [part~="cell"][last-frozen]:not([part~="details-cell"]) {
        border-right-color: var(--_lumo-grid-border-color);
      }

      /* Row stripes */

      :host([theme~="row-stripes"]) [part~="row"]:not([odd]) [part~="body-cell"],
      :host([theme~="row-stripes"]) [part~="row"]:not([odd]) [part~="details-cell"] {
        background-image: linear-gradient(var(--lumo-contrast-5pct), var(--lumo-contrast-5pct));
        background-repeat: repeat-x;
      }

      /* Selected row */

      /* Raise the selected rows above unselected rows (so that box-shadow can cover unselected rows) */
      :host(:not([reordering])) [part~="row"][selected] {
        z-index: 1;
      }

      :host(:not([reordering])) [part~="row"][selected] [part~="body-cell"]:not([part~="details-cell"]) {
        background-image: linear-gradient(var(--_lumo-grid-selected-row-color), var(--_lumo-grid-selected-row-color));
        background-repeat: repeat;
      }

      /* Cover the border of an unselected row */
      :host(:not([theme~="no-row-borders"])) [part~="row"][selected] [part~="cell"]:not([part~="details-cell"]) {
        box-shadow: 0 var(--_lumo-grid-border-width) 0 0 var(--_lumo-grid-selected-row-color);
      }

      /* Compact */

      :host([theme~="compact"]) [part="row"]:only-child [part~="header-cell"] {
        min-height: var(--lumo-size-m);
      }

      :host([theme~="compact"]) [part~="cell"] {
        min-height: var(--lumo-size-s);
      }

      :host([theme~="compact"]) [part="row"][first] [part~="cell"]:not([part~="details-cell"]) {
        min-height: calc(var(--lumo-size-s) - var(--_lumo-grid-border-width));
      }

      :host([theme~="compact"]) [part~="cell"] ::slotted(vaadin-grid-cell-content) {
        padding: var(--lumo-space-xs) var(--lumo-space-s);
      }

      /* Wrap cell contents */

      :host([theme~="wrap-cell-content"]) [part~="cell"] ::slotted(vaadin-grid-cell-content) {
        white-space: normal;
      }

      /* RTL specific styles */

      :host([dir="rtl"]) [part~="row"][dragstart] [part~="cell"][last-column] {
        border-radius: var(--lumo-border-radius-s) 0 0 var(--lumo-border-radius-s);
      }

      :host([dir="rtl"]) [part~="row"][dragstart] [part~="cell"][first-column] {
        border-radius: 0 var(--lumo-border-radius-s) var(--lumo-border-radius-s) 0;
      }

      :host([dir="rtl"][theme~="column-borders"]) [part~="cell"]:not([last-column]):not([part~="details-cell"]) {
        border-right: none;
        border-left: var(--_lumo-grid-border-width) solid var(--_lumo-grid-secondary-border-color);
      }

      :host([dir="rtl"]) [last-frozen] {
        border-right: none;
        border-left: var(--_lumo-grid-border-width) solid transparent;
      }

      :host([dir="rtl"][overflow~="right"]) [part~="cell"][last-frozen]:not([part~="details-cell"]) {
        border-left-color: var(--_lumo-grid-border-color);
      }
    </style>
  </template>
</dom-module><dom-module theme-for="vaadin-checkbox" id="vaadin-grid-select-all-checkbox-lumo">
  <template>
    <style>
      :host(.vaadin-grid-select-all-checkbox) {
        font-size: var(--lumo-font-size-m);
      }
   </style>
  </template>
</dom-module>`;document.head.appendChild(Dzt.content);
/**
    @license
    Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
    This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
    The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
    The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
    Code distributed by Google as part of the polymer project is also
    subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
    */
var Bzt=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),Hzt=Bzt&&Bzt[1]>=8,Fzt=_t,Vzt=yt,jzt=vt;const Uzt=Ir({behaviors:[mo,zo],_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_collection:null,_lastVisibleIndexVal:null,_maxPages:2,_focusedVirtualIndex:-1,_itemsPerRow:1,_rowHeight:0,_templateCost:0,get _physicalBottom(){return this._physicalTop+this._physicalSize},get _scrollBottom(){return this._scrollPosition+this._viewportHeight},get _virtualEnd(){return this._virtualStart+this._physicalCount-1},get _hiddenContentSize(){return(this.grid?this._physicalRows*this._rowHeight:this._physicalSize)-this._viewportHeight},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},get _maxVirtualStart(){var t=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,t-this._physicalCount)},set _virtualStart(t){t=this._clamp(t,0,this._maxVirtualStart),this.grid&&(t-=t%this._itemsPerRow),this._virtualStartVal=t},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(t){(t%=this._physicalCount)<0&&(t=this._physicalCount+t),this.grid&&(t-=t%this._itemsPerRow),this._physicalStartVal=t},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+this._physicalCount-1)%this._physicalCount},set _physicalCount(t){this._physicalCountVal=t},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return 0===this._viewportHeight?1/0:this._viewportHeight*this._maxPages},get _isVisible(){return Boolean(this.offsetWidth||this.offsetHeight)},get firstVisibleIndex(){var t=this._firstVisibleIndexVal;if(null==t){var e=this._physicalTop+this._scrollOffset;t=this._iterateItems((function(t,n){return(e+=this._getPhysicalSizeIncrement(t))>this._scrollPosition?this.grid?n-n%this._itemsPerRow:n:this.grid&&this._virtualCount-1===n?n-n%this._itemsPerRow:void 0}))||0,this._firstVisibleIndexVal=t}return t},get lastVisibleIndex(){var t=this._lastVisibleIndexVal;if(null==t){if(this.grid)t=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var e=this._physicalTop+this._scrollOffset;this._iterateItems((function(n,i){e<this._scrollBottom&&(t=i),e+=this._getPhysicalSizeIncrement(n)}))}this._lastVisibleIndexVal=t}return t},get _scrollOffset(){return this._scrollerPaddingTop},attached:function(){this._debounce("_render",this._render,Fzt),this.listen(this,"iron-resize","_resizeHandler")},detached:function(){this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){var t=window.getComputedStyle(this);this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(t["padding-top"],10),this._isRTL=Boolean("rtl"===t.direction),this._viewportWidth=this.$.items.offsetWidth,this._viewportHeight=this._scrollTargetHeight,this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var t=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),e=t-this._scrollPosition,n=e>=0;if(this._scrollPosition=t,this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,Math.abs(e)>this._physicalSize&&this._physicalSize>0){e-=this._scrollOffset;var i=Math.round(e/this._physicalAverage)*this._itemsPerRow;this._virtualStart=this._virtualStart+i,this._physicalStart=this._physicalStart+i,this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._update()}else if(this._physicalCount>0){var r=this._getReusables(n);n?(this._physicalTop=r.physicalTop,this._virtualStart=this._virtualStart+r.indexes.length,this._physicalStart=this._physicalStart+r.indexes.length):(this._virtualStart=this._virtualStart-r.indexes.length,this._physicalStart=this._physicalStart-r.indexes.length),this._update(r.indexes,n?null:r.indexes),this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,0),jzt)}},_getReusables:function(t){var e,n,i,r=[],o=this._hiddenContentSize*this._ratio,a=this._virtualStart,s=this._virtualEnd,l=this._physicalCount,c=this._physicalTop+this._scrollOffset,u=this._scrollTop,h=this._scrollBottom;for(t?(e=this._physicalStart,n=u-c):(e=this._physicalEnd,n=this._physicalBottom+this._scrollOffset-h);n-=i=this._getPhysicalSizeIncrement(e),!(r.length>=l||n<=o);)if(t){if(s+r.length+1>=this._virtualCount)break;if(c+i>=u-this._scrollOffset)break;r.push(e),c+=i,e=(e+1)%l}else{if(a-r.length<=0)break;if(c+this._physicalSize-i<=h)break;r.push(e),c-=i,e=0===e?l-1:e-1}return{indexes:r,physicalTop:c-this._scrollOffset}},_update:function(t,e){if(!(t&&0===t.length||0===this._physicalCount)){if(this._manageFocus(),this._assignModels(t),this._updateMetrics(t),e)for(;e.length;){var n=e.pop();this._physicalTop-=this._getPhysicalSizeIncrement(n)}this._positionItems(),this._updateScrollerSize()}},_isClientFull:function(){return 0!=this._scrollBottom&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(t){var e=this._clamp(this._physicalCount+t,3,this._virtualCount-this._virtualStart),n=(e=this._convertIndexToCompleteRow(e))-this._physicalCount,i=Math.round(.5*this._physicalCount);if(!(n<0)){if(n>0){var r=window.performance.now();[].push.apply(this._physicalItems,this._createPool(n));for(var o=0;o<n;o++)this._physicalSizes.push(0);this._physicalCount=this._physicalCount+n,this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart=this._physicalStart+n),this._update(),this._templateCost=(window.performance.now()-r)/n,i=Math.round(.5*this._physicalCount)}this._virtualEnd>=this._virtualCount-1||0===i||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,i)),Vzt):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,i),jzt))}},_render:function(){if(this.isAttached&&this._isVisible)if(0!==this._physicalCount){var t=this._getReusables(!0);this._physicalTop=t.physicalTop,this._virtualStart=this._virtualStart+t.indexes.length,this._physicalStart=this._physicalStart+t.indexes.length,this._update(t.indexes),this._update(),this._increasePoolIfNeeded(0)}else this._virtualCount>0&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(3))},_itemsChanged:function(t){"items"===t.path&&(this._virtualStart=0,this._physicalTop=0,this._virtualCount=this.items?this.items.length:0,this._collection=null,this._physicalIndexForKey={},this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this._physicalCount=this._physicalCount||0,this._physicalItems=this._physicalItems||[],this._physicalSizes=this._physicalSizes||[],this._physicalStart=0,this._scrollTop>this._scrollOffset&&this._resetScrollPosition(0),this._removeFocusedItem(),this._debounce("_render",this._render,Fzt))},_iterateItems:function(t,e){var n,i,r,o;if(2===arguments.length&&e){for(o=0;o<e.length;o++)if(i=this._computeVidx(n=e[o]),null!=(r=t.call(this,n,i)))return r}else{for(n=this._physicalStart,i=this._virtualStart;n<this._physicalCount;n++,i++)if(null!=(r=t.call(this,n,i)))return r;for(n=0;n<this._physicalStart;n++,i++)if(null!=(r=t.call(this,n,i)))return r}},_computeVidx:function(t){return t>=this._physicalStart?this._virtualStart+(t-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+t},_updateMetrics:function(t){zi();var e=0,n=0,i=this._physicalAverageCount,r=this._physicalAverage;this._iterateItems((function(t,i){n+=this._physicalSizes[t],this._physicalSizes[t]=this._physicalItems[t].offsetHeight,e+=this._physicalSizes[t],this._physicalAverageCount+=this._physicalSizes[t]?1:0}),t),this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(n=1===this._itemsPerRow?n:Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+e-n,this._itemsPerRow=1),this._physicalAverageCount!==i&&(this._physicalAverage=Math.round((r*i+e)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();var t=this._physicalTop;this._iterateItems((function(e,n){this.translate3d(0,t+"px",0,this._physicalItems[e]),t+=this._physicalSizes[e]}))},_getPhysicalSizeIncrement:function(t){return this.grid?this._computeVidx(t)%this._itemsPerRow!=this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[t]},_adjustScrollPosition:function(){var t=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(0!==t){this._physicalTop=this._physicalTop-t;var e=this._scrollTop;!Hzt&&e>0&&this._resetScrollPosition(e-t)}},_resetScrollPosition:function(t){this.scrollTarget&&t>=0&&(this._scrollTop=t,this._scrollPosition=this._scrollTop)},_updateScrollerSize:function(t){this._estScrollHeight=this.grid?this._virtualRowCount*this._rowHeight:this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage,((t=(t=(t=t||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||this.grid&&this.$.items.style.height<this._estScrollHeight)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)&&(this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight)},scrollToIndex:function(t){if(!("number"!=typeof t||t<0||t>this.items.length-1)&&(zi(),0!==this._physicalCount)){t=this._clamp(t,0,this._virtualCount-1),(!this._isIndexRendered(t)||t>=this._maxVirtualStart)&&(this._virtualStart=this.grid?t-2*this._itemsPerRow:t-1),this._manageFocus(),this._assignModels(),this._updateMetrics(),this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var e=this._physicalStart,n=this._virtualStart,i=0,r=this._hiddenContentSize;n<t&&i<=r;)i+=this._getPhysicalSizeIncrement(e),e=(e+1)%this._physicalCount,n++;this._updateScrollerSize(!0),this._positionItems(),this._resetScrollPosition(this._physicalTop+this._scrollOffset+i),this._increasePoolIfNeeded(0),this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverage=0,this._physicalAverageCount=0},_resizeHandler:function(){this._debounce("_render",(function(){this._firstVisibleIndexVal=null,this._lastVisibleIndexVal=null,this.updateViewportBoundaries(),this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)}),Fzt)},_convertIndexToCompleteRow:function(t){return this._itemsPerRow=this._itemsPerRow||1,this.grid?Math.ceil(t/this._itemsPerRow)*this._itemsPerRow:t},_isIndexRendered:function(t){return t>=this._virtualStart&&t<=this._virtualEnd},_getPhysicalIndex:function(t){return(this._physicalStart+(t-this._virtualStart))%this._physicalCount},_clamp:function(t,e,n){return Math.min(n,Math.max(e,t))},_debounce:function(t,e,n){this._debouncers=this._debouncers||{},this._debouncers[t]=En.debounce(this._debouncers[t],n,e.bind(this)),An(this._debouncers[t])}});
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */class Gzt extends Uzt{static get is(){return"vaadin-grid-scroller"}static get properties(){return{size:{type:Number,notify:!0},_vidxOffset:{value:0}}}static get observers(){return["_effectiveSizeChanged(_effectiveSize)"]}connectedCallback(){super.connectedCallback(),this._scrollHandler()}_updateScrollerItem(t,e){}_afterScroll(){}_getRowTarget(){}_createScrollerRows(){}_canPopulate(){}scrollToIndex(t){this._warnPrivateAPIAccess("scrollToIndex"),this._scrollingToIndex=!0,t=Math.min(Math.max(t,0),this._effectiveSize-1),this.$.table.scrollTop=t/this._effectiveSize*(this.$.table.scrollHeight-this.$.table.offsetHeight),this._scrollHandler(),this._accessIronListAPI((()=>this._maxScrollTop))&&this._virtualCount<this._effectiveSize&&this._adjustVirtualIndexOffset(1e6),this._accessIronListAPI((()=>super.scrollToIndex(t-this._vidxOffset))),this._scrollHandler();const e=Array.from(this.$.items.children).filter((e=>e.index===t))[0];if(e){const t=e.getBoundingClientRect().top-this.$.header.getBoundingClientRect().bottom;Math.abs(t)>1&&(this.$.table.scrollTop+=t,this._scrollHandler())}this._scrollingToIndex=!1}_effectiveSizeChanged(t){let e,n=0;this._iterateItems(((t,i)=>{if(i===this._firstVisibleIndex){const i=this._physicalItems[t];e=i.index,n=i.getBoundingClientRect().top}})),this.items&&t<this.items.length&&(this._scrollTop=0),Array.isArray(this.items)||(this.items={length:Math.min(t,this._edge||this._ie?3e4:1e5)}),this._accessIronListAPI((()=>super._itemsChanged({path:"items"}))),this._virtualCount=Math.min(this.items.length,t)||0,0===this._scrollTop&&(this._accessIronListAPI((()=>this._scrollToIndex(Math.min(t-1,e)))),this._iterateItems(((t,i)=>{const r=this._physicalItems[t];if(r.index===e&&(this.$.table.scrollTop+=Math.round(r.getBoundingClientRect().top-n)),r.index===this._focusedItemIndex&&this._itemsFocusable&&this.$.items.contains(this.shadowRoot.activeElement)){const t=Array.from(this._itemsFocusable.parentElement.children).indexOf(this._itemsFocusable);r.children[t].focus()}}))),this._assignModels(),requestAnimationFrame((()=>this._update())),this.__updateFooterPositioning(),this._ie&&(this.$.table.style.display="block",setTimeout((()=>{this.$.table.style.display="flex",this._translateStationaryElements()})))}_positionItems(){let t;this._adjustScrollPosition(),isNaN(this._physicalTop)&&(t=!0,this._physicalTop=0);let e=this._physicalTop;this._iterateItems(((t,n)=>{this._physicalItems[t].style.transform=`translateY(${e}px)`,e+=this._physicalSizes[t]})),t&&this._scrollToIndex(0)}_increasePoolIfNeeded(t){0===t&&this._scrollingToIndex||!this._canPopulate()||!this._effectiveSize||(this._initialPoolCreated?this._optPhysicalSize!==1/0&&(this._debounceIncreasePool=En.debounce(this._debounceIncreasePool,_t,(()=>{this._updateMetrics();let t=Math.ceil((this._optPhysicalSize-this._physicalSize)/this._physicalAverage);this._physicalCount+t>this._effectiveSize&&(t=Math.max(0,this._effectiveSize-this._physicalCount)),this._physicalSize&&t>0&&this._optPhysicalSize!==1/0&&(super._increasePoolIfNeeded(t),this.__reorderChildNodes())}))):(this._initialPoolCreated=!0,super._increasePoolIfNeeded(25)))}__reorderChildNodes(){const t=Array.from(this.$.items.childNodes);t.reduce(((t,e,n,i)=>{if(0===n||i[n-1].index===e.index-1)return t}),!0)||t.sort(((t,e)=>t.index-e.index)).forEach((t=>this.$.items.appendChild(t)))}_createPool(t){const e=document.createDocumentFragment(),n=this._createScrollerRows(t);n.forEach((t=>e.appendChild(t))),this._getRowTarget().appendChild(e);const i=this.querySelector("[slot]");if(i){const t=i.getAttribute("slot");i.setAttribute("slot","foo-bar"),i.setAttribute("slot",t)}return ki(this,(()=>this.notifyResize())),n}_assignModels(t){this._iterateItems(((t,e)=>{const n=this._physicalItems[t];this._toggleAttribute("hidden",e>=this._effectiveSize,n),this._updateScrollerItem(n,e+(this._vidxOffset||0))}),t)}_scrollHandler(){const t=this.$.table.scrollTop-this._scrollPosition;this._accessIronListAPI(super._scrollHandler);const e=this._vidxOffset;this._accessIronListAPI((()=>this._maxScrollTop))&&this._virtualCount<this._effectiveSize?this._adjustVirtualIndexOffset(t):this._vidxOffset=0,this._vidxOffset!==e&&this._update(),this._afterScroll()}_adjustVirtualIndexOffset(t){if(Math.abs(t)>1e4){if(this._noScale)return void(this._noScale=!1);const t=this.$.table.scrollTop/(this.$.table.scrollHeight-this.$.table.offsetHeight);this._vidxOffset=Math.round(t*this._effectiveSize-t*this._virtualCount)}else{const t=this._vidxOffset||0,e=1e3,n=100;0===this._scrollTop?(this._vidxOffset=0,t!==this._vidxOffset&&super.scrollToIndex(0)):this.firstVisibleIndex<e&&this._vidxOffset>0&&(this._vidxOffset-=Math.min(this._vidxOffset,n),t!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex+(t-this._vidxOffset)),this._noScale=!0);const i=this._effectiveSize-this._virtualCount;this._scrollTop>=this._maxScrollTop&&this._maxScrollTop>0?(this._vidxOffset=i,t!==this._vidxOffset&&super.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-e&&this._vidxOffset<i&&(this._vidxOffset+=Math.min(i-this._vidxOffset,n),t!==this._vidxOffset&&super.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-t)),this._noScale=!0)}}_accessIronListAPI(t){this._warnPrivateAPIAccessAsyncEnabled=!1;const e=t.apply(this);return this._debouncerWarnPrivateAPIAccess=En.debounce(this._debouncerWarnPrivateAPIAccess,_t,(()=>this._warnPrivateAPIAccessAsyncEnabled=!0)),e}_debounceRender(t,e){super._debounceRender((()=>this._accessIronListAPI(t)),e)}_warnPrivateAPIAccess(t){this._warnPrivateAPIAccessAsyncEnabled&&console.warn(`Accessing private API (${t})!`)}_render(){this._accessIronListAPI(super._render)}_createFocusBackfillItem(){}_multiSelectionChanged(){}clearSelection(){}_itemsChanged(){}_manageFocus(){}_removeFocusedItem(){}get _firstVisibleIndex(){return this._accessIronListAPI((()=>super.firstVisibleIndex))}get _lastVisibleIndex(){return this._accessIronListAPI((()=>super.lastVisibleIndex))}_scrollToIndex(t){this._accessIronListAPI((()=>this.scrollToIndex(t)))}get firstVisibleIndex(){return this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex}set firstVisibleIndex(t){this._warnPrivateAPIAccess("firstVisibleIndex"),super.firstVisibleIndex=t}get lastVisibleIndex(){return this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex}set lastVisibleIndex(t){this._warnPrivateAPIAccess("lastVisibleIndex"),super.lastVisibleIndex=t}updateViewportBoundaries(){this._warnPrivateAPIAccess("updateViewportBoundaries"),super.updateViewportBoundaries.apply(this,arguments)}_resizeHandler(){super._resizeHandler(),zi()}}customElements.define(Gzt.is,Gzt);
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */
const Wzt=t=>class extends t{static get observers(){return["_a11yUpdateGridSize(size, _columnTree, _columnTree.*)"]}_a11yGetHeaderRowCount(t){return t.filter((t=>t.some((t=>t._headerTemplate||t.headerRenderer||t.path||t.header)))).length}_a11yGetFooterRowCount(t){return t.filter((t=>t.some((t=>t._headerTemplate||t.headerRenderer)))).length}_a11yUpdateGridSize(t,e){if(void 0===t||void 0===e)return;const n=e[e.length-1];this.$.table.setAttribute("aria-rowcount",t+this._a11yGetHeaderRowCount(e)+this._a11yGetFooterRowCount(e)),this.$.table.setAttribute("aria-colcount",n&&n.length||0),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows()}_a11yUpdateHeaderRows(){Array.from(this.$.header.children).forEach(((t,e)=>t.setAttribute("aria-rowindex",e+1)))}_a11yUpdateFooterRows(){Array.from(this.$.footer.children).forEach(((t,e)=>t.setAttribute("aria-rowindex",this._a11yGetHeaderRowCount(this._columnTree)+this.size+e+1)))}_a11yUpdateRowRowindex(t,e){t.setAttribute("aria-rowindex",e+this._a11yGetHeaderRowCount(this._columnTree)+1)}_a11yUpdateRowSelected(t,e){t.setAttribute("aria-selected",Boolean(e)),Array.from(t.children).forEach((t=>t.setAttribute("aria-selected",Boolean(e))))}_a11yUpdateRowLevel(t,e){t.setAttribute("aria-level",e+1)}_a11yUpdateRowDetailsOpened(t,e){Array.from(t.children).forEach((t=>{"boolean"==typeof e?t.setAttribute("aria-expanded",e):t.hasAttribute("aria-expanded")&&t.removeAttribute("aria-expanded")}))}_a11ySetRowDetailsCell(t,e){Array.from(t.children).forEach((t=>{t!==e&&t.setAttribute("aria-controls",e.id)}))}_a11yUpdateCellColspan(t,e){t.setAttribute("aria-colspan",Number(e))}_a11yUpdateSorters(){Array.from(this.querySelectorAll("vaadin-grid-sorter")).forEach((t=>{let e=t.parentNode;for(;e&&"vaadin-grid-cell-content"!==e.localName;)e=e.parentNode;e&&e.assignedSlot&&e.assignedSlot.parentNode.setAttribute("aria-sort",{asc:"ascending",desc:"descending"}[String(t.direction)]||"none")}))}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,qzt=t=>class extends t{static get properties(){return{activeItem:{type:Object,notify:!0,value:null}}}ready(){super.ready(),this.$.scroller.addEventListener("click",this._onClick.bind(this)),this.addEventListener("cell-activate",this._activateItem.bind(this))}_activateItem(t){const e=t.detail.model,n=e?e.item:null;n&&(this.activeItem=this._itemsEqual(this.activeItem,n)?null:n)}_onClick(t){if(t.defaultPrevented)return;const e=t.composedPath(),n=e[e.indexOf(this.$.table)-3];if(!n||n.getAttribute("part").indexOf("details-cell")>-1)return;const i=n._content,r=this.getRootNode().activeElement;i.contains(r)&&(!this._ie||this._isFocusable(r))||this._isFocusable(t.target)||this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(n.parentElement)}}))}_isFocusable(t){return Yzt(t)}},Yzt=t=>{if(!t.parentNode)return!1;const e=-1!==Array.from(t.parentNode.querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]")).filter((t=>"cell body-cell"!==t.getAttribute("part"))).indexOf(t);return!t.disabled&&e},Xzt=t=>class extends t{static get properties(){return{items:Array}}static get observers(){return["_itemsChanged(items, items.*, isAttached)"]}_itemsChanged(t,e,n){if(n){if(!Array.isArray(t))return null==t&&(this.size=0),void(this.dataProvider===this._arrayDataProvider&&(this.dataProvider=void 0));this.size=t.length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache(),this._ensureFirstPageLoaded()}}_arrayDataProvider(t,e){let n=(Array.isArray(this.items)?this.items:[]).slice(0);this._filters&&this._checkPaths(this._filters,"filtering",n)&&(n=this._filter(n)),this.size=n.length,t.sortOrders.length&&this._checkPaths(this._sorters,"sorting",n)&&(n=n.sort(this._multiSort.bind(this)));const i=t.page*t.pageSize;e(n.slice(i,i+t.pageSize),n.length)}_checkPaths(t,e,n){if(!n.length)return!1;let i=!0;for(var r in t){const o=t[r].path;if(!o||-1===o.indexOf("."))continue;const a=o.replace(/\.[^\.]*$/,"");void 0===po.get(a,n[0])&&(console.warn(`Path "${o}" used for ${e} does not exist in all of the items, ${e} is disabled.`),i=!1)}return i}_multiSort(t,e){return this._sorters.map((n=>"asc"===n.direction?this._compare(po.get(n.path,t),po.get(n.path,e)):"desc"===n.direction?this._compare(po.get(n.path,e),po.get(n.path,t)):0)).reduce(((t,e)=>t||e),0)}_normalizeEmptyValue(t){return[void 0,null].indexOf(t)>=0?"":isNaN(t)?t.toString():t}_compare(t,e){return(t=this._normalizeEmptyValue(t))<(e=this._normalizeEmptyValue(e))?-1:t>e?1:0}_filter(t){return t.filter(((t,e)=>0===this._filters.filter((e=>{const n=this._normalizeEmptyValue(po.get(e.path,t)),i=this._normalizeEmptyValue(e.value).toString().toLowerCase();return-1===n.toString().toLowerCase().indexOf(i)})).length))}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,$zt=t=>class extends(di(t)){ready(){super.ready();const t=this.$.scroller;ni(t,"track",this._onHeaderTrack.bind(this)),t.addEventListener("touchmove",(e=>t.hasAttribute("column-resizing")&&e.preventDefault())),t.addEventListener("contextmenu",(t=>"resize-handle"==t.target.getAttribute("part")&&t.preventDefault())),t.addEventListener("mousedown",(t=>"resize-handle"===t.target.getAttribute("part")&&t.preventDefault()))}_onHeaderTrack(t){const e=t.target;if("resize-handle"===e.getAttribute("part")){let o=e.parentElement._column;for(this._toggleAttribute("column-resizing",!0,this.$.scroller);"vaadin-grid-column-group"===o.localName;)o=Array.prototype.slice.call(o._childColumns,0).sort((function(t,e){return t._order-e._order})).filter((function(t){return!t.hidden})).pop();const a=Array.from(this.$.header.querySelectorAll('[part~="row"]:last-child [part~="cell"]'));var n=a.filter((t=>t._column===o))[0];if(n.offsetWidth){var i=window.getComputedStyle(n),r=10+parseInt(i.paddingLeft)+parseInt(i.paddingRight)+parseInt(i.borderLeftWidth)+parseInt(i.borderRightWidth)+parseInt(i.marginLeft)+parseInt(i.marginRight);const e=n.offsetWidth+(this.__isRTL?n.getBoundingClientRect().left-t.detail.x:t.detail.x-n.getBoundingClientRect().right);o.width=Math.max(r,e)+"px",o.flexGrow=0}a.sort((function(t,e){return t._column._order-e._column._order})).forEach((function(t,e,i){e<i.indexOf(n)&&(t._column.width=t.offsetWidth+"px",t._column.flexGrow=0)})),"end"===t.detail.state&&(this._toggleAttribute("column-resizing",!1,this.$.scroller),this.dispatchEvent(new CustomEvent("column-resize",{detail:{resizedColumn:o}}))),this._resizeHandler()}}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,Kzt=class t{constructor(t,e,n){this.grid=t,this.parentCache=e,this.parentItem=n,this.itemCaches={},this.items={},this.effectiveSize=0,this.size=0,this.pendingRequests={}}isLoading(){return Boolean(Object.keys(this.pendingRequests).length||Object.keys(this.itemCaches).filter((t=>this.itemCaches[t].isLoading()))[0])}getItemForIndex(t){const{cache:e,scaledIndex:n}=this.getCacheAndIndex(t);return e.items[n]}updateSize(){this.effectiveSize=!this.parentItem||this.grid._isExpanded(this.parentItem)?this.size+Object.keys(this.itemCaches).reduce(((t,e)=>{const n=this.itemCaches[e];return n.updateSize(),t+n.effectiveSize}),0):0}ensureSubCacheForScaledIndex(e){if(!this.itemCaches[e]){const n=new t(this.grid,this,this.items[e]);this.itemCaches[e]=n,this.grid._loadPage(0,n)}}getCacheAndIndex(t){let e=t;const n=Object.keys(this.itemCaches);for(var i=0;i<n.length;i++){const t=Number(n[i]),r=this.itemCaches[t];if(e<=t)return{cache:this,scaledIndex:e};if(e<=t+r.effectiveSize)return r.getCacheAndIndex(e-t-1);e-=r.effectiveSize}return{cache:this,scaledIndex:e}}},Zzt=t=>class extends t{static get properties(){return{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},loading:{type:Boolean,notify:!0,readOnly:!0,reflectToAttribute:!0},_cache:{type:Object,value:function(){return new Kzt(this)}},itemIdPath:{type:String,value:null},expandedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_sizeChanged(size)","_itemIdPathChanged(itemIdPath)","_expandedItemsChanged(expandedItems.*)"]}_sizeChanged(t){const e=t-this._cache.size;this._cache.size+=e,this._cache.effectiveSize+=e,this._effectiveSize=this._cache.effectiveSize,this._increasePoolIfNeeded(0),this._debounceIncreasePool&&this._debounceIncreasePool.flush()}_getItem(t,e){if(t>=this._effectiveSize)return;e.index=t;const{cache:n,scaledIndex:i}=this._cache.getCacheAndIndex(t),r=n.items[i];r?(this._toggleAttribute("loading",!1,e),this._updateItem(e,r),this._isExpanded(r)&&n.ensureSubCacheForScaledIndex(i)):(this._toggleAttribute("loading",!0,e),this._loadPage(this._getPageForIndex(i),n))}_expandedInstanceChangedCallback(t,e){void 0!==t.item&&(e?this.expandItem(t.item):this.collapseItem(t.item))}getItemId(t){return this.itemIdPath?this.get(this.itemIdPath,t):t}_isExpanded(t){return this.__expandedKeys.has(this.getItemId(t))}_expandedItemsChanged(t){this.__cacheExpandedKeys(),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,this._assignModels()}_itemIdPathChanged(t){this.__cacheExpandedKeys()}__cacheExpandedKeys(){this.expandedItems&&(this.__expandedKeys=new Set,this.expandedItems.forEach((t=>{this.__expandedKeys.add(this.getItemId(t))})))}expandItem(t){this._isExpanded(t)||this.push("expandedItems",t)}collapseItem(t){this._isExpanded(t)&&this.splice("expandedItems",this._getItemIndexInArray(t,this.expandedItems),1)}_getIndexLevel(t){let{cache:e}=this._cache.getCacheAndIndex(t),n=0;for(;e.parentCache;)e=e.parentCache,n++;return n}_canPopulate(){return Boolean(this._hasData&&this._columnTree)}_loadPage(t,e){if(!e.pendingRequests[t]&&this.dataProvider){this._setLoading(!0),e.pendingRequests[t]=!0;const n={page:t,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters(),parentItem:e.parentItem};this._debounceIncreasePool&&this._debounceIncreasePool.flush(),this.dataProvider(n,((i,r)=>{void 0!==r?e.size=r:n.parentItem&&(e.size=i.length);const o=Array.from(this.$.items.children).map((t=>t._item));i.forEach(((n,i)=>{const r=t*this.pageSize+i;e.items[r]=n,this._isExpanded(n)&&o.indexOf(n)>-1&&e.ensureSubCacheForScaledIndex(r)})),this._hasData=!0,delete e.pendingRequests[t],this._debouncerApplyCachedData=En.debounce(this._debouncerApplyCachedData,gt.after(0),(()=>{this._setLoading(!1),this._cache.updateSize(),this._effectiveSize=this._cache.effectiveSize,Array.from(this.$.items.children).filter((t=>!t.hidden)).forEach((t=>{this._cache.getItemForIndex(t.index)&&this._getItem(t.index,t)})),this._increasePoolIfNeeded(0),this.__scrollToPendingIndex()})),this._cache.isLoading()||this._debouncerApplyCachedData.flush(),this.__itemsReceived()}))}}_getPageForIndex(t){return Math.floor(t/this.pageSize)}clearCache(){this._cache=new Kzt(this),Array.from(this.$.items.children).forEach((t=>{Array.from(t.children).forEach((t=>{t._instance&&t._instance._setPendingProperty("item",{},!1)}))})),this._cache.size=this.size||0,this._cache.updateSize(),this._hasData=!1,this._assignModels(),this._effectiveSize&&this._initialPoolCreated||this._loadPage(0,this._cache)}_pageSizeChanged(t,e){void 0!==e&&t!==e&&this.clearCache()}_checkSize(){void 0===this.size&&0===this._effectiveSize&&console.warn("The <vaadin-grid> needs the total number of items in order to display rows. Set the total number of items to the `size` property, or provide the total number of items in the second argument of the `dataProvider`’s `callback` call.")}_dataProviderChanged(t,e){void 0!==e&&this.clearCache(),t&&this.items&&this.items.length&&this._scrollToIndex(this._firstVisibleIndex),this._ensureFirstPageLoaded(),this._debouncerCheckSize=En.debounce(this._debouncerCheckSize,gt.after(2e3),this._checkSize.bind(this)),this._scrollHandler()}_ensureFirstPageLoaded(){this._hasData||this._loadPage(0,this._cache)}_itemsEqual(t,e){return this.getItemId(t)===this.getItemId(e)}_getItemIndexInArray(t,e){let n=-1;return e.forEach(((e,i)=>{this._itemsEqual(e,t)&&(n=i)})),n}scrollToIndex(t){super.scrollToIndex(t),isNaN(t)||!this._cache.isLoading()&&this.clientHeight||(this.__pendingScrollToIndex=t)}__scrollToPendingIndex(){if(this.__pendingScrollToIndex&&this.$.items.children.length){const t=this.__pendingScrollToIndex;delete this.__pendingScrollToIndex,this.scrollToIndex(t)}}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,Jzt=t=>class extends t{ready(){super.ready(),this._addNodeObserver()}_hasColumnGroups(t){for(let e=0;e<t.length;e++)if("vaadin-grid-column-group"===t[e].localName)return!0;return!1}_getChildColumns(t){return Ri.getFlattenedNodes(t).filter(this._isColumnElement)}_flattenColumnGroups(t){return t.map((t=>"vaadin-grid-column-group"===t.localName?this._getChildColumns(t):[t])).reduce(((t,e)=>t.concat(e)),[])}_getColumnTree(){for(var t=[],e=Ri.getFlattenedNodes(this).filter(this._isColumnElement);t.push(e),this._hasColumnGroups(e);)e=this._flattenColumnGroups(e);return t}_updateColumnTree(){var t=this._getColumnTree();this._arrayEquals(t,this._columnTree)||(this._columnTree=t)}_addNodeObserver(){this._observer=new Ri(this,(t=>{const e=t.addedNodes.filter((t=>"template"===t.localName&&t.classList.contains("row-details")))[0];e&&this._rowDetailsTemplate!==e&&(this._rowDetailsTemplate=e),(t.addedNodes.filter(this._isColumnElement).length>0||t.removedNodes.filter(this._isColumnElement).length>0)&&this._updateColumnTree(),this._debouncerCheckImports=En.debounce(this._debouncerCheckImports,gt.after(2e3),this._checkImports.bind(this)),this._ensureFirstPageLoaded()}))}_arrayEquals(t,e){if(!t||!e||t.length!=e.length)return!1;for(var n=0,i=t.length;n<i;n++)if(t[n]instanceof Array&&e[n]instanceof Array){if(!this._arrayEquals(t[n],e[n]))return!1}else if(t[n]!=e[n])return!1;return!0}_checkImports(){["vaadin-grid-column-group","vaadin-grid-filter","vaadin-grid-filter-column","vaadin-grid-tree-toggle","vaadin-grid-selection-column","vaadin-grid-sort-column","vaadin-grid-sorter"].forEach((t=>{var e=this.querySelector(t);!e||e instanceof ye||console.warn(`Make sure you have imported the required module for <${t}> element.`)}))}_updateFirstAndLastColumn(){Array.from(this.shadowRoot.querySelectorAll("tr")).forEach((t=>this._updateFirstAndLastColumnForRow(t)))}_updateFirstAndLastColumnForRow(t){Array.from(t.querySelectorAll('[part~="cell"]:not([part~="details-cell"])')).sort(((t,e)=>t._column._order-e._column._order)).forEach(((t,e,n)=>{this._toggleAttribute("first-column",0===e,t),this._toggleAttribute("last-column",e===n.length-1,t)}))}_isColumnElement(t){return t.nodeType===Node.ELEMENT_NODE&&/\bcolumn\b/.test(t.localName)}}
/**
    @license
    Copyright (c) 2018 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,Qzt=t=>class extends t{getEventContext(t){const e={},n=t.composedPath(),i=n[n.indexOf(this.$.table)-3];return i?(e.section=["body","header","footer","details"].filter((t=>i.getAttribute("part").indexOf(t)>-1))[0],i._column&&(e.column=i._column),"body"!==e.section&&"details"!==e.section||Object.assign(e,this.__getRowModel(i.parentElement)),e):e}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,tDt=t=>class extends t{static get properties(){return{_filters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("filter-changed",this._filterChanged.bind(this))}_filterChanged(t){-1===this._filters.indexOf(t.target)&&this._filters.push(t.target),t.stopPropagation(),this.dataProvider&&this.clearCache()}_mapFilters(){return this._filters.map((t=>({path:t.path,value:t.value})))}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */;class eDt extends class extends ye{}{static get is(){return"vaadin-grid-templatizer"}static get properties(){return{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}},_grid:Object}}static get observers(){return["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"]}constructor(){super(),this._instanceProps={detailsOpened:!0,index:!0,item:!0,selected:!0,expanded:!0,level:!0}}createInstance(){this._ensureTemplatized();const t=new this._TemplateClass({});return this.addInstance(t),t}addInstance(t){-1===this._templateInstances.indexOf(t)&&(this._templateInstances.push(t),requestAnimationFrame((()=>this.notifyPath("_templateInstances.*",this._templateInstances))))}removeInstance(t){const e=this._templateInstances.indexOf(t);this.splice("_templateInstances",e,1)}_ensureTemplatized(){this._TemplateClass||(this._TemplateClass=Xr(this.template,this,{instanceProps:this._instanceProps,parentModel:!0,forwardHostProp:function(t,e){this._forwardParentProp(t,e),this._templateInstances&&this._templateInstances.forEach((n=>n.notifyPath(t,e)))},notifyInstanceProp:function(t,e,n){if("index"===e||"item"===e)return;const i=`__${e}__`;if(t[i]===n)return;t[i]=n;const r=Array.from(this._grid.$.items.children).filter((e=>this._grid._itemsEqual(e._item,t.item)))[0];r&&Array.from(r.children).forEach((t=>{t._instance&&(t._instance[i]=n,t._instance.notifyPath(e,n))}));const o="item.";if(Array.isArray(this._grid.items)&&0===e.indexOf(o)){const i=this._grid.items.indexOf(t.item),r=e.slice(o.length);this._grid.notifyPath(`items.${i}.${r}`,n)}const a=`_${e}InstanceChangedCallback`;this._grid&&this._grid[a]&&this._grid[a](t,n)}}))}_forwardParentProp(t,e){this._parentPathValues[t]=e,this._templateInstances.forEach((n=>n.notifyPath(t,e)))}_templateInstancesChanged(t,e){let n,i;if("_templateInstances"===t.path)n=0,i=this._templateInstances.length;else{if("_templateInstances.splices"!==t.path)return;n=t.value.index,i=t.value.addedCount}Object.keys(this._parentPathValues||{}).forEach((t=>{for(var e=n;e<n+i;e++)this._templateInstances[e].set(t,this._parentPathValues[t])}))}}customElements.define(eDt.is,eDt);
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */
const nDt=t=>class extends t{static get properties(){return{detailsOpenedItems:{type:Array,value:function(){return[]}},_rowDetailsTemplate:Object,rowDetailsRenderer:Function,_detailsCells:{type:Array}}}static get observers(){return["_detailsOpenedItemsChanged(detailsOpenedItems.*, _rowDetailsTemplate, rowDetailsRenderer)","_rowDetailsTemplateOrRendererChanged(_rowDetailsTemplate, rowDetailsRenderer)"]}_rowDetailsTemplateOrRendererChanged(t,e){if(t&&e)throw new Error("You should only use either a renderer or a template for row details");if(t||e){if(t&&!t.templatizer){var n=new eDt;n._grid=this,n.dataHost=this.dataHost,n.template=t,t.templatizer=n}this._columnTree&&Array.from(this.$.items.children).forEach((t=>{t.querySelector("[part~=details-cell]")||(this._updateRow(t,this._columnTree[this._columnTree.length-1]),this._a11yUpdateRowDetailsOpened(t,!1)),delete t.querySelector("[part~=details-cell]")._instance})),this.detailsOpenedItems.length&&(Array.from(this.$.items.children).forEach(this._toggleDetailsCell,this),this._update())}}_detailsOpenedItemsChanged(t,e,n){"detailsOpenedItems.length"!==t.path&&t.value&&Array.from(this.$.items.children).forEach((t=>{this._toggleDetailsCell(t,t._item),this._a11yUpdateRowDetailsOpened(t,this._isDetailsOpened(t._item)),this._toggleAttribute("details-opened",this._isDetailsOpened(t._item),t)}))}_configureDetailsCell(t){t.setAttribute("part","cell details-cell"),this._toggleAttribute("frozen",!0,t)}_toggleDetailsCell(t,e){const n=t.querySelector('[part~="details-cell"]');if(!n)return;const i=!this._isDetailsOpened(e),r=!!n.hidden!==i;(n._instance||n._renderer)&&n.hidden===i||(n.hidden=i,i?t.style.removeProperty("padding-bottom"):(this.rowDetailsRenderer?(n._renderer=this.rowDetailsRenderer,n._renderer.call(this,n._content,this,{index:t.index,item:e})):this._rowDetailsTemplate&&!n._instance&&(n._instance=this._rowDetailsTemplate.templatizer.createInstance(),n._content.innerHTML="",n._content.appendChild(n._instance.root),this._updateItem(t,e)),zi(),t.style.setProperty("padding-bottom",`${n.offsetHeight}px`),requestAnimationFrame((()=>this.notifyResize())))),r&&(this._updateMetrics(),this._positionItems())}_updateDetailsCellHeights(){Array.from(this.$.items.querySelectorAll('[part~="details-cell"]:not([hidden])')).forEach((t=>{t.parentElement.style.setProperty("padding-bottom",`${t.offsetHeight}px`)}))}_isDetailsOpened(t){return this.detailsOpenedItems&&-1!==this._getItemIndexInArray(t,this.detailsOpenedItems)}openItemDetails(t){this._isDetailsOpened(t)||this.push("detailsOpenedItems",t)}closeItemDetails(t){this._isDetailsOpened(t)&&this.splice("detailsOpenedItems",this._getItemIndexInArray(t,this.detailsOpenedItems),1)}_detailsOpenedInstanceChangedCallback(t,e){super._detailsOpenedInstanceChangedCallback&&super._detailsOpenedInstanceChangedCallback(t,e),e?this.openItemDetails(t.item):this.closeItemDetails(t.item)}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,iDt=t=>class extends t{get _timeouts(){return{SCROLLING:500,IGNORE_WHEEL:500}}static get properties(){return{_frozenCells:{type:Array,value:()=>[]},_rowWithFocusedElement:Element,_deltaYAcc:{type:Number,value:0},_useSticky:{type:Boolean,value:window.CSS&&window.CSS.supports&&(window.CSS.supports("position","sticky")||window.CSS.supports("position","-webkit-sticky"))}}}static get observers(){return["_scrollViewportHeightUpdated(_viewportHeight)"]}set _scrollTop(t){this.$.table.scrollTop=t}get _scrollTop(){return this.$.table.scrollTop}constructor(){super(),this._scrollLineHeight=this._getScrollLineHeight()}_getScrollLineHeight(){const t=document.createElement("div");t.style.fontSize="initial",t.style.display="none",document.body.appendChild(t);const e=window.getComputedStyle(t).fontSize;return document.body.removeChild(t),e?window.parseInt(e):void 0}_scrollViewportHeightUpdated(t){this._scrollPageHeight=t-this.$.header.clientHeight-this.$.footer.clientHeight-this._scrollLineHeight}ready(){super.ready(),this.$.outerscroller=document.createElement("div"),this.scrollTarget=this.$.table,this.addEventListener("wheel",this._onWheel),this.$.items.addEventListener("focusin",(t=>{const e=t.composedPath().indexOf(this.$.items);this._rowWithFocusedElement=t.composedPath()[e-1]})),this.$.items.addEventListener("focusout",(()=>this._rowWithFocusedElement=void 0)),this.scrollTarget.addEventListener("mousedown",(()=>this.__mouseDown=!0)),this.scrollTarget.addEventListener("mouseup",(()=>{this.__mouseDown=!1,this.__pendingReorder&&(this.__pendingReorder=!1,setTimeout((()=>this._reorderRows()),this._timeouts.SCROLLING))}))}scrollToIndex(t){this._accessIronListAPI((()=>super.scrollToIndex(t)))}_onWheel(t){if(t.ctrlKey||this._hasScrolledAncestor(t.target,t.deltaX,t.deltaY))return;const e=this.$.table;let n=t.deltaY;if(t.deltaMode===WheelEvent.DOM_DELTA_LINE?n*=this._scrollLineHeight:t.deltaMode===WheelEvent.DOM_DELTA_PAGE&&(n*=this._scrollPageHeight),this._wheelAnimationFrame)return this._deltaYAcc+=n,void t.preventDefault();n+=this._deltaYAcc,this._deltaYAcc=0,this._wheelAnimationFrame=!0,this._debouncerWheelAnimationFrame=En.debounce(this._debouncerWheelAnimationFrame,_t,(()=>this._wheelAnimationFrame=!1));var i=Math.abs(t.deltaX)+Math.abs(n);this._canScroll(e,t.deltaX,n)?(t.preventDefault(),e.scrollTop+=n,e.scrollLeft+=t.deltaX,this._scrollHandler(),this._hasResidualMomentum=!0,this._ignoreNewWheel=!0,this._debouncerIgnoreNewWheel=En.debounce(this._debouncerIgnoreNewWheel,gt.after(this._timeouts.IGNORE_WHEEL),(()=>this._ignoreNewWheel=!1))):this._hasResidualMomentum&&i<=this._previousMomentum||this._ignoreNewWheel?t.preventDefault():i>this._previousMomentum&&(this._hasResidualMomentum=!1),this._previousMomentum=i}_hasScrolledAncestor(t,e,n){return"vaadin-grid-cell-content"!==t.localName&&(!(!this._canScroll(t,e,n)||-1===["auto","scroll"].indexOf(getComputedStyle(t).overflow))||(t!==this&&t.parentElement?this._hasScrolledAncestor(t.parentElement,e,n):void 0))}_canScroll(t,e,n){return n>0&&t.scrollTop<t.scrollHeight-t.offsetHeight||n<0&&t.scrollTop>0||e>0&&t.scrollLeft<t.scrollWidth-t.offsetWidth||e<0&&t.scrollLeft>0}_scheduleScrolling(){this._scrollingFrame||(this._scrollingFrame=requestAnimationFrame((()=>this._toggleAttribute("scrolling",!0,this.$.scroller)))),this._debounceScrolling=En.debounce(this._debounceScrolling,gt.after(this._timeouts.SCROLLING),(()=>{cancelAnimationFrame(this._scrollingFrame),delete this._scrollingFrame,this._toggleAttribute("scrolling",!1,this.$.scroller),this._reorderRows()}))}_afterScroll(){this._translateStationaryElements(),this.hasAttribute("reordering")||this._scheduleScrolling(),this._updateOverflow()}_updateOverflow(){let t="";const e=this.$.table;e.scrollTop<e.scrollHeight-e.clientHeight&&(t+=" bottom"),e.scrollTop>0&&(t+=" top"),e.scrollLeft<e.scrollWidth-e.clientWidth&&(t+=" right"),e.scrollLeft>0&&(t+=" left"),this._debounceOverflow=En.debounce(this._debounceOverflow,_t,(()=>{const e=t.trim();e.length>0&&this.getAttribute("overflow")!==e?this.setAttribute("overflow",e):0==e.length&&this.hasAttribute("overflow")&&this.removeAttribute("overflow")}))}_reorderRows(){if(this.__mouseDown)return void(this.__pendingReorder=!0);const t=this.$.items,e=t.querySelectorAll("tr");if(!e.length)return;const n=this._virtualStart+this._vidxOffset,i=this._rowWithFocusedElement||Array.from(e).filter((t=>!t.hidden))[0];if(!i)return;const r=i.index-n,o=Array.from(e).indexOf(i)-r;if(o>0)for(let n=0;n<o;n++)t.appendChild(e[n]);else if(o<0)for(let n=e.length+o;n<e.length;n++)t.insertBefore(e[n],e[0]);if(this._safari){const{transform:t}=this.$.header.style;this.$.header.style.transform="",setTimeout((()=>this.$.header.style.transform=t))}}_frozenCellsChanged(){this._debouncerCacheElements=En.debounce(this._debouncerCacheElements,vt,(()=>{Array.from(this.shadowRoot.querySelectorAll('[part~="cell"]')).forEach((function(t){t.style.transform=""})),this._frozenCells=Array.prototype.slice.call(this.$.table.querySelectorAll("[frozen]")),this._updateScrollerMeasurements(),this._translateStationaryElements()})),this._updateLastFrozen()}_updateScrollerMeasurements(){this._frozenCells.length>0&&this.__isRTL&&(this.__scrollerMetrics={scrollWidth:this.$.table.scrollWidth,clientWidth:this.$.table.clientWidth})}_updateLastFrozen(){if(!this._columnTree)return;const t=this._columnTree[this._columnTree.length-1].slice(0);t.sort(((t,e)=>t._order-e._order));const e=t.reduce(((t,e,n)=>(e._lastFrozen=!1,e.frozen&&!e.hidden?n:t)),void 0);void 0!==e&&(t[e]._lastFrozen=!0)}_translateStationaryElements(){const t=Math.max(0,this._scrollLeft),e=Math.max(0,this._scrollTop);let n=0,i=0,r=0;if(this._useSticky||(n=t,i=e,r=this.$.table.clientHeight-this.$.footer.offsetHeight-this.$.footer.offsetTop),this.$.header.style.transform=this._getTranslate(-t+n,i),this.$.footer.style.transform=this._getTranslate(-t+n,i+r),this.$.items.style.transform=this._getTranslate(-t+n,0),this._frozenCells.length>0){const t=this.__isRTL?this.__getNormalizedScrollLeft(this.$.table)+this.__scrollerMetrics.clientWidth-this.__scrollerMetrics.scrollWidth:this._scrollLeft;for(var o=this._getTranslate(t,0),a=0;a<this._frozenCells.length;a++)this._frozenCells[a].style.transform=o}}_getTranslate(t,e){return`translate(${t}px, ${e}px)`}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,rDt=t=>class extends t{static get properties(){return{selectedItems:{type:Object,notify:!0,value:()=>[]}}}static get observers(){return["_selectedItemsChanged(selectedItems.*)"]}_isSelected(t){return this.selectedItems&&this._getItemIndexInArray(t,this.selectedItems)>-1}selectItem(t){this._isSelected(t)||this.push("selectedItems",t)}deselectItem(t){const e=this._getItemIndexInArray(t,this.selectedItems);e>-1&&this.splice("selectedItems",e,1)}_toggleItem(t){-1===this._getItemIndexInArray(t,this.selectedItems)?this.selectItem(t):this.deselectItem(t)}_selectedItemsChanged(t){!this.$.items.children.length||"selectedItems"!==t.path&&"selectedItems.splices"!==t.path||Array.from(this.$.items.children).forEach((t=>{this._updateItem(t,t._item)}))}_selectedInstanceChangedCallback(t,e){super._selectedInstanceChangedCallback&&super._selectedInstanceChangedCallback(t,e),e?this.selectItem(t.item):this.deselectItem(t.item)}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,oDt=t=>class extends t{static get properties(){return{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}}}ready(){super.ready(),this.addEventListener("sorter-changed",this._onSorterChanged),window.ShadyDOM&&vt.run((()=>{const t=this.querySelectorAll("vaadin-grid-sorter");Array.from(t).forEach((t=>{t instanceof ye&&t.dispatchEvent(new CustomEvent("sorter-changed",{bubbles:!0,composed:!0}))}))}))}_onSorterChanged(t){const e=t.target;this._removeArrayItem(this._sorters,e),e._order=null,this.multiSort?(e.direction&&this._sorters.unshift(e),this._sorters.forEach(((t,e)=>t._order=this._sorters.length>1?e:null),this)):e.direction&&(this._sorters.forEach((t=>{t._order=null,t.direction=null})),this._sorters=[e]),t.stopPropagation(),this.dataProvider&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache(),this._a11yUpdateSorters(),this._previousSorters=this._mapSorters()}_mapSorters(){return this._sorters.map((t=>({path:t.path,direction:t.direction})))}_removeArrayItem(t,e){const n=t.indexOf(e);n>-1&&t.splice(n,1)}}
/**
    @license
    Copyright (c) 2018 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,aDt=t=>class extends t{static get properties(){return{cellClassNameGenerator:Function}}static get observers(){return["__cellClassNameGeneratorChanged(cellClassNameGenerator)"]}__cellClassNameGeneratorChanged(t){this.generateCellClassNames()}generateCellClassNames(){Array.from(this.$.items.children).filter((t=>!t.hidden)).forEach((t=>this._generateCellClassNames(t,this.__getRowModel(t))))}_generateCellClassNames(t,e){Array.from(t.children).forEach((t=>{if(t.__generatedClasses&&t.__generatedClasses.forEach((e=>t.classList.remove(e))),this.cellClassNameGenerator){const n=this.cellClassNameGenerator(t._column,e);t.__generatedClasses=n&&n.split(" ").filter((t=>t.length>0)),t.__generatedClasses&&t.__generatedClasses.forEach((e=>t.classList.add(e)))}}))}}
/**
    @license
    Copyright (c) 2019 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,sDt="between",lDt="on-top-or-between",cDt="above",uDt="below",hDt="empty",dDt=t=>class extends t{static get properties(){return{dropMode:String,rowsDraggable:Boolean,dragFilter:Function,dropFilter:Function,__dndAutoScrollThreshold:{value:50}}}static get observers(){return["_dragDropAccessChanged(rowsDraggable, dropMode, dragFilter, dropFilter)"]}ready(){super.ready(),this.$.table.addEventListener("dragstart",this._onDragStart.bind(this)),this.$.table.addEventListener("dragend",this._onDragEnd.bind(this)),this.$.table.addEventListener("dragover",this._onDragOver.bind(this)),this.$.table.addEventListener("dragleave",this._onDragLeave.bind(this)),this.$.table.addEventListener("drop",this._onDrop.bind(this)),this.$.table.addEventListener("dragenter",(t=>{this.dropMode&&(t.preventDefault(),t.stopPropagation())}))}_onDragStart(t){if(this.rowsDraggable){let e=t.target;if("vaadin-grid-cell-content"===e.localName&&(e=e.assignedSlot.parentNode.parentNode),e.parentNode!==this.$.items)return;if(t.stopPropagation(),this._toggleAttribute("dragging-rows",!0,this),this._safari){const t=e.style.transform;e.style.top=/translateY\((.*)\)/.exec(t)[1],e.style.transform="none",requestAnimationFrame((()=>{e.style.top="",e.style.transform=t}))}const n=e.getBoundingClientRect();window.ShadyDOM||(this._ios?t.dataTransfer.setDragImage(e):t.dataTransfer.setDragImage(e,t.clientX-n.left,t.clientY-n.top));let i=[e];this._isSelected(e._item)&&(i=this.__getViewportRows().filter((t=>this._isSelected(t._item))).filter((t=>!this.dragFilter||this.dragFilter(this.__getRowModel(t))))),t.dataTransfer.setData("text",this.__formatDefaultTransferData(i)),e.setAttribute("dragstart",i.length>1?i.length:""),this.updateStyles({"--_grid-drag-start-x":t.clientX-n.left+20+"px","--_grid-drag-start-y":t.clientY-n.top+10+"px"}),requestAnimationFrame((()=>{e.removeAttribute("dragstart"),this.updateStyles({"--_grid-drag-start-x":"","--_grid-drag-start-y":""})}));const r=new CustomEvent("grid-dragstart",{detail:{draggedItems:i.map((t=>t._item)),setDragData:(e,n)=>t.dataTransfer.setData(e,n),setDraggedItemsCount:t=>e.setAttribute("dragstart",t)}});r.originalEvent=t,this.dispatchEvent(r)}}_onDragEnd(t){this._toggleAttribute("dragging-rows",!1,this),t.stopPropagation();const e=new CustomEvent("grid-dragend");e.originalEvent=t,this.dispatchEvent(e)}_onDragLeave(t){t.stopPropagation(),this._clearDragStyles()}_onDragOver(t){if(this.dropMode){if(this._dropLocation=void 0,this._dragOverItem=void 0,this.__dndAutoScroll(t.clientY))return void this._clearDragStyles();let e=t.composedPath().filter((t=>"tr"===t.localName))[0];if(this._effectiveSize&&"on-grid"!==this.dropMode)if(e&&e.parentNode===this.$.items){const n=e.getBoundingClientRect();this._dropLocation="on-top",this.dropMode===sDt?this._dropLocation=t.clientY-n.top<n.bottom-t.clientY?cDt:uDt:this.dropMode===lDt&&(t.clientY-n.top<n.height/3?this._dropLocation=cDt:t.clientY-n.top>n.height/3*2&&(this._dropLocation=uDt))}else{if(e)return;if(this.dropMode!==sDt&&this.dropMode!==lDt)return;e=Array.from(this.$.items.children).filter((t=>!t.hidden)).pop(),this._dropLocation=uDt}else this._dropLocation=hDt;if(e&&e.hasAttribute("drop-disabled"))return void(this._dropLocation=void 0);t.stopPropagation(),t.preventDefault(),this._dropLocation===hDt?this._toggleAttribute("dragover",!0,this):e?(this._dragOverItem=e._item,e.getAttribute("dragover")!==this._dropLocation&&e.setAttribute("dragover",this._dropLocation)):this._clearDragStyles()}}__dndAutoScroll(t){if(this.__dndAutoScrolling)return!0;const e=this.$.header.getBoundingClientRect().bottom,n=this.$.footer.getBoundingClientRect().top,i=e-t+this.__dndAutoScrollThreshold,r=t-n+this.__dndAutoScrollThreshold;let o=0;if(r>0?o=2*r:i>0&&(o=2*-i),o){const t=this.$.table.scrollTop;if(this.$.table.scrollTop+=o,t!==this.$.table.scrollTop)return this.__dndAutoScrolling=!0,setTimeout((()=>this.__dndAutoScrolling=!1),20),this._scrollHandler(),!0}}__getViewportRows(){const t=this.$.header.getBoundingClientRect().bottom,e=this.$.footer.getBoundingClientRect().top;return Array.from(this.$.items.children).filter((n=>{const i=n.getBoundingClientRect();return i.bottom>t&&i.top<e}))}_clearDragStyles(){this.removeAttribute("dragover"),Array.from(this.$.items.children).forEach((t=>t.removeAttribute("dragover")))}_onDrop(t){if(this.dropMode){t.stopPropagation(),t.preventDefault();const e=t.dataTransfer.types&&Array.from(t.dataTransfer.types).map((e=>({type:e,data:t.dataTransfer.getData(e)})));this._clearDragStyles();const n=new CustomEvent("grid-drop",{bubbles:t.bubbles,cancelable:t.cancelable,detail:{dropTargetItem:this._dragOverItem,dropLocation:this._dropLocation,dragData:e}});n.originalEvent=t,this.dispatchEvent(n)}}__formatDefaultTransferData(t){return t.map((t=>Array.from(t.children).filter((t=>!t.hidden&&-1===t.getAttribute("part").indexOf("details-cell"))).sort(((t,e)=>t._column._order>e._column._order?1:-1)).map((t=>t._content.textContent.trim())).filter((t=>t)).join("\t"))).join("\n")}_dragDropAccessChanged(t,e,n,i){this.filterDragAndDrop()}filterDragAndDrop(){Array.from(this.$.items.children).filter((t=>!t.hidden)).forEach((t=>{this._filterDragAndDrop(t,this.__getRowModel(t))}))}_filterDragAndDrop(t,e){const n=!this.rowsDraggable||this.dragFilter&&!this.dragFilter(e),i=!this.dropMode||this.dropFilter&&!this.dropFilter(e);(window.ShadyDOM?[t]:Array.from(t.children).map((t=>t._content))).forEach((t=>{n?t.removeAttribute("draggable"):t.setAttribute("draggable",!0)})),this._toggleAttribute("drag-disabled",n,t),this._toggleAttribute("drop-disabled",i,t)}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,pDt=t=>class extends t{static get properties(){return{_headerFocusable:{type:Object,observer:"_focusableChanged"},_itemsFocusable:{type:Object,observer:"_focusableChanged"},_footerFocusable:{type:Object,observer:"_focusableChanged"},_navigatingIsHidden:Boolean,_focusedItemIndex:{type:Number,value:0},_focusedColumnOrder:Number}}ready(){super.ready(),this._ios||this._android||(this.addEventListener("keydown",this._onKeyDown),this.addEventListener("keyup",this._onKeyUp),this.addEventListener("focusin",this._onFocusIn),this.addEventListener("focusout",this._onFocusOut),this.$.table.addEventListener("focusin",this._onCellFocusIn.bind(this)),this.$.table.addEventListener("focusout",this._onCellFocusOut.bind(this)),this.addEventListener("mousedown",(()=>{this._toggleAttribute("navigating",!1,this),this._isMousedown=!0})),this.addEventListener("mouseup",(()=>this._isMousedown=!1)))}_focusableChanged(t,e){e&&e.setAttribute("tabindex","-1"),t&&t.setAttribute("tabindex","0")}_onKeyDown(t){let e,n=t.key;switch("Up"!==n&&"Down"!==n&&"Left"!==n&&"Right"!==n||(n="Arrow"+n),"Esc"===n&&(n="Escape"),"Spacebar"===n&&(n=" "),n){case"ArrowUp":case"ArrowDown":case"ArrowLeft":case"ArrowRight":case"PageUp":case"PageDown":case"Home":case"End":e="Navigation";break;case"Enter":case"Escape":case"F2":e="Interaction";break;case"Tab":e="Tab";break;case" ":e="Space"}this._detectInteracting(t),this.hasAttribute("interacting")&&"Interaction"!==e&&(e=void 0),e&&this[`_on${e}KeyDown`](t,n)}_ensureScrolledToIndex(t){Array.from(this.$.items.children).filter((e=>e.index===t))[0]||this._scrollToIndex(t)}_onNavigationKeyDown(t,e){function n(t){return Array.prototype.indexOf.call(t.parentNode.children,t)}this._scrollHandler(),t.preventDefault();const i=this._lastVisibleIndex-this._firstVisibleIndex-1;let r=0,o=0;switch(e){case"ArrowRight":r=this.__isRTL?-1:1;break;case"ArrowLeft":r=this.__isRTL?1:-1;break;case"Home":r=-1/0,t.ctrlKey&&(o=-1/0);break;case"End":r=1/0,t.ctrlKey&&(o=1/0);break;case"ArrowDown":o=1;break;case"ArrowUp":o=-1;break;case"PageDown":o=i;break;case"PageUp":o=-i}const a=t.composedPath()[0],s=n(a),l=this._elementMatches(a,'[part~="details-cell"]'),c=a.parentNode,u=c.parentNode,h=(u===this.$.items?this._effectiveSize:u.children.length)-1,d=u===this.$.items?void 0!==this._focusedItemIndex?this._focusedItemIndex:c.index:n(c);let p=Math.max(0,Math.min(d+o,h)),f=!1;if(u===this.$.items){const t=c._item,e=this._cache.getItemForIndex(p);f=l?0===o:1===o&&this._isDetailsOpened(t)||-1===o&&p!==d&&this._isDetailsOpened(e),f!==l&&(1===o&&f||-1===o&&!f)&&(p=d)}if(u!==this.$.items)if(p>d)for(;p<h&&u.children[p].hidden;)p++;else if(p<d)for(;p>0&&u.children[p].hidden;)p--;void 0===this._focusedColumnOrder&&(this._focusedColumnOrder=l?0:this._getColumns(u,d).filter((t=>!t.hidden))[s]._order);const m=this._getColumns(u,p).filter((t=>!t.hidden)),g=m.map((t=>t._order)).sort(((t,e)=>t-e)),_=g.length-1,y=g.indexOf(g.slice(0).sort(((t,e)=>Math.abs(t-this._focusedColumnOrder)-Math.abs(e-this._focusedColumnOrder)))[0]),v=0===o&&l?y:Math.max(0,Math.min(y+r,_));v!==y&&(this._focusedColumnOrder=void 0),u===this.$.items&&this._ensureScrolledToIndex(p),this._toggleAttribute("navigating",!0,this);const b=m.reduce(((t,e,n)=>(t[e._order]=n,t)),{})[g[v]],x=u===this.$.items?Array.from(u.children).filter((t=>t.index===p))[0]:u.children[p];if(!x)return;const w=f?Array.from(x.children).filter((t=>this._elementMatches(t,'[part~="details-cell"]')))[0]:x.children[b];if(this._scrollHorizontallyToCell(w),u===this.$.items&&(this._focusedItemIndex=p),u===this.$.items){const t=w.getBoundingClientRect(),e=this.$.footer.getBoundingClientRect().top,n=this.$.header.getBoundingClientRect().bottom;t.bottom>e?(this.$.table.scrollTop+=t.bottom-e,this._scrollHandler()):t.top<n&&(this.$.table.scrollTop-=n-t.top,this._scrollHandler())}w.focus()}_parseEventPath(t){const e=t.indexOf(this.$.table);return{rowGroup:t[e-1],row:t[e-2],cell:t[e-3]}}_onInteractionKeyDown(t,e){const n=t.composedPath()[0],i="input"===n.localName&&!/^(button|checkbox|color|file|image|radio|range|reset|submit)$/i.test(n.type);let r;switch(e){case"Enter":r=!this.hasAttribute("interacting")||!i;break;case"Escape":r=!1;break;case"F2":r=!this.hasAttribute("interacting")}const{cell:o}=this._parseEventPath(t.composedPath());if(this.hasAttribute("interacting")!==r)if(r){const e=o._content.querySelector("[focus-target]")||o._content.firstElementChild;e&&(t.preventDefault(),e.focus(),this._toggleAttribute("interacting",!0,this),this._toggleAttribute("navigating",!1,this))}else t.preventDefault(),this._focusedColumnOrder=void 0,o.focus(),this._toggleAttribute("interacting",!1,this),this._toggleAttribute("navigating",!0,this)}_predictFocusStepTarget(t,e){const n=[this.$.table,this._headerFocusable,this._itemsFocusable,this._footerFocusable,this.$.focusexit];let i=n.indexOf(t);for(i+=e;i>=0&&i<=n.length-1&&(!n[i]||n[i].parentNode.hidden);)i+=e;return n[i]}_onTabKeyDown(t){const e=this._predictFocusStepTarget(t.composedPath()[0],t.shiftKey?-1:1);if(e===this.$.table)this.$.table.focus();else if(e===this.$.focusexit)this.$.focusexit.focus();else if(e===this._itemsFocusable){let n=e;const i=this._itemsFocusable.parentNode;if(this._ensureScrolledToIndex(this._focusedItemIndex),i.index!==this._focusedItemIndex){const t=Array.from(i.children).indexOf(this._itemsFocusable),e=Array.from(this.$.items.children).filter((t=>t.index===this._focusedItemIndex))[0];e&&(n=e.children[t])}t.preventDefault(),n.focus()}else t.preventDefault(),e.focus();this._toggleAttribute("navigating",!0,this)}_onSpaceKeyDown(t){t.preventDefault();const e=t.composedPath()[0];e._content&&e._content.firstElementChild||this.dispatchEvent(new CustomEvent("cell-activate",{detail:{model:this.__getRowModel(e.parentElement)}}))}_onKeyUp(t){if(!/^( |SpaceBar)$/.test(t.key))return;t.preventDefault();const e=t.composedPath()[0];if(e._content&&e._content.firstElementChild){const t=this.hasAttribute("navigating");e._content.firstElementChild.click(),this._toggleAttribute("navigating",t,this)}}_onFocusIn(t){this._isMousedown||this._toggleAttribute("navigating",!0,this);const e=t.composedPath()[0];e===this.$.table||e===this.$.focusexit?(this._predictFocusStepTarget(e,e===this.$.table?1:-1).focus(),this._toggleAttribute("interacting",!1,this)):this._detectInteracting(t)}_onFocusOut(t){this._toggleAttribute("navigating",!1,this),this._detectInteracting(t)}_onCellFocusIn(t){if(this._detectInteracting(t),3===t.composedPath().indexOf(this.$.table)){const e=t.composedPath()[0];this._activeRowGroup=e.parentNode.parentNode,this._activeRowGroup===this.$.header?this._headerFocusable=e:this._activeRowGroup===this.$.items?this._itemsFocusable=e:this._activeRowGroup===this.$.footer&&(this._footerFocusable=e),e._content.dispatchEvent(new CustomEvent("cell-focusin",{bubbles:!1}))}this._detectFocusedItemIndex(t)}_onCellFocusOut(t){3===t.composedPath().indexOf(this.$.table)&&t.composedPath()[0]._content.dispatchEvent(new CustomEvent("cell-focusout",{bubbles:!1}))}_detectInteracting(t){this._toggleAttribute("interacting",t.composedPath().some((t=>"vaadin-grid-cell-content"===t.localName)),this)}_detectFocusedItemIndex(t){const{rowGroup:e,row:n}=this._parseEventPath(t.composedPath());e===this.$.items&&(this._focusedItemIndex=n.index)}_preventScrollerRotatingCellFocus(t,e){t.index===this._focusedItemIndex&&this.hasAttribute("navigating")&&this._activeRowGroup===this.$.items&&(this._navigatingIsHidden=!0,this._toggleAttribute("navigating",!1,this)),e===this._focusedItemIndex&&this._navigatingIsHidden&&(this._navigatingIsHidden=!1,this._toggleAttribute("navigating",!0,this))}_getColumns(t,e){let n=this._columnTree.length-1;return t===this.$.header?n=e:t===this.$.footer&&(n=this._columnTree.length-1-e),this._columnTree[n]}_resetKeyboardNavigation(){if(this.$.header.firstElementChild&&(this._headerFocusable=Array.from(this.$.header.firstElementChild.children).filter((t=>!t.hidden))[0]),this.$.items.firstElementChild){const t=this._iterateItems(((t,e)=>{if(this._firstVisibleIndex===e)return this.$.items.children[t]}));t&&(this._itemsFocusable=Array.from(t.children).filter((t=>!t.hidden))[0])}this.$.footer.firstElementChild&&(this._footerFocusable=Array.from(this.$.footer.firstElementChild.children).filter((t=>!t.hidden))[0])}_scrollHorizontallyToCell(t){if(t.hasAttribute("frozen")||this._elementMatches(t,'[part~="details-cell"]'))return;const e=t.getBoundingClientRect(),n=t.parentNode,i=Array.from(n.children).indexOf(t),r=this.$.table.getBoundingClientRect();let o=r.left,a=r.right;for(let t=i-1;t>=0;t--){const e=n.children[t];if(!e.hasAttribute("hidden")&&!this._elementMatches(e,'[part~="details-cell"]')&&e.hasAttribute("frozen")){o=e.getBoundingClientRect().right;break}}for(let t=i+1;t<n.children.length;t++){const e=n.children[t];if(!e.hasAttribute("hidden")&&!this._elementMatches(e,'[part~="details-cell"]')&&e.hasAttribute("frozen")){a=e.getBoundingClientRect().left;break}}e.left<o&&(this.$.table.scrollLeft+=Math.round(e.left-o)),e.right>a&&(this.$.table.scrollLeft+=Math.round(e.right-a))}_elementMatches(t,e){return t.matches?t.matches(e):-1!==Array.from(t.parentNode.querySelectorAll(e)).indexOf(t)}}
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,fDt=t=>class extends(di(t)){static get properties(){return{columnReorderingAllowed:{type:Boolean,value:!1},_orderBaseScope:{type:Number,value:1e7}}}static get observers(){return["_updateOrders(_columnTree, _columnTree.*)"]}ready(){super.ready(),ni(this,"track",this._onTrackEvent),this._reorderGhost=this.shadowRoot.querySelector('[part="reorder-ghost"]'),this.addEventListener("touchstart",this._onTouchStart.bind(this)),this.addEventListener("touchmove",this._onTouchMove.bind(this)),this.addEventListener("touchend",this._onTouchEnd.bind(this)),this.addEventListener("contextmenu",this._onContextMenu.bind(this))}_onContextMenu(t){this.hasAttribute("reordering")&&t.preventDefault()}_onTouchStart(t){this._startTouchReorderTimeout=setTimeout((()=>{this._onTrackStart({detail:{x:t.touches[0].clientX,y:t.touches[0].clientY}})}),100)}_onTouchMove(t){this._draggedColumn&&t.preventDefault(),clearTimeout(this._startTouchReorderTimeout)}_onTouchEnd(){clearTimeout(this._startTouchReorderTimeout),this._onTrackEnd()}_onTrackEvent(t){if("start"===t.detail.state){const e=t.composedPath(),n=e[e.indexOf(this.$.header)-2];if(!n||!n._content)return;const i=this.getRootNode().activeElement;if(n._content.contains(this.getRootNode().activeElement)&&(!this._ie||!this._isFocusable(i)))return;if(this.$.scroller.hasAttribute("column-resizing"))return;this._touchDevice||this._onTrackStart(t)}else"track"===t.detail.state?this._onTrack(t):"end"===t.detail.state&&this._onTrackEnd(t)}_onTrackStart(t){if(!this.columnReorderingAllowed)return;const e=t.path||qi(t).path;if(e&&e.filter((t=>t.hasAttribute&&t.hasAttribute("draggable")))[0])return;const n=this._cellFromPoint(t.detail.x,t.detail.y);if(n&&-1!==n.getAttribute("part").indexOf("header-cell")){for(this._toggleAttribute("reordering",!0,this),this._draggedColumn=n._column;1===this._draggedColumn.parentElement.childElementCount;)this._draggedColumn=this._draggedColumn.parentElement;this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",this._updateGhost(n),this._reorderGhost.style.visibility="visible",this._updateGhostPosition(t.detail.x,this._touchDevice?t.detail.y-50:t.detail.y),this._autoScroller()}}_onTrack(t){if(!this._draggedColumn)return;const e=this._cellFromPoint(t.detail.x,t.detail.y);if(!e)return;const n=this._getTargetColumn(e,this._draggedColumn);this._isSwapAllowed(this._draggedColumn,n)&&this._isSwappableByPosition(n,t.detail.x)&&this._swapColumnOrders(this._draggedColumn,n),this._updateGhostPosition(t.detail.x,this._touchDevice?t.detail.y-50:t.detail.y),this._lastDragClientX=t.detail.x}_onTrackEnd(){this._draggedColumn&&(this._toggleAttribute("reordering",!1,this),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._draggedColumn=null,this._lastDragClientX=null,this._reorderGhost.style.visibility="hidden",this.dispatchEvent(new CustomEvent("column-reorder",{detail:{columns:this._getColumnsInOrder()}})))}_getColumnsInOrder(){return this._columnTree.slice(0).pop().filter((t=>!t.hidden)).sort(((t,e)=>t._order-e._order))}_cellFromPoint(t,e){let n;if(t=t||0,e=e||0,this._draggedColumn||this._toggleAttribute("no-content-pointer-events",!0,this.$.scroller),m?n=this.shadowRoot.elementFromPoint(t,e):(n=document.elementFromPoint(t,e),"vaadin-grid-cell-content"===n.localName&&(n=n.assignedSlot.parentNode)),this._toggleAttribute("no-content-pointer-events",!1,this.$.scroller),n&&n._column)return n}_updateGhostPosition(t,e){const n=this._reorderGhost.getBoundingClientRect(),i=t-n.width/2,r=e-n.height/2,o=parseInt(this._reorderGhost._left||0),a=parseInt(this._reorderGhost._top||0);this._reorderGhost._left=o-(n.left-i),this._reorderGhost._top=a-(n.top-r),this._reorderGhost.style.transform=`translate(${this._reorderGhost._left}px, ${this._reorderGhost._top}px)`}_getInnerText(t){return t.localName?"none"===getComputedStyle(t).display?"":Array.from(t.childNodes).map((t=>this._getInnerText(t))).join(""):t.textContent}_updateGhost(t){const e=this._reorderGhost;e.textContent=this._getInnerText(t._content);const n=window.getComputedStyle(t);return["boxSizing","display","width","height","background","alignItems","padding","border","flex-direction","overflow"].forEach((t=>e.style[t]=n[t])),e}_updateOrders(t,e){void 0!==t&&void 0!==e&&(t[0].forEach(((t,e)=>t._order=0)),t[0].forEach(((t,e)=>t._order=(e+1)*this._orderBaseScope)))}_setSiblingsReorderStatus(t,e){Array.from(t.parentNode.children).filter((e=>/column/.test(e.localName)&&this._isSwapAllowed(e,t))).forEach((t=>t._reorderStatus=e))}_autoScroller(){if(this._lastDragClientX){const t=this._lastDragClientX-this.getBoundingClientRect().right+50,e=this.getBoundingClientRect().left-this._lastDragClientX+50;t>0?this.$.table.scrollLeft+=t/10:e>0&&(this.$.table.scrollLeft-=e/10),this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)}_isSwapAllowed(t,e){if(t&&e){const n=t.parentElement===e.parentElement,i=t.frozen===e.frozen;return t!==e&&n&&i}}_isSwappableByPosition(t,e){const n=Array.from(this.$.header.querySelectorAll('tr:not([hidden]) [part~="cell"]')).filter((e=>t.contains(e._column)))[0],i=this.$.header.querySelector("tr:not([hidden]) [reorder-status=dragging]").getBoundingClientRect(),r=n.getBoundingClientRect();return r.left>i.left?e>r.right-i.width:e<r.left+i.width}_swapColumnOrders(t,e){const n=t._order;t._order=e._order,e._order=n,this._updateLastFrozen(),this._updateFirstAndLastColumn()}_getTargetColumn(t,e){if(t&&e){let n=t._column;for(;n.parentElement!==e.parentElement&&n!==this;)n=n.parentElement;return n.parentElement===e.parentElement?n:t._column}}}
/**
    @license
    Copyright (c) 2018 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */,mDt=t=>class extends t{static get properties(){return{resizable:{type:Boolean,value:function(){if("vaadin-grid-column-group"===this.localName)return;const t=this.parentNode;return t&&"vaadin-grid-column-group"===t.localName&&t.resizable||!1}},_headerTemplate:{type:Object},_footerTemplate:{type:Object},frozen:{type:Boolean,value:!1},hidden:{type:Boolean},header:{type:String},textAlign:{type:String},_lastFrozen:{type:Boolean,value:!1},_order:Number,_reorderStatus:Boolean,_emptyCells:Array,_headerCell:Object,_footerCell:Object,_grid:Object,headerRenderer:Function,footerRenderer:Function}}static get observers(){return["_widthChanged(width, _headerCell, _footerCell, _cells.*)","_frozenChanged(frozen, _headerCell, _footerCell, _cells.*)","_flexGrowChanged(flexGrow, _headerCell, _footerCell, _cells.*)","_pathOrHeaderChanged(path, header, _headerCell, _footerCell, _cells.*, renderer, headerRenderer, _bodyTemplate, _headerTemplate)","_textAlignChanged(textAlign, _cells.*, _headerCell, _footerCell)","_orderChanged(_order, _headerCell, _footerCell, _cells.*)","_lastFrozenChanged(_lastFrozen)","_setBodyTemplateOrRenderer(_bodyTemplate, renderer, _cells, _cells.*)","_setHeaderTemplateOrRenderer(_headerTemplate, headerRenderer, _headerCell)","_setFooterTemplateOrRenderer(_footerTemplate, footerRenderer, _footerCell)","_resizableChanged(resizable, _headerCell)","_reorderStatusChanged(_reorderStatus, _headerCell, _footerCell, _cells.*)","_hiddenChanged(hidden, _headerCell, _footerCell, _cells.*)"]}connectedCallback(){super.connectedCallback(),this._bodyTemplate&&(this._bodyTemplate.templatizer._grid=this._grid),this._headerTemplate&&(this._headerTemplate.templatizer._grid=this._grid),this._footerTemplate&&(this._footerTemplate.templatizer._grid=this._grid),this._templateObserver.flush(),this._bodyTemplate||this._templateObserver.callback(),requestAnimationFrame((()=>{this._allCells.forEach((t=>{t._content.parentNode||this._grid&&this._grid.appendChild(t._content)}))}))}disconnectedCallback(){super.disconnectedCallback(),requestAnimationFrame((()=>{this._findHostGrid()||this._allCells.forEach((t=>{t._content.parentNode&&t._content.parentNode.removeChild(t._content)}))})),this._gridValue=void 0}_findHostGrid(){let t=this;for(;t&&!/^vaadin.*grid(-pro)?$/.test(t.localName);)t=t.assignedSlot?t.assignedSlot.parentNode:t.parentNode;return t||void 0}get _grid(){return this._gridValue||(this._gridValue=this._findHostGrid()),this._gridValue}get _allCells(){return[].concat(this._cells||[]).concat(this._emptyCells||[]).concat(this._headerCell).concat(this._footerCell).filter((t=>t))}constructor(){super(),this._templateObserver=new Ri(this,(t=>{this._headerTemplate=this._prepareHeaderTemplate(),this._footerTemplate=this._prepareFooterTemplate(),this._bodyTemplate=this._prepareBodyTemplate()}))}_prepareHeaderTemplate(){return this._prepareTemplatizer(this._findTemplate(!0)||null,{})}_prepareFooterTemplate(){return this._prepareTemplatizer(this._findTemplate(!1,!0)||null,{})}_prepareBodyTemplate(){return this._prepareTemplatizer(this._findTemplate()||null)}_prepareTemplatizer(t,e){if(t&&!t.templatizer){const n=new eDt;n._grid=this._grid,n.dataHost=this.dataHost,n._instanceProps=e||n._instanceProps,n.template=t,t.templatizer=n}return t}_renderHeaderAndFooter(){this.headerRenderer&&this._headerCell&&this.__runRenderer(this.headerRenderer,this._headerCell),this.footerRenderer&&this._footerCell&&this.__runRenderer(this.footerRenderer,this._footerCell)}__runRenderer(t,e,n){const i=[e._content,this];n&&n.item&&i.push(n),t.apply(this,i)}__setColumnTemplateOrRenderer(t,e,n){if(!this.hidden){if(t&&e)throw new Error("You should only use either a renderer or a template");n.forEach((n=>{const i=this._grid.__getRowModel(n.parentElement);if(e)n._renderer=e,(i.item||e===this.headerRenderer||e===this.footerRenderer)&&this.__runRenderer(e,n,i);else if(n._template!==t){n._template=t,n._content.innerHTML="",t.templatizer._grid=t.templatizer._grid||this._grid;const e=t.templatizer.createInstance();n._content.appendChild(e.root),n._instance=e,i.item&&n._instance.setProperties(i)}}))}}_setBodyTemplateOrRenderer(t,e,n,i){(t||e)&&n&&this.__setColumnTemplateOrRenderer(t,e,n)}_setHeaderTemplateOrRenderer(t,e,n){(t||e)&&n&&this.__setColumnTemplateOrRenderer(t,e,[n])}_setFooterTemplateOrRenderer(t,e,n){(t||e)&&n&&(this.__setColumnTemplateOrRenderer(t,e,[n]),this._grid.__updateHeaderFooterRowVisibility(n.parentElement))}_selectFirstTemplate(t=!1,e=!1){return Ri.getFlattenedNodes(this).filter((n=>"template"===n.localName&&n.classList.contains("header")===t&&n.classList.contains("footer")===e))[0]}_findTemplate(t,e){const n=this._selectFirstTemplate(t,e);return n&&this.dataHost&&(n._rootDataHost=this.dataHost._rootDataHost||this.dataHost),n}_flexGrowChanged(t,e,n,i){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("flexGrow"),this._allCells.forEach((e=>e.style.flexGrow=t))}_orderChanged(t,e,n,i){this._allCells.forEach((e=>e.style.order=t))}_widthChanged(t,e,n,i){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("width"),this._allCells.forEach((e=>e.style.width=t)),this._grid&&this._grid.__forceReflow&&this._grid.__forceReflow()}_frozenChanged(t,e,n,i){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("frozen",t),this._allCells.forEach((e=>this._toggleAttribute("frozen",t,e))),this._grid&&this._grid._frozenCellsChanged&&this._grid._frozenCellsChanged()}_lastFrozenChanged(t){this._allCells.forEach((e=>this._toggleAttribute("last-frozen",t,e))),this.parentElement&&this.parentElement._columnPropChanged&&(this.parentElement._lastFrozen=t)}_pathOrHeaderChanged(t,e,n,i,r,o,a,s,l){const c=void 0!==e;!a&&!l&&c&&n&&this.__setTextContent(n._content,e),t&&r.value&&(o||s||this.__setColumnTemplateOrRenderer(void 0,((e,n,{item:i})=>this.__setTextContent(e,this.get(t,i))),r.value),a||l||c||!n||null===e||this.__setTextContent(n._content,this._generateHeader(t))),n&&this._grid.__updateHeaderFooterRowVisibility(n.parentElement)}__setTextContent(t,e){t.textContent!==e&&(t.textContent=e)}_generateHeader(t){return t.substr(t.lastIndexOf(".")+1).replace(/([A-Z])/g,"-$1").toLowerCase().replace(/-/g," ").replace(/^./,(t=>t.toUpperCase()))}_toggleAttribute(t,e,n){n.hasAttribute(t)===!e&&(e?n.setAttribute(t,""):n.removeAttribute(t))}_reorderStatusChanged(t,e,n,i){this._allCells.forEach((e=>e.setAttribute("reorder-status",t)))}_resizableChanged(t,e){void 0!==t&&void 0!==e&&e&&[e].concat(this._emptyCells).forEach((e=>{if(e){const n=e.querySelector('[part~="resize-handle"]');if(n&&e.removeChild(n),t){const t=document.createElement("div");t.setAttribute("part","resize-handle"),e.appendChild(t)}}}))}_textAlignChanged(t,e,n,i){if(void 0===t)return;if(-1===["start","end","center"].indexOf(t))return void console.warn('textAlign can only be set as "start", "end" or "center"');let r;"ltr"===getComputedStyle(this._grid).direction?"start"===t?r="left":"end"===t&&(r="right"):"start"===t?r="right":"end"===t&&(r="left"),this._allCells.forEach((e=>{e._content.style.textAlign=t,getComputedStyle(e._content).textAlign!==t&&(e._content.style.textAlign=r)}))}_hiddenChanged(t,e,n,i){this.parentElement&&this.parentElement._columnPropChanged&&this.parentElement._columnPropChanged("hidden",t),!!t!=!!this._previousHidden&&this._grid&&(!0===t&&this._allCells.forEach((t=>{t._content.parentNode&&t._content.parentNode.removeChild(t._content)})),this._grid._debouncerHiddenChanged=En.debounce(this._grid._debouncerHiddenChanged,_t,(()=>{this._grid&&this._grid._renderColumnTree&&this._grid._renderColumnTree(this._grid._columnTree)})),this._grid._updateLastFrozen&&this._grid._updateLastFrozen(),this._grid.notifyResize&&this._grid.notifyResize(),this._grid._resetKeyboardNavigation&&this._grid._resetKeyboardNavigation()),this._previousHidden=t}};class gDt extends(mDt(Tzt(ye))){static get is(){return"vaadin-grid-column"}static get properties(){return{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},renderer:Function,path:{type:String},autoWidth:{type:Boolean,value:!1},_bodyTemplate:{type:Object},_cells:Array}}}customElements.define(gDt.is,gDt);
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */
const _Dt=document.createElement("dom-module");_Dt.appendChild(_e`
  <style>
    @keyframes vaadin-grid-appear {
      to {
        opacity: 1;
      }
    }

    :host {
      display: block;
      animation: 1ms vaadin-grid-appear;
      height: 400px;
      flex: 1 1 auto;
      align-self: stretch;
      position: relative;
    }

    :host([hidden]) {
      display: none !important;
    }

    #scroller {
      display: block;
      transform: translateY(0);
      width: auto;
      height: auto;
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }

    :host([height-by-rows]) {
      height: auto;
      align-self: flex-start;
      flex-grow: 0;
      width: 100%;
    }

    :host([height-by-rows]) #scroller {
      width: 100%;
      height: 100%;
      position: relative;
    }

    #table {
      display: flex;
      flex-direction: column;
      width: 100%;
      height: 100%;
      overflow: auto;
      position: relative;
      outline: none;
      /* Workaround for a Desktop Safari bug: new stacking context here prevents the scrollbar from getting hidden */
      z-index: 0;
    }

    #header,
    #footer {
      display: block;
      position: -webkit-sticky;
      position: sticky;
      left: 0;
      overflow: visible;
      width: 100%;
      z-index: 1;
    }

    #header {
      top: 0;
    }

    th {
      text-align: inherit;
    }

    /* Safari doesn't work with "inherit" */
    [safari] th {
      text-align: initial;
    }

    #footer {
      bottom: 0;
    }

    #items {
      flex-grow: 1;
      flex-shrink: 0;
      display: block;
      position: -webkit-sticky;
      position: sticky;
      width: 100%;
      left: 0;
      overflow: visible;
    }

    [part~="row"] {
      display: flex;
      width: 100%;
      box-sizing: border-box;
      margin: 0;
    }

    [part~="row"][loading] [part~="body-cell"] ::slotted(vaadin-grid-cell-content) {
      opacity: 0;
    }

    #items [part~="row"] {
      position: absolute;
    }

    #items [part~="row"]:empty {
      height: 1em;
    }

    [part~="cell"]:not([part~="details-cell"]) {
      flex-shrink: 0;
      flex-grow: 1;
      box-sizing: border-box;
      display: flex;
      width: 100%;
      position: relative;
      align-items: center;
      padding: 0;
      white-space: nowrap;
    }

    [part~="details-cell"] {
      position: absolute;
      bottom: 0;
      width: 100%;
      box-sizing: border-box;
      padding: 0;
    }

    [part~="cell"] ::slotted(vaadin-grid-cell-content) {
      display: block;
      width: 100%;
      box-sizing: border-box;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    [hidden] {
      display: none !important;
    }

    [frozen] {
      z-index: 2;
      will-change: transform;
    }

    [no-scrollbars][safari] #table,
    [no-scrollbars][firefox] #table {
      overflow: hidden;
    }

    /* Reordering styles */
    :host([reordering]) [part~="cell"] ::slotted(vaadin-grid-cell-content),
    :host([reordering]) [part~="resize-handle"],
    #scroller[no-content-pointer-events] [part~="cell"] ::slotted(vaadin-grid-cell-content) {
      pointer-events: none;
    }

    [part~="reorder-ghost"] {
      visibility: hidden;
      position: fixed;
      pointer-events: none;
      opacity: 0.5;

      /* Prevent overflowing the grid in Firefox */
      top: 0;
      left: 0;
    }

    :host([reordering]) {
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    #scroller[ie][column-reordering-allowed] [part~="header-cell"] {
      -ms-user-select: none;
    }

    /* Resizing styles */
    [part~="resize-handle"] {
      position: absolute;
      top: 0;
      right: 0;
      height: 100%;
      cursor: col-resize;
      z-index: 1;
    }

    [part~="resize-handle"]::before {
      position: absolute;
      content: "";
      height: 100%;
      width: 35px;
      transform: translateX(-50%);
    }

    [last-column] [part~="resize-handle"]::before,
    [last-frozen] [part~="resize-handle"]::before {
      width: 18px;
      transform: none;
      right: 0;
    }

    #scroller[column-resizing] {
      -ms-user-select: none;
      -moz-user-select: none;
      -webkit-user-select: none;
      user-select: none;
    }

    /* Sizer styles */
    #sizer {
      display: flex;
      position: absolute;
      visibility: hidden;
    }

    #sizer [part~="details-cell"] {
      display: none !important;
    }

    #sizer [part~="cell"][hidden] {
      display: none !important;
    }

    #sizer [part~="cell"] {
      display: block;
      flex-shrink: 0;
      line-height: 0;
      height: 0 !important;
      min-height: 0 !important;
      max-height: 0 !important;
      padding: 0 !important;
      border: none !important;
    }

    #sizer [part~="cell"]::before {
      content: "-";
    }

    #sizer [part~="cell"] ::slotted(vaadin-grid-cell-content) {
      display: none !important;
    }

    /* RTL specific styles */

    :host([dir="rtl"]) #items,
    :host([dir="rtl"]) #header,
    :host([dir="rtl"]) #footer {
      left: auto;
    }

    :host([dir="rtl"]) [part~="reorder-ghost"] {
      left: auto;
      right: 0;
    }

    :host([dir="rtl"]) [part~="resize-handle"] {
      left: 0;
      right: auto;
    }

    :host([dir="rtl"]) [part~="resize-handle"]::before {
      transform: translateX(50%);
    }

    :host([dir="rtl"]) [last-column] [part~="resize-handle"]::before,
    :host([dir="rtl"]) [last-frozen] [part~="resize-handle"]::before {
      left: 0;
      right: auto;
    }
  </style>
`),_Dt.register("vaadin-grid-styles");
/**
    @license
    Copyright (c) 2017 Vaadin Ltd.
    This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
    */
const yDt=(()=>{try{return document.createEvent("TouchEvent"),!0}catch(t){return!1}})();class vDt extends(Rzt(yzt(Zzt(Xzt(Jzt(qzt(iDt(rDt(oDt(nDt(pDt(Wzt(tDt(fDt($zt(Qzt(dDt(aDt(Gzt))))))))))))))))))){static get template(){return _e`
    <style include="vaadin-grid-styles"></style>

    <div id="scroller" safari\$="[[_safari]]" ios\$="[[_ios]]" ie\$="[[_ie]]" loading\$="[[loading]]" column-reordering-allowed\$="[[columnReorderingAllowed]]">

      <table id="table" role="grid" aria-multiselectable="true" tabindex="0">
        <caption id="sizer" part="row"></caption>
        <thead id="header" role="rowgroup"></thead>
        <tbody id="items" role="rowgroup"></tbody>
        <tfoot id="footer" role="rowgroup"></tfoot>
      </table>

      <div part="reorder-ghost"></div>
    </div>

    <!-- The template needs at least one slot or else shady doesn't distribute -->
    <slot name="nodistribute"></slot>

    <div id="focusexit" tabindex="0"></div>
`}static get is(){return"vaadin-grid"}static get version(){return"5.7.11"}static get observers(){return["_columnTreeChanged(_columnTree, _columnTree.*)"]}static get properties(){return{_safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},_ios:{type:Boolean,value:/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||"MacIntel"===navigator.platform&&navigator.maxTouchPoints>1},_edge:{type:Boolean,value:"undefined"!=typeof CSS&&CSS.supports("(-ms-ime-align:auto)")},_ie:{type:Boolean,value:!(!navigator.userAgent.match(/Trident/)||navigator.userAgent.match(/MSIE/))},_firefox:{type:Boolean,value:navigator.userAgent.toLowerCase().indexOf("firefox")>-1},_android:{type:Boolean,value:/android/i.test(navigator.userAgent)},_touchDevice:{type:Boolean,value:yDt},heightByRows:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"_heightByRowsChanged"},_recalculateColumnWidthOnceLoadingFinished:{type:Boolean,value:!0}}}constructor(){super(),this.addEventListener("animationend",this._onAnimationEnd)}connectedCallback(){super.connectedCallback(),this.recalculateColumnWidths()}attributeChangedCallback(t,e,n){super.attributeChangedCallback(t,e,n),"dir"===t&&(this.__isRTL="rtl"===n,this._updateScrollerMeasurements())}__hasRowsWithClientHeight(){return!!Array.from(this.$.items.children).filter((t=>t.clientHeight)).length}__itemsReceived(){this._recalculateColumnWidthOnceLoadingFinished&&!this._cache.isLoading()&&this.__hasRowsWithClientHeight()&&(this._recalculateColumnWidthOnceLoadingFinished=!1,this.recalculateColumnWidths())}_recalculateColumnWidths(t){t.forEach((t=>{t.width="auto",t._origFlexGrow=t.flexGrow,t.flexGrow=0})),t.forEach((t=>{t._currentWidth=0,t._allCells.forEach((e=>{t._currentWidth=Math.max(t._currentWidth,e.offsetWidth+1)}))})),t.forEach((t=>{t.width=`${t._currentWidth}px`,t.flexGrow=t._origFlexGrow,t._currentWidth=void 0,t._origFlexGrow=void 0}))}recalculateColumnWidths(){if(this._columnTree)if(this._cache.isLoading())this._recalculateColumnWidthOnceLoadingFinished=!0;else{const t=this._getColumns().filter((t=>!t.hidden&&t.autoWidth));this._recalculateColumnWidths(t)}}_createScrollerRows(t){const e=[];for(var n=0;n<t;n++){const t=document.createElement("tr");t.setAttribute("part","row"),t.setAttribute("role","row"),this._columnTree&&this._updateRow(t,this._columnTree[this._columnTree.length-1],"body",!1,!0),e.push(t)}return this._columnTree&&this._columnTree[this._columnTree.length-1].forEach((t=>t.notifyPath&&t.notifyPath("_cells.*",t._cells))),(function i(t,e,n){Mi||Ai(),Ei.push([t,e,n])})(this,(()=>{this._updateFirstAndLastColumn(),this._resetKeyboardNavigation()})),e}_getRowTarget(){return this.$.items}_createCell(t){const e="vaadin-grid-cell-content-"+(this._contentIndex=this._contentIndex+1||0),n=document.createElement("vaadin-grid-cell-content");n.setAttribute("slot",e);const i=document.createElement(t);i.id=e.replace("-content-","-"),i.setAttribute("tabindex","-1"),i.setAttribute("role","td"===t?"gridcell":"columnheader");const r=document.createElement("slot");return r.setAttribute("name",e),i.appendChild(r),i._content=n,n.addEventListener("mousedown",(()=>{if(window.chrome){const t=()=>{n.contains(this.getRootNode().activeElement)||i.focus(),document.removeEventListener("mouseup",t,!0)};document.addEventListener("mouseup",t,!0)}else setTimeout((()=>{n.contains(this.getRootNode().activeElement)||i.focus()}))})),i}_updateRow(t,e,n,i,r){n=n||"body";const o=document.createDocumentFragment();Array.from(t.children).forEach((t=>t._vacant=!0)),t.innerHTML="","sizer"!==t.id&&(t.hidden=!0),e.filter((t=>!t.hidden)).forEach(((e,a,s)=>{let l;if("body"===n){if(e._cells=e._cells||[],l=e._cells.filter((t=>t._vacant))[0],l||(l=this._createCell("td"),e._cells.push(l)),l.setAttribute("part","cell body-cell"),t.appendChild(l),a===s.length-1&&(this._rowDetailsTemplate||this.rowDetailsRenderer)){this._detailsCells=this._detailsCells||[];const e=this._detailsCells.filter((t=>t._vacant))[0]||this._createCell("td");-1===this._detailsCells.indexOf(e)&&this._detailsCells.push(e),e._content.parentElement||o.appendChild(e._content),this._configureDetailsCell(e),t.appendChild(e),this._a11ySetRowDetailsCell(t,e),e._vacant=!1}e.notifyPath&&!r&&e.notifyPath("_cells.*",e._cells)}else{const r="header"===n?"th":"td";i||"vaadin-grid-column-group"===e.localName?(l=e[`_${n}Cell`]||this._createCell(r),l._column=e,t.appendChild(l),e[`_${n}Cell`]=l):(e._emptyCells=e._emptyCells||[],l=e._emptyCells.filter((t=>t._vacant))[0]||this._createCell(r),l._column=e,t.appendChild(l),-1===e._emptyCells.indexOf(l)&&e._emptyCells.push(l)),l.setAttribute("part",`cell ${n}-cell`),this.__updateHeaderFooterRowVisibility(t)}l._content.parentElement||o.appendChild(l._content),l._vacant=!1,l._column=e})),this.appendChild(o),this._frozenCellsChanged(),this._updateFirstAndLastColumnForRow(t)}__updateHeaderFooterRowVisibility(t){if(!t)return;const e=Array.from(t.children).filter((e=>{const n=e._column;if(n._emptyCells&&n._emptyCells.indexOf(e)>-1)return!1;if(t.parentElement===this.$.header){if(n.headerRenderer||n._headerTemplate)return!0;if(null===n.header)return!1;if(n.path||void 0!==n.header)return!0}else if(n.footerRenderer||n._footerTemplate)return!0}));t.hidden!==!e.length&&(t.hidden=!e.length,this.notifyResize())}_updateScrollerItem(t,e){this._preventScrollerRotatingCellFocus(t,e),this._columnTree&&(this._toggleAttribute("first",0===e,t),this._toggleAttribute("odd",e%2,t),this._a11yUpdateRowRowindex(t,e),this._getItem(e,t))}_columnTreeChanged(t,e){this._renderColumnTree(t),this.recalculateColumnWidths()}_renderColumnTree(t){for(Array.from(this.$.items.children).forEach((e=>this._updateRow(e,t[t.length-1],null,!1,!0)));this.$.header.children.length<t.length;){const t=document.createElement("tr");t.setAttribute("part","row"),t.setAttribute("role","row"),this.$.header.appendChild(t);const e=document.createElement("tr");e.setAttribute("part","row"),e.setAttribute("role","row"),this.$.footer.appendChild(e)}for(;this.$.header.children.length>t.length;)this.$.header.removeChild(this.$.header.firstElementChild),this.$.footer.removeChild(this.$.footer.firstElementChild);Array.from(this.$.header.children).forEach(((e,n)=>this._updateRow(e,t[n],"header",n===t.length-1))),Array.from(this.$.footer.children).forEach(((e,n)=>this._updateRow(e,t[t.length-1-n],"footer",0===n))),this._updateRow(this.$.sizer,t[t.length-1]),this._resizeHandler(),this._frozenCellsChanged(),this._updateFirstAndLastColumn(),this._resetKeyboardNavigation(),this._a11yUpdateHeaderRows(),this._a11yUpdateFooterRows(),this.__updateFooterPositioning()}__updateFooterPositioning(){this._firefox&&(this.$.items.style.paddingBottom=0,this.heightByRows||(this.$.items.style.paddingBottom=`${this.$.footer.offsetHeight}px`)),this._ios&&!window.CSS.supports("position","sticky")&&(this.$.table.style.height="",this.$.table.style.minHeight="100%",this.$.table.style.maxHeight="100%",setTimeout((()=>this.$.table.style.height=`${this.$.scroller.offsetHeight}px`)))}_updateItem(t,e){t._item=e;const n=this.__getRowModel(t);this._toggleAttribute("selected",n.selected,t),this._a11yUpdateRowSelected(t,n.selected),this._a11yUpdateRowLevel(t,n.level),this._toggleAttribute("expanded",n.expanded,t),(this._rowDetailsTemplate||this.rowDetailsRenderer)&&this._toggleDetailsCell(t,e),this._generateCellClassNames(t,n),this._filterDragAndDrop(t,n),Array.from(t.children).forEach((t=>{if(t._renderer){const e=t._column||this;t._renderer.call(e,t._content,e,n)}else t._instance&&(t._instance.__detailsOpened__=n.detailsOpened,t._instance.__selected__=n.selected,t._instance.__level__=n.level,t._instance.__expanded__=n.expanded,t._instance.setProperties(n))})),this._debouncerUpdateHeights=En.debounce(this._debouncerUpdateHeights,gt.after(1),(()=>{this._updateMetrics(),this._positionItems(),this._updateScrollerSize()}))}_resizeHandler(){this._updateDetailsCellHeights(),this._accessIronListAPI(super._resizeHandler,!0),this._updateScrollerMeasurements(),this.__updateFooterPositioning()}_onAnimationEnd(t){0===t.animationName.indexOf("vaadin-grid-appear")&&(this._render(),t.stopPropagation(),this.notifyResize(),this.__itemsReceived(),requestAnimationFrame((()=>{this.__scrollToPendingIndex(),this.$.table.style.webkitOverflowScrolling="touch"})))}_toggleAttribute(t,e,n){n.hasAttribute(t)===!e&&(e?n.setAttribute(t,""):n.removeAttribute(t))}__getRowModel(t){return{index:t.index,item:t._item,level:this._getIndexLevel(t.index),expanded:this._isExpanded(t._item),selected:this._isSelected(t._item),detailsOpened:!(!this._rowDetailsTemplate&&!this.rowDetailsRenderer)&&this._isDetailsOpened(t._item)}}render(){this._columnTree&&(this._columnTree.forEach((t=>{t.forEach((t=>t._renderHeaderAndFooter()))})),this._update())}notifyResize(){super.notifyResize()}_heightByRowsChanged(t,e){(t||e)&&this.notifyResize()}__forceReflow(){this._debouncerForceReflow=En.debounce(this._debouncerForceReflow,_t,(()=>{this.$.scroller.style.overflow="hidden",setTimeout((()=>this.$.scroller.style.overflow=""))}))}}customElements.define(vDt.is,vDt);let bDt=class extends ye{constructor(){super(...arguments),this._run=""}_csvUrl(t,e,n){return e?OO(n(t,e),{format:"csv"}):""}_jsonUrl(t,e,n){return e?n(t,e):""}_csvName(t,e){return e?`run-${e}-tag-${t}.csv`:""}_jsonName(t,e){return e?`run-${e}-tag-${t}.json`:""}};bDt.template=_e`
    <paper-dropdown-menu
      no-label-float="true"
      label="run to download"
      selected-item-label="{{_run}}"
    >
      <paper-listbox slot="dropdown-content">
        <template is="dom-repeat" items="[[runs]]">
          <paper-item no-label-float="true">[[item]]</paper-item>
        </template>
      </paper-listbox>
    </paper-dropdown-menu>
    <template is="dom-if" if="[[_run]]">
      <a download="[[_csvName(tag, _run)]]" href="[[_csvUrl(tag, _run, urlFn)]]"
        >CSV</a
      ><!--
      --><a
        download="[[_jsonName(tag, _run)]]"
        href="[[_jsonUrl(tag, _run, urlFn)]]"
        >JSON</a
      >
    </template>
    <style>
      :host {
        display: flex;
        align-items: center;
        height: 32px;
      }
      paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }
      a {
        font-size: 10px;
        margin: 0 0.2em;
      }
      paper-input {
        font-size: 22px;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],bDt.prototype,"_run",void 0),t([o({type:Array}),e("design:type",Array)],bDt.prototype,"runs",void 0),t([o({type:String}),e("design:type",String)],bDt.prototype,"tag",void 0),t([o({type:Object}),e("design:type",Object)],bDt.prototype,"urlFn",void 0),bDt=t([i("tf-downloader")],bDt),new URLSearchParams(window.location.search);let xDt=class extends ye{constructor(){super(...arguments),this.colorScale=null,this._loadDataCallback=(t,e,n)=>{if(null==n)return void console.error("Failed to load data for:",e);const i=n.map((t=>({wall_time:new Date(1e3*t[0]),step:t[1],scalar:t[2]}))),r=this._getSeriesNameFromDatum(e);t.setSeriesMetadata(r,e),t.setSeriesData(r,i)},this.getDataLoadUrl=({tag:t,run:e})=>gr().pluginRoute("scalars","/scalars",new URLSearchParams({tag:t,run:e})),this._downloadUrlFn=(t,e)=>this.getDataLoadUrl({tag:t,run:e}),this.requestData=(t,e,n)=>this.inColab?this._requestDataGet(t,e,n):this._requestDataPost(t,e,n),this._requestDataGet=(t,e,n)=>{const i=gr().pluginRoute("scalars","/scalars");Promise.all(t.map((t=>{const n=OO(i,{tag:t.tag,run:t.run});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this._requestDataPost=(t,e,n)=>{var i;const r=gr().pluginRoute("scalars","/scalars_multirun"),o=new Map;for(const{tag:e,run:n}of t){let t=o.get(e);null==t&&o.set(e,t=[]),t.push(n)}const a=null!==(i=this.batchSize)&&void 0!==i?i:64,s=[];for(const[t,e]of o)for(let n=0;n<e.length;n+=a)s.push({tag:t,runs:e.slice(n,n+a)});Promise.all(s.map((({tag:t,runs:n})=>this.requestManager.request(r,{tag:t,runs:n}).then((i=>{for(const r of n){const n={tag:t,run:r};Object.prototype.hasOwnProperty.call(i,r)?e({item:n,data:i[r]}):e({item:n,data:null})}}))))).finally((()=>{n()}))},this._getDataLoadName=t=>this._getSeriesNameFromDatum(t),this._expanded=!1,this._tooltipColumns=(()=>{const t=D_t.slice(),e=t.findIndex((t=>"Name"==t.title));return t.splice(e,1,{title:"Name",evaluate:t=>{const e=t.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(e)}}),t})()}_getChartDataLoader(){return this.shadowRoot.querySelector("tf-line-chart-data-loader")}reload(){this._getChartDataLoader().reload()}redraw(){this._getChartDataLoader().redraw()}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)}_resetDomain(){const t=this._getChartDataLoader();t&&t.resetDomain()}_updateDownloadLink(){const t=this._getChartDataLoader().exportAsSvgString();this.shadowRoot.querySelector("#svgLink").href=`data:image/svg+xml;base64,${btoa(t)}`}_runsFromData(t){return t.map((t=>t.run))}_getDataSeries(){return this.dataToLoad.map((t=>this._getSeriesNameFromDatum(t)))}_getSeriesNameFromDatum({run:t,experiment:e={name:"_default"}}){return JSON.stringify([e.name,t])}_getSeriesDisplayNameFromDatum(t){return t.run}_getColorScale(){return null!==this.colorScale?this.colorScale:{scale:t=>{const[,e]=JSON.parse(t);return xO(e)}}}};xDt.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>
    <div id="tf-line-chart-data-loader-container">
      <tf-line-chart-data-loader
        active="[[active]]"
        color-scale="[[_getColorScale(colorScale)]]"
        data-series="[[_getDataSeries(dataToLoad.*)]]"
        data-to-load="[[dataToLoad]]"
        get-data-load-name="[[_getDataLoadName]]"
        get-data-load-url="[[getDataLoadUrl]]"
        request-data="[[requestData]]"
        ignore-y-outliers="[[ignoreYOutliers]]"
        load-data-callback="[[_loadDataCallback]]"
        load-key="[[tag]]"
        log-scale-active="[[_logScaleActive]]"
        request-manager="[[requestManager]]"
        smoothing-enabled="[[smoothingEnabled]]"
        smoothing-weight="[[smoothingWeight]]"
        tag-metadata="[[tagMetadata]]"
        tooltip-columns="[[_tooltipColumns]]"
        tooltip-position="auto"
        tooltip-sorting-method="[[tooltipSortingMethod]]"
        x-type="[[xType]]"
      >
      </tf-line-chart-data-loader>
    </div>
    <div id="buttons">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        selected$="[[_logScaleActive]]"
        icon="line-weight"
        on-tap="_toggleLogScale"
        title="Toggle y-axis log scale"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Fit domain to data"
      ></paper-icon-button>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <paper-menu-button on-paper-dropdown-open="_updateDownloadLink">
          <paper-icon-button
            class="dropdown-trigger"
            slot="dropdown-trigger"
            icon="file-download"
          ></paper-icon-button>
          <paper-listbox class="dropdown-content" slot="dropdown-content">
            <paper-item>
              <a id="svgLink" download="[[tag]].svg">
                Download Current Chart as SVG
              </a>
            </paper-item>
          </paper-listbox>
        </paper-menu-button>
      </template>
      <span style="flex-grow: 1"></span>
      <template is="dom-if" if="[[showDownloadLinks]]">
        <div class="download-links">
          <tf-downloader
            runs="[[_runsFromData(dataToLoad)]]"
            tag="[[tag]]"
            url-fn="[[_downloadUrlFn]]"
          ></tf-downloader>
        </div>
      </template>
    </div>
    <style>
      :host {
        margin: 5px;
        display: block;
        width: 330px;
      }

      :host([_expanded]) {
        width: 100%;
      }

      :host([_expanded]) #tf-line-chart-data-loader-container {
        height: 400px;
      }

      #tf-line-chart-data-loader-container {
        height: 200px;
        width: 100%;
      }

      tf-card-heading {
        display: block;
        margin-bottom: 10px;
      }

      #buttons {
        display: flex;
        flex-direction: row;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }

      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }

      .download-links {
        display: flex;
        height: 32px;
      }

      .download-links a {
        align-self: center;
        font-size: 10px;
        margin: 2px;
      }

      .download-links paper-dropdown-menu {
        width: 100px;
        --paper-input-container-label: {
          font-size: 10px;
        }
        --paper-input-container-input: {
          font-size: 10px;
        }
      }

      paper-menu-button {
        padding: 0;
      }
      paper-item a {
        color: inherit;
        text-decoration: none;
        white-space: nowrap;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],xDt.prototype,"tag",void 0),t([o({type:Array}),e("design:type",Array)],xDt.prototype,"dataToLoad",void 0),t([o({type:String}),e("design:type",String)],xDt.prototype,"xType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xDt.prototype,"active",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xDt.prototype,"ignoreYOutliers",void 0),t([o({type:Object}),e("design:type",hr)],xDt.prototype,"requestManager",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xDt.prototype,"showDownLinks",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xDt.prototype,"smoothingEnabled",void 0),t([o({type:Number}),e("design:type",Number)],xDt.prototype,"smoothingWeight",void 0),t([o({type:Object}),e("design:type",Object)],xDt.prototype,"tagMetadata",void 0),t([o({type:Object}),e("design:type",Object)],xDt.prototype,"colorScale",void 0),t([o({type:String}),e("design:type",String)],xDt.prototype,"tooltipSortingMethod",void 0),t([o({type:Number}),e("design:type",Number)],xDt.prototype,"batchSize",void 0),t([o({type:Boolean}),e("design:type",Number)],xDt.prototype,"inColab",void 0),t([o({type:Object}),e("design:type",Object)],xDt.prototype,"_loadDataCallback",void 0),t([o({type:Object}),e("design:type",Function)],xDt.prototype,"getDataLoadUrl",void 0),t([o({type:Object}),e("design:type",Object)],xDt.prototype,"_downloadUrlFn",void 0),t([o({type:Object}),e("design:type",Function)],xDt.prototype,"requestData",void 0),t([o({type:Object}),e("design:type",Object)],xDt.prototype,"_getDataLoadName",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],xDt.prototype,"_expanded",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xDt.prototype,"_logScaleActive",void 0),t([o({type:Array}),e("design:type",Array)],xDt.prototype,"_tooltipColumns",void 0),xDt=t([i("tf-scalar-card")],xDt);let wDt=class extends((function t(e,n){return Pr({},tr(n),e)})([go],ye)){constructor(){super(...arguments),this.sessionGroup=null,this._xType=Wgt.STEP,this._noMultiExperiments=!1,this._requestData=(t,e,n)=>{Promise.all(t.map((t=>this.backend.listMetricEvals({experimentName:this.experimentName,sessionName:t.run,metricName:t.tag}).then((n=>{e({item:t,data:n})}))))).finally((()=>{n()}))},this._colorScale={scale:t=>{const e=JSON.parse(t)[1],n=this._indexOfSession.get(e);return gO[(this._sessionGroupNameHash+n)%gO.length]}}}connectedCallback(){super.connectedCallback(),this.addEventListener("iron-resize",this.redraw.bind(this))}redraw(){this.shadowRoot.querySelectorAll("tf-scalar-card").forEach((t=>t.redraw()))}_sessionGroupChanged(){this.sessionGroup&&0!=Object.keys(this.sessionGroup).length?(this._indexOfSession=new Map(this.sessionGroup.sessions.map(((t,e)=>[t.name,e]))),this._sessionGroupNameHash=$Rt(this.sessionGroup.name)):(this._indexOfSession=new Map,this._sessionGroupNameHash=0),this.shadowRoot.querySelectorAll("tf-scalar-card").forEach((t=>{const e=t,n=e.get("tag");e.set("tag",""),e.set("tag",n)}))}_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&this.visibleSchema.metricInfos.length>0}_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()}_computeSeriesForSessionGroupMetric(t,e){return null===t||0==Object.keys(t).length||null===e?[]:t.sessions.filter((t=>void 0!==LRt(t.metricValues,e.name))).map((t=>({tag:e.name,run:t.name})))}_computeTagMetadata(t){return{displayName:MRt(t),description:t.description||""}}};wDt.template=_e`
    <template is="dom-if" if="[[!sessionGroup]]">
      <div>
        <h3>No session group selected</h3>
        <p>Please select a session group to see its metric-graphs here.</p>
      </div>
    </template>
    <template is="dom-if" if="[[!_haveMetrics(visibleSchema.*)]]">
      <div>
        <h3>No metrics are enabled</h3>
        <p>Please enable some metrics to see content here.</p>
      </div>
    </template>
    <div class="layout horizontal wrap session-group-details">
      <template
        is="dom-if"
        if="[[_haveMetricsAndSessionGroup(visibleSchema.*, sessionGroup)]]"
      >
        <template
          is="dom-repeat"
          items="[[visibleSchema.metricInfos]]"
          as="metricInfo"
        >
          <!-- Note that we do not provide a request-manager attribute since
               we provide a function in request-data for calling the backend
               to get the metrics data.
            -->
          <tf-scalar-card
            class="scalar-card"
            color-scale="[[_colorScale]]"
            data-to-load="[[_computeSeriesForSessionGroupMetric(sessionGroup, metricInfo)]]"
            tag="[[metricInfo.name.tag]]"
            tag-metadata="[[_computeTagMetadata(metricInfo)]]"
            x-type="[[_xType]]"
            multi-experiments="[[_noMultiExperiments]]"
            request-data="[[_requestData]]"
            active
          >
          </tf-scalar-card>
        </template>
      </template>
    </div>
    <!-- "iron-flex" is needed to use the layout classes in the div above -->
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],wDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],wDt.prototype,"experimentName",void 0),t([o({type:Object}),e("design:type",Object)],wDt.prototype,"visibleSchema",void 0),t([o({type:Object}),e("design:type",Object)],wDt.prototype,"sessionGroup",void 0),t([o({type:String}),e("design:type",String)],wDt.prototype,"_xType",void 0),t([o({type:Boolean}),e("design:type",Boolean)],wDt.prototype,"_noMultiExperiments",void 0),t([o({type:Object}),e("design:type",Object)],wDt.prototype,"_indexOfSession",void 0),t([o({type:Number}),e("design:type",Number)],wDt.prototype,"_sessionGroupNameHash",void 0),t([o({type:Object}),e("design:type",Function)],wDt.prototype,"_requestData",void 0),t([o({type:Object}),e("design:type",Object)],wDt.prototype,"_colorScale",void 0),t([a("sessionGroup.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],wDt.prototype,"_sessionGroupChanged",null),wDt=t([i("tf-hparams-session-group-details")],wDt);let SDt=class extends(tr(ye)){constructor(){super(...arguments),this._hparamName=SRt,this._metricName=MRt}_visibleSchemaOrSessionGroupsChanged(){const t=this.$.sessionGroupsTable.get("detailsOpenedItems");this.$.sessionGroupsTable.set("detailsOpenedItems",[]),zi();const e=new Map;this.sessionGroups.forEach((t=>{e.set(t.name,t)})),this.$.sessionGroupsTable.set("detailsOpenedItems",t.map((t=>e.get(t.name))).filter(Boolean))}_sessionGroupHParam(t,e){return null!=t&&0!=Object.keys(t).length&&Object.prototype.hasOwnProperty.call(t.hparams,e)?URt(t.hparams[e]):""}_sessionGroupMetric(t,e){if(null==t||0==Object.keys(t).length)return"";for(let n=0;n<t.metricValues.length;++n){let i=t.metricValues[n];if(i.name.group===e.group&&i.name.tag==e.tag)return URt(i.value)}return""}_rowNumber(t){return t+1}};SDt.template=_e`
    <vaadin-grid
      class="session-group-table"
      id="sessionGroupsTable"
      column-reordering-allowed=""
      items="[[sessionGroups]]"
    >
      <vaadin-grid-column flex-grow="0" width="10em" resizable="">
        <template class="header">
          <div class="table-header table-cell">Trial ID</div>
        </template>
        <template>
          <div class="table-cell">[[item.name]]</div>
        </template>
      </vaadin-grid-column>
      <template is="dom-if" if="[[enableShowMetrics]]">
        <vaadin-grid-column flex-grow="0" autoWidth="" resizable="">
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{detailsOpened}}">
            </paper-checkbox>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="[[visibleSchema.hparamInfos]]"
        as="hparamInfo"
        index-as="hparamIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_hparamName(hparamInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupHParam(item, hparamInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template
        is="dom-repeat"
        items="{{visibleSchema.metricInfos}}"
        as="metricInfo"
        index-as="metricIndex"
      >
        <vaadin-grid-column flex-grow="2" width="10em" resizable="">
          <template class="header">
            <div class="table-header table-cell">
              [[_metricName(metricInfo)]]
            </div>
          </template>
          <template>
            <div class="table-cell">
              [[_sessionGroupMetric(item, metricInfo.name)]]
            </div>
          </template>
        </vaadin-grid-column>
      </template>
      <template class="row-details">
        <tf-hparams-session-group-details
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          session-group="[[item]]"
          visible-schema="[[visibleSchema]]"
          class="session-group-details"
        >
        </tf-hparams-session-group-details>
      </template>
    </vaadin-grid>

    <style>
      :host {
        display: inline;
      }
      .table-cell {
        white-space: nowrap;
        text-overflow: ellipsis;
        overflow: hidden;
      }
      .table-header {
        /* line-break overflowing column headers */
        white-space: normal;
        overflow-wrap: break-word;
      }
      .session-group-table {
        height: 100%;
      }
      .session-group-details {
        height: 360px;
        overflow-y: auto;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],SDt.prototype,"visibleSchema",void 0),t([o({type:Array}),e("design:type",Array)],SDt.prototype,"sessionGroups",void 0),t([o({type:Boolean}),e("design:type",Boolean)],SDt.prototype,"enableShowMetrics",void 0),t([o({type:Object}),e("design:type",Object)],SDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],SDt.prototype,"experimentName",void 0),t([a("visibleSchema.*","sessionGroups.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],SDt.prototype,"_visibleSchemaOrSessionGroupsChanged",null),SDt=t([i("tf-hparams-table-view")],SDt);let MDt=class extends ye{constructor(){super(...arguments),this.sessionGroup=null,this.visibleSchema=null}_propertiesArePopulated(t,e){return null!=t&&null!=e}_singletonSessionGroups(t){return null==t?[]:[t]}};function EDt(t,e,n){function i(){if(0===t.length)return[1,2];const[e,n]=Ll(t);return e!==n?[e,n]:e>0?[.5*e,1.5*e]:e<0?[1.5*e,.5*e]:[-1,1]}if("LINEAR"===n)return zM().domain(i()).range([e,0]);if("LOG"===n){const n=i();return n[0]<=0&&n[1]>=0?EDt(t,e,"LINEAR"):WM().domain(n).range([e,0])}if("QUANTILE"===n){const n=20,i=zl(n).map((t=>e-t*e/(n-1)));return 0===t.length&&(t=[1]),tE().domain(we.uniq(t)).range(i)}if("NON_NUMERIC"===n)return SM().domain(we.uniq(t.sort())).range([e,0]).padding(.1);throw RangeError("Unknown scale: "+n)}var TDt,ADt;MDt.template=_e`
    <!-- If sessionGroup or visibleSchema are not populated, do not display
         anything.
      -->
    <template
      is="dom-if"
      if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <!-- Display one row without a "show-metrics" column -->
      <tf-hparams-table-view
        visible-schema="[[visibleSchema]]"
        session-groups="[[_singletonSessionGroups(sessionGroup)]]"
      >
      </tf-hparams-table-view>
    </template>
    <template
      is="dom-if"
      if="[[!_propertiesArePopulated(visibleSchema, sessionGroup)]]"
    >
      <div>Click or hover over a session group to display its values here.</div>
    </template>

    <style>
      :host {
        display: block;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],MDt.prototype,"sessionGroup",void 0),t([o({type:Object}),e("design:type",Object)],MDt.prototype,"visibleSchema",void 0),MDt=t([i("tf-hparams-session-group-values")],MDt),(function(t){t.LINEAR="LINEAR",t.LOG="LOG",t.QUANTILE="QUANTILE",t.NON_NUMERIC="NON_NUMERIC"})(TDt||(TDt={}));class CDt{isPassing(t){return!0}}class kDt{constructor(t,e,n,i){this._lower=t,this._upper=e,this._lowerOpen=n,this._upperOpen=i}isPassing(t){const e=t;return this._before(this._lower,e,!this._lowerOpen)&&this._before(e,this._upper,!this._upperOpen)}_before(t,e,n){return n?t<=e:t<e}}class LDt{constructor(t){this._domainSet=t}isPassing(t){return-1!==this._domainSet.findIndex((e=>e===t))}}class PDt{constructor(t,e,n,i){this._svgProps=t,this._schema=e,this._interactionManager=n,this._colIndex=i,this._isDisplayed=!1,this._yScale=null,this._scaleType=null,this.setBrushSelection(null)}colIndex(){return this._colIndex}yScale(){return this._yScale}scaleType(){return this._scaleType}brushSelection(){return this._brushSelection}isDisplayed(){return this._isDisplayed}setBrushSelection(t){this._brushSelection=t,this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}setDomainAndScale(t,e){this._scaleType=e,this._yScale=EDt(t.slice(),this._svgProps.height,this.scaleType()),this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(t){let e=ac(this.yScale());this.scaleType()===TDt.QUANTILE&&(e=e.tickValues(this.yScale().quantiles()).tickFormat(py("-.6g")));const n=Su(t);n.selectAll("g").remove(),n.append("g").classed("axis",!0).call(e).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text((t=>ERt(this._schema,t))),n.call(vh().on("start",(()=>{t.setAttribute("is-dragging",""),this._interactionManager.onDragStart(this.colIndex())})).on("drag",(()=>this._interactionManager.onDrag(uu.x))).on("end",(()=>{this._interactionManager.onDragEnd(),t.removeAttribute("is-dragging")})));const i=Km().extent([[-8,0],[8,this._svgProps.height+1]]).on("start",(()=>{NDt(uu)&&(t.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex(),uu.selection))})).on("brush",(()=>{NDt(uu)&&this._interactionManager.onBrushChanged(this.colIndex(),uu.selection)})).on("end",(()=>{NDt(uu)&&(this._interactionManager.onBrushChanged(this.colIndex(),uu.selection),t.removeAttribute("is-brushing"))})),r=Su(t).append("g").classed("brush",!0);r.call(i),i.move(r,this.brushSelection())}setDisplayed(t){this._isDisplayed=t}_buildBrushFilter(t,e,n){if(null===t)return new CDt;if(null===e)return console.error("Scale type is null, but brushSelection isn't: ",t),new CDt;switch(e){case TDt.LINEAR:case TDt.LOG:{const[e,i]=(function i(t,e,n){return[t.invert(e),t.invert(n)].sort(((t,e)=>t-e))})(n,t[0],t[1]);return new kDt(e,i,!1,!1)}case TDt.QUANTILE:{const[e,i]=(function r(t,e,n){const i=t.range(),r=i.filter((t=>e<=t&&t<=n)).map((e=>{const n=t.invertExtent(e);return e===i[i.length-1]?[n[0],n[1]+1]:n}));return 0==r.length?[0,0]:Ll(ql(r))})(n,t[0],t[1]);return new kDt(e,i,!1,!0)}case TDt.NON_NUMERIC:return new LDt((function o(t,e,n){return t.domain().filter((i=>{const r=t(i);return e<=r&&r<=n}))})(n,t[0],t[1]))}return console.error("Unknown scale type: ",e),new CDt}}class IDt{constructor(t,e,n){this._svgProps=t,this._schema=e,this._axes=this._createAxes(n),this._stationaryAxesPositions=SM().range([1,this._svgProps.width-1]).padding(.5),this._draggedAxis=null,this._svgProps.svgG.selectAll("g.axis-parent").remove(),this._parentsSel=this._svgProps.svgG.selectAll(".axis-parent")}updateAxes(t,e){console.assert(!this.isAxisDragging());const n=new Set;t.columns.forEach((t=>{const i=t.absoluteIndex;let r=this._axes[i];r.setDisplayed(!0);const o=e.map((t=>NRt(this._schema,t,i)));r.setDomainAndScale(o,t.scale),n.add(i)})),this._axes.forEach((t=>{n.has(t.colIndex())||t.setDisplayed(!1)})),this._updateStationaryAxesPositions(n),this._parentsSel=this._parentsSel.data(Array.from(n),(t=>t)),this._parentsSel.exit().remove(),this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);const i=this;this._parentsSel.call((t=>this._updateAxesPositionsInDOM(t))).each((function(t){i._axes[t].updateDOM(this)}))}mapVisibleAxes(t){return this._stationaryAxesPositions.domain().map((e=>t(this.getAxisPosition(e),this._axes[e])))}allVisibleAxesSatisfy(t){return this._stationaryAxesPositions.domain().every((e=>t(this.getAxisPosition(e),this._axes[e])))}getAxisForColIndex(t){return this._axes[t]}dragStart(t){console.assert(!this.isAxisDragging()),console.assert(this._axes[t].isDisplayed()),this._draggedAxis=this._axes[t],this._draggedAxisPosition=this._stationaryAxesPositions(t)}drag(t){t=Math.min(Math.max(t,0),this._svgProps.width),this._draggedAxisPosition=t;let e=this._stationaryAxesPositions.domain();e.sort(((t,e)=>this.getAxisPosition(t)-this.getAxisPosition(e))),this._stationaryAxesPositions.domain(e),this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(t){console.assert(this.isAxisDragging()),this._draggedAxisPosition=null,this._draggedAxis=null,this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(t))}isAxisDragging(){return null!==this._draggedAxis}getAxisPosition(t){return null!==this._draggedAxis&&this._draggedAxis.colIndex()===t?this._draggedAxisPosition:this._stationaryAxesPositions(t)}_updateStationaryAxesPositions(t){const e=this._stationaryAxesPositions.domain().filter((e=>t.has(e))),n=Array.from(new Set([...e,...Array.from(t)]));this._stationaryAxesPositions.domain(n)}_updateAxesPositionsInDOM(t){t.attr("transform",(t=>YRt(this.getAxisPosition(t))))}_createAxes(t){return zl(CRt(this._schema)).map((e=>new PDt(this._svgProps,this._schema,t,e)))}}function NDt(t){return null!==t.sourceEvent}!(function(t){t[t.FOREGROUND=0]="FOREGROUND",t[t.BACKGROUND=1]="BACKGROUND"})(ADt||(ADt={}));class ODt{constructor(t){void 0===t&&(t=sh(null)),console.assert(t.size()<=1),this._sessionGroupSel=t}sessionGroup(){return 1===this._sessionGroupSel.size()?this._sessionGroupSel.datum():null}isNull(){return null===this.sessionGroup()}selection(){return this._sessionGroupSel}equalsTo(t){return this.isNull()?t.isNull():!t.isNull()&&t.sessionGroup().name==this.sessionGroup().name}}class RDt{constructor(t,e,n){this._svgProps=t,this._schema=e,this._axesCollection=n,this._sessionGroups=[],this._svgProps.svgG.selectAll("g.background").remove(),this._svgProps.svgG.selectAll("g.foreground").remove(),this._bgPathsSel=this._svgProps.svgG.append("g").classed("background",!0).selectAll("path"),this._fgPathsSel=this._svgProps.svgG.append("g").classed("foreground",!0).selectAll("path"),this._updateVisibleFgPathsSel(),this._peakedSessionGroupHandle=new ODt,this._selectedSessionGroupHandle=new ODt,this._d3line=Vk().curve(Bk)}getSessionGroupHandle(t){return null==t?new ODt:new ODt(this._fgPathsSel.filter((e=>e.name===t.name)))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(t,e=0){(t===ADt.FOREGROUND?this._fgPathsSel:this._bgPathsSel).transition().duration(e).attr("d",(t=>this._pathDAttribute(t))),t===ADt.FOREGROUND&&window.setTimeout((()=>{const t=this;this._fgPathsSel.each((function(e){t._setControlPointsProperty(this,e)}))}))}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",(t=>!this._axesCollection.allVisibleAxesSatisfy(((e,n)=>n.brushFilter().isPassing(NRt(this._schema,t,n.colIndex())))))),this._updateVisibleFgPathsSel()}setForegroundLinesColor(t,e,n){const i=this._createLineColorFunction(t,e,n);this._fgPathsSel.attr("stroke",i)}redraw(t,e,n,i){const r=this._peakedSessionGroupHandle.sessionGroup(),o=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=t,this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel),this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel),this._peakedSessionGroupHandle=this.getSessionGroupHandle(r),this._selectedSessionGroupHandle=this.getSessionGroupHandle(o),this.recomputeControlPoints(ADt.FOREGROUND),this.recomputeControlPoints(ADt.BACKGROUND),this.recomputeForegroundLinesVisibility(),this.setForegroundLinesColor(e,n,i)}updatePeakedSessionGroup(t){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1),this._peakedSessionGroupHandle=t,this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new ODt)}updateSelectedSessionGroup(t){this._selectedSessionGroupHandle.selection().classed("selected-path",!1),this._selectedSessionGroupHandle=t,this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(t,e){const n=this._axesCollection.mapVisibleAxes(((t,e)=>t)),i=(function r(t,e,n,i){if(e.length<2)return console.error("Less than two axes in parallel coordinates plot."),null;const r=n[0],o=n[1];if(r<=e[0]||r>=e[e.length-1])return null;const a=we.sortedIndex(e,r);console.assert(a>0),console.assert(a<e.length);const s=a-1;let l=null,c=null;return t.forEach((t=>{const e=(function n(t,e,i,a){const s=t-i,l=e-a,c=r-i,u=o-a,h=(s*c+l*u)/(s*s+l*l);return h<=0?GRt(c,u):h>=1?GRt(t-r,e-o):GRt(c-h*s,u-h*l)})(t.controlPoints[s][0],t.controlPoints[s][1],t.controlPoints[a][0],t.controlPoints[a][1]);e>i||(null===l||e<l)&&(l=e,c=t)})),c})(this._visibleFgPathsSel.nodes(),n,[t,e],100);return null===i?new ODt:new ODt(Su(i))}_createLineColorFunction(t,e,n){if(null===t)return()=>"red";const i=zM().domain(ORt(this._schema,this._sessionGroups,t)).range([e,n]).interpolate(cp);return e=>i(NRt(this._schema,e,t))}_recomputePathSelection(t){return(t=t.data(this._sessionGroups,(t=>t.name))).exit().remove(),t.enter().append("path").merge(t)}_setControlPointsProperty(t,e){t.controlPoints=this._computeControlPoints(e)}_computeControlPoints(t){return this._axesCollection.mapVisibleAxes(((e,n)=>[e,n.yScale()(NRt(this._schema,t,n.colIndex()))]))}_pathDAttribute(t){return this._d3line(this._computeControlPoints(t))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=this._fgPathsSel.filter(":not(.invisible-path)")}}class zDt{constructor(t,e){this.svg=Su(t);const n=100*e+10+10;this.svg.attr("viewBox",`0 0 ${n} 240`),this.svg.attr("preserveAspectRatio","xMidYMid"),this.svg.style("min-width",n+"px"),this.svg.style("min-height","240px"),this.width=n-10-10,this.height=200,this.svgG=this.svg.append("g").attr("transform",YRt(10,30))}}class DDt{constructor(t,e,n,i){this._svgProps=t,this._schema=e,this._peakedSessionGroupChangedCB=n,this._selectedSessionGroupChangedCB=i,this._axesCollection=new IDt(t,e,this),this._linesCollection=new RDt(t,e,this._axesCollection),this._svgProps.svg.on("click",(()=>this.onClick())).on("mousemove mouseenter",(()=>{const[t,e]=ah(this._svgProps.svgG.node());this.onMouseMoved(t,e)})).on("mouseleave",(()=>this.onMouseLeave()))}onDragStart(t){this._axesCollection.dragStart(t),this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t),this._linesCollection.recomputeControlPoints(ADt.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd(500),this._linesCollection.recomputeControlPoints(ADt.FOREGROUND,500),window.setTimeout((()=>{this._linesCollection.recomputeControlPoints(ADt.BACKGROUND),this._linesCollection.showBackgroundLines()}),500)}onBrushChanged(t,e){this._axesCollection.getAxisForColIndex(t).setBrushSelection(e),this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,e){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,e)),this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup())}onMouseLeave(){this._linesCollection.peakedSessionGroupHandle().isNull()||(this._linesCollection.clearPeakedSessionGroup(),this._peakedSessionGroupChangedCB(null))}onClick(){this._linesCollection.peakedSessionGroupHandle().sessionGroup()===this._linesCollection.selectedSessionGroupHandle().sessionGroup()?this._linesCollection.updateSelectedSessionGroup(new ODt):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle()),this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,e){this._axesCollection.updateAxes(t,e);const n=this._linesCollection.peakedSessionGroupHandle(),i=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(e,void 0!==t.colorByColumnIndex?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor),n.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup()),i.equalsTo(this._linesCollection.selectedSessionGroupHandle())||this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}}let BDt=class extends(tr(ye)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this.redrawCount=0}_optionsOrSessionGroupsChanged(){if(!this.options)return;const t=this.options.configuration;if(void 0===this._interactionManager||!we.isEqual(this._interactionManager.schema(),t.schema)){Su(this.$.svg).selectAll("*").remove();const e=new zDt(this.$.svg,CRt(t.schema));this.scopeSubtree(this.$.svg,!0),this._interactionManager=new DDt(e,t.schema,(t=>this.closestSessionGroupChanged(t)),(t=>this.selectedSessionGroupChanged(t)))}this._computeValidSessionGroups(),this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,this._validSessionGroups),this.redrawCount++}closestSessionGroupChanged(t){this.closestSessionGroup=t}selectedSessionGroupChanged(t){this.selectedSessionGroup=t}_computeValidSessionGroups(){const t=KRt;if(void 0===this.sessionGroups)return void(this._validSessionGroups=void 0);const e=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter((n=>{for(let i=0;i<t.numColumns(e);++i)if(this.options.configuration.columnsVisibility[i]&&void 0===t.columnValueByIndex(e,n,i))return!1;return!0}))}};BDt.template=_e`
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      .background path {
        fill: none;
        stroke: #ddd;
        shape-rendering: crispEdges;
      }

      .foreground path {
        fill: none;
        stroke-opacity: 0.7;
        stroke-width: 1;
      }

      /* Will be set on foreground paths that are not "contained" in the current
         axes brushes. If no brushes are set, no path will have this class. */
      .foreground .invisible-path {
        display: none;
      }

      /* Style for the path closest to the mouse pointer (typically will become
      the selected path when the user clicks). */
      .foreground .peaked-path {
        stroke-width: 3;
      }

      /* The currently selected path class. We use !important to override the
         inline style that sets the regular color of a path. */
      .foreground .selected-path {
        stroke-width: 3 !important;
        stroke: #0f0 !important;
      }

      #container {
        height: 100%;
        width: 100%;
      }

      svg {
        width: 100%;
        height: 100%;
      }

      .axis text {
        text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
        fill: #000;
        cursor: move;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],BDt.prototype,"sessionGroups",void 0),t([o({type:Object}),e("design:type",Object)],BDt.prototype,"options",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],BDt.prototype,"selectedSessionGroup",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],BDt.prototype,"closestSessionGroup",void 0),t([o({type:Number}),e("design:type",Number)],BDt.prototype,"redrawCount",void 0),t([o({type:Array}),e("design:type",Array)],BDt.prototype,"_validSessionGroups",void 0),t([o({type:Object}),e("design:type",Object)],BDt.prototype,"_interactionManager",void 0),t([a("options.*","sessionGroups.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],BDt.prototype,"_optionsOrSessionGroupsChanged",null),BDt=t([i("tf-hparams-parallel-coords-plot")],BDt);let HDt=class extends ye{_closestOrSelected(t,e){return null!==t?t:e}};HDt.template=_e`
    <!-- Controls behavior of parallel coordinates plot
         outputs set options to the _options property.
      -->
    <hparams-split-layout orientation="vertical">
      <!-- The scale and color controls. -->
      <tf-hparams-scale-and-color-controls
        id="controls"
        slot="content"
        class="section"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual parallel coordinates plot -->
      <tf-hparams-parallel-coords-plot
        id="plot"
        slot="content"
        class="section"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-parallel-coords-plot>
      <tf-hparams-session-group-values
        id="values"
        slot="content"
        class="section"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <tf-hparams-session-group-details
        id="details"
        slot="content"
        class="section"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>

    <style>
      .section {
        padding: 10px;
      }
      #values {
        height: 115px;
      }
      #details {
        flex-grow: 1;
        max-height: fit-content;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],HDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],HDt.prototype,"experimentName",void 0),t([o({type:Object}),e("design:type",Object)],HDt.prototype,"configuration",void 0),t([o({type:Array}),e("design:type",Array)],HDt.prototype,"sessionGroups",void 0),HDt=t([i("tf-hparams-parallel-coords-view")],HDt);let FDt=class extends(tr(ye)){constructor(){super(...arguments),this.selectedSessionGroup=null,this.closestSessionGroup=null,this._container=null,this._svg=null,this.width=0,this.height=0,this._brushedCellIndex=null,this._brushSelection=null}ready(){super.ready(),this._container=this.$.container,this._svg=Su(this.$.svg),this._redraw()}_sessionGroupsChanged(){null!==this.selectedSessionGroup&&(this.selectedSessionGroup=HRt(this.sessionGroups,this.selectedSessionGroup.name)||null),this._redraw()}_visibleSchemaChanged(){this._brushedCellIndex=null,this._brushSelection=null,this._redraw()}_redraw(){this.debounce("_redraw",(()=>{const t=KRt;this.width=Math.max(150*t.numVisibleColumns(this.visibleSchema),1200),this.height=Math.max(112.5*t.numVisibleMetrics(this.visibleSchema),480),this._container.style.width=this.width+"px",this._container.style.height=this.height+"px",this._svg.attr("width",this.width).attr("height",this.height),this._svg.selectAll("g").remove(),this._draw()}),100)}_draw(){const t=KRt,e=this;if(!this.sessionGroups||0==this.sessionGroups.length||!this.visibleSchema||0==this.visibleSchema.metricInfos.length)return;const n=zl(t.numVisibleColumns(e.visibleSchema)),i=zl(t.numVisibleMetrics(e.visibleSchema)),r=xM().domain(n).range([85,this.width-1-5]).paddingInner(.1),o=xM().domain(i).range([this.height-1-5-50,5]).paddingInner(.1),a=r.bandwidth(),s=o.bandwidth(),l=n.map((t=>e._cellScale(t,[0,a-1]))),c=i.map((n=>e._cellScale(n+t.numVisibleHParams(e.visibleSchema),[s-1,0]))),u=this._svg.selectAll(".x-axis").data(n).enter().append("g").classed("x-axis",!0).attr("transform",(e=>t.translateStr(r(e),0)));function h(t){return"x-axis-clip-path-"+t}function d(t){return"x-label-clip-path-"+t}u.append("clipPath").attr("id",h).append("rect").attr("x",-5).attr("y",0).attr("width",a+10).attr("height",e.height-25),u.append("clipPath").attr("id",d).append("rect").attr("x",0).attr("y",e.height-25).attr("width",a).attr("height",25),u.append("g").attr("clip-path",(t=>"url(#"+h(t)+")")).each((function(t){Su(this).call(g,oc(l[t]).tickSize(e.height-50),a,40,e.options.columns[t].scale)})),u.append("g").classed("x-axis-label",!0).attr("clip-path",(t=>"url(#"+d(t)+")")).append("text").attr("text-anchor","middle").attr("x",a/2).attr("y",e.height-1-12.5).text((n=>t.schemaVisibleColumnName(e.visibleSchema,n))).append("title").text((n=>t.schemaVisibleColumnName(e.visibleSchema,n)));const p=this._svg.selectAll(".y-axis").data(i).enter().append("g").classed("y-axis",!0).attr("transform",(n=>t.translateStr(e.width-1,o(n))));function f(t){return"y-axis-clip-path-"+t}function m(t){return"y-label-clip-path-"+t}function g(t,e,n,i,r){const o=Math.floor(n/i),a=e.scale();if("QUANTILE"===r){let t=a.quantiles();const n=Math.ceil(t.length/o);t=zl(0,t.length,n).map((e=>t[e])),e.tickValues(t).tickFormat(py("-.2g"))}"LINEAR"!==r&&"LOG"!==r||e.ticks(o),t.call(e),t.selectAll(".domain").remove(),t.selectAll(".tick line").attr("stroke","#ddd")}p.append("clipPath").attr("id",f).append("rect").attr("x",-(e.width-40-1)).attr("y",-5).attr("width",e.width-40).attr("height",s+10),p.append("clipPath").attr("id",m).append("rect").attr("x",-(e.width-1)).attr("y",0).attr("width",40).attr("height",s),p.append("g").attr("clip-path",(t=>"url(#"+f(t)+")")).each((function(n){Su(this).call(g,ac(c[n]).tickSize(e.width-80),s,20,e.options.columns[n+t.numVisibleHParams(e.visibleSchema)].scale)})),p.append("g").classed("y-axis-label",!0).attr("clip-path",(t=>"url(#"+m(t)+")")).append("text").attr("text-anchor","middle").attr("x",-(e.width-20-1)).attr("y",s/2).attr("transform",t.rotateStr(90,-(e.width-20-1),s/2)).text((n=>t.metricName(e.visibleSchema.metricInfos[n]))).append("title").text((n=>t.metricName(e.visibleSchema.metricInfos[n])));const _=this._svg.selectAll(".cell").data(Tl(n,i)).enter().append("g").classed("cell",!0).attr("transform",(([e,n])=>t.translateStr(r(e),o(n))));_.append("g").classed("frame",!0).append("rect").attr("x",-5).attr("y",-5).attr("width",a+10).attr("height",s+10).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges");let y=null;void 0!==e.options.colorByColumnIndex&&(y=zM().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(cp));const v=void 0===e.options.colorByColumnIndex?()=>"red":({sessionGroup:t})=>y(this._colValue(t,e.options.colorByColumnIndex));function b(t,n){return l[n](e._colValue(t,n))}function x(t,n){return c[n](e._metricValue(t,n))}const[w,S,M]=(function E(t,r){const o=t.selectAll(".data-marker").data((([t,n])=>e.sessionGroups.filter((i=>void 0!==e._colValue(i,t)&&void 0!==e._metricValue(i,n))).map((e=>({col:t,metric:n,sessionGroup:e,x:b(e,t),y:x(e,n),sessionGroupMarkers:null}))))).enter().append("circle").classed("data-marker",!0).attr("cx",(({x:t})=>t)).attr("cy",(({y:t})=>t)).attr("r",2).attr("fill",r),a=new Map;e.sessionGroups.forEach((t=>{a.set(t,[])})),o.each((function(t){a.get(t.sessionGroup).push(this)})),o.each((t=>{const e=a.get(t.sessionGroup);t.sessionGroupMarkers=new Set(e)}));const s=n.map((t=>i.map((e=>o.filter((n=>n.col==t&&n.metric==e))))));return[o,s,a]})(_.append("g"),v),T=n.map((t=>i.map((e=>(function n(t,e){const n=[];return S[t][e].each((function(){n.push(this)})),P_().x((t=>Su(t).datum().x)).y((t=>Su(t).datum().y)).addAll(n)})(t,e)))));let A=null;I()&&(A=_.filter((t=>we.isEqual(t,e._brushedCellIndex))),console.assert(1==A.size(),A));let C=new Set(w.nodes());function k(){let n=new Set(w.nodes());(function i(){return!I()||e._brushSelection[0][0]===e._brushSelection[1][0]||e._brushSelection[0][1]===e._brushSelection[1][1]})()||(n=(function r(e,n){console.assert(null!==e),console.assert(null!==n);const[i,r]=e,o=new Set;return t.quadTreeVisitPointsInRect(T[i][r],n[0][0],n[0][1],n[1][0],n[1][1],(t=>{Su(t).datum().sessionGroupMarkers.forEach((t=>{o.add(t)}))})),o})(e._brushedCellIndex,e._brushSelection)),sh(Array.from(t.filterSet(n,(t=>!C.has(t))))).attr("fill",v),sh(Array.from(t.filterSet(C,(t=>!n.has(t))))).attr("fill","#ddd"),C=n}k();const L=Zm().extent([[-4,-4],[a-1+5-1,s-1+5-1]]).on("start",(function(){I()&&A.node()!=this&&L.move(A,null),P(this)})).on("brush",(function(){P(this)})).on("end",(function(){P(this)}));function P(t){const n=$m(t);!I()&&null===n||I()&&t===A.node()&&we.isEqual(n,e._brushSelection)||(e._brushSelection=n,null!==n?(A=Su(t),e._brushedCellIndex=A.datum()):(A=null,e._brushedCellIndex=null),k())}function I(){return null!==e._brushedCellIndex&&null!==e._brushSelection}_.call(L),I()&&L.move(A,e._brushSelection);let N=null,O=null;null!==this.selectedSessionGroup&&(O=sh(M.get(this.selectedSessionGroup)).classed("selected-marker",!0)),_.on("click",(function(){const t=N===O?null:N;if(t===O)return;null!==O&&O.classed("selected-marker",!1),O=t,null!==O&&O.classed("selected-marker",!0);const n=null===O?null:O.datum().sessionGroup;e.selectedSessionGroup=n})).on("mousemove mouseenter",(function([n,i]){const[r,o]=ah(this),a=(function s(e,n,i,r,o){let a=1/0,s=null;return t.quadTreeVisitPointsInDisk(T[e][n],i,r,o,((t,e)=>{if(C.has(t)&&e<a){const n=Su(t).datum();a=e,s=n.sessionGroup}})),null===s?null:sh(M.get(s))})(n,i,r,o,20);N!==a&&(null!==N&&N.classed("closest-marker",!1),N=a,null!==N?(N.classed("closest-marker",!0),e.closestSessionGroup=N.datum().sessionGroup):e.closestSessionGroup=null)})).on("mouseleave",(function([t,n]){null!==N&&(N.classed("closest-marker",!1),N=null,e.closestSessionGroup=null)})),this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}_cellScale(t,e){const n=this._colExtent(t),i=zM().domain(n).range(e);if("LINEAR"===this.options.columns[t].scale)return i;if("LOG"===this.options.columns[t].scale)return n[0]<=0&&n[1]>=0?i:WM().domain(n).range(e);if("QUANTILE"===this.options.columns[t].scale){const n=(e[1]-e[0])/19,i=zl(20).map((t=>e[0]+n*t));return tE().domain(we.uniq(this.sessionGroups.map((e=>this._colValue(e,t))))).range(i)}if("NON_NUMERIC"===this.options.columns[t].scale)return SM().domain(we.uniq(this.sessionGroups.map((e=>this._colValue(e,t))).sort())).range(e).padding(.1);throw"Unknown scale for column: "+t+". options: "+this.options}_colValue(t,e){return jRt(this.visibleSchema,t,e)}_metricValue(t,e){return VRt(this.visibleSchema,t,e)}_colExtent(t){return BRt(this.visibleSchema,this.sessionGroups,t)}};FDt.template=_e`
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      /* The closest data point marker to the mouse pointer. We use !important
         to override the inline style that sets the regular style of a marker.
      */
      .closest-marker {
        r: 6 !important;
      }

      /* The currently selected data point marker. We use !important to
         override the inline style that sets the regular style of a marker. */
      .selected-marker {
        r: 6 !important;
        fill: #0f0 !important;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],FDt.prototype,"visibleSchema",void 0),t([o({type:Array}),e("design:type",Array)],FDt.prototype,"sessionGroups",void 0),t([o({type:Object}),e("design:type",Object)],FDt.prototype,"options",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],FDt.prototype,"selectedSessionGroup",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],FDt.prototype,"closestSessionGroup",void 0),t([o({type:Object}),e("design:type",HTMLElement)],FDt.prototype,"_container",void 0),t([o({type:Object}),e("design:type",Object)],FDt.prototype,"_svg",void 0),t([o({type:Number}),e("design:type",Number)],FDt.prototype,"width",void 0),t([o({type:Number}),e("design:type",Number)],FDt.prototype,"height",void 0),t([o({type:Object}),e("design:type",Object)],FDt.prototype,"_brushedCellIndex",void 0),t([o({type:Object}),e("design:type",Object)],FDt.prototype,"_brushSelection",void 0),t([a("sessionGroups.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],FDt.prototype,"_sessionGroupsChanged",null),t([a("visibleSchema.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],FDt.prototype,"_visibleSchemaChanged",null),t([a("options.*"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],FDt.prototype,"_redraw",null),FDt=t([i("tf-hparams-scatter-plot-matrix-plot")],FDt);let VDt=class extends ye{_closestOrSelected(t,e){return null!==t?t:e}};VDt.template=_e`
    <hparams-split-layout orientation="vertical">
      <!-- Controls behavior of the scatter plot matrix
             outputs the configured options to the _options property. -->
      <tf-hparams-scale-and-color-controls
        slot="content"
        class="section"
        id="controls"
        configuration="[[configuration]]"
        session-groups="[[sessionGroups]]"
        options="{{_options}}"
      >
      </tf-hparams-scale-and-color-controls>
      <!-- The actual scatter plot matrix -->
      <tf-hparams-scatter-plot-matrix-plot
        slot="content"
        class="section"
        id="plot"
        visible-schema="[[configuration.visibleSchema]]"
        session-groups="[[sessionGroups]]"
        selected-session-group="{{_selectedGroup}}"
        closest-session-group="{{_closestGroup}}"
        options="[[_options]]"
      >
      </tf-hparams-scatter-plot-matrix-plot>
      <tf-hparams-session-group-values
        slot="content"
        class="section"
        id="values"
        visible-schema="[[configuration.visibleSchema]]"
        session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]"
      >
      </tf-hparams-session-group-values>
      <!-- Shows session group details for the clicked marker. -->
      <tf-hparams-session-group-details
        slot="content"
        class="section"
        id="details"
        backend="[[backend]]"
        experiment-name="[[experimentName]]"
        session-group="[[_selectedGroup]]"
        visible-schema="[[configuration.visibleSchema]]"
      >
      </tf-hparams-session-group-details>
    </hparams-split-layout>
    <style>
      .section {
        padding: 10px;
      }
      #controls {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #plot {
        flex-grow: 1;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 115px;
        overflow-y: auto;
        max-height: fit-content;
      }
      #details {
        flex-grow: 0;
        flex-shrink: 1;
        flex-basis: auto;
        height: auto;
        overflow-y: auto;
        max-height: fit-content;
      }
      vaadin-split-layout {
        height: 100%;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],VDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],VDt.prototype,"experimentName",void 0),t([o({type:Object}),e("design:type",Object)],VDt.prototype,"configuration",void 0),t([o({type:Array}),e("design:type",Array)],VDt.prototype,"sessionGroups",void 0),VDt=t([i("tf-hparams-scatter-plot-matrix-view")],VDt);let jDt=class extends ye{constructor(){super(...arguments),this._selectedTab=0}};jDt.template=_e`
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          <!-- view-id can be used by integration tests to locate a tab.
               It should be the name of the root element implementing the view
               without the 'tf-hparams-' prefix. -->
          <paper-tab view-id="table-view"> TABLE VIEW </paper-tab>
          <paper-tab view-id="parallel-coords-view">
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab view-id="scatter-plot-matrix-view">
            SCATTER PLOT MATRIX VIEW
          </paper-tab>
          <div class="help-and-feedback">
            <template is="dom-if" if="[[bugReportUrl]]">
              <a
                href$="[[bugReportUrl]]"
                target="_blank"
                rel="noopener noreferrer"
              >
                <paper-button
                  id="bug-report"
                  raised
                  title="Send a bug report or feature request"
                >
                  Bug Report / Feature Request
                </paper-button>
              </a>
            </template>
            <template is="dom-if" if="[[helpUrl]]">
              <a href$="[[helpUrl]]" target="_blank" rel="noopener noreferrer">
                <paper-icon-button
                  icon="help-outline"
                  title="View documentation"
                >
                </paper-icon-button>
              </a>
            </template>
          </div>
        </paper-tabs>
      </paper-toolbar>
      <iron-pages selected="[[_selectedTab]]" class="fit tab-view">
        <div id="0" class="tab">
          <tf-hparams-table-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            visible-schema="[[configuration.visibleSchema]]"
            session-groups="[[sessionGroups]]"
            enable-show-metrics
          >
          </tf-hparams-table-view>
        </div>
        <div id="1" class="tab">
          <tf-hparams-parallel-coords-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-parallel-coords-view>
        </div>
        <div id="2" class="tab">
          <tf-hparams-scatter-plot-matrix-view
            backend="[[backend]]"
            experiment-name="[[experimentName]]"
            configuration="[[configuration]]"
            session-groups="[[sessionGroups]]"
          >
          </tf-hparams-scatter-plot-matrix-view>
        </div>
      </iron-pages>
    </paper-header-panel>

    <style>
      .tab-view {
        height: 100%;
      }
      .tab-bar {
        overflow-y: auto;
        color: white;
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
      }
      .tab {
        height: 100%;
      }
      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
        }
      }
      tf-hparams-table-view {
        width: 100%;
        height: 100%;
      }
      .help-and-feedback {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }
      #bug-report {
        border: solid black;
        background: red;
        white-space: normal;
        word-break: break-words;
        font-size: 12px;
        max-width: 150px;
        text-align: left;
      }
      .help-and-feedback a {
        color: white;
        text-decoration: none;
      }
    </style>
  `,t([o({type:Object}),e("design:type",Object)],jDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],jDt.prototype,"helpUrl",void 0),t([o({type:String}),e("design:type",String)],jDt.prototype,"bugReportUrl",void 0),t([o({type:String}),e("design:type",String)],jDt.prototype,"experimentName",void 0),t([o({type:Object}),e("design:type",Object)],jDt.prototype,"configuration",void 0),t([o({type:Array}),e("design:type",Array)],jDt.prototype,"sessionGroups",void 0),t([o({type:Number}),e("design:type",Number)],jDt.prototype,"_selectedTab",void 0),jDt=t([i("tf-hparams-sessions-pane")],jDt);class UDt{constructor(t,e,n=!0){this._apiUrl=t,this._requestManager=e,this._useHttpGet=n}getExperiment(t){return this._sendRequest("experiment",t)}getDownloadUrl(t,e,n){return this._apiUrl+"/download_data?"+new URLSearchParams({format:t,columnsVisibility:JSON.stringify(n),request:JSON.stringify(e)})}listSessionGroups(t){return this._sendRequest("session_groups",t)}listMetricEvals(t){return this._sendRequest("metric_evals",t)}_sendRequest(t,e){if(this._useHttpGet){const n=encodeURIComponent(JSON.stringify(e));return this._requestManager.request(this._apiUrl+"/"+t+"?request="+n)}const n=new ur;return n.withCredentials=!0,n.methodType=cr.POST,n.contentType="text/plain",n.body=JSON.stringify(e),this._requestManager.requestWithOptions(this._apiUrl+"/"+t,n)}}let GDt=class extends(tr(ye)){reload(){this.$["query-pane"].reload()}};GDt.template=_e`
    <hparams-split-layout>
      <div slot="content" class="sidebar">
        <tf-hparams-query-pane
          id="query-pane"
          backend="[[backend]]"
          experiment-name="[[experimentName]]"
          configuration="{{_configuration}}"
          session-groups="{{_sessionGroups}}"
          data-loaded-with-non-empty-hparams="{{_dataLoadedWithNonEmptyHparams}}"
          data-loaded-with-empty-hparams="{{_dataLoadedWithEmptyHparams}}"
        >
        </tf-hparams-query-pane>
      </div>
      <div slot="content" class="center">
        <template is="dom-if" if="[[_dataLoadedWithEmptyHparams]]">
          <div class="no-data-warning">
            <h3>No hparams data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any hparams data to your event files.</li>
              <li>
                Event files are still being loaded (try reloading this page).
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>

        <template is="dom-if" if="[[_dataLoadedWithNonEmptyHparams]]">
          <tf-hparams-sessions-pane
            id="sessions-pane"
            backend="[[backend]]"
            help-url="[[helpUrl]]"
            bug-report-url="[[bugReportUrl]]"
            experiment-name="[[experimentName]]"
            configuration="[[_configuration]]"
            session-groups="[[_sessionGroups]]"
          >
          </tf-hparams-sessions-pane>
        </template>
      </div>
    </hparams-split-layout>
    <style>
      hparams-split-layout {
        width: 100%;
      }

      .sidebar {
        width: 20%;
        height: 100%;
        overflow: auto;
        flex-grow: 0;
        flex-shrink: 0;
        min-width: 10%;
      }

      .center {
        height: 100%;
        overflow-y: auto;
        flex-grow: 1;
        flex-shrink: 1;
        width: 80%;
      }

      :host {
        display: flex;
        flex-direction: row;
        height: 100%;
        width: 100%;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Object}),e("design:type",UDt)],GDt.prototype,"backend",void 0),t([o({type:String}),e("design:type",String)],GDt.prototype,"experimentName",void 0),t([o({type:String}),e("design:type",String)],GDt.prototype,"helpUrl",void 0),t([o({type:String}),e("design:type",String)],GDt.prototype,"bugReportUrl",void 0),t([o({type:Object}),e("design:type",Object)],GDt.prototype,"_configuration",void 0),t([o({type:Array}),e("design:type",Array)],GDt.prototype,"_sessionGroups",void 0),t([o({type:Boolean}),e("design:type",Boolean)],GDt.prototype,"_dataLoadedWithNonEmptyHparams",void 0),t([o({type:Boolean}),e("design:type",Boolean)],GDt.prototype,"_dataLoadedWithEmptyHparams",void 0),GDt=t([i("tf-hparams-main")],GDt);const WDt="true"===new URLSearchParams(window.location.search).get("tensorboardColab");let qDt=class extends(tr(ye)){constructor(){super(...arguments),this._backend=new UDt(gr().pluginRoute("hparams",""),new hr,WDt)}reload(){this.$["hparams-main"].reload()}};qDt.template=_e`
    <!-- TensorBoard does not specify an experimentName. Currently it only
         supports one experiment per invocation. -->
    <tf-hparams-main
      id="hparams-main"
      backend="[[_backend]]"
      experiment-name=""
    >
    </tf-hparams-main>
  `,t([o({type:Object}),e("design:type",Object)],qDt.prototype,"_backend",void 0),qDt=t([i("tf-hparams-dashboard")],qDt);let YDt=class extends(tr(ye)){constructor(){super(...arguments),this.actualSize=!1,this.brightnessAdjustment=.5,this.contrastPercentage=0,this._metadataCanceller=new EO,this._imageCanceller=new EO,this._steps=[],this._isImageLoading=!1}get _runColor(){return xO(this.run)}get _hasAtLeastOneStep(){var t=this._steps;return!!t&&t.length>0}get _hasMultipleSteps(){var t=this._steps;return!!t&&t.length>1}get _currentStep(){return this._steps[this._stepIndex]||null}get _stepValue(){var t=this._currentStep;return t?t.step:0}get _currentWallTime(){var t=this._currentStep;return t?AO(t.wall_time):""}get _maxStepIndex(){return this._steps.length-1}get _sampleText(){return`${this.sample+1}`}get _hasMultipleSamples(){return this.ofSamples>1}_getAriaExpanded(){return this.actualSize?"true":"false"}attached(){this.reload()}reload(){if(!this.isAttached)return;this._metadataCanceller.cancelAll();const t=OO(gr().pluginRoute("images","/images"),{tag:this.tag,run:this.run,sample:this.sample}),e=this._metadataCanceller.cancellable((t=>{if(t.cancelled)return;const e=t.value.map(this._createStepDatum.bind(this));this.set("_steps",e),this.set("_stepIndex",e.length-1)}));this.requestManager.request(t).then(e)}_createStepDatum(t){let e=gr().pluginRoute("images","/individualImage");return e=OO(e,{ts:t.wall_time}),e+="&"+t.query,{wall_time:new Date(1e3*t.wall_time),step:t.step,url:e}}_updateImageUrl(){var t=this._currentStep,e=this.brightnessAdjustment,n=this.contrastPercentage;if(!t)return;const i=new Image;this._imageCanceller.cancelAll(),i.onload=i.onerror=this._imageCanceller.cancellable((t=>{if(t.cancelled)return;const e=this.$$("#main-image-container");e.textContent="",qi(e).appendChild(i),this.set("_isImageLoading",!1)})).bind(this),i.style.filter=`contrast(${n}%) `,i.style.filter+=`brightness(${e})`,this.set("_isImageLoading",!0),i.src=t.url}_handleTap(t){this.set("actualSize",!this.actualSize)}_toLocaleString(t){return t.toLocaleString()}};YDt.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      run="[[run]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
      color="[[_runColor]]"
    >
      <template is="dom-if" if="[[_hasMultipleSamples]]">
        <div>sample: [[_sampleText]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[_toLocaleString(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right datetime">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isImageLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_maxStepIndex]]"
            max-markers="[[_maxStepIndex]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>

    <!-- Semantically a button but <img> inside a <button> disallows user to do
    an interesting operation like "Copy Image" in non-Chromium browsers. -->
    <a
      id="main-image-container"
      role="button"
      aria-label="Toggle actual size"
      aria-expanded$="[[_getAriaExpanded(actualSize)]]"
      on-tap="_handleTap"
    ></a>

    <style include="tf-card-heading-style">
      /** Make button a div. */
      button {
        width: 100%;
        display: block;
        background: none;
        border: 0;
        padding: 0;
      }

      /** Firefox: Get rid of dotted line inside button. */
      button::-moz-focus-inner {
        border: 0;
        padding: 0;
      }

      /** Firefox: Simulate Chrome's outer glow on button when focused. */
      button:-moz-focusring {
        outline: none;
        box-shadow: 0px 0px 1px 2px Highlight;
      }

      :host {
        display: block;
        width: 350px;
        height: auto;
        position: relative;
        margin: 0 15px 40px 0;
        overflow-x: auto;
      }

      /** When actual size shown is on, use the actual image width. */
      :host([actual-size]) {
        max-width: 100%;
        width: auto;
      }

      :host([actual-size]) #main-image-container {
        max-height: none;
        width: auto;
      }

      :host([actual-size]) #main-image-container img {
        width: auto;
      }

      paper-spinner-lite {
        width: 14px;
        height: 14px;
        vertical-align: text-bottom;
        --paper-spinner-color: var(--tb-orange-strong);
      }

      #steps {
        height: 15px;
        margin: 0 0 0 -15px;
        /*
         * 31 comes from adding a padding of 15px from both sides of the
         * paper-slider, subtracting 1px so that the slider width aligns
         * with the image (the last slider marker takes up 1px), and
         * adding 2px to account for a border of 1px on both sides of
         * the image. 30 - 1 + 2.
         */
        width: calc(100% + 31px);
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }

      #main-image-container {
        max-height: 1024px;
        overflow: auto;
      }

      #main-image-container img {
        cursor: pointer;
        display: block;
        image-rendering: -moz-crisp-edges;
        image-rendering: pixelated;
        width: 100%;
        height: auto;
      }

      paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      [hidden] {
        display: none;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],YDt.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],YDt.prototype,"tag",void 0),t([o({type:Number}),e("design:type",Number)],YDt.prototype,"sample",void 0),t([o({type:Number}),e("design:type",Number)],YDt.prototype,"ofSamples",void 0),t([o({type:Object}),e("design:type",Object)],YDt.prototype,"tagMetadata",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],YDt.prototype,"actualSize",void 0),t([o({type:Number}),e("design:type",Number)],YDt.prototype,"brightnessAdjustment",void 0),t([o({type:Number}),e("design:type",Number)],YDt.prototype,"contrastPercentage",void 0),t([o({type:Object}),e("design:type",hr)],YDt.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",Object)],YDt.prototype,"_metadataCanceller",void 0),t([o({type:Object}),e("design:type",Object)],YDt.prototype,"_imageCanceller",void 0),t([o({type:Array,notify:!0}),e("design:type",Array)],YDt.prototype,"_steps",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],YDt.prototype,"_stepIndex",void 0),t([o({type:Boolean}),e("design:type",Boolean)],YDt.prototype,"_isImageLoading",void 0),t([s("run"),e("design:type",String),e("design:paramtypes",[])],YDt.prototype,"_runColor",null),t([s("_steps"),e("design:type",Boolean),e("design:paramtypes",[])],YDt.prototype,"_hasAtLeastOneStep",null),t([s("_steps"),e("design:type",Boolean),e("design:paramtypes",[])],YDt.prototype,"_hasMultipleSteps",null),t([s("_steps","_stepIndex"),e("design:type",Object),e("design:paramtypes",[])],YDt.prototype,"_currentStep",null),t([s("_currentStep"),e("design:type",Number),e("design:paramtypes",[])],YDt.prototype,"_stepValue",null),t([s("_currentStep"),e("design:type",String),e("design:paramtypes",[])],YDt.prototype,"_currentWallTime",null),t([s("_steps"),e("design:type",Number),e("design:paramtypes",[])],YDt.prototype,"_maxStepIndex",null),t([s("sample"),e("design:type",String),e("design:paramtypes",[])],YDt.prototype,"_sampleText",null),t([s("ofSamples"),e("design:type",Boolean),e("design:paramtypes",[])],YDt.prototype,"_hasMultipleSamples",null),t([a("run","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],YDt.prototype,"reload",null),t([a("_currentStep","brightnessAdjustment","contrastPercentage"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],YDt.prototype,"_updateImageUrl",null),YDt=t([i("tf-image-loader")],YDt);let XDt=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._defaultBrightnessAdjustment=1,this._defaultContrastPercentage=100,this._brightnessAdjustment=1,this._contrastPercentage=100,this._requestManager=new hr}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadImages()}))}_fetchTags(){const t=gr().pluginRoute("images","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=or(we.mapValues(t,(t=>Object.keys(t))));this.set("_dataNotFound",0===e.length),this.set("_runToTagInfo",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadImages(){this.root.querySelectorAll("tf-image-loader").forEach((t=>{t.reload()}))}_shouldOpen(t){return t<=2}_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment}_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage}get _brightnessIsDefault(){return this._brightnessAdjustment===this._defaultBrightnessAdjustment}get _contrastIsDefault(){return this._contrastPercentage===this._defaultContrastPercentage}get _categories(){var t=this._runToTagInfo,e=this._selectedRuns,n=this._tagFilter;function i(e){const n=t[e.run][e.tag].samples;return we.range(n).map((t=>Object.assign({},e,{sample:t,ofSamples:n})))}return Sr(we.mapValues(t,(t=>Object.keys(t))),e,n).map((t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(i))})))}_tagMetadata(t,e,n){return t[e][n]}};var $Dt,KDt,ZDt;XDt.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox checked="{{_actualSize}}"
                >Show actual image size</paper-checkbox
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Brightness adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="2"
                snaps
                pin
                step="0.01"
                value="{{_brightnessAdjustment}}"
                immediate-value="{{_brightnessAdjustment}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetBrightness"
                disabled="[[_brightnessIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
          <div class="sidebar-section">
            <h3 class="tooltip-container">Contrast adjustment</h3>
            <div class="resettable-slider-container">
              <paper-slider
                min="0"
                max="500"
                snaps
                pin
                step="1"
                value="{{_contrastPercentage}}"
                immediate-value="{{_contrastPercentage}}"
              ></paper-slider>
              <paper-button
                class="x-button"
                on-tap="_resetContrast"
                disabled="[[_contrastIsDefault]]"
                >Reset</paper-button
              >
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector
            id="runs-selector"
            selected-runs="{{_selectedRuns}}"
          ></tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No image data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any image data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-image-loader
                  active="[[active]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.run, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  actual-size="[[_actualSize]]"
                  brightness-adjustment="[[_brightnessAdjustment]]"
                  contrast-percentage="[[_contrastPercentage]]"
                ></tf-image-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .resettable-slider-container {
        display: flex;
      }
      .resettable-slider-container paper-slider {
        flex-grow: 1;
      }
      .resettable-slider-container paper-button {
        flex-grow: 0;
      }
      .resettable-slider-container paper-button[disabled] {
        background-color: unset;
      }
      .x-button {
        font-size: 13px;
        background-color: var(--tb-ui-light-accent);
        color: var(--tb-ui-dark-accent);
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-slider {
        --paper-slider-active-color: var(--tb-orange-strong);
        --paper-slider-knob-color: var(--tb-orange-strong);
        --paper-slider-knob-start-border-color: var(--tb-orange-strong);
        --paper-slider-knob-start-color: var(--tb-orange-strong);
        --paper-slider-markers-color: var(--tb-orange-strong);
        --paper-slider-pin-color: var(--tb-orange-strong);
        --paper-slider-pin-start-color: var(--tb-orange-strong);
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],XDt.prototype,"reloadOnReady",void 0),t([o({type:Array}),e("design:type",Array)],XDt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],XDt.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],XDt.prototype,"_dataNotFound",void 0),t([o({type:Boolean}),e("design:type",Boolean)],XDt.prototype,"_actualSize",void 0),t([o({type:Number}),e("design:type",Number)],XDt.prototype,"_defaultBrightnessAdjustment",void 0),t([o({type:Number}),e("design:type",Number)],XDt.prototype,"_defaultContrastPercentage",void 0),t([o({type:Number}),e("design:type",Number)],XDt.prototype,"_brightnessAdjustment",void 0),t([o({type:Number}),e("design:type",Number)],XDt.prototype,"_contrastPercentage",void 0),t([o({type:String}),e("design:type",String)],XDt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],XDt.prototype,"_categoriesDomReady",void 0),t([o({type:Object}),e("design:type",Object)],XDt.prototype,"_requestManager",void 0),t([s("_brightnessAdjustment"),e("design:type",Boolean),e("design:paramtypes",[])],XDt.prototype,"_brightnessIsDefault",null),t([s("_contrastPercentage"),e("design:type",Boolean),e("design:paramtypes",[])],XDt.prototype,"_contrastIsDefault",null),t([s("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Array),e("design:paramtypes",[])],XDt.prototype,"_categories",null),XDt=t([i("tf-image-dashboard")],XDt),(function(t){t[t.CANCELLED=1]="CANCELLED"})($Dt||($Dt={})),(function(t){t[t.VERTEX=1]="VERTEX",t[t.FACE=2]="FACE",t[t.COLOR=3]="COLOR"})(KDt||(KDt={})),(function(t){t.VERTEX="float32",t.FACE="int32",t.COLOR="uint8"})(ZDt||(ZDt={}));class JDt{constructor(t){this._canceller=new EO,this._requestManager=t}reload(t,e,n){return this._canceller.cancelAll(),this._fetchMetadata(t,e,n)}_fetchDataByStep(t,e,n,i,r,o){const a=gr().pluginRoute("mesh","/data",new URLSearchParams({tag:e,run:t,content_type:n,sample:String(i),step:String(r)})),s=function(t){let e=[];for(let n=0;n<t.length/3;n++){let i=[];for(let e=0;e<3;e++)i.push(t[3*n+e]);e.push(i)}return e},l=this._canceller.cancellable((t=>{if(t.cancelled)return Promise.reject({code:$Dt.CANCELLED,message:"Response was invalidated."});let e=t.value;switch(n){case"VERTEX":o.vertices=s(new Float32Array(e));break;case"FACE":o.faces=s(new Int32Array(e));break;case"COLOR":o.colors=s(new Uint8Array(e))}return o}));return this._requestManager.fetch(a,{method:"GET",headers:{responseType:"arraybuffer",contentType:ZDt[n]}}).then((t=>t.arrayBuffer())).then(l)}fetchData(t,e,n,i){let r=[],o=new Map;return Object.keys(KDt).forEach((a=>{t.components&1<<KDt[a]&&r.push(this._fetchDataByStep(e,n,a,i,t.step,o))})),Promise.all(r)}_fetchMetadata(t,e,n){this._canceller.cancelAll();const i=gr().pluginRoute("mesh","/meshes",new URLSearchParams({tag:e,run:t,sample:n})),r=this._canceller.cancellable((t=>t.cancelled?Promise.reject({code:$Dt.CANCELLED,message:"Response was invalidated."}):t.value));return this._requestManager.fetch(i).then((t=>t.json())).then(r).then(this._processMetadata.bind(this))}_processMetadata(t){if(!t)return;const e=new Map;for(let n=0;n<t.length;n++){let i=t[n];e.has(i.step)||e.set(i.step,[]),e.get(i.step).push(i)}let n=[];return e.forEach((t=>{let e=this._createStepDatum(t[0]);n.push(e)})),n}_createStepDatum(t){return{wall_time:new Date(1e3*t.wall_time),step:t.step,config:t.config,content_type:t.content_type,components:t.components}}}const QDt="125",tBt={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2},eBt={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3},nBt=100,iBt=300,rBt=301,oBt=302,aBt=303,sBt=304,lBt=306,cBt=307,uBt=1e3,hBt=1001,dBt=1002,pBt=1003,fBt=1004,mBt=1005,gBt=1006,_Bt=1007,yBt=1008,vBt=1009,bBt=1012,xBt=1014,wBt=1015,SBt=1016,MBt=1020,EBt=1022,TBt=1023,ABt=1026,CBt=1027,kBt=33776,LBt=33777,PBt=33778,IBt=33779,NBt=35840,OBt=35841,RBt=35842,zBt=35843,DBt=37492,BBt=37496,HBt=2300,FBt=2301,VBt=2302,jBt=2400,UBt=2401,GBt=2402,WBt=2500,qBt=2501,YBt=3e3,XBt=3001,$Bt=3007,KBt=3002,ZBt=3004,JBt=3005,QBt=3006,tHt=7680,eHt=35044,nHt=35048,iHt="300 es";function rHt(){}Object.assign(rHt.prototype,{addEventListener:function(t,e){void 0===this._listeners&&(this._listeners={});const n=this._listeners;void 0===n[t]&&(n[t]=[]),-1===n[t].indexOf(e)&&n[t].push(e)},hasEventListener:function(t,e){if(void 0===this._listeners)return!1;const n=this._listeners;return void 0!==n[t]&&-1!==n[t].indexOf(e)},removeEventListener:function(t,e){if(void 0===this._listeners)return;const n=this._listeners[t];if(void 0!==n){const t=n.indexOf(e);-1!==t&&n.splice(t,1)}},dispatchEvent:function(t){if(void 0===this._listeners)return;const e=this._listeners[t.type];if(void 0!==e){t.target=this;const n=e.slice(0);for(let e=0,i=n.length;e<i;e++)n[e].call(this,t)}}});const oHt=[];for(let t=0;t<256;t++)oHt[t]=(t<16?"0":"")+t.toString(16);let aHt=1234567;const sHt={DEG2RAD:Math.PI/180,RAD2DEG:180/Math.PI,generateUUID:function(){const t=4294967295*Math.random()|0,e=4294967295*Math.random()|0,n=4294967295*Math.random()|0,i=4294967295*Math.random()|0;return(oHt[255&t]+oHt[t>>8&255]+oHt[t>>16&255]+oHt[t>>24&255]+"-"+oHt[255&e]+oHt[e>>8&255]+"-"+oHt[e>>16&15|64]+oHt[e>>24&255]+"-"+oHt[63&n|128]+oHt[n>>8&255]+"-"+oHt[n>>16&255]+oHt[n>>24&255]+oHt[255&i]+oHt[i>>8&255]+oHt[i>>16&255]+oHt[i>>24&255]).toUpperCase()},clamp:function(t,e,n){return Math.max(e,Math.min(n,t))},euclideanModulo:function(t,e){return(t%e+e)%e},mapLinear:function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},lerp:function(t,e,n){return(1-n)*t+n*e},damp:function(t,e,n,i){return sHt.lerp(t,e,1-Math.exp(-n*i))},pingpong:function(t,e=1){return e-Math.abs(sHt.euclideanModulo(t,2*e)-e)},smoothstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*(3-2*t)},smootherstep:function(t,e,n){return t<=e?0:t>=n?1:(t=(t-e)/(n-e))*t*t*(t*(6*t-15)+10)},randInt:function(t,e){return t+Math.floor(Math.random()*(e-t+1))},randFloat:function(t,e){return t+Math.random()*(e-t)},randFloatSpread:function(t){return t*(.5-Math.random())},seededRandom:function(t){return void 0!==t&&(aHt=t%2147483647),aHt=16807*aHt%2147483647,(aHt-1)/2147483646},degToRad:function(t){return t*sHt.DEG2RAD},radToDeg:function(t){return t*sHt.RAD2DEG},isPowerOfTwo:function(t){return 0==(t&t-1)&&0!==t},ceilPowerOfTwo:function(t){return Math.pow(2,Math.ceil(Math.log(t)/Math.LN2))},floorPowerOfTwo:function(t){return Math.pow(2,Math.floor(Math.log(t)/Math.LN2))},setQuaternionFromProperEuler:function(t,e,n,i,r){const o=Math.cos,a=Math.sin,s=o(n/2),l=a(n/2),c=o((e+i)/2),u=a((e+i)/2),h=o((e-i)/2),d=a((e-i)/2),p=o((i-e)/2),f=a((i-e)/2);switch(r){case"XYX":t.set(s*u,l*h,l*d,s*c);break;case"YZY":t.set(l*d,s*u,l*h,s*c);break;case"ZXZ":t.set(l*h,l*d,s*u,s*c);break;case"XZX":t.set(s*u,l*f,l*p,s*c);break;case"YXY":t.set(l*p,s*u,l*f,s*c);break;case"ZYZ":t.set(l*f,l*p,s*u,s*c);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+r)}}};class lHt{constructor(t=0,e=0){Object.defineProperty(this,"isVector2",{value:!0}),this.x=t,this.y=e}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,e){return this.x=t,this.y=e,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){const e=this.x,n=this.y,i=t.elements;return this.x=i[0]*e+i[3]*n+i[6],this.y=i[1]*e+i[4]*n+i[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y;return e*e+n*n}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t}fromBufferAttribute(t,e,n){return void 0!==n&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this}rotateAround(t,e){const n=Math.cos(e),i=Math.sin(e),r=this.x-t.x,o=this.y-t.y;return this.x=r*n-o*i+t.x,this.y=r*i+o*n+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}}class cHt{constructor(){Object.defineProperty(this,"isMatrix3",{value:!0}),this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,e,n,i,r,o,a,s,l){const c=this.elements;return c[0]=t,c[1]=i,c[2]=a,c[3]=e,c[4]=r,c[5]=s,c[6]=n,c[7]=o,c[8]=l,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}clone(){return(new this.constructor).fromArray(this.elements)}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],this}extractBasis(t,e,n){return t.setFromMatrix3Column(this,0),e.setFromMatrix3Column(this,1),n.setFromMatrix3Column(this,2),this}setFromMatrix4(t){const e=t.elements;return this.set(e[0],e[4],e[8],e[1],e[5],e[9],e[2],e[6],e[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,o=n[0],a=n[3],s=n[6],l=n[1],c=n[4],u=n[7],h=n[2],d=n[5],p=n[8],f=i[0],m=i[3],g=i[6],_=i[1],y=i[4],v=i[7],b=i[2],x=i[5],w=i[8];return r[0]=o*f+a*_+s*b,r[3]=o*m+a*y+s*x,r[6]=o*g+a*v+s*w,r[1]=l*f+c*_+u*b,r[4]=l*m+c*y+u*x,r[7]=l*g+c*v+u*w,r[2]=h*f+d*_+p*b,r[5]=h*m+d*y+p*x,r[8]=h*g+d*v+p*w,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=t,e[4]*=t,e[7]*=t,e[2]*=t,e[5]*=t,e[8]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],o=t[4],a=t[5],s=t[6],l=t[7],c=t[8];return e*o*c-e*a*l-n*r*c+n*a*s+i*r*l-i*o*s}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],o=t[4],a=t[5],s=t[6],l=t[7],c=t[8],u=c*o-a*l,h=a*s-c*r,d=l*r-o*s,p=e*u+n*h+i*d;if(0===p)return this.set(0,0,0,0,0,0,0,0,0);const f=1/p;return t[0]=u*f,t[1]=(i*l-c*n)*f,t[2]=(a*n-i*o)*f,t[3]=h*f,t[4]=(c*e-i*s)*f,t[5]=(i*r-a*e)*f,t[6]=d*f,t[7]=(n*s-l*e)*f,t[8]=(o*e-n*r)*f,this}transpose(){let t;const e=this.elements;return t=e[1],e[1]=e[3],e[3]=t,t=e[2],e[2]=e[6],e[6]=t,t=e[5],e[5]=e[7],e[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).copy(this).invert().transpose()}transposeIntoArray(t){const e=this.elements;return t[0]=e[0],t[1]=e[3],t[2]=e[6],t[3]=e[1],t[4]=e[4],t[5]=e[7],t[6]=e[2],t[7]=e[5],t[8]=e[8],this}setUvTransform(t,e,n,i,r,o,a){const s=Math.cos(r),l=Math.sin(r);return this.set(n*s,n*l,-n*(s*o+l*a)+o+t,-i*l,i*s,-i*(-l*o+s*a)+a+e,0,0,1),this}scale(t,e){const n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=e,n[4]*=e,n[7]*=e,this}rotate(t){const e=Math.cos(t),n=Math.sin(t),i=this.elements,r=i[0],o=i[3],a=i[6],s=i[1],l=i[4],c=i[7];return i[0]=e*r+n*s,i[3]=e*o+n*l,i[6]=e*a+n*c,i[1]=-n*r+e*s,i[4]=-n*o+e*l,i[7]=-n*a+e*c,this}translate(t,e){const n=this.elements;return n[0]+=t*n[2],n[3]+=t*n[5],n[6]+=t*n[8],n[1]+=e*n[2],n[4]+=e*n[5],n[7]+=e*n[8],this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<9;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<9;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t}}let uHt;const hHt={getDataURL:function(t){if(/^data:/i.test(t.src))return t.src;if("undefined"==typeof HTMLCanvasElement)return t.src;let e;if(t instanceof HTMLCanvasElement)e=t;else{void 0===uHt&&(uHt=document.createElementNS("http://www.w3.org/1999/xhtml","canvas")),uHt.width=t.width,uHt.height=t.height;const n=uHt.getContext("2d");t instanceof ImageData?n.putImageData(t,0,0):n.drawImage(t,0,0,t.width,t.height),e=uHt}return e.width>2048||e.height>2048?e.toDataURL("image/jpeg",.6):e.toDataURL("image/png")}};let dHt=0;function pHt(t=pHt.DEFAULT_IMAGE,e=pHt.DEFAULT_MAPPING,n=1001,i=1001,r=1006,o=1008,a=1023,s=1009,l=1,c=3e3){Object.defineProperty(this,"id",{value:dHt++}),this.uuid=sHt.generateUUID(),this.name="",this.image=t,this.mipmaps=[],this.mapping=e,this.wrapS=n,this.wrapT=i,this.magFilter=r,this.minFilter=o,this.anisotropy=l,this.format=a,this.internalFormat=null,this.type=s,this.offset=new lHt(0,0),this.repeat=new lHt(1,1),this.center=new lHt(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new cHt,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=c,this.version=0,this.onUpdate=null}function fHt(t){return"undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap?hHt.getDataURL(t):t.data?{data:Array.prototype.slice.call(t.data),width:t.width,height:t.height,type:t.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}pHt.DEFAULT_IMAGE=void 0,pHt.DEFAULT_MAPPING=iBt,pHt.prototype=Object.assign(Object.create(rHt.prototype),{constructor:pHt,isTexture:!0,updateMatrix:function(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)},clone:function(){return(new this.constructor).copy(this)},copy:function(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this},toJSON:function(t){const e=void 0===t||"string"==typeof t;if(!e&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];const n={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){const i=this.image;if(void 0===i.uuid&&(i.uuid=sHt.generateUUID()),!e&&void 0===t.images[i.uuid]){let e;if(Array.isArray(i)){e=[];for(let t=0,n=i.length;t<n;t++)e.push(fHt(i[t].isDataTexture?i[t].image:i[t]))}else e=fHt(i);t.images[i.uuid]={uuid:i.uuid,url:e}}n.image=i.uuid}return e||(t.textures[this.uuid]=n),n},dispose:function(){this.dispatchEvent({type:"dispose"})},transformUv:function(t){if(this.mapping!==iBt)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case uBt:t.x=t.x-Math.floor(t.x);break;case hBt:t.x=t.x<0?0:1;break;case dBt:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case uBt:t.y=t.y-Math.floor(t.y);break;case hBt:t.y=t.y<0?0:1;break;case dBt:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}}),Object.defineProperty(pHt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}});class mHt{constructor(t=0,e=0,n=0,i=1){Object.defineProperty(this,"isVector4",{value:!0}),this.x=t,this.y=e,this.z=n,this.w=i}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,e,n,i){return this.x=t,this.y=e,this.z=n,this.w=i,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this.w=t.w+e.w,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this.w+=t.w*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this.w=t.w-e.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=this.w,o=t.elements;return this.x=o[0]*e+o[4]*n+o[8]*i+o[12]*r,this.y=o[1]*e+o[5]*n+o[9]*i+o[13]*r,this.z=o[2]*e+o[6]*n+o[10]*i+o[14]*r,this.w=o[3]*e+o[7]*n+o[11]*i+o[15]*r,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);const e=Math.sqrt(1-t.w*t.w);return e<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/e,this.y=t.y/e,this.z=t.z/e),this}setAxisAngleFromRotationMatrix(t){let e,n,i,r;const o=.01,a=.1,s=t.elements,l=s[0],c=s[4],u=s[8],h=s[1],d=s[5],p=s[9],f=s[2],m=s[6],g=s[10];if(Math.abs(c-h)<o&&Math.abs(u-f)<o&&Math.abs(p-m)<o){if(Math.abs(c+h)<a&&Math.abs(u+f)<a&&Math.abs(p+m)<a&&Math.abs(l+d+g-3)<a)return this.set(1,0,0,0),this;e=Math.PI;const t=(l+1)/2,s=(d+1)/2,_=(g+1)/2,y=(c+h)/4,v=(u+f)/4,b=(p+m)/4;return t>s&&t>_?t<o?(n=0,i=.707106781,r=.707106781):(n=Math.sqrt(t),i=y/n,r=v/n):s>_?s<o?(n=.707106781,i=0,r=.707106781):(i=Math.sqrt(s),n=y/i,r=b/i):_<o?(n=.707106781,i=.707106781,r=0):(r=Math.sqrt(_),n=v/r,i=b/r),this.set(n,i,r,e),this}let _=Math.sqrt((m-p)*(m-p)+(u-f)*(u-f)+(h-c)*(h-c));return Math.abs(_)<.001&&(_=1),this.x=(m-p)/_,this.y=(u-f)/_,this.z=(h-c)/_,this.w=Math.acos((l+d+g-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this.w=Math.max(t.w,Math.min(e.w,this.w)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this.w=Math.max(t,Math.min(e,this.w)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this.w+=(t.w-this.w)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this.z=t.z+(e.z-t.z)*n,this.w=t.w+(e.w-t.w)*n,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this.w=t[e+3],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t[e+3]=this.w,t}fromBufferAttribute(t,e,n){return void 0!==n&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this.w=t.getW(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}}class gHt extends rHt{constructor(t,e,n){super(),Object.defineProperty(this,"isWebGLRenderTarget",{value:!0}),this.width=t,this.height=e,this.scissor=new mHt(0,0,t,e),this.scissorTest=!1,this.viewport=new mHt(0,0,t,e),this.texture=new pHt(void 0,(n=n||{}).mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture.image={},this.texture.image.width=t,this.texture.image.height=e,this.texture.generateMipmaps=void 0!==n.generateMipmaps&&n.generateMipmaps,this.texture.minFilter=void 0!==n.minFilter?n.minFilter:gBt,this.depthBuffer=void 0===n.depthBuffer||n.depthBuffer,this.stencilBuffer=void 0!==n.stencilBuffer&&n.stencilBuffer,this.depthTexture=void 0!==n.depthTexture?n.depthTexture:null}setSize(t,e){this.width===t&&this.height===e||(this.width=t,this.height=e,this.texture.image.width=t,this.texture.image.height=e,this.dispose()),this.viewport.set(0,0,t,e),this.scissor.set(0,0,t,e)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}}class _Ht{constructor(t=0,e=0,n=0,i=1){Object.defineProperty(this,"isQuaternion",{value:!0}),this._x=t,this._y=e,this._z=n,this._w=i}static slerp(t,e,n,i){return n.copy(t).slerp(e,i)}static slerpFlat(t,e,n,i,r,o,a){let s=n[i+0],l=n[i+1],c=n[i+2],u=n[i+3];const h=r[o+0],d=r[o+1],p=r[o+2],f=r[o+3];if(u!==f||s!==h||l!==d||c!==p){let t=1-a;const e=s*h+l*d+c*p+u*f,n=e>=0?1:-1,i=1-e*e;if(i>Number.EPSILON){const r=Math.sqrt(i),o=Math.atan2(r,e*n);t=Math.sin(t*o)/r,a=Math.sin(a*o)/r}const r=a*n;if(s=s*t+h*r,l=l*t+d*r,c=c*t+p*r,u=u*t+f*r,t===1-a){const t=1/Math.sqrt(s*s+l*l+c*c+u*u);s*=t,l*=t,c*=t,u*=t}}t[e]=s,t[e+1]=l,t[e+2]=c,t[e+3]=u}static multiplyQuaternionsFlat(t,e,n,i,r,o){const a=n[i],s=n[i+1],l=n[i+2],c=n[i+3],u=r[o],h=r[o+1],d=r[o+2],p=r[o+3];return t[e]=a*p+c*u+s*d-l*h,t[e+1]=s*p+c*h+l*u-a*d,t[e+2]=l*p+c*d+a*h-s*u,t[e+3]=c*p-a*u-s*h-l*d,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,e,n,i){return this._x=t,this._y=e,this._z=n,this._w=i,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,e){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");const n=t._x,i=t._y,r=t._z,o=t._order,a=Math.cos,s=Math.sin,l=a(n/2),c=a(i/2),u=a(r/2),h=s(n/2),d=s(i/2),p=s(r/2);switch(o){case"XYZ":this._x=h*c*u+l*d*p,this._y=l*d*u-h*c*p,this._z=l*c*p+h*d*u,this._w=l*c*u-h*d*p;break;case"YXZ":this._x=h*c*u+l*d*p,this._y=l*d*u-h*c*p,this._z=l*c*p-h*d*u,this._w=l*c*u+h*d*p;break;case"ZXY":this._x=h*c*u-l*d*p,this._y=l*d*u+h*c*p,this._z=l*c*p+h*d*u,this._w=l*c*u-h*d*p;break;case"ZYX":this._x=h*c*u-l*d*p,this._y=l*d*u+h*c*p,this._z=l*c*p-h*d*u,this._w=l*c*u+h*d*p;break;case"YZX":this._x=h*c*u+l*d*p,this._y=l*d*u+h*c*p,this._z=l*c*p-h*d*u,this._w=l*c*u-h*d*p;break;case"XZY":this._x=h*c*u-l*d*p,this._y=l*d*u-h*c*p,this._z=l*c*p+h*d*u,this._w=l*c*u+h*d*p;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+o)}return!1!==e&&this._onChangeCallback(),this}setFromAxisAngle(t,e){const n=e/2,i=Math.sin(n);return this._x=t.x*i,this._y=t.y*i,this._z=t.z*i,this._w=Math.cos(n),this._onChangeCallback(),this}setFromRotationMatrix(t){const e=t.elements,n=e[0],i=e[4],r=e[8],o=e[1],a=e[5],s=e[9],l=e[2],c=e[6],u=e[10],h=n+a+u;if(h>0){const t=.5/Math.sqrt(h+1);this._w=.25/t,this._x=(c-s)*t,this._y=(r-l)*t,this._z=(o-i)*t}else if(n>a&&n>u){const t=2*Math.sqrt(1+n-a-u);this._w=(c-s)/t,this._x=.25*t,this._y=(i+o)/t,this._z=(r+l)/t}else if(a>u){const t=2*Math.sqrt(1+a-n-u);this._w=(r-l)/t,this._x=(i+o)/t,this._y=.25*t,this._z=(s+c)/t}else{const t=2*Math.sqrt(1+u-n-a);this._w=(o-i)/t,this._x=(r+l)/t,this._y=(s+c)/t,this._z=.25*t}return this._onChangeCallback(),this}setFromUnitVectors(t,e){let n=t.dot(e)+1;return n<1e-6?(n=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=n):(this._x=0,this._y=-t.z,this._z=t.y,this._w=n)):(this._x=t.y*e.z-t.z*e.y,this._y=t.z*e.x-t.x*e.z,this._z=t.x*e.y-t.y*e.x,this._w=n),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(sHt.clamp(this.dot(t),-1,1)))}rotateTowards(t,e){const n=this.angleTo(t);if(0===n)return this;const i=Math.min(1,e/n);return this.slerp(t,i),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,e){return void 0!==e?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,e)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,e){const n=t._x,i=t._y,r=t._z,o=t._w,a=e._x,s=e._y,l=e._z,c=e._w;return this._x=n*c+o*a+i*l-r*s,this._y=i*c+o*s+r*a-n*l,this._z=r*c+o*l+n*s-i*a,this._w=o*c-n*a-i*s-r*l,this._onChangeCallback(),this}slerp(t,e){if(0===e)return this;if(1===e)return this.copy(t);const n=this._x,i=this._y,r=this._z,o=this._w;let a=o*t._w+n*t._x+i*t._y+r*t._z;if(a<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,a=-a):this.copy(t),a>=1)return this._w=o,this._x=n,this._y=i,this._z=r,this;const s=1-a*a;if(s<=Number.EPSILON){const t=1-e;return this._w=t*o+e*this._w,this._x=t*n+e*this._x,this._y=t*i+e*this._y,this._z=t*r+e*this._z,this.normalize(),this._onChangeCallback(),this}const l=Math.sqrt(s),c=Math.atan2(l,a),u=Math.sin((1-e)*c)/l,h=Math.sin(e*c)/l;return this._w=o*u+this._w*h,this._x=n*u+this._x*h,this._y=i*u+this._y*h,this._z=r*u+this._z*h,this._onChangeCallback(),this}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,e=0){return this._x=t[e],this._y=t[e+1],this._z=t[e+2],this._w=t[e+3],this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._w,t}fromBufferAttribute(t,e){return this._x=t.getX(e),this._y=t.getY(e),this._z=t.getZ(e),this._w=t.getW(e),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}class yHt{constructor(t=0,e=0,n=0){Object.defineProperty(this,"isVector3",{value:!0}),this.x=t,this.y=e,this.z=n}set(t,e,n){return void 0===n&&(n=this.z),this.x=t,this.y=e,this.z=n,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,e){return void 0!==e?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,e)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,e){return this.x=t.x+e.x,this.y=t.y+e.y,this.z=t.z+e.z,this}addScaledVector(t,e){return this.x+=t.x*e,this.y+=t.y*e,this.z+=t.z*e,this}sub(t,e){return void 0!==e?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,e)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,e){return this.x=t.x-e.x,this.y=t.y-e.y,this.z=t.z-e.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,e)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,e){return this.x=t.x*e.x,this.y=t.y*e.y,this.z=t.z*e.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(bHt.setFromEuler(t))}applyAxisAngle(t,e){return this.applyQuaternion(bHt.setFromAxisAngle(t,e))}applyMatrix3(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[3]*n+r[6]*i,this.y=r[1]*e+r[4]*n+r[7]*i,this.z=r[2]*e+r[5]*n+r[8]*i,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){const e=this.x,n=this.y,i=this.z,r=t.elements,o=1/(r[3]*e+r[7]*n+r[11]*i+r[15]);return this.x=(r[0]*e+r[4]*n+r[8]*i+r[12])*o,this.y=(r[1]*e+r[5]*n+r[9]*i+r[13])*o,this.z=(r[2]*e+r[6]*n+r[10]*i+r[14])*o,this}applyQuaternion(t){const e=this.x,n=this.y,i=this.z,r=t.x,o=t.y,a=t.z,s=t.w,l=s*e+o*i-a*n,c=s*n+a*e-r*i,u=s*i+r*n-o*e,h=-r*e-o*n-a*i;return this.x=l*s+h*-r+c*-a-u*-o,this.y=c*s+h*-o+u*-r-l*-a,this.z=u*s+h*-a+l*-o-c*-r,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){const e=this.x,n=this.y,i=this.z,r=t.elements;return this.x=r[0]*e+r[4]*n+r[8]*i,this.y=r[1]*e+r[5]*n+r[9]*i,this.z=r[2]*e+r[6]*n+r[10]*i,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,e){return this.x=Math.max(t.x,Math.min(e.x,this.x)),this.y=Math.max(t.y,Math.min(e.y,this.y)),this.z=Math.max(t.z,Math.min(e.z,this.z)),this}clampScalar(t,e){return this.x=Math.max(t,Math.min(e,this.x)),this.y=Math.max(t,Math.min(e,this.y)),this.z=Math.max(t,Math.min(e,this.z)),this}clampLength(t,e){const n=this.length();return this.divideScalar(n||1).multiplyScalar(Math.max(t,Math.min(e,n)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,e){return this.x+=(t.x-this.x)*e,this.y+=(t.y-this.y)*e,this.z+=(t.z-this.z)*e,this}lerpVectors(t,e,n){return this.x=t.x+(e.x-t.x)*n,this.y=t.y+(e.y-t.y)*n,this.z=t.z+(e.z-t.z)*n,this}cross(t,e){return void 0!==e?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,e)):this.crossVectors(this,t)}crossVectors(t,e){const n=t.x,i=t.y,r=t.z,o=e.x,a=e.y,s=e.z;return this.x=i*s-r*a,this.y=r*o-n*s,this.z=n*a-i*o,this}projectOnVector(t){const e=t.lengthSq();if(0===e)return this.set(0,0,0);const n=t.dot(this)/e;return this.copy(t).multiplyScalar(n)}projectOnPlane(t){return vHt.copy(this).projectOnVector(t),this.sub(vHt)}reflect(t){return this.sub(vHt.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){const e=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===e)return Math.PI/2;const n=this.dot(t)/e;return Math.acos(sHt.clamp(n,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const e=this.x-t.x,n=this.y-t.y,i=this.z-t.z;return e*e+n*n+i*i}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,e,n){const i=Math.sin(e)*t;return this.x=i*Math.sin(n),this.y=Math.cos(e)*t,this.z=i*Math.cos(n),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,e,n){return this.x=t*Math.sin(e),this.y=n,this.z=t*Math.cos(e),this}setFromMatrixPosition(t){const e=t.elements;return this.x=e[12],this.y=e[13],this.z=e[14],this}setFromMatrixScale(t){const e=this.setFromMatrixColumn(t,0).length(),n=this.setFromMatrixColumn(t,1).length(),i=this.setFromMatrixColumn(t,2).length();return this.x=e,this.y=n,this.z=i,this}setFromMatrixColumn(t,e){return this.fromArray(t.elements,4*e)}setFromMatrix3Column(t,e){return this.fromArray(t.elements,3*e)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,e=0){return this.x=t[e],this.y=t[e+1],this.z=t[e+2],this}toArray(t=[],e=0){return t[e]=this.x,t[e+1]=this.y,t[e+2]=this.z,t}fromBufferAttribute(t,e,n){return void 0!==n&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(e),this.y=t.getY(e),this.z=t.getZ(e),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}}const vHt=new yHt,bHt=new _Ht;class xHt{constructor(t,e){Object.defineProperty(this,"isBox3",{value:!0}),this.min=void 0!==t?t:new yHt(1/0,1/0,1/0),this.max=void 0!==e?e:new yHt(-1/0,-1/0,-1/0)}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromArray(t){let e=1/0,n=1/0,i=1/0,r=-1/0,o=-1/0,a=-1/0;for(let s=0,l=t.length;s<l;s+=3){const l=t[s],c=t[s+1],u=t[s+2];l<e&&(e=l),c<n&&(n=c),u<i&&(i=u),l>r&&(r=l),c>o&&(o=c),u>a&&(a=u)}return this.min.set(e,n,i),this.max.set(r,o,a),this}setFromBufferAttribute(t){let e=1/0,n=1/0,i=1/0,r=-1/0,o=-1/0,a=-1/0;for(let s=0,l=t.count;s<l;s++){const l=t.getX(s),c=t.getY(s),u=t.getZ(s);l<e&&(e=l),c<n&&(n=c),u<i&&(i=u),l>r&&(r=l),c>o&&(o=c),u>a&&(a=u)}return this.min.set(e,n,i),this.max.set(r,o,a),this}setFromPoints(t){this.makeEmpty();for(let e=0,n=t.length;e<n;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){const n=MHt.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}setFromObject(t){return this.makeEmpty(),this.expandByObject(t)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return void 0===t&&(console.warn("THREE.Box3: .getCenter() target is now required"),t=new yHt),this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return void 0===t&&(console.warn("THREE.Box3: .getSize() target is now required"),t=new yHt),this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t){t.updateWorldMatrix(!1,!1);const e=t.geometry;void 0!==e&&(null===e.boundingBox&&e.computeBoundingBox(),EHt.copy(e.boundingBox),EHt.applyMatrix4(t.matrixWorld),this.union(EHt));const n=t.children;for(let t=0,e=n.length;t<e;t++)this.expandByObject(n[t]);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,e){return void 0===e&&(console.warn("THREE.Box3: .getParameter() target is now required"),e=new yHt),e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,MHt),MHt.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let e,n;return t.normal.x>0?(e=t.normal.x*this.min.x,n=t.normal.x*this.max.x):(e=t.normal.x*this.max.x,n=t.normal.x*this.min.x),t.normal.y>0?(e+=t.normal.y*this.min.y,n+=t.normal.y*this.max.y):(e+=t.normal.y*this.max.y,n+=t.normal.y*this.min.y),t.normal.z>0?(e+=t.normal.z*this.min.z,n+=t.normal.z*this.max.z):(e+=t.normal.z*this.max.z,n+=t.normal.z*this.min.z),e<=-t.constant&&n>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(IHt),NHt.subVectors(this.max,IHt),THt.subVectors(t.a,IHt),AHt.subVectors(t.b,IHt),CHt.subVectors(t.c,IHt),kHt.subVectors(AHt,THt),LHt.subVectors(CHt,AHt),PHt.subVectors(THt,CHt);let e=[0,-kHt.z,kHt.y,0,-LHt.z,LHt.y,0,-PHt.z,PHt.y,kHt.z,0,-kHt.x,LHt.z,0,-LHt.x,PHt.z,0,-PHt.x,-kHt.y,kHt.x,0,-LHt.y,LHt.x,0,-PHt.y,PHt.x,0];return!!wHt(e,THt,AHt,CHt,NHt)&&(e=[1,0,0,0,1,0,0,0,1],!!wHt(e,THt,AHt,CHt,NHt)&&(OHt.crossVectors(kHt,LHt),e=[OHt.x,OHt.y,OHt.z],wHt(e,THt,AHt,CHt,NHt)))}clampPoint(t,e){return void 0===e&&(console.warn("THREE.Box3: .clampPoint() target is now required"),e=new yHt),e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return MHt.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return void 0===t&&console.error("THREE.Box3: .getBoundingSphere() target is now required"),this.getCenter(t.center),t.radius=.5*this.getSize(MHt).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(SHt[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),SHt[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),SHt[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),SHt[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),SHt[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),SHt[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),SHt[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),SHt[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(SHt)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}function wHt(t,e,n,i,r){for(let o=0,a=t.length-3;o<=a;o+=3){RHt.fromArray(t,o);const a=r.x*Math.abs(RHt.x)+r.y*Math.abs(RHt.y)+r.z*Math.abs(RHt.z),s=e.dot(RHt),l=n.dot(RHt),c=i.dot(RHt);if(Math.max(-Math.max(s,l,c),Math.min(s,l,c))>a)return!1}return!0}const SHt=[new yHt,new yHt,new yHt,new yHt,new yHt,new yHt,new yHt,new yHt],MHt=new yHt,EHt=new xHt,THt=new yHt,AHt=new yHt,CHt=new yHt,kHt=new yHt,LHt=new yHt,PHt=new yHt,IHt=new yHt,NHt=new yHt,OHt=new yHt,RHt=new yHt,zHt=new xHt;class DHt{constructor(t,e){this.center=void 0!==t?t:new yHt,this.radius=void 0!==e?e:-1}set(t,e){return this.center.copy(t),this.radius=e,this}setFromPoints(t,e){const n=this.center;void 0!==e?n.copy(e):zHt.setFromPoints(t).getCenter(n);let i=0;for(let e=0,r=t.length;e<r;e++)i=Math.max(i,n.distanceToSquared(t[e]));return this.radius=Math.sqrt(i),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){const e=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=e*e}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,e){const n=this.center.distanceToSquared(t);return void 0===e&&(console.warn("THREE.Sphere: .clampPoint() target is now required"),e=new yHt),e.copy(t),n>this.radius*this.radius&&(e.sub(this.center).normalize(),e.multiplyScalar(this.radius).add(this.center)),e}getBoundingBox(t){return void 0===t&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),t=new xHt),this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}}const BHt=new yHt,HHt=new yHt,FHt=new yHt,VHt=new yHt,jHt=new yHt,UHt=new yHt,GHt=new yHt;class WHt{constructor(t,e){this.origin=void 0!==t?t:new yHt,this.direction=void 0!==e?e:new yHt(0,0,-1)}set(t,e){return this.origin.copy(t),this.direction.copy(e),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,e){return void 0===e&&(console.warn("THREE.Ray: .at() target is now required"),e=new yHt),e.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,BHt)),this}closestPointToPoint(t,e){void 0===e&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),e=new yHt),e.subVectors(t,this.origin);const n=e.dot(this.direction);return n<0?e.copy(this.origin):e.copy(this.direction).multiplyScalar(n).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){const e=BHt.subVectors(t,this.origin).dot(this.direction);return e<0?this.origin.distanceToSquared(t):(BHt.copy(this.direction).multiplyScalar(e).add(this.origin),BHt.distanceToSquared(t))}distanceSqToSegment(t,e,n,i){HHt.copy(t).add(e).multiplyScalar(.5),FHt.copy(e).sub(t).normalize(),VHt.copy(this.origin).sub(HHt);const r=.5*t.distanceTo(e),o=-this.direction.dot(FHt),a=VHt.dot(this.direction),s=-VHt.dot(FHt),l=VHt.lengthSq(),c=Math.abs(1-o*o);let u,h,d,p;if(c>0)if(u=o*s-a,h=o*a-s,p=r*c,u>=0)if(h>=-p)if(h<=p){const t=1/c;u*=t,h*=t,d=u*(u+o*h+2*a)+h*(o*u+h+2*s)+l}else h=r,u=Math.max(0,-(o*h+a)),d=-u*u+h*(h+2*s)+l;else h=-r,u=Math.max(0,-(o*h+a)),d=-u*u+h*(h+2*s)+l;else h<=-p?(u=Math.max(0,-(-o*r+a)),h=u>0?-r:Math.min(Math.max(-r,-s),r),d=-u*u+h*(h+2*s)+l):h<=p?(u=0,h=Math.min(Math.max(-r,-s),r),d=h*(h+2*s)+l):(u=Math.max(0,-(o*r+a)),h=u>0?r:Math.min(Math.max(-r,-s),r),d=-u*u+h*(h+2*s)+l);else h=o>0?-r:r,u=Math.max(0,-(o*h+a)),d=-u*u+h*(h+2*s)+l;return n&&n.copy(this.direction).multiplyScalar(u).add(this.origin),i&&i.copy(FHt).multiplyScalar(h).add(HHt),d}intersectSphere(t,e){BHt.subVectors(t.center,this.origin);const n=BHt.dot(this.direction),i=BHt.dot(BHt)-n*n,r=t.radius*t.radius;if(i>r)return null;const o=Math.sqrt(r-i),a=n-o,s=n+o;return a<0&&s<0?null:this.at(a<0?s:a,e)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){const e=t.normal.dot(this.direction);if(0===e)return 0===t.distanceToPoint(this.origin)?0:null;const n=-(this.origin.dot(t.normal)+t.constant)/e;return n>=0?n:null}intersectPlane(t,e){const n=this.distanceToPlane(t);return null===n?null:this.at(n,e)}intersectsPlane(t){const e=t.distanceToPoint(this.origin);return 0===e||t.normal.dot(this.direction)*e<0}intersectBox(t,e){let n,i,r,o,a,s;const l=1/this.direction.x,c=1/this.direction.y,u=1/this.direction.z,h=this.origin;return l>=0?(n=(t.min.x-h.x)*l,i=(t.max.x-h.x)*l):(n=(t.max.x-h.x)*l,i=(t.min.x-h.x)*l),c>=0?(r=(t.min.y-h.y)*c,o=(t.max.y-h.y)*c):(r=(t.max.y-h.y)*c,o=(t.min.y-h.y)*c),n>o||r>i?null:((r>n||n!=n)&&(n=r),(o<i||i!=i)&&(i=o),u>=0?(a=(t.min.z-h.z)*u,s=(t.max.z-h.z)*u):(a=(t.max.z-h.z)*u,s=(t.min.z-h.z)*u),n>s||a>i?null:((a>n||n!=n)&&(n=a),(s<i||i!=i)&&(i=s),i<0?null:this.at(n>=0?n:i,e)))}intersectsBox(t){return null!==this.intersectBox(t,BHt)}intersectTriangle(t,e,n,i,r){jHt.subVectors(e,t),UHt.subVectors(n,t),GHt.crossVectors(jHt,UHt);let o,a=this.direction.dot(GHt);if(a>0){if(i)return null;o=1}else{if(!(a<0))return null;o=-1,a=-a}VHt.subVectors(this.origin,t);const s=o*this.direction.dot(UHt.crossVectors(VHt,UHt));if(s<0)return null;const l=o*this.direction.dot(jHt.cross(VHt));if(l<0)return null;if(s+l>a)return null;const c=-o*VHt.dot(GHt);return c<0?null:this.at(c/a,r)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}}class qHt{constructor(){Object.defineProperty(this,"isMatrix4",{value:!0}),this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,e,n,i,r,o,a,s,l,c,u,h,d,p,f,m){const g=this.elements;return g[0]=t,g[4]=e,g[8]=n,g[12]=i,g[1]=r,g[5]=o,g[9]=a,g[13]=s,g[2]=l,g[6]=c,g[10]=u,g[14]=h,g[3]=d,g[7]=p,g[11]=f,g[15]=m,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new qHt).fromArray(this.elements)}copy(t){const e=this.elements,n=t.elements;return e[0]=n[0],e[1]=n[1],e[2]=n[2],e[3]=n[3],e[4]=n[4],e[5]=n[5],e[6]=n[6],e[7]=n[7],e[8]=n[8],e[9]=n[9],e[10]=n[10],e[11]=n[11],e[12]=n[12],e[13]=n[13],e[14]=n[14],e[15]=n[15],this}copyPosition(t){const e=this.elements,n=t.elements;return e[12]=n[12],e[13]=n[13],e[14]=n[14],this}setFromMatrix3(t){const e=t.elements;return this.set(e[0],e[3],e[6],0,e[1],e[4],e[7],0,e[2],e[5],e[8],0,0,0,0,1),this}extractBasis(t,e,n){return t.setFromMatrixColumn(this,0),e.setFromMatrixColumn(this,1),n.setFromMatrixColumn(this,2),this}makeBasis(t,e,n){return this.set(t.x,e.x,n.x,0,t.y,e.y,n.y,0,t.z,e.z,n.z,0,0,0,0,1),this}extractRotation(t){const e=this.elements,n=t.elements,i=1/YHt.setFromMatrixColumn(t,0).length(),r=1/YHt.setFromMatrixColumn(t,1).length(),o=1/YHt.setFromMatrixColumn(t,2).length();return e[0]=n[0]*i,e[1]=n[1]*i,e[2]=n[2]*i,e[3]=0,e[4]=n[4]*r,e[5]=n[5]*r,e[6]=n[6]*r,e[7]=0,e[8]=n[8]*o,e[9]=n[9]*o,e[10]=n[10]*o,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");const e=this.elements,n=t.x,i=t.y,r=t.z,o=Math.cos(n),a=Math.sin(n),s=Math.cos(i),l=Math.sin(i),c=Math.cos(r),u=Math.sin(r);if("XYZ"===t.order){const t=o*c,n=o*u,i=a*c,r=a*u;e[0]=s*c,e[4]=-s*u,e[8]=l,e[1]=n+i*l,e[5]=t-r*l,e[9]=-a*s,e[2]=r-t*l,e[6]=i+n*l,e[10]=o*s}else if("YXZ"===t.order){const t=s*c,n=s*u,i=l*c,r=l*u;e[0]=t+r*a,e[4]=i*a-n,e[8]=o*l,e[1]=o*u,e[5]=o*c,e[9]=-a,e[2]=n*a-i,e[6]=r+t*a,e[10]=o*s}else if("ZXY"===t.order){const t=s*c,n=s*u,i=l*c,r=l*u;e[0]=t-r*a,e[4]=-o*u,e[8]=i+n*a,e[1]=n+i*a,e[5]=o*c,e[9]=r-t*a,e[2]=-o*l,e[6]=a,e[10]=o*s}else if("ZYX"===t.order){const t=o*c,n=o*u,i=a*c,r=a*u;e[0]=s*c,e[4]=i*l-n,e[8]=t*l+r,e[1]=s*u,e[5]=r*l+t,e[9]=n*l-i,e[2]=-l,e[6]=a*s,e[10]=o*s}else if("YZX"===t.order){const t=o*s,n=o*l,i=a*s,r=a*l;e[0]=s*c,e[4]=r-t*u,e[8]=i*u+n,e[1]=u,e[5]=o*c,e[9]=-a*c,e[2]=-l*c,e[6]=n*u+i,e[10]=t-r*u}else if("XZY"===t.order){const t=o*s,n=o*l,i=a*s,r=a*l;e[0]=s*c,e[4]=-u,e[8]=l*c,e[1]=t*u+r,e[5]=o*c,e[9]=n*u-i,e[2]=i*u-n,e[6]=a*c,e[10]=r*u+t}return e[3]=0,e[7]=0,e[11]=0,e[12]=0,e[13]=0,e[14]=0,e[15]=1,this}makeRotationFromQuaternion(t){return this.compose($Ht,t,KHt)}lookAt(t,e,n){const i=this.elements;return QHt.subVectors(t,e),0===QHt.lengthSq()&&(QHt.z=1),QHt.normalize(),ZHt.crossVectors(n,QHt),0===ZHt.lengthSq()&&(1===Math.abs(n.z)?QHt.x+=1e-4:QHt.z+=1e-4,QHt.normalize(),ZHt.crossVectors(n,QHt)),ZHt.normalize(),JHt.crossVectors(QHt,ZHt),i[0]=ZHt.x,i[4]=JHt.x,i[8]=QHt.x,i[1]=ZHt.y,i[5]=JHt.y,i[9]=QHt.y,i[2]=ZHt.z,i[6]=JHt.z,i[10]=QHt.z,this}multiply(t,e){return void 0!==e?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,e)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,e){const n=t.elements,i=e.elements,r=this.elements,o=n[0],a=n[4],s=n[8],l=n[12],c=n[1],u=n[5],h=n[9],d=n[13],p=n[2],f=n[6],m=n[10],g=n[14],_=n[3],y=n[7],v=n[11],b=n[15],x=i[0],w=i[4],S=i[8],M=i[12],E=i[1],T=i[5],A=i[9],C=i[13],k=i[2],L=i[6],P=i[10],I=i[14],N=i[3],O=i[7],R=i[11],z=i[15];return r[0]=o*x+a*E+s*k+l*N,r[4]=o*w+a*T+s*L+l*O,r[8]=o*S+a*A+s*P+l*R,r[12]=o*M+a*C+s*I+l*z,r[1]=c*x+u*E+h*k+d*N,r[5]=c*w+u*T+h*L+d*O,r[9]=c*S+u*A+h*P+d*R,r[13]=c*M+u*C+h*I+d*z,r[2]=p*x+f*E+m*k+g*N,r[6]=p*w+f*T+m*L+g*O,r[10]=p*S+f*A+m*P+g*R,r[14]=p*M+f*C+m*I+g*z,r[3]=_*x+y*E+v*k+b*N,r[7]=_*w+y*T+v*L+b*O,r[11]=_*S+y*A+v*P+b*R,r[15]=_*M+y*C+v*I+b*z,this}multiplyScalar(t){const e=this.elements;return e[0]*=t,e[4]*=t,e[8]*=t,e[12]*=t,e[1]*=t,e[5]*=t,e[9]*=t,e[13]*=t,e[2]*=t,e[6]*=t,e[10]*=t,e[14]*=t,e[3]*=t,e[7]*=t,e[11]*=t,e[15]*=t,this}determinant(){const t=this.elements,e=t[0],n=t[4],i=t[8],r=t[12],o=t[1],a=t[5],s=t[9],l=t[13],c=t[2],u=t[6],h=t[10],d=t[14];return t[3]*(+r*s*u-i*l*u-r*a*h+n*l*h+i*a*d-n*s*d)+t[7]*(+e*s*d-e*l*h+r*o*h-i*o*d+i*l*c-r*s*c)+t[11]*(+e*l*u-e*a*d-r*o*u+n*o*d+r*a*c-n*l*c)+t[15]*(-i*a*c-e*s*u+e*a*h+i*o*u-n*o*h+n*s*c)}transpose(){const t=this.elements;let e;return e=t[1],t[1]=t[4],t[4]=e,e=t[2],t[2]=t[8],t[8]=e,e=t[6],t[6]=t[9],t[9]=e,e=t[3],t[3]=t[12],t[12]=e,e=t[7],t[7]=t[13],t[13]=e,e=t[11],t[11]=t[14],t[14]=e,this}setPosition(t,e,n){const i=this.elements;return t.isVector3?(i[12]=t.x,i[13]=t.y,i[14]=t.z):(i[12]=t,i[13]=e,i[14]=n),this}invert(){const t=this.elements,e=t[0],n=t[1],i=t[2],r=t[3],o=t[4],a=t[5],s=t[6],l=t[7],c=t[8],u=t[9],h=t[10],d=t[11],p=t[12],f=t[13],m=t[14],g=t[15],_=u*m*l-f*h*l+f*s*d-a*m*d-u*s*g+a*h*g,y=p*h*l-c*m*l-p*s*d+o*m*d+c*s*g-o*h*g,v=c*f*l-p*u*l+p*a*d-o*f*d-c*a*g+o*u*g,b=p*u*s-c*f*s-p*a*h+o*f*h+c*a*m-o*u*m,x=e*_+n*y+i*v+r*b;if(0===x)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);const w=1/x;return t[0]=_*w,t[1]=(f*h*r-u*m*r-f*i*d+n*m*d+u*i*g-n*h*g)*w,t[2]=(a*m*r-f*s*r+f*i*l-n*m*l-a*i*g+n*s*g)*w,t[3]=(u*s*r-a*h*r-u*i*l+n*h*l+a*i*d-n*s*d)*w,t[4]=y*w,t[5]=(c*m*r-p*h*r+p*i*d-e*m*d-c*i*g+e*h*g)*w,t[6]=(p*s*r-o*m*r-p*i*l+e*m*l+o*i*g-e*s*g)*w,t[7]=(o*h*r-c*s*r+c*i*l-e*h*l-o*i*d+e*s*d)*w,t[8]=v*w,t[9]=(p*u*r-c*f*r-p*n*d+e*f*d+c*n*g-e*u*g)*w,t[10]=(o*f*r-p*a*r+p*n*l-e*f*l-o*n*g+e*a*g)*w,t[11]=(c*a*r-o*u*r-c*n*l+e*u*l+o*n*d-e*a*d)*w,t[12]=b*w,t[13]=(c*f*i-p*u*i+p*n*h-e*f*h-c*n*m+e*u*m)*w,t[14]=(p*a*i-o*f*i-p*n*s+e*f*s+o*n*m-e*a*m)*w,t[15]=(o*u*i-c*a*i+c*n*s-e*u*s-o*n*h+e*a*h)*w,this}scale(t){const e=this.elements,n=t.x,i=t.y,r=t.z;return e[0]*=n,e[4]*=i,e[8]*=r,e[1]*=n,e[5]*=i,e[9]*=r,e[2]*=n,e[6]*=i,e[10]*=r,e[3]*=n,e[7]*=i,e[11]*=r,this}getMaxScaleOnAxis(){const t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,e,n){return this.set(1,0,0,t,0,1,0,e,0,0,1,n,0,0,0,1),this}makeRotationX(t){const e=Math.cos(t),n=Math.sin(t);return this.set(1,0,0,0,0,e,-n,0,0,n,e,0,0,0,0,1),this}makeRotationY(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,0,n,0,0,1,0,0,-n,0,e,0,0,0,0,1),this}makeRotationZ(t){const e=Math.cos(t),n=Math.sin(t);return this.set(e,-n,0,0,n,e,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,e){const n=Math.cos(e),i=Math.sin(e),r=1-n,o=t.x,a=t.y,s=t.z,l=r*o,c=r*a;return this.set(l*o+n,l*a-i*s,l*s+i*a,0,l*a+i*s,c*a+n,c*s-i*o,0,l*s-i*a,c*s+i*o,r*s*s+n,0,0,0,0,1),this}makeScale(t,e,n){return this.set(t,0,0,0,0,e,0,0,0,0,n,0,0,0,0,1),this}makeShear(t,e,n){return this.set(1,e,n,0,t,1,n,0,t,e,1,0,0,0,0,1),this}compose(t,e,n){const i=this.elements,r=e._x,o=e._y,a=e._z,s=e._w,l=r+r,c=o+o,u=a+a,h=r*l,d=r*c,p=r*u,f=o*c,m=o*u,g=a*u,_=s*l,y=s*c,v=s*u,b=n.x,x=n.y,w=n.z;return i[0]=(1-(f+g))*b,i[1]=(d+v)*b,i[2]=(p-y)*b,i[3]=0,i[4]=(d-v)*x,i[5]=(1-(h+g))*x,i[6]=(m+_)*x,i[7]=0,i[8]=(p+y)*w,i[9]=(m-_)*w,i[10]=(1-(h+f))*w,i[11]=0,i[12]=t.x,i[13]=t.y,i[14]=t.z,i[15]=1,this}decompose(t,e,n){const i=this.elements;let r=YHt.set(i[0],i[1],i[2]).length();const o=YHt.set(i[4],i[5],i[6]).length(),a=YHt.set(i[8],i[9],i[10]).length();this.determinant()<0&&(r=-r),t.x=i[12],t.y=i[13],t.z=i[14],XHt.copy(this);const s=1/r,l=1/o,c=1/a;return XHt.elements[0]*=s,XHt.elements[1]*=s,XHt.elements[2]*=s,XHt.elements[4]*=l,XHt.elements[5]*=l,XHt.elements[6]*=l,XHt.elements[8]*=c,XHt.elements[9]*=c,XHt.elements[10]*=c,e.setFromRotationMatrix(XHt),n.x=r,n.y=o,n.z=a,this}makePerspective(t,e,n,i,r,o){void 0===o&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");const a=this.elements,s=2*r/(n-i),l=(e+t)/(e-t),c=(n+i)/(n-i),u=-(o+r)/(o-r),h=-2*o*r/(o-r);return a[0]=2*r/(e-t),a[4]=0,a[8]=l,a[12]=0,a[1]=0,a[5]=s,a[9]=c,a[13]=0,a[2]=0,a[6]=0,a[10]=u,a[14]=h,a[3]=0,a[7]=0,a[11]=-1,a[15]=0,this}makeOrthographic(t,e,n,i,r,o){const a=this.elements,s=1/(e-t),l=1/(n-i),c=1/(o-r),u=(e+t)*s,h=(n+i)*l,d=(o+r)*c;return a[0]=2*s,a[4]=0,a[8]=0,a[12]=-u,a[1]=0,a[5]=2*l,a[9]=0,a[13]=-h,a[2]=0,a[6]=0,a[10]=-2*c,a[14]=-d,a[3]=0,a[7]=0,a[11]=0,a[15]=1,this}equals(t){const e=this.elements,n=t.elements;for(let t=0;t<16;t++)if(e[t]!==n[t])return!1;return!0}fromArray(t,e=0){for(let n=0;n<16;n++)this.elements[n]=t[n+e];return this}toArray(t=[],e=0){const n=this.elements;return t[e]=n[0],t[e+1]=n[1],t[e+2]=n[2],t[e+3]=n[3],t[e+4]=n[4],t[e+5]=n[5],t[e+6]=n[6],t[e+7]=n[7],t[e+8]=n[8],t[e+9]=n[9],t[e+10]=n[10],t[e+11]=n[11],t[e+12]=n[12],t[e+13]=n[13],t[e+14]=n[14],t[e+15]=n[15],t}}const YHt=new yHt,XHt=new qHt,$Ht=new yHt(0,0,0),KHt=new yHt(1,1,1),ZHt=new yHt,JHt=new yHt,QHt=new yHt;class tFt{constructor(t=0,e=0,n=0,i=tFt.DefaultOrder){Object.defineProperty(this,"isEuler",{value:!0}),this._x=t,this._y=e,this._z=n,this._order=i}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,e,n,i){return this._x=t,this._y=e,this._z=n,this._order=i||this._order,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,e,n){const i=sHt.clamp,r=t.elements,o=r[0],a=r[4],s=r[8],l=r[1],c=r[5],u=r[9],h=r[2],d=r[6],p=r[10];switch(e=e||this._order){case"XYZ":this._y=Math.asin(i(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-u,p),this._z=Math.atan2(-a,o)):(this._x=Math.atan2(d,c),this._z=0);break;case"YXZ":this._x=Math.asin(-i(u,-1,1)),Math.abs(u)<.9999999?(this._y=Math.atan2(s,p),this._z=Math.atan2(l,c)):(this._y=Math.atan2(-h,o),this._z=0);break;case"ZXY":this._x=Math.asin(i(d,-1,1)),Math.abs(d)<.9999999?(this._y=Math.atan2(-h,p),this._z=Math.atan2(-a,c)):(this._y=0,this._z=Math.atan2(l,o));break;case"ZYX":this._y=Math.asin(-i(h,-1,1)),Math.abs(h)<.9999999?(this._x=Math.atan2(d,p),this._z=Math.atan2(l,o)):(this._x=0,this._z=Math.atan2(-a,c));break;case"YZX":this._z=Math.asin(i(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-u,c),this._y=Math.atan2(-h,o)):(this._x=0,this._y=Math.atan2(s,p));break;case"XZY":this._z=Math.asin(-i(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(d,c),this._y=Math.atan2(s,o)):(this._x=Math.atan2(-u,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+e)}return this._order=e,!1!==n&&this._onChangeCallback(),this}setFromQuaternion(t,e,n){return eFt.makeRotationFromQuaternion(t),this.setFromRotationMatrix(eFt,e,n)}setFromVector3(t,e){return this.set(t.x,t.y,t.z,e||this._order)}reorder(t){return nFt.setFromEuler(this),this.setFromQuaternion(nFt,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],e=0){return t[e]=this._x,t[e+1]=this._y,t[e+2]=this._z,t[e+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new yHt(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}tFt.DefaultOrder="XYZ",tFt.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];const eFt=new qHt,nFt=new _Ht;class iFt{constructor(){this.mask=1}set(t){this.mask=1<<t|0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}}let rFt=0;const oFt=new yHt,aFt=new _Ht,sFt=new qHt,lFt=new yHt,cFt=new yHt,uFt=new yHt,hFt=new _Ht,dFt=new yHt(1,0,0),pFt=new yHt(0,1,0),fFt=new yHt(0,0,1),mFt={type:"added"},gFt={type:"removed"};function _Ft(){Object.defineProperty(this,"id",{value:rFt++}),this.uuid=sHt.generateUUID(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=_Ft.DefaultUp.clone();const t=new yHt,e=new tFt,n=new _Ht,i=new yHt(1,1,1);e._onChange((function r(){n.setFromEuler(e,!1)})),n._onChange((function o(){e.setFromQuaternion(n,void 0,!1)})),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:e},quaternion:{configurable:!0,enumerable:!0,value:n},scale:{configurable:!0,enumerable:!0,value:i},modelViewMatrix:{value:new qHt},normalMatrix:{value:new cHt}}),this.matrix=new qHt,this.matrixWorld=new qHt,this.matrixAutoUpdate=_Ft.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new iFt,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}_Ft.DefaultUp=new yHt(0,1,0),_Ft.DefaultMatrixAutoUpdate=!0,_Ft.prototype=Object.assign(Object.create(rHt.prototype),{constructor:_Ft,isObject3D:!0,onBeforeRender:function(){},onAfterRender:function(){},applyMatrix4:function(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)},applyQuaternion:function(t){return this.quaternion.premultiply(t),this},setRotationFromAxisAngle:function(t,e){this.quaternion.setFromAxisAngle(t,e)},setRotationFromEuler:function(t){this.quaternion.setFromEuler(t,!0)},setRotationFromMatrix:function(t){this.quaternion.setFromRotationMatrix(t)},setRotationFromQuaternion:function(t){this.quaternion.copy(t)},rotateOnAxis:function(t,e){return aFt.setFromAxisAngle(t,e),this.quaternion.multiply(aFt),this},rotateOnWorldAxis:function(t,e){return aFt.setFromAxisAngle(t,e),this.quaternion.premultiply(aFt),this},rotateX:function(t){return this.rotateOnAxis(dFt,t)},rotateY:function(t){return this.rotateOnAxis(pFt,t)},rotateZ:function(t){return this.rotateOnAxis(fFt,t)},translateOnAxis:function(t,e){return oFt.copy(t).applyQuaternion(this.quaternion),this.position.add(oFt.multiplyScalar(e)),this},translateX:function(t){return this.translateOnAxis(dFt,t)},translateY:function(t){return this.translateOnAxis(pFt,t)},translateZ:function(t){return this.translateOnAxis(fFt,t)},localToWorld:function(t){return t.applyMatrix4(this.matrixWorld)},worldToLocal:function(t){return t.applyMatrix4(sFt.copy(this.matrixWorld).invert())},lookAt:function(t,e,n){t.isVector3?lFt.copy(t):lFt.set(t,e,n);const i=this.parent;this.updateWorldMatrix(!0,!1),cFt.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?sFt.lookAt(cFt,lFt,this.up):sFt.lookAt(lFt,cFt,this.up),this.quaternion.setFromRotationMatrix(sFt),i&&(sFt.extractRotation(i.matrixWorld),aFt.setFromRotationMatrix(sFt),this.quaternion.premultiply(aFt.invert()))},add:function(t){if(arguments.length>1){for(let t=0;t<arguments.length;t++)this.add(arguments[t]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(mFt)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)},remove:function(t){if(arguments.length>1){for(let t=0;t<arguments.length;t++)this.remove(arguments[t]);return this}const e=this.children.indexOf(t);return-1!==e&&(t.parent=null,this.children.splice(e,1),t.dispatchEvent(gFt)),this},clear:function(){for(let t=0;t<this.children.length;t++){const e=this.children[t];e.parent=null,e.dispatchEvent(gFt)}return this.children.length=0,this},attach:function(t){return this.updateWorldMatrix(!0,!1),sFt.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),sFt.multiply(t.parent.matrixWorld)),t.applyMatrix4(sFt),t.updateWorldMatrix(!1,!1),this.add(t),this},getObjectById:function(t){return this.getObjectByProperty("id",t)},getObjectByName:function(t){return this.getObjectByProperty("name",t)},getObjectByProperty:function(t,e){if(this[t]===e)return this;for(let n=0,i=this.children.length;n<i;n++){const i=this.children[n].getObjectByProperty(t,e);if(void 0!==i)return i}},getWorldPosition:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldPosition() target is now required"),t=new yHt),this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)},getWorldQuaternion:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldQuaternion() target is now required"),t=new _Ht),this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(cFt,t,uFt),t},getWorldScale:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldScale() target is now required"),t=new yHt),this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(cFt,hFt,t),t},getWorldDirection:function(t){void 0===t&&(console.warn("THREE.Object3D: .getWorldDirection() target is now required"),t=new yHt),this.updateWorldMatrix(!0,!1);const e=this.matrixWorld.elements;return t.set(e[8],e[9],e[10]).normalize()},raycast:function(){},traverse:function(t){t(this);const e=this.children;for(let n=0,i=e.length;n<i;n++)e[n].traverse(t)},traverseVisible:function(t){if(!1===this.visible)return;t(this);const e=this.children;for(let n=0,i=e.length;n<i;n++)e[n].traverseVisible(t)},traverseAncestors:function(t){const e=this.parent;null!==e&&(t(e),e.traverseAncestors(t))},updateMatrix:function(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0},updateMatrixWorld:function(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);const e=this.children;for(let n=0,i=e.length;n<i;n++)e[n].updateMatrixWorld(t)},updateWorldMatrix:function(t,e){const n=this.parent;if(!0===t&&null!==n&&n.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===e){const t=this.children;for(let e=0,n=t.length;e<n;e++)t[e].updateWorldMatrix(!1,!0)}},toJSON:function(t){const e=void 0===t||"string"==typeof t,n={};e&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},n.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});const i={};function r(e,n){return void 0===e[n.uuid]&&(e[n.uuid]=n.toJSON(t)),n.uuid}if(i.uuid=this.uuid,i.type=this.type,""!==this.name&&(i.name=this.name),!0===this.castShadow&&(i.castShadow=!0),!0===this.receiveShadow&&(i.receiveShadow=!0),!1===this.visible&&(i.visible=!1),!1===this.frustumCulled&&(i.frustumCulled=!1),0!==this.renderOrder&&(i.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(i.userData=this.userData),i.layers=this.layers.mask,i.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(i.matrixAutoUpdate=!1),this.isInstancedMesh&&(i.type="InstancedMesh",i.count=this.count,i.instanceMatrix=this.instanceMatrix.toJSON()),this.isMesh||this.isLine||this.isPoints){i.geometry=r(t.geometries,this.geometry);const e=this.geometry.parameters;if(void 0!==e&&void 0!==e.shapes){const n=e.shapes;if(Array.isArray(n))for(let e=0,i=n.length;e<i;e++)r(t.shapes,n[e]);else r(t.shapes,n)}}if(this.isSkinnedMesh&&(i.bindMode=this.bindMode,i.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(r(t.skeletons,this.skeleton),i.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){const e=[];for(let n=0,i=this.material.length;n<i;n++)e.push(r(t.materials,this.material[n]));i.material=e}else i.material=r(t.materials,this.material);if(this.children.length>0){i.children=[];for(let e=0;e<this.children.length;e++)i.children.push(this.children[e].toJSON(t).object)}if(this.animations.length>0){i.animations=[];for(let e=0;e<this.animations.length;e++)i.animations.push(r(t.animations,this.animations[e]))}if(e){const e=o(t.geometries),i=o(t.materials),r=o(t.textures),a=o(t.images),s=o(t.shapes),l=o(t.skeletons),c=o(t.animations);e.length>0&&(n.geometries=e),i.length>0&&(n.materials=i),r.length>0&&(n.textures=r),a.length>0&&(n.images=a),s.length>0&&(n.shapes=s),l.length>0&&(n.skeletons=l),c.length>0&&(n.animations=c)}return n.object=i,n;function o(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}},clone:function(t){return(new this.constructor).copy(this,t)},copy:function(t,e=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===e)for(let e=0;e<t.children.length;e++)this.add(t.children[e].clone());return this}});const yFt=new yHt,vFt=new yHt,bFt=new cHt;class xFt{constructor(t,e){Object.defineProperty(this,"isPlane",{value:!0}),this.normal=void 0!==t?t:new yHt(1,0,0),this.constant=void 0!==e?e:0}set(t,e){return this.normal.copy(t),this.constant=e,this}setComponents(t,e,n,i){return this.normal.set(t,e,n),this.constant=i,this}setFromNormalAndCoplanarPoint(t,e){return this.normal.copy(t),this.constant=-e.dot(this.normal),this}setFromCoplanarPoints(t,e,n){const i=yFt.subVectors(n,e).cross(vFt.subVectors(t,e)).normalize();return this.setFromNormalAndCoplanarPoint(i,t),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){const t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,e){return void 0===e&&(console.warn("THREE.Plane: .projectPoint() target is now required"),e=new yHt),e.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,e){void 0===e&&(console.warn("THREE.Plane: .intersectLine() target is now required"),e=new yHt);const n=t.delta(yFt),i=this.normal.dot(n);if(0===i)return 0===this.distanceToPoint(t.start)?e.copy(t.start):void 0;const r=-(t.start.dot(this.normal)+this.constant)/i;return r<0||r>1?void 0:e.copy(n).multiplyScalar(r).add(t.start)}intersectsLine(t){const e=this.distanceToPoint(t.start),n=this.distanceToPoint(t.end);return e<0&&n>0||n<0&&e>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return void 0===t&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),t=new yHt),t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,e){const n=e||bFt.getNormalMatrix(t),i=this.coplanarPoint(yFt).applyMatrix4(t),r=this.normal.applyMatrix3(n).normalize();return this.constant=-i.dot(r),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}}const wFt=new yHt,SFt=new yHt,MFt=new yHt,EFt=new yHt,TFt=new yHt,AFt=new yHt,CFt=new yHt,kFt=new yHt,LFt=new yHt,PFt=new yHt;class IFt{constructor(t,e,n){this.a=void 0!==t?t:new yHt,this.b=void 0!==e?e:new yHt,this.c=void 0!==n?n:new yHt}static getNormal(t,e,n,i){void 0===i&&(console.warn("THREE.Triangle: .getNormal() target is now required"),i=new yHt),i.subVectors(n,e),wFt.subVectors(t,e),i.cross(wFt);const r=i.lengthSq();return r>0?i.multiplyScalar(1/Math.sqrt(r)):i.set(0,0,0)}static getBarycoord(t,e,n,i,r){wFt.subVectors(i,e),SFt.subVectors(n,e),MFt.subVectors(t,e);const o=wFt.dot(wFt),a=wFt.dot(SFt),s=wFt.dot(MFt),l=SFt.dot(SFt),c=SFt.dot(MFt),u=o*l-a*a;if(void 0===r&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),r=new yHt),0===u)return r.set(-2,-1,-1);const h=1/u,d=(l*s-a*c)*h,p=(o*c-a*s)*h;return r.set(1-d-p,p,d)}static containsPoint(t,e,n,i){return this.getBarycoord(t,e,n,i,EFt),EFt.x>=0&&EFt.y>=0&&EFt.x+EFt.y<=1}static getUV(t,e,n,i,r,o,a,s){return this.getBarycoord(t,e,n,i,EFt),s.set(0,0),s.addScaledVector(r,EFt.x),s.addScaledVector(o,EFt.y),s.addScaledVector(a,EFt.z),s}static isFrontFacing(t,e,n,i){return wFt.subVectors(n,e),SFt.subVectors(t,e),wFt.cross(SFt).dot(i)<0}set(t,e,n){return this.a.copy(t),this.b.copy(e),this.c.copy(n),this}setFromPointsAndIndices(t,e,n,i){return this.a.copy(t[e]),this.b.copy(t[n]),this.c.copy(t[i]),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return wFt.subVectors(this.c,this.b),SFt.subVectors(this.a,this.b),.5*wFt.cross(SFt).length()}getMidpoint(t){return void 0===t&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),t=new yHt),t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return IFt.getNormal(this.a,this.b,this.c,t)}getPlane(t){return void 0===t&&(console.warn("THREE.Triangle: .getPlane() target is now required"),t=new xFt),t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,e){return IFt.getBarycoord(t,this.a,this.b,this.c,e)}getUV(t,e,n,i,r){return IFt.getUV(t,this.a,this.b,this.c,e,n,i,r)}containsPoint(t){return IFt.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return IFt.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,e){void 0===e&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),e=new yHt);const n=this.a,i=this.b,r=this.c;let o,a;TFt.subVectors(i,n),AFt.subVectors(r,n),kFt.subVectors(t,n);const s=TFt.dot(kFt),l=AFt.dot(kFt);if(s<=0&&l<=0)return e.copy(n);LFt.subVectors(t,i);const c=TFt.dot(LFt),u=AFt.dot(LFt);if(c>=0&&u<=c)return e.copy(i);const h=s*u-c*l;if(h<=0&&s>=0&&c<=0)return o=s/(s-c),e.copy(n).addScaledVector(TFt,o);PFt.subVectors(t,r);const d=TFt.dot(PFt),p=AFt.dot(PFt);if(p>=0&&d<=p)return e.copy(r);const f=d*l-s*p;if(f<=0&&l>=0&&p<=0)return a=l/(l-p),e.copy(n).addScaledVector(AFt,a);const m=c*p-d*u;if(m<=0&&u-c>=0&&d-p>=0)return CFt.subVectors(r,i),a=(u-c)/(u-c+(d-p)),e.copy(i).addScaledVector(CFt,a);const g=1/(m+f+h);return o=f*g,a=h*g,e.copy(n).addScaledVector(TFt,o).addScaledVector(AFt,a)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}}const NFt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},OFt={h:0,s:0,l:0},RFt={h:0,s:0,l:0};function zFt(t,e,n){return n<0&&(n+=1),n>1&&(n-=1),n<1/6?t+6*(e-t)*n:n<.5?e:n<2/3?t+6*(e-t)*(2/3-n):t}function DFt(t){return t<.04045?.0773993808*t:Math.pow(.9478672986*t+.0521327014,2.4)}function BFt(t){return t<.0031308?12.92*t:1.055*Math.pow(t,.41666)-.055}class HFt{constructor(t,e,n){return Object.defineProperty(this,"isColor",{value:!0}),void 0===e&&void 0===n?this.set(t):this.setRGB(t,e,n)}set(t){return t&&t.isColor?this.copy(t):"number"==typeof t?this.setHex(t):"string"==typeof t&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(255&t)/255,this}setRGB(t,e,n){return this.r=t,this.g=e,this.b=n,this}setHSL(t,e,n){if(t=sHt.euclideanModulo(t,1),e=sHt.clamp(e,0,1),n=sHt.clamp(n,0,1),0===e)this.r=this.g=this.b=n;else{const i=n<=.5?n*(1+e):n+e-n*e,r=2*n-i;this.r=zFt(r,i,t+1/3),this.g=zFt(r,i,t),this.b=zFt(r,i,t-1/3)}return this}setStyle(t){function e(e){void 0!==e&&parseFloat(e)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let n;if(n=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let t;const i=n[2];switch(n[1]){case"rgb":case"rgba":if(t=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(i))return this.r=Math.min(255,parseInt(t[1],10))/255,this.g=Math.min(255,parseInt(t[2],10))/255,this.b=Math.min(255,parseInt(t[3],10))/255,e(t[4]),this;if(t=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(i))return this.r=Math.min(100,parseInt(t[1],10))/100,this.g=Math.min(100,parseInt(t[2],10))/100,this.b=Math.min(100,parseInt(t[3],10))/100,e(t[4]),this;break;case"hsl":case"hsla":if(t=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(i)){const n=parseFloat(t[1])/360,i=parseInt(t[2],10)/100,r=parseInt(t[3],10)/100;return e(t[4]),this.setHSL(n,i,r)}}}else if(n=/^\#([A-Fa-f\d]+)$/.exec(t)){const t=n[1],e=t.length;if(3===e)return this.r=parseInt(t.charAt(0)+t.charAt(0),16)/255,this.g=parseInt(t.charAt(1)+t.charAt(1),16)/255,this.b=parseInt(t.charAt(2)+t.charAt(2),16)/255,this;if(6===e)return this.r=parseInt(t.charAt(0)+t.charAt(1),16)/255,this.g=parseInt(t.charAt(2)+t.charAt(3),16)/255,this.b=parseInt(t.charAt(4)+t.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){const e=NFt[t];return void 0!==e?this.setHex(e):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copyGammaToLinear(t,e=2){return this.r=Math.pow(t.r,e),this.g=Math.pow(t.g,e),this.b=Math.pow(t.b,e),this}copyLinearToGamma(t,e=2){const n=e>0?1/e:1;return this.r=Math.pow(t.r,n),this.g=Math.pow(t.g,n),this.b=Math.pow(t.b,n),this}convertGammaToLinear(t){return this.copyGammaToLinear(this,t),this}convertLinearToGamma(t){return this.copyLinearToGamma(this,t),this}copySRGBToLinear(t){return this.r=DFt(t.r),this.g=DFt(t.g),this.b=DFt(t.b),this}copyLinearToSRGB(t){return this.r=BFt(t.r),this.g=BFt(t.g),this.b=BFt(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){void 0===t&&(console.warn("THREE.Color: .getHSL() target is now required"),t={h:0,s:0,l:0});const e=this.r,n=this.g,i=this.b,r=Math.max(e,n,i),o=Math.min(e,n,i);let a,s;const l=(o+r)/2;if(o===r)a=0,s=0;else{const t=r-o;switch(s=l<=.5?t/(r+o):t/(2-r-o),r){case e:a=(n-i)/t+(n<i?6:0);break;case n:a=(i-e)/t+2;break;case i:a=(e-n)/t+4}a/=6}return t.h=a,t.s=s,t.l=l,t}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(t,e,n){return this.getHSL(OFt),OFt.h+=t,OFt.s+=e,OFt.l+=n,this.setHSL(OFt.h,OFt.s,OFt.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,e){return this.r=t.r+e.r,this.g=t.g+e.g,this.b=t.b+e.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,e){return this.r+=(t.r-this.r)*e,this.g+=(t.g-this.g)*e,this.b+=(t.b-this.b)*e,this}lerpColors(t,e,n){return this.r=t.r+(e.r-t.r)*n,this.g=t.g+(e.g-t.g)*n,this.b=t.b+(e.b-t.b)*n,this}lerpHSL(t,e){this.getHSL(OFt),t.getHSL(RFt);const n=sHt.lerp(OFt.h,RFt.h,e),i=sHt.lerp(OFt.s,RFt.s,e),r=sHt.lerp(OFt.l,RFt.l,e);return this.setHSL(n,i,r),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,e=0){return this.r=t[e],this.g=t[e+1],this.b=t[e+2],this}toArray(t=[],e=0){return t[e]=this.r,t[e+1]=this.g,t[e+2]=this.b,t}fromBufferAttribute(t,e){return this.r=t.getX(e),this.g=t.getY(e),this.b=t.getZ(e),!0===t.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}HFt.NAMES=NFt,HFt.prototype.r=1,HFt.prototype.g=1,HFt.prototype.b=1;class FFt{constructor(t,e,n,i,r,o=0){this.a=t,this.b=e,this.c=n,this.normal=i&&i.isVector3?i:new yHt,this.vertexNormals=Array.isArray(i)?i:[],this.color=r&&r.isColor?r:new HFt,this.vertexColors=Array.isArray(r)?r:[],this.materialIndex=o}clone(){return(new this.constructor).copy(this)}copy(t){this.a=t.a,this.b=t.b,this.c=t.c,this.normal.copy(t.normal),this.color.copy(t.color),this.materialIndex=t.materialIndex;for(let e=0,n=t.vertexNormals.length;e<n;e++)this.vertexNormals[e]=t.vertexNormals[e].clone();for(let e=0,n=t.vertexColors.length;e<n;e++)this.vertexColors[e]=t.vertexColors[e].clone();return this}}let VFt=0;function jFt(){Object.defineProperty(this,"id",{value:VFt++}),this.uuid=sHt.generateUUID(),this.name="",this.type="Material",this.fog=!0,this.blending=1,this.side=0,this.flatShading=!1,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=204,this.blendDst=205,this.blendEquation=nBt,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=tHt,this.stencilZFail=tHt,this.stencilZPass=tHt,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaTest=0,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0}function UFt(t){jFt.call(this),this.type="MeshBasicMaterial",this.color=new HFt(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.setValues(t)}jFt.prototype=Object.assign(Object.create(rHt.prototype),{constructor:jFt,isMaterial:!0,onBeforeCompile:function(){},customProgramCacheKey:function(){return this.onBeforeCompile.toString()},setValues:function(t){if(void 0!==t)for(const e in t){const n=t[e];if(void 0===n){console.warn("THREE.Material: '"+e+"' parameter is undefined.");continue}if("shading"===e){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===n;continue}const i=this[e];void 0!==i?i&&i.isColor?i.set(n):i&&i.isVector3&&n&&n.isVector3?i.copy(n):this[e]=n:console.warn("THREE."+this.type+": '"+e+"' is not a property of this material.")}},toJSON:function(t){const e=void 0===t||"string"==typeof t;e&&(t={textures:{},images:{}});const n={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function i(t){const e=[];for(const n in t){const i=t[n];delete i.metadata,e.push(i)}return e}if(n.uuid=this.uuid,n.type=this.type,""!==this.name&&(n.name=this.name),this.color&&this.color.isColor&&(n.color=this.color.getHex()),void 0!==this.roughness&&(n.roughness=this.roughness),void 0!==this.metalness&&(n.metalness=this.metalness),this.sheen&&this.sheen.isColor&&(n.sheen=this.sheen.getHex()),this.emissive&&this.emissive.isColor&&(n.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(n.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(n.specular=this.specular.getHex()),void 0!==this.shininess&&(n.shininess=this.shininess),void 0!==this.clearcoat&&(n.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(n.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(n.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(n.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(n.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,n.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(n.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(n.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(n.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(n.lightMap=this.lightMap.toJSON(t).uuid),this.aoMap&&this.aoMap.isTexture&&(n.aoMap=this.aoMap.toJSON(t).uuid,n.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(n.bumpMap=this.bumpMap.toJSON(t).uuid,n.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(n.normalMap=this.normalMap.toJSON(t).uuid,n.normalMapType=this.normalMapType,n.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(n.displacementMap=this.displacementMap.toJSON(t).uuid,n.displacementScale=this.displacementScale,n.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(n.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(n.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(n.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(n.specularMap=this.specularMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(n.envMap=this.envMap.toJSON(t).uuid,n.reflectivity=this.reflectivity,n.refractionRatio=this.refractionRatio,void 0!==this.combine&&(n.combine=this.combine),void 0!==this.envMapIntensity&&(n.envMapIntensity=this.envMapIntensity)),this.gradientMap&&this.gradientMap.isTexture&&(n.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.size&&(n.size=this.size),void 0!==this.sizeAttenuation&&(n.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(n.blending=this.blending),!0===this.flatShading&&(n.flatShading=this.flatShading),0!==this.side&&(n.side=this.side),this.vertexColors&&(n.vertexColors=!0),this.opacity<1&&(n.opacity=this.opacity),!0===this.transparent&&(n.transparent=this.transparent),n.depthFunc=this.depthFunc,n.depthTest=this.depthTest,n.depthWrite=this.depthWrite,n.stencilWrite=this.stencilWrite,n.stencilWriteMask=this.stencilWriteMask,n.stencilFunc=this.stencilFunc,n.stencilRef=this.stencilRef,n.stencilFuncMask=this.stencilFuncMask,n.stencilFail=this.stencilFail,n.stencilZFail=this.stencilZFail,n.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(n.rotation=this.rotation),!0===this.polygonOffset&&(n.polygonOffset=!0),0!==this.polygonOffsetFactor&&(n.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(n.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(n.linewidth=this.linewidth),void 0!==this.dashSize&&(n.dashSize=this.dashSize),void 0!==this.gapSize&&(n.gapSize=this.gapSize),void 0!==this.scale&&(n.scale=this.scale),!0===this.dithering&&(n.dithering=!0),this.alphaTest>0&&(n.alphaTest=this.alphaTest),!0===this.premultipliedAlpha&&(n.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(n.wireframe=this.wireframe),this.wireframeLinewidth>1&&(n.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(n.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(n.wireframeLinejoin=this.wireframeLinejoin),!0===this.morphTargets&&(n.morphTargets=!0),!0===this.morphNormals&&(n.morphNormals=!0),!0===this.skinning&&(n.skinning=!0),!1===this.visible&&(n.visible=!1),!1===this.toneMapped&&(n.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(n.userData=this.userData),e){const e=i(t.textures),r=i(t.images);e.length>0&&(n.textures=e),r.length>0&&(n.images=r)}return n},clone:function(){return(new this.constructor).copy(this)},copy:function(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.flatShading=t.flatShading,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;const e=t.clippingPlanes;let n=null;if(null!==e){const t=e.length;n=new Array(t);for(let i=0;i!==t;++i)n[i]=e[i].clone()}return this.clippingPlanes=n,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this},dispose:function(){this.dispatchEvent({type:"dispose"})}}),Object.defineProperty(jFt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),(UFt.prototype=Object.create(jFt.prototype)).constructor=UFt,UFt.prototype.isMeshBasicMaterial=!0,UFt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this};const GFt=new yHt,WFt=new lHt;function qFt(t,e,n){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=e,this.count=void 0!==t?t.length/e:0,this.normalized=!0===n,this.usage=eHt,this.updateRange={offset:0,count:-1},this.version=0}function YFt(t,e,n){qFt.call(this,new Int8Array(t),e,n)}function XFt(t,e,n){qFt.call(this,new Uint8Array(t),e,n)}function $Ft(t,e,n){qFt.call(this,new Uint8ClampedArray(t),e,n)}function KFt(t,e,n){qFt.call(this,new Int16Array(t),e,n)}function ZFt(t,e,n){qFt.call(this,new Uint16Array(t),e,n)}function JFt(t,e,n){qFt.call(this,new Int32Array(t),e,n)}function QFt(t,e,n){qFt.call(this,new Uint32Array(t),e,n)}function tVt(t,e,n){qFt.call(this,new Uint16Array(t),e,n)}function eVt(t,e,n){qFt.call(this,new Float32Array(t),e,n)}function nVt(t,e,n){qFt.call(this,new Float64Array(t),e,n)}function iVt(t){if(0===t.length)return-1/0;let e=t[0];for(let n=1,i=t.length;n<i;++n)t[n]>e&&(e=t[n]);return e}Object.defineProperty(qFt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(qFt.prototype,{isBufferAttribute:!0,onUploadCallback:function(){},setUsage:function(t){return this.usage=t,this},copy:function(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this},copyAt:function(t,e,n){t*=this.itemSize,n*=e.itemSize;for(let i=0,r=this.itemSize;i<r;i++)this.array[t+i]=e.array[n+i];return this},copyArray:function(t){return this.array.set(t),this},copyColorsArray:function(t){const e=this.array;let n=0;for(let i=0,r=t.length;i<r;i++){let r=t[i];void 0===r&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",i),r=new HFt),e[n++]=r.r,e[n++]=r.g,e[n++]=r.b}return this},copyVector2sArray:function(t){const e=this.array;let n=0;for(let i=0,r=t.length;i<r;i++){let r=t[i];void 0===r&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",i),r=new lHt),e[n++]=r.x,e[n++]=r.y}return this},copyVector3sArray:function(t){const e=this.array;let n=0;for(let i=0,r=t.length;i<r;i++){let r=t[i];void 0===r&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",i),r=new yHt),e[n++]=r.x,e[n++]=r.y,e[n++]=r.z}return this},copyVector4sArray:function(t){const e=this.array;let n=0;for(let i=0,r=t.length;i<r;i++){let r=t[i];void 0===r&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",i),r=new mHt),e[n++]=r.x,e[n++]=r.y,e[n++]=r.z,e[n++]=r.w}return this},applyMatrix3:function(t){if(2===this.itemSize)for(let e=0,n=this.count;e<n;e++)WFt.fromBufferAttribute(this,e),WFt.applyMatrix3(t),this.setXY(e,WFt.x,WFt.y);else if(3===this.itemSize)for(let e=0,n=this.count;e<n;e++)GFt.fromBufferAttribute(this,e),GFt.applyMatrix3(t),this.setXYZ(e,GFt.x,GFt.y,GFt.z);return this},applyMatrix4:function(t){for(let e=0,n=this.count;e<n;e++)GFt.x=this.getX(e),GFt.y=this.getY(e),GFt.z=this.getZ(e),GFt.applyMatrix4(t),this.setXYZ(e,GFt.x,GFt.y,GFt.z);return this},applyNormalMatrix:function(t){for(let e=0,n=this.count;e<n;e++)GFt.x=this.getX(e),GFt.y=this.getY(e),GFt.z=this.getZ(e),GFt.applyNormalMatrix(t),this.setXYZ(e,GFt.x,GFt.y,GFt.z);return this},transformDirection:function(t){for(let e=0,n=this.count;e<n;e++)GFt.x=this.getX(e),GFt.y=this.getY(e),GFt.z=this.getZ(e),GFt.transformDirection(t),this.setXYZ(e,GFt.x,GFt.y,GFt.z);return this},set:function(t,e=0){return this.array.set(t,e),this},getX:function(t){return this.array[t*this.itemSize]},setX:function(t,e){return this.array[t*this.itemSize]=e,this},getY:function(t){return this.array[t*this.itemSize+1]},setY:function(t,e){return this.array[t*this.itemSize+1]=e,this},getZ:function(t){return this.array[t*this.itemSize+2]},setZ:function(t,e){return this.array[t*this.itemSize+2]=e,this},getW:function(t){return this.array[t*this.itemSize+3]},setW:function(t,e){return this.array[t*this.itemSize+3]=e,this},setXY:function(t,e,n){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=n,this},setXYZ:function(t,e,n,i){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=n,this.array[t+2]=i,this},setXYZW:function(t,e,n,i,r){return this.array[0+(t*=this.itemSize)]=e,this.array[t+1]=n,this.array[t+2]=i,this.array[t+3]=r,this},onUpload:function(t){return this.onUploadCallback=t,this},clone:function(){return new this.constructor(this.array,this.itemSize).copy(this)},toJSON:function(){return{itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized}}}),(YFt.prototype=Object.create(qFt.prototype)).constructor=YFt,(XFt.prototype=Object.create(qFt.prototype)).constructor=XFt,($Ft.prototype=Object.create(qFt.prototype)).constructor=$Ft,(KFt.prototype=Object.create(qFt.prototype)).constructor=KFt,(ZFt.prototype=Object.create(qFt.prototype)).constructor=ZFt,(JFt.prototype=Object.create(qFt.prototype)).constructor=JFt,(QFt.prototype=Object.create(qFt.prototype)).constructor=QFt,(tVt.prototype=Object.create(qFt.prototype)).constructor=tVt,tVt.prototype.isFloat16BufferAttribute=!0,(eVt.prototype=Object.create(qFt.prototype)).constructor=eVt,(nVt.prototype=Object.create(qFt.prototype)).constructor=nVt;const rVt={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:"undefined"!=typeof Uint8ClampedArray?Uint8ClampedArray:Uint8Array,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,Float64Array:Float64Array};function oVt(t,e){return new rVt[t](e)}let aVt=0;const sVt=new qHt,lVt=new _Ft,cVt=new yHt,uVt=new xHt,hVt=new xHt,dVt=new yHt;function pVt(){Object.defineProperty(this,"id",{value:aVt++}),this.uuid=sHt.generateUUID(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}pVt.prototype=Object.assign(Object.create(rHt.prototype),{constructor:pVt,isBufferGeometry:!0,getIndex:function(){return this.index},setIndex:function(t){return this.index=Array.isArray(t)?new(iVt(t)>65535?QFt:ZFt)(t,1):t,this},getAttribute:function(t){return this.attributes[t]},setAttribute:function(t,e){return this.attributes[t]=e,this},deleteAttribute:function(t){return delete this.attributes[t],this},hasAttribute:function(t){return void 0!==this.attributes[t]},addGroup:function(t,e,n=0){this.groups.push({start:t,count:e,materialIndex:n})},clearGroups:function(){this.groups=[]},setDrawRange:function(t,e){this.drawRange.start=t,this.drawRange.count=e},applyMatrix4:function(t){const e=this.attributes.position;void 0!==e&&(e.applyMatrix4(t),e.needsUpdate=!0);const n=this.attributes.normal;if(void 0!==n){const e=(new cHt).getNormalMatrix(t);n.applyNormalMatrix(e),n.needsUpdate=!0}const i=this.attributes.tangent;return void 0!==i&&(i.transformDirection(t),i.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this},rotateX:function(t){return sVt.makeRotationX(t),this.applyMatrix4(sVt),this},rotateY:function(t){return sVt.makeRotationY(t),this.applyMatrix4(sVt),this},rotateZ:function(t){return sVt.makeRotationZ(t),this.applyMatrix4(sVt),this},translate:function(t,e,n){return sVt.makeTranslation(t,e,n),this.applyMatrix4(sVt),this},scale:function(t,e,n){return sVt.makeScale(t,e,n),this.applyMatrix4(sVt),this},lookAt:function(t){return lVt.lookAt(t),lVt.updateMatrix(),this.applyMatrix4(lVt.matrix),this},center:function(){return this.computeBoundingBox(),this.boundingBox.getCenter(cVt).negate(),this.translate(cVt.x,cVt.y,cVt.z),this},setFromPoints:function(t){const e=[];for(let n=0,i=t.length;n<i;n++){const i=t[n];e.push(i.x,i.y,i.z||0)}return this.setAttribute("position",new eVt(e,3)),this},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new xHt);const t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new yHt(-1/0,-1/0,-1/0),new yHt(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),e)for(let t=0,n=e.length;t<n;t++)uVt.setFromBufferAttribute(e[t]),this.morphTargetsRelative?(dVt.addVectors(this.boundingBox.min,uVt.min),this.boundingBox.expandByPoint(dVt),dVt.addVectors(this.boundingBox.max,uVt.max),this.boundingBox.expandByPoint(dVt)):(this.boundingBox.expandByPoint(uVt.min),this.boundingBox.expandByPoint(uVt.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)},computeBoundingSphere:function(){null===this.boundingSphere&&(this.boundingSphere=new DHt);const t=this.attributes.position,e=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new yHt,1/0);if(t){const n=this.boundingSphere.center;if(uVt.setFromBufferAttribute(t),e)for(let t=0,n=e.length;t<n;t++)hVt.setFromBufferAttribute(e[t]),this.morphTargetsRelative?(dVt.addVectors(uVt.min,hVt.min),uVt.expandByPoint(dVt),dVt.addVectors(uVt.max,hVt.max),uVt.expandByPoint(dVt)):(uVt.expandByPoint(hVt.min),uVt.expandByPoint(hVt.max));uVt.getCenter(n);let i=0;for(let e=0,r=t.count;e<r;e++)dVt.fromBufferAttribute(t,e),i=Math.max(i,n.distanceToSquared(dVt));if(e)for(let r=0,o=e.length;r<o;r++){const o=e[r],a=this.morphTargetsRelative;for(let e=0,r=o.count;e<r;e++)dVt.fromBufferAttribute(o,e),a&&(cVt.fromBufferAttribute(t,e),dVt.add(cVt)),i=Math.max(i,n.distanceToSquared(dVt))}this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}},computeFaceNormals:function(){},computeTangents:function(){const t=this.index,e=this.attributes;if(null===t||void 0===e.position||void 0===e.normal||void 0===e.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");const n=t.array,i=e.position.array,r=e.normal.array,o=e.uv.array,a=i.length/3;void 0===e.tangent&&this.setAttribute("tangent",new qFt(new Float32Array(4*a),4));const s=e.tangent.array,l=[],c=[];for(let t=0;t<a;t++)l[t]=new yHt,c[t]=new yHt;const u=new yHt,h=new yHt,d=new yHt,p=new lHt,f=new lHt,m=new lHt,g=new yHt,_=new yHt;function y(t,e,n){u.fromArray(i,3*t),h.fromArray(i,3*e),d.fromArray(i,3*n),p.fromArray(o,2*t),f.fromArray(o,2*e),m.fromArray(o,2*n),h.sub(u),d.sub(u),f.sub(p),m.sub(p);const r=1/(f.x*m.y-m.x*f.y);isFinite(r)&&(g.copy(h).multiplyScalar(m.y).addScaledVector(d,-f.y).multiplyScalar(r),_.copy(d).multiplyScalar(f.x).addScaledVector(h,-m.x).multiplyScalar(r),l[t].add(g),l[e].add(g),l[n].add(g),c[t].add(_),c[e].add(_),c[n].add(_))}let v=this.groups;0===v.length&&(v=[{start:0,count:n.length}]);for(let t=0,e=v.length;t<e;++t){const e=v[t],i=e.start;for(let t=i,r=i+e.count;t<r;t+=3)y(n[t+0],n[t+1],n[t+2])}const b=new yHt,x=new yHt,w=new yHt,S=new yHt;function M(t){w.fromArray(r,3*t),S.copy(w);const e=l[t];b.copy(e),b.sub(w.multiplyScalar(w.dot(e))).normalize(),x.crossVectors(S,e);const n=x.dot(c[t])<0?-1:1;s[4*t]=b.x,s[4*t+1]=b.y,s[4*t+2]=b.z,s[4*t+3]=n}for(let t=0,e=v.length;t<e;++t){const e=v[t],i=e.start;for(let t=i,r=i+e.count;t<r;t+=3)M(n[t+0]),M(n[t+1]),M(n[t+2])}},computeVertexNormals:function(){const t=this.index,e=this.getAttribute("position");if(void 0!==e){let n=this.getAttribute("normal");if(void 0===n)n=new qFt(new Float32Array(3*e.count),3),this.setAttribute("normal",n);else for(let t=0,e=n.count;t<e;t++)n.setXYZ(t,0,0,0);const i=new yHt,r=new yHt,o=new yHt,a=new yHt,s=new yHt,l=new yHt,c=new yHt,u=new yHt;if(t)for(let h=0,d=t.count;h<d;h+=3){const d=t.getX(h+0),p=t.getX(h+1),f=t.getX(h+2);i.fromBufferAttribute(e,d),r.fromBufferAttribute(e,p),o.fromBufferAttribute(e,f),c.subVectors(o,r),u.subVectors(i,r),c.cross(u),a.fromBufferAttribute(n,d),s.fromBufferAttribute(n,p),l.fromBufferAttribute(n,f),a.add(c),s.add(c),l.add(c),n.setXYZ(d,a.x,a.y,a.z),n.setXYZ(p,s.x,s.y,s.z),n.setXYZ(f,l.x,l.y,l.z)}else for(let t=0,a=e.count;t<a;t+=3)i.fromBufferAttribute(e,t+0),r.fromBufferAttribute(e,t+1),o.fromBufferAttribute(e,t+2),c.subVectors(o,r),u.subVectors(i,r),c.cross(u),n.setXYZ(t+0,c.x,c.y,c.z),n.setXYZ(t+1,c.x,c.y,c.z),n.setXYZ(t+2,c.x,c.y,c.z);this.normalizeNormals(),n.needsUpdate=!0}},merge:function(t,e){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===e&&(e=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));const n=this.attributes;for(const i in n){if(void 0===t.attributes[i])continue;const r=n[i].array,o=t.attributes[i],a=o.array,s=o.itemSize*e,l=Math.min(a.length,r.length-s);for(let t=0,e=s;t<l;t++,e++)r[e]=a[t]}return this},normalizeNormals:function(){const t=this.attributes.normal;for(let e=0,n=t.count;e<n;e++)dVt.fromBufferAttribute(t,e),dVt.normalize(),t.setXYZ(e,dVt.x,dVt.y,dVt.z)},toNonIndexed:function(){function t(t,e){const n=t.array,i=t.itemSize,r=t.normalized,o=new n.constructor(e.length*i);let a=0,s=0;for(let t=0,r=e.length;t<r;t++){a=e[t]*i;for(let t=0;t<i;t++)o[s++]=n[a++]}return new qFt(o,i,r)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;const e=new pVt,n=this.index.array,i=this.attributes;for(const r in i){const o=t(i[r],n);e.setAttribute(r,o)}const r=this.morphAttributes;for(const i in r){const o=[],a=r[i];for(let e=0,i=a.length;e<i;e++){const i=t(a[e],n);o.push(i)}e.morphAttributes[i]=o}e.morphTargetsRelative=this.morphTargetsRelative;const o=this.groups;for(let t=0,n=o.length;t<n;t++){const n=o[t];e.addGroup(n.start,n.count,n.materialIndex)}return e},toJSON:function(){const t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){const e=this.parameters;for(const n in e)void 0!==e[n]&&(t[n]=e[n]);return t}t.data={attributes:{}};const e=this.index;null!==e&&(t.data.index={type:e.array.constructor.name,array:Array.prototype.slice.call(e.array)});const n=this.attributes;for(const e in n){const i=n[e],r=i.toJSON(t.data);""!==i.name&&(r.name=i.name),t.data.attributes[e]=r}const i={};let r=!1;for(const e in this.morphAttributes){const n=this.morphAttributes[e],o=[];for(let e=0,i=n.length;e<i;e++){const i=n[e],r=i.toJSON(t.data);""!==i.name&&(r.name=i.name),o.push(r)}o.length>0&&(i[e]=o,r=!0)}r&&(t.data.morphAttributes=i,t.data.morphTargetsRelative=this.morphTargetsRelative);const o=this.groups;o.length>0&&(t.data.groups=JSON.parse(JSON.stringify(o)));const a=this.boundingSphere;return null!==a&&(t.data.boundingSphere={center:a.center.toArray(),radius:a.radius}),t},clone:function(){return(new pVt).copy(this)},copy:function(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const e={};this.name=t.name;const n=t.index;null!==n&&this.setIndex(n.clone(e));const i=t.attributes;for(const t in i)this.setAttribute(t,i[t].clone(e));const r=t.morphAttributes;for(const t in r){const n=[],i=r[t];for(let t=0,r=i.length;t<r;t++)n.push(i[t].clone(e));this.morphAttributes[t]=n}this.morphTargetsRelative=t.morphTargetsRelative;const o=t.groups;for(let t=0,e=o.length;t<e;t++){const e=o[t];this.addGroup(e.start,e.count,e.materialIndex)}const a=t.boundingBox;null!==a&&(this.boundingBox=a.clone());const s=t.boundingSphere;return null!==s&&(this.boundingSphere=s.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,this},dispose:function(){this.dispatchEvent({type:"dispose"})}});const fVt=new qHt,mVt=new WHt,gVt=new DHt,_Vt=new yHt,yVt=new yHt,vVt=new yHt,bVt=new yHt,xVt=new yHt,wVt=new yHt,SVt=new yHt,MVt=new yHt,EVt=new yHt,TVt=new lHt,AVt=new lHt,CVt=new lHt,kVt=new yHt,LVt=new yHt;function PVt(t=new pVt,e=new UFt){_Ft.call(this),this.type="Mesh",this.geometry=t,this.material=e,this.updateMorphTargets()}function IVt(t,e,n,i,r,o,a,s,l,c,u,h){_Vt.fromBufferAttribute(r,c),yVt.fromBufferAttribute(r,u),vVt.fromBufferAttribute(r,h);const d=t.morphTargetInfluences;if(e.morphTargets&&o&&d){SVt.set(0,0,0),MVt.set(0,0,0),EVt.set(0,0,0);for(let t=0,e=o.length;t<e;t++){const e=d[t],n=o[t];0!==e&&(bVt.fromBufferAttribute(n,c),xVt.fromBufferAttribute(n,u),wVt.fromBufferAttribute(n,h),a?(SVt.addScaledVector(bVt,e),MVt.addScaledVector(xVt,e),EVt.addScaledVector(wVt,e)):(SVt.addScaledVector(bVt.sub(_Vt),e),MVt.addScaledVector(xVt.sub(yVt),e),EVt.addScaledVector(wVt.sub(vVt),e)))}_Vt.add(SVt),yVt.add(MVt),vVt.add(EVt)}t.isSkinnedMesh&&(t.boneTransform(c,_Vt),t.boneTransform(u,yVt),t.boneTransform(h,vVt));const p=(function f(t,e,n,i,r,o,a,s){let l;if(l=1===e.side?i.intersectTriangle(a,o,r,!0,s):i.intersectTriangle(r,o,a,2!==e.side,s),null===l)return null;LVt.copy(s),LVt.applyMatrix4(t.matrixWorld);const c=n.ray.origin.distanceTo(LVt);return c<n.near||c>n.far?null:{distance:c,point:LVt.clone(),object:t}})(t,e,n,i,_Vt,yVt,vVt,kVt);if(p){s&&(TVt.fromBufferAttribute(s,c),AVt.fromBufferAttribute(s,u),CVt.fromBufferAttribute(s,h),p.uv=IFt.getUV(kVt,_Vt,yVt,vVt,TVt,AVt,CVt,new lHt)),l&&(TVt.fromBufferAttribute(l,c),AVt.fromBufferAttribute(l,u),CVt.fromBufferAttribute(l,h),p.uv2=IFt.getUV(kVt,_Vt,yVt,vVt,TVt,AVt,CVt,new lHt));const t=new FFt(c,u,h);IFt.getNormal(_Vt,yVt,vVt,t.normal),p.face=t}return p}PVt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:PVt,isMesh:!0,copy:function(t){return _Ft.prototype.copy.call(this,t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const e=t.morphAttributes,n=Object.keys(e);if(n.length>0){const t=e[n[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let e=0,n=t.length;e<n;e++){const n=t[e].name||String(e);this.morphTargetInfluences.push(0),this.morphTargetDictionary[n]=e}}}}else{const e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}},raycast:function(t,e){const n=this.geometry,i=this.material,r=this.matrixWorld;if(void 0===i)return;if(null===n.boundingSphere&&n.computeBoundingSphere(),gVt.copy(n.boundingSphere),gVt.applyMatrix4(r),!1===t.ray.intersectsSphere(gVt))return;if(fVt.copy(r).invert(),mVt.copy(t.ray).applyMatrix4(fVt),null!==n.boundingBox&&!1===mVt.intersectsBox(n.boundingBox))return;let o;if(n.isBufferGeometry){const r=n.index,a=n.attributes.position,s=n.morphAttributes.position,l=n.morphTargetsRelative,c=n.attributes.uv,u=n.attributes.uv2,h=n.groups,d=n.drawRange;if(null!==r)if(Array.isArray(i))for(let n=0,p=h.length;n<p;n++){const p=h[n],f=i[p.materialIndex];for(let n=Math.max(p.start,d.start),i=Math.min(p.start+p.count,d.start+d.count);n<i;n+=3){const i=r.getX(n),h=r.getX(n+1),d=r.getX(n+2);o=IVt(this,f,t,mVt,a,s,l,c,u,i,h,d),o&&(o.faceIndex=Math.floor(n/3),o.face.materialIndex=p.materialIndex,e.push(o))}}else for(let n=Math.max(0,d.start),h=Math.min(r.count,d.start+d.count);n<h;n+=3){const h=r.getX(n),d=r.getX(n+1),p=r.getX(n+2);o=IVt(this,i,t,mVt,a,s,l,c,u,h,d,p),o&&(o.faceIndex=Math.floor(n/3),e.push(o))}else if(void 0!==a)if(Array.isArray(i))for(let n=0,r=h.length;n<r;n++){const r=h[n],p=i[r.materialIndex];for(let n=Math.max(r.start,d.start),i=Math.min(r.start+r.count,d.start+d.count);n<i;n+=3)o=IVt(this,p,t,mVt,a,s,l,c,u,n,n+1,n+2),o&&(o.faceIndex=Math.floor(n/3),o.face.materialIndex=r.materialIndex,e.push(o))}else for(let n=Math.max(0,d.start),r=Math.min(a.count,d.start+d.count);n<r;n+=3)o=IVt(this,i,t,mVt,a,s,l,c,u,n,n+1,n+2),o&&(o.faceIndex=Math.floor(n/3),e.push(o))}else n.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}});class NVt extends pVt{constructor(t=1,e=1,n=1,i=1,r=1,o=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:e,depth:n,widthSegments:i,heightSegments:r,depthSegments:o};const a=this;i=Math.floor(i),r=Math.floor(r),o=Math.floor(o);const s=[],l=[],c=[],u=[];let h=0,d=0;function p(t,e,n,i,r,o,p,f,m,g,_){const y=o/m,v=p/g,b=o/2,x=p/2,w=f/2,S=m+1,M=g+1;let E=0,T=0;const A=new yHt;for(let o=0;o<M;o++){const a=o*v-x;for(let s=0;s<S;s++)A[t]=(s*y-b)*i,A[e]=a*r,A[n]=w,l.push(A.x,A.y,A.z),A[t]=0,A[e]=0,A[n]=f>0?1:-1,c.push(A.x,A.y,A.z),u.push(s/m),u.push(1-o/g),E+=1}for(let t=0;t<g;t++)for(let e=0;e<m;e++){const n=h+e+S*(t+1),i=h+(e+1)+S*(t+1),r=h+(e+1)+S*t;s.push(h+e+S*t,n,r),s.push(n,i,r),T+=6}a.addGroup(d,T,_),d+=T,h+=E}p("z","y","x",-1,-1,n,e,t,o,r,0),p("z","y","x",1,-1,n,e,-t,o,r,1),p("x","z","y",1,1,t,n,e,i,o,2),p("x","z","y",1,-1,t,n,-e,i,o,3),p("x","y","z",1,-1,t,e,n,i,r,4),p("x","y","z",-1,-1,t,e,-n,i,r,5),this.setIndex(s),this.setAttribute("position",new eVt(l,3)),this.setAttribute("normal",new eVt(c,3)),this.setAttribute("uv",new eVt(u,2))}}function OVt(t){const e={};for(const n in t){e[n]={};for(const i in t[n]){const r=t[n][i];e[n][i]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture)?r.clone():Array.isArray(r)?r.slice():r}}return e}function RVt(t){const e={};for(let n=0;n<t.length;n++){const i=OVt(t[n]);for(const t in i)e[t]=i[t]}return e}const zVt={clone:OVt,merge:RVt};function DVt(t){jFt.call(this),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}function BVt(){_Ft.call(this),this.type="Camera",this.matrixWorldInverse=new qHt,this.projectionMatrix=new qHt,this.projectionMatrixInverse=new qHt}function HVt(t=50,e=1,n=.1,i=2e3){BVt.call(this),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=n,this.far=i,this.focus=10,this.aspect=e,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}(DVt.prototype=Object.create(jFt.prototype)).constructor=DVt,DVt.prototype.isShaderMaterial=!0,DVt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=OVt(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this},DVt.prototype.toJSON=function(t){const e=jFt.prototype.toJSON.call(this,t);e.glslVersion=this.glslVersion,e.uniforms={};for(const n in this.uniforms){const i=this.uniforms[n].value;e.uniforms[n]=i&&i.isTexture?{type:"t",value:i.toJSON(t).uuid}:i&&i.isColor?{type:"c",value:i.getHex()}:i&&i.isVector2?{type:"v2",value:i.toArray()}:i&&i.isVector3?{type:"v3",value:i.toArray()}:i&&i.isVector4?{type:"v4",value:i.toArray()}:i&&i.isMatrix3?{type:"m3",value:i.toArray()}:i&&i.isMatrix4?{type:"m4",value:i.toArray()}:{value:i}}Object.keys(this.defines).length>0&&(e.defines=this.defines),e.vertexShader=this.vertexShader,e.fragmentShader=this.fragmentShader;const n={};for(const t in this.extensions)!0===this.extensions[t]&&(n[t]=!0);return Object.keys(n).length>0&&(e.extensions=n),e},BVt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:BVt,isCamera:!0,copy:function(t,e){return _Ft.prototype.copy.call(this,t,e),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this},getWorldDirection:function(t){void 0===t&&(console.warn("THREE.Camera: .getWorldDirection() target is now required"),t=new yHt),this.updateWorldMatrix(!0,!1);const e=this.matrixWorld.elements;return t.set(-e[8],-e[9],-e[10]).normalize()},updateMatrixWorld:function(t){_Ft.prototype.updateMatrixWorld.call(this,t),this.matrixWorldInverse.copy(this.matrixWorld).invert()},updateWorldMatrix:function(t,e){_Ft.prototype.updateWorldMatrix.call(this,t,e),this.matrixWorldInverse.copy(this.matrixWorld).invert()},clone:function(){return(new this.constructor).copy(this)}}),HVt.prototype=Object.assign(Object.create(BVt.prototype),{constructor:HVt,isPerspectiveCamera:!0,copy:function(t,e){return BVt.prototype.copy.call(this,t,e),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this},setFocalLength:function(t){const e=.5*this.getFilmHeight()/t;this.fov=2*sHt.RAD2DEG*Math.atan(e),this.updateProjectionMatrix()},getFocalLength:function(){const t=Math.tan(.5*sHt.DEG2RAD*this.fov);return.5*this.getFilmHeight()/t},getEffectiveFOV:function(){return 2*sHt.RAD2DEG*Math.atan(Math.tan(.5*sHt.DEG2RAD*this.fov)/this.zoom)},getFilmWidth:function(){return this.filmGauge*Math.min(this.aspect,1)},getFilmHeight:function(){return this.filmGauge/Math.max(this.aspect,1)},setViewOffset:function(t,e,n,i,r,o){this.aspect=t/e,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=n,this.view.offsetY=i,this.view.width=r,this.view.height=o,this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()},updateProjectionMatrix:function(){const t=this.near;let e=t*Math.tan(.5*sHt.DEG2RAD*this.fov)/this.zoom,n=2*e,i=this.aspect*n,r=-.5*i;const o=this.view;if(null!==this.view&&this.view.enabled){const t=o.fullWidth,a=o.fullHeight;r+=o.offsetX*i/t,e-=o.offsetY*n/a,i*=o.width/t,n*=o.height/a}const a=this.filmOffset;0!==a&&(r+=t*a/this.getFilmWidth()),this.projectionMatrix.makePerspective(r,r+i,e,e-n,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()},toJSON:function(t){const e=_Ft.prototype.toJSON.call(this,t);return e.object.fov=this.fov,e.object.zoom=this.zoom,e.object.near=this.near,e.object.far=this.far,e.object.focus=this.focus,e.object.aspect=this.aspect,null!==this.view&&(e.object.view=Object.assign({},this.view)),e.object.filmGauge=this.filmGauge,e.object.filmOffset=this.filmOffset,e}});const FVt=90;function VVt(t,e,n){if(_Ft.call(this),this.type="CubeCamera",!0!==n.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=n;const i=new HVt(FVt,1,t,e);i.layers=this.layers,i.up.set(0,-1,0),i.lookAt(new yHt(1,0,0)),this.add(i);const r=new HVt(FVt,1,t,e);r.layers=this.layers,r.up.set(0,-1,0),r.lookAt(new yHt(-1,0,0)),this.add(r);const o=new HVt(FVt,1,t,e);o.layers=this.layers,o.up.set(0,0,1),o.lookAt(new yHt(0,1,0)),this.add(o);const a=new HVt(FVt,1,t,e);a.layers=this.layers,a.up.set(0,0,-1),a.lookAt(new yHt(0,-1,0)),this.add(a);const s=new HVt(FVt,1,t,e);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new yHt(0,0,1)),this.add(s);const l=new HVt(FVt,1,t,e);l.layers=this.layers,l.up.set(0,-1,0),l.lookAt(new yHt(0,0,-1)),this.add(l),this.update=function(t,e){null===this.parent&&this.updateMatrixWorld();const c=t.xr.enabled,u=t.getRenderTarget();t.xr.enabled=!1;const h=n.texture.generateMipmaps;n.texture.generateMipmaps=!1,t.setRenderTarget(n,0),t.render(e,i),t.setRenderTarget(n,1),t.render(e,r),t.setRenderTarget(n,2),t.render(e,o),t.setRenderTarget(n,3),t.render(e,a),t.setRenderTarget(n,4),t.render(e,s),n.texture.generateMipmaps=h,t.setRenderTarget(n,5),t.render(e,l),t.setRenderTarget(u),t.xr.enabled=c}}function jVt(t,e,n,i,r,o,a,s,l,c){pHt.call(this,t=void 0!==t?t:[],e=void 0!==e?e:rBt,n,i,r,o,a=void 0!==a?a:EBt,s,l,c),this.flipY=!1,this._needsFlipEnvMap=!0}(VVt.prototype=Object.create(_Ft.prototype)).constructor=VVt,(jVt.prototype=Object.create(pHt.prototype)).constructor=jVt,jVt.prototype.isCubeTexture=!0,Object.defineProperty(jVt.prototype,"images",{get:function(){return this.image},set:function(t){this.image=t}});class UVt extends gHt{constructor(t,e,n){Number.isInteger(e)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),e=n),super(t,t,e),Object.defineProperty(this,"isWebGLCubeRenderTarget",{value:!0}),this.texture=new jVt(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture._needsFlipEnvMap=!1}fromEquirectangularTexture(t,e){this.texture.type=e.type,this.texture.format=TBt,this.texture.encoding=e.encoding,this.texture.generateMipmaps=e.generateMipmaps,this.texture.minFilter=e.minFilter,this.texture.magFilter=e.magFilter;const n=new NVt(5,5,5),i=new DVt({name:"CubemapFromEquirect",uniforms:OVt({tEquirect:{value:null}}),vertexShader:"\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",fragmentShader:"\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",side:1,blending:0});i.uniforms.tEquirect.value=e;const r=new PVt(n,i),o=e.minFilter;return e.minFilter===yBt&&(e.minFilter=gBt),new VVt(1,10,this).update(t,r),e.minFilter=o,r.geometry.dispose(),r.material.dispose(),this}clear(t,e,n,i){const r=t.getRenderTarget();for(let r=0;r<6;r++)t.setRenderTarget(this,r),t.clear(e,n,i);t.setRenderTarget(r)}}function GVt(t,e,n,i,r,o,a,s,l,c,u,h){pHt.call(this,null,o,a,s,l,c,i,r,u,h),this.image={data:t||null,width:e||1,height:n||1},this.magFilter=void 0!==l?l:pBt,this.minFilter=void 0!==c?c:pBt,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1,this.needsUpdate=!0}(GVt.prototype=Object.create(pHt.prototype)).constructor=GVt,GVt.prototype.isDataTexture=!0;const WVt=new DHt,qVt=new yHt;class YVt{constructor(t,e,n,i,r,o){this.planes=[void 0!==t?t:new xFt,void 0!==e?e:new xFt,void 0!==n?n:new xFt,void 0!==i?i:new xFt,void 0!==r?r:new xFt,void 0!==o?o:new xFt]}set(t,e,n,i,r,o){const a=this.planes;return a[0].copy(t),a[1].copy(e),a[2].copy(n),a[3].copy(i),a[4].copy(r),a[5].copy(o),this}clone(){return(new this.constructor).copy(this)}copy(t){const e=this.planes;for(let n=0;n<6;n++)e[n].copy(t.planes[n]);return this}setFromProjectionMatrix(t){const e=this.planes,n=t.elements,i=n[0],r=n[1],o=n[2],a=n[3],s=n[4],l=n[5],c=n[6],u=n[7],h=n[8],d=n[9],p=n[10],f=n[11],m=n[12],g=n[13],_=n[14],y=n[15];return e[0].setComponents(a-i,u-s,f-h,y-m).normalize(),e[1].setComponents(a+i,u+s,f+h,y+m).normalize(),e[2].setComponents(a+r,u+l,f+d,y+g).normalize(),e[3].setComponents(a-r,u-l,f-d,y-g).normalize(),e[4].setComponents(a-o,u-c,f-p,y-_).normalize(),e[5].setComponents(a+o,u+c,f+p,y+_).normalize(),this}intersectsObject(t){const e=t.geometry;return null===e.boundingSphere&&e.computeBoundingSphere(),WVt.copy(e.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(WVt)}intersectsSprite(t){return WVt.center.set(0,0,0),WVt.radius=.7071067811865476,WVt.applyMatrix4(t.matrixWorld),this.intersectsSphere(WVt)}intersectsSphere(t){const e=this.planes,n=t.center,i=-t.radius;for(let t=0;t<6;t++)if(e[t].distanceToPoint(n)<i)return!1;return!0}intersectsBox(t){const e=this.planes;for(let n=0;n<6;n++){const i=e[n];if(qVt.x=i.normal.x>0?t.max.x:t.min.x,qVt.y=i.normal.y>0?t.max.y:t.min.y,qVt.z=i.normal.z>0?t.max.z:t.min.z,i.distanceToPoint(qVt)<0)return!1}return!0}containsPoint(t){const e=this.planes;for(let n=0;n<6;n++)if(e[n].distanceToPoint(t)<0)return!1;return!0}}function XVt(){let t=null,e=!1,n=null,i=null;function r(e,o){n(e,o),i=t.requestAnimationFrame(r)}return{start:function(){!0!==e&&null!==n&&(i=t.requestAnimationFrame(r),e=!0)},stop:function(){t.cancelAnimationFrame(i),e=!1},setAnimationLoop:function(t){n=t},setContext:function(e){t=e}}}function $Vt(t,e){const n=e.isWebGL2,i=new WeakMap;return{get:function r(t){return t.isInterleavedBufferAttribute&&(t=t.data),i.get(t)},remove:function o(e){e.isInterleavedBufferAttribute&&(e=e.data);const n=i.get(e);n&&(t.deleteBuffer(n.buffer),i.delete(e))},update:function a(e,r){if(e.isGLBufferAttribute){const t=i.get(e);return void((!t||t.version<e.version)&&i.set(e,{buffer:e.buffer,type:e.type,bytesPerElement:e.elementSize,version:e.version}))}e.isInterleavedBufferAttribute&&(e=e.data);const o=i.get(e);void 0===o?i.set(e,(function a(e,i){const r=e.array,o=e.usage,a=t.createBuffer();t.bindBuffer(i,a),t.bufferData(i,r,o),e.onUploadCallback();let s=5126;return r instanceof Float32Array?s=5126:r instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):r instanceof Uint16Array?e.isFloat16BufferAttribute?n?s=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):s=5123:r instanceof Int16Array?s=5122:r instanceof Uint32Array?s=5125:r instanceof Int32Array?s=5124:r instanceof Int8Array?s=5120:r instanceof Uint8Array&&(s=5121),{buffer:a,type:s,bytesPerElement:r.BYTES_PER_ELEMENT,version:e.version}})(e,r)):o.version<e.version&&((function s(e,i,r){const o=i.array,a=i.updateRange;t.bindBuffer(r,e),-1===a.count?t.bufferSubData(r,0,o):(n?t.bufferSubData(r,a.offset*o.BYTES_PER_ELEMENT,o,a.offset,a.count):t.bufferSubData(r,a.offset*o.BYTES_PER_ELEMENT,o.subarray(a.offset,a.offset+a.count)),a.count=-1)})(o.buffer,e,r),o.version=e.version)}}}class KVt extends pVt{constructor(t=1,e=1,n=1,i=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:e,widthSegments:n,heightSegments:i};const r=t/2,o=e/2,a=Math.floor(n),s=Math.floor(i),l=a+1,c=s+1,u=t/a,h=e/s,d=[],p=[],f=[],m=[];for(let t=0;t<c;t++){const e=t*h-o;for(let n=0;n<l;n++)p.push(n*u-r,-e,0),f.push(0,0,1),m.push(n/a),m.push(1-t/s)}for(let t=0;t<s;t++)for(let e=0;e<a;e++){const n=e+l*(t+1),i=e+1+l*(t+1),r=e+1+l*t;d.push(e+l*t,n,r),d.push(n,i,r)}this.setIndex(d),this.setAttribute("position",new eVt(p,3)),this.setAttribute("normal",new eVt(f,3)),this.setAttribute("uv",new eVt(m,2))}}const ZVt={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + viewDir );\n\tfloat dotNL = saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss = F * brdf.x + brdf.y;\n\tfloat Ess = brdf.x + brdf.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha = 1.0 / roughness;\n\tfloat cos2h = NoH * NoH;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N = geometry.normal;\n\tvec3 V = geometry.viewDir;\n\tvec3 H = normalize( V + L );\n\tfloat dotNH = saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor.xyz *= color.xyz;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 );\n\t\tvec2 f = fract( uv );\n\t\tuv += 0.5 - f;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\tvec3 tl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x += texelSize;\n\t\tvec3 tr = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.y += texelSize;\n\t\tvec3 br = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x -= texelSize;\n\t\tvec3 bl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tvec3 tm = mix( tl, tr, f.x );\n\t\tvec3 bm = mix( bl, br, f.x );\n\t\treturn mix( tm, bm, f.y );\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat D = max( maxRange / maxRGB, 1.0 );\n\tD = clamp( floor( D ) / 255.0, 0.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value ) {\n\tvec3 Xp_Y_XYZp = cLogLuvM * value.rgb;\n\tXp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract( Le );\n\tvResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifndef ENVMAP_TYPE_CUBE_UV\n\t\tenvColor = envMapTexelToLinear( envColor );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform int maxMipLevel;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( -viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tfogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn texture2D( gradientMap, coord ).rgb;\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\treflectedLight.indirectDiffuse += PI * lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.specularRoughness = max( roughnessFactor, 0.0525 );material.specularRoughness += geometryRoughness;\nmaterial.specularRoughness = min( material.specularRoughness, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheen;\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat specularRoughness;\n\tvec3 specularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *= PI;\n\t\t#endif\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL = ccDotNV;\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\tfloat clearcoatInv = 1.0 - clearcoatDHR;\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifndef USE_MORPHNORMALS\n\t\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\t\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t#endif\n#endif",normal_fragment_begin:"#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent = bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( -vViewPosition, normal, mapN );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\t\tmat3 tsn = mat3( S, T, N );\n\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ));\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmissionmap_fragment:"#ifdef USE_TRANSMISSIONMAP\n\ttotalTransmission *= texture2D( transmissionMap, vUv ).r;\n#endif",transmissionmap_pars_fragment:"#ifdef USE_TRANSMISSIONMAP\n\tuniform sampler2D transmissionMap;\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tvec4 texColor = texture2D( tEquirect, sampleUV );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t\tmatcapColor = matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor = vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#ifndef FLAT_SHADED\n\t\tvNormal = normalize( transformedNormal );\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSMISSION\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSMISSION\n\tuniform float transmission;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <transmissionmap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#ifdef TRANSMISSION\n\t\tfloat totalTransmission = transmission;\n\t#endif\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <transmissionmap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSMISSION\n\t\tdiffuseColor.a *= mix( saturate( 1. - totalTransmission + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) ), 1.0, metalness );\n\t#endif\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",normal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",normal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}"},JVt={common:{diffuse:{value:new HFt(15658734)},opacity:{value:1},map:{value:null},uvTransform:{value:new cHt},uv2Transform:{value:new cHt},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new lHt(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new HFt(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new HFt(15658734)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},uvTransform:{value:new cHt}},sprite:{diffuse:{value:new HFt(15658734)},opacity:{value:1},center:{value:new lHt(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},uvTransform:{value:new cHt}}},QVt={basic:{uniforms:RVt([JVt.common,JVt.specularmap,JVt.envmap,JVt.aomap,JVt.lightmap,JVt.fog]),vertexShader:ZVt.meshbasic_vert,fragmentShader:ZVt.meshbasic_frag},lambert:{uniforms:RVt([JVt.common,JVt.specularmap,JVt.envmap,JVt.aomap,JVt.lightmap,JVt.emissivemap,JVt.fog,JVt.lights,{emissive:{value:new HFt(0)}}]),vertexShader:ZVt.meshlambert_vert,fragmentShader:ZVt.meshlambert_frag},phong:{uniforms:RVt([JVt.common,JVt.specularmap,JVt.envmap,JVt.aomap,JVt.lightmap,JVt.emissivemap,JVt.bumpmap,JVt.normalmap,JVt.displacementmap,JVt.fog,JVt.lights,{emissive:{value:new HFt(0)},specular:{value:new HFt(1118481)},shininess:{value:30}}]),vertexShader:ZVt.meshphong_vert,fragmentShader:ZVt.meshphong_frag},standard:{uniforms:RVt([JVt.common,JVt.envmap,JVt.aomap,JVt.lightmap,JVt.emissivemap,JVt.bumpmap,JVt.normalmap,JVt.displacementmap,JVt.roughnessmap,JVt.metalnessmap,JVt.fog,JVt.lights,{emissive:{value:new HFt(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:ZVt.meshphysical_vert,fragmentShader:ZVt.meshphysical_frag},toon:{uniforms:RVt([JVt.common,JVt.aomap,JVt.lightmap,JVt.emissivemap,JVt.bumpmap,JVt.normalmap,JVt.displacementmap,JVt.gradientmap,JVt.fog,JVt.lights,{emissive:{value:new HFt(0)}}]),vertexShader:ZVt.meshtoon_vert,fragmentShader:ZVt.meshtoon_frag},matcap:{uniforms:RVt([JVt.common,JVt.bumpmap,JVt.normalmap,JVt.displacementmap,JVt.fog,{matcap:{value:null}}]),vertexShader:ZVt.meshmatcap_vert,fragmentShader:ZVt.meshmatcap_frag},points:{uniforms:RVt([JVt.points,JVt.fog]),vertexShader:ZVt.points_vert,fragmentShader:ZVt.points_frag},dashed:{uniforms:RVt([JVt.common,JVt.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:ZVt.linedashed_vert,fragmentShader:ZVt.linedashed_frag},depth:{uniforms:RVt([JVt.common,JVt.displacementmap]),vertexShader:ZVt.depth_vert,fragmentShader:ZVt.depth_frag},normal:{uniforms:RVt([JVt.common,JVt.bumpmap,JVt.normalmap,JVt.displacementmap,{opacity:{value:1}}]),vertexShader:ZVt.normal_vert,fragmentShader:ZVt.normal_frag},sprite:{uniforms:RVt([JVt.sprite,JVt.fog]),vertexShader:ZVt.sprite_vert,fragmentShader:ZVt.sprite_frag},background:{uniforms:{uvTransform:{value:new cHt},t2D:{value:null}},vertexShader:ZVt.background_vert,fragmentShader:ZVt.background_frag},cube:{uniforms:RVt([JVt.envmap,{opacity:{value:1}}]),vertexShader:ZVt.cube_vert,fragmentShader:ZVt.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:ZVt.equirect_vert,fragmentShader:ZVt.equirect_frag},distanceRGBA:{uniforms:RVt([JVt.common,JVt.displacementmap,{referencePosition:{value:new yHt},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:ZVt.distanceRGBA_vert,fragmentShader:ZVt.distanceRGBA_frag},shadow:{uniforms:RVt([JVt.lights,JVt.fog,{color:{value:new HFt(0)},opacity:{value:1}}]),vertexShader:ZVt.shadow_vert,fragmentShader:ZVt.shadow_frag}};function tjt(t,e,n,i,r){const o=new HFt(0);let a,s,l=0,c=null,u=0,h=null;function d(t,e){n.buffers.color.setClear(t.r,t.g,t.b,e,r)}return{getClearColor:function(){return o},setClearColor:function(t,e=1){o.set(t),l=e,d(o,l)},getClearAlpha:function(){return l},setClearAlpha:function(t){l=t,d(o,l)},render:function p(n,r,f,m){let g=!0===r.isScene?r.background:null;g&&g.isTexture&&(g=e.get(g));const _=t.xr,y=_.getSession&&_.getSession();y&&"additive"===y.environmentBlendMode&&(g=null),null===g?d(o,l):g&&g.isColor&&(d(g,1),m=!0),(t.autoClear||m)&&t.clear(t.autoClearColor,t.autoClearDepth,t.autoClearStencil),g&&(g.isCubeTexture||g.isWebGLCubeRenderTarget||g.mapping===lBt)?(void 0===s&&(s=new PVt(new NVt(1,1,1),new DVt({name:"BackgroundCubeMaterial",uniforms:OVt(QVt.cube.uniforms),vertexShader:QVt.cube.vertexShader,fragmentShader:QVt.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),s.geometry.deleteAttribute("normal"),s.geometry.deleteAttribute("uv"),s.onBeforeRender=function(t,e,n){this.matrixWorld.copyPosition(n.matrixWorld)},Object.defineProperty(s.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),i.update(s)),g.isWebGLCubeRenderTarget&&(g=g.texture),s.material.uniforms.envMap.value=g,s.material.uniforms.flipEnvMap.value=g.isCubeTexture&&g._needsFlipEnvMap?-1:1,c===g&&u===g.version&&h===t.toneMapping||(s.material.needsUpdate=!0,c=g,u=g.version,h=t.toneMapping),n.unshift(s,s.geometry,s.material,0,0,null)):g&&g.isTexture&&(void 0===a&&(a=new PVt(new KVt(2,2),new DVt({name:"BackgroundMaterial",uniforms:OVt(QVt.background.uniforms),vertexShader:QVt.background.vertexShader,fragmentShader:QVt.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,fog:!1})),a.geometry.deleteAttribute("normal"),Object.defineProperty(a.material,"map",{get:function(){return this.uniforms.t2D.value}}),i.update(a)),a.material.uniforms.t2D.value=g,!0===g.matrixAutoUpdate&&g.updateMatrix(),a.material.uniforms.uvTransform.value.copy(g.matrix),c===g&&u===g.version&&h===t.toneMapping||(a.material.needsUpdate=!0,c=g,u=g.version,h=t.toneMapping),n.unshift(a,a.geometry,a.material,0,0,null))}}}function ejt(t,e,n,i){const r=t.getParameter(34921),o=i.isWebGL2?null:e.get("OES_vertex_array_object"),a=i.isWebGL2||null!==o,s={},l=d(null);let c=l;function u(e){return i.isWebGL2?t.bindVertexArray(e):o.bindVertexArrayOES(e)}function h(e){return i.isWebGL2?t.deleteVertexArray(e):o.deleteVertexArrayOES(e)}function d(t){const e=[],n=[],i=[];for(let t=0;t<r;t++)e[t]=0,n[t]=0,i[t]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:e,enabledAttributes:n,attributeDivisors:i,object:t,attributes:{},index:null}}function p(){const t=c.newAttributes;for(let e=0,n=t.length;e<n;e++)t[e]=0}function f(t){m(t,0)}function m(n,r){const o=c.enabledAttributes,a=c.attributeDivisors;c.newAttributes[n]=1,0===o[n]&&(t.enableVertexAttribArray(n),o[n]=1),a[n]!==r&&((i.isWebGL2?t:e.get("ANGLE_instanced_arrays"))[i.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](n,r),a[n]=r)}function g(){const e=c.newAttributes,n=c.enabledAttributes;for(let i=0,r=n.length;i<r;i++)n[i]!==e[i]&&(t.disableVertexAttribArray(i),n[i]=0)}function _(e,n,r,o,a,s){!0!==i.isWebGL2||5124!==r&&5125!==r?t.vertexAttribPointer(e,n,r,o,a,s):t.vertexAttribIPointer(e,n,r,a,s)}function y(){v(),c!==l&&(c=l,u(c.object))}function v(){l.geometry=null,l.program=null,l.wireframe=!1}return{setup:function b(r,l,h,y,v){let b=!1;if(a){const e=(function x(e,n,r){const a=!0===r.wireframe;let l=s[e.id];void 0===l&&(l={},s[e.id]=l);let c=l[n.id];void 0===c&&(c={},l[n.id]=c);let u=c[a];return void 0===u&&(u=d((function h(){return i.isWebGL2?t.createVertexArray():o.createVertexArrayOES()})()),c[a]=u),u})(y,h,l);c!==e&&(c=e,u(c.object)),b=(function w(t,e){const n=c.attributes,i=t.attributes;let r=0;for(const t in i){const e=n[t],o=i[t];if(void 0===e)return!0;if(e.attribute!==o)return!0;if(e.data!==o.data)return!0;r++}return c.attributesNum!==r||c.index!==e})(y,v),b&&(function S(t,e){const n={},i=t.attributes;let r=0;for(const t in i){const e=i[t],o={};o.attribute=e,e.data&&(o.data=e.data),n[t]=o,r++}c.attributes=n,c.attributesNum=r,c.index=e})(y,v)}else{const t=!0===l.wireframe;c.geometry===y.id&&c.program===h.id&&c.wireframe===t||(c.geometry=y.id,c.program=h.id,c.wireframe=t,b=!0)}!0===r.isInstancedMesh&&(b=!0),null!==v&&n.update(v,34963),b&&((function M(r,o,a,s){if(!1===i.isWebGL2&&(r.isInstancedMesh||s.isInstancedBufferGeometry)&&null===e.get("ANGLE_instanced_arrays"))return;p();const l=s.attributes,c=a.getAttributes(),u=o.defaultAttributeValues;for(const e in c){const i=c[e];if(i>=0){const o=l[e];if(void 0!==o){const e=o.normalized,r=o.itemSize,a=n.get(o);if(void 0===a)continue;const l=a.buffer,c=a.type,u=a.bytesPerElement;if(o.isInterleavedBufferAttribute){const n=o.data,a=n.stride,h=o.offset;n&&n.isInstancedInterleavedBuffer?(m(i,n.meshPerAttribute),void 0===s._maxInstanceCount&&(s._maxInstanceCount=n.meshPerAttribute*n.count)):f(i),t.bindBuffer(34962,l),_(i,r,c,e,a*u,h*u)}else o.isInstancedBufferAttribute?(m(i,o.meshPerAttribute),void 0===s._maxInstanceCount&&(s._maxInstanceCount=o.meshPerAttribute*o.count)):f(i),t.bindBuffer(34962,l),_(i,r,c,e,0,0)}else if("instanceMatrix"===e){const e=n.get(r.instanceMatrix);if(void 0===e)continue;const o=e.buffer,a=e.type;m(i+0,1),m(i+1,1),m(i+2,1),m(i+3,1),t.bindBuffer(34962,o),t.vertexAttribPointer(i+0,4,a,!1,64,0),t.vertexAttribPointer(i+1,4,a,!1,64,16),t.vertexAttribPointer(i+2,4,a,!1,64,32),t.vertexAttribPointer(i+3,4,a,!1,64,48)}else if("instanceColor"===e){const e=n.get(r.instanceColor);if(void 0===e)continue;const o=e.buffer,a=e.type;m(i,1),t.bindBuffer(34962,o),t.vertexAttribPointer(i,3,a,!1,12,0)}else if(void 0!==u){const n=u[e];if(void 0!==n)switch(n.length){case 2:t.vertexAttrib2fv(i,n);break;case 3:t.vertexAttrib3fv(i,n);break;case 4:t.vertexAttrib4fv(i,n);break;default:t.vertexAttrib1fv(i,n)}}}}g()})(r,l,h,y),null!==v&&t.bindBuffer(34963,n.get(v).buffer))},reset:y,resetDefaultState:v,dispose:function x(){y();for(const t in s){const e=s[t];for(const t in e){const n=e[t];for(const t in n)h(n[t].object),delete n[t];delete e[t]}delete s[t]}},releaseStatesOfGeometry:function w(t){if(void 0===s[t.id])return;const e=s[t.id];for(const t in e){const n=e[t];for(const t in n)h(n[t].object),delete n[t];delete e[t]}delete s[t.id]},releaseStatesOfProgram:function S(t){for(const e in s){const n=s[e];if(void 0===n[t.id])continue;const i=n[t.id];for(const t in i)h(i[t].object),delete i[t];delete n[t.id]}},initAttributes:p,enableAttribute:f,disableUnusedAttributes:g}}function njt(t,e,n,i){const r=i.isWebGL2;let o;this.setMode=function a(t){o=t},this.render=function s(e,i){t.drawArrays(o,e,i),n.update(i,o,1)},this.renderInstances=function l(i,a,s){if(0===s)return;let l,c;if(r)l=t,c="drawArraysInstanced";else if(l=e.get("ANGLE_instanced_arrays"),c="drawArraysInstancedANGLE",null===l)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");l[c](o,i,a,s),n.update(a,o,s)}}function ijt(t,e,n){let i;function r(e){if("highp"===e){if(t.getShaderPrecisionFormat(35633,36338).precision>0&&t.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";e="mediump"}return"mediump"===e&&t.getShaderPrecisionFormat(35633,36337).precision>0&&t.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}const o="undefined"!=typeof WebGL2RenderingContext&&t instanceof WebGL2RenderingContext||"undefined"!=typeof WebGL2ComputeRenderingContext&&t instanceof WebGL2ComputeRenderingContext;let a=void 0!==n.precision?n.precision:"highp";const s=r(a);s!==a&&(console.warn("THREE.WebGLRenderer:",a,"not supported, using",s,"instead."),a=s);const l=!0===n.logarithmicDepthBuffer,c=t.getParameter(34930),u=t.getParameter(35660),h=t.getParameter(3379),d=t.getParameter(34076),p=t.getParameter(34921),f=t.getParameter(36347),m=t.getParameter(36348),g=t.getParameter(36349),_=u>0,y=o||!!e.get("OES_texture_float");return{isWebGL2:o,getMaxAnisotropy:function v(){if(void 0!==i)return i;const n=e.get("EXT_texture_filter_anisotropic");return i=null!==n?t.getParameter(n.MAX_TEXTURE_MAX_ANISOTROPY_EXT):0,i},getMaxPrecision:r,precision:a,logarithmicDepthBuffer:l,maxTextures:c,maxVertexTextures:u,maxTextureSize:h,maxCubemapSize:d,maxAttributes:p,maxVertexUniforms:f,maxVaryings:m,maxFragmentUniforms:g,vertexTextures:_,floatFragmentTextures:y,floatVertexTextures:_&&y,maxSamples:o?t.getParameter(36183):0}}function rjt(t){const e=this;let n=null,i=0,r=!1,o=!1;const a=new xFt,s=new cHt,l={value:null,needsUpdate:!1};function c(){l.value!==n&&(l.value=n,l.needsUpdate=i>0),e.numPlanes=i,e.numIntersection=0}function u(t,n,i,r){const o=null!==t?t.length:0;let c=null;if(0!==o){if(c=l.value,!0!==r||null===c){const e=i+4*o,r=n.matrixWorldInverse;s.getNormalMatrix(r),(null===c||c.length<e)&&(c=new Float32Array(e));for(let e=0,n=i;e!==o;++e,n+=4)a.copy(t[e]).applyMatrix4(r,s),a.normal.toArray(c,n),c[n+3]=a.constant}l.value=c,l.needsUpdate=!0}return e.numPlanes=o,e.numIntersection=0,c}this.uniform=l,this.numPlanes=0,this.numIntersection=0,this.init=function(t,e,o){const a=0!==t.length||e||0!==i||r;return r=e,n=u(t,o,0),i=t.length,a},this.beginShadows=function(){o=!0,u(null)},this.endShadows=function(){o=!1,c()},this.setState=function(e,a,s){const h=e.clippingPlanes,d=e.clipIntersection,p=e.clipShadows,f=t.get(e);if(!r||null===h||0===h.length||o&&!p)o?u(null):c();else{const t=o?0:i,e=4*t;let r=f.clippingState||null;l.value=r,r=u(h,a,e,s);for(let t=0;t!==e;++t)r[t]=n[t];f.clippingState=r,this.numIntersection=d?this.numPlanes:0,this.numPlanes+=t}}}function ojt(t){let e=new WeakMap;function n(t,e){return e===aBt?t.mapping=rBt:e===sBt&&(t.mapping=oBt),t}function i(t){const n=t.target;n.removeEventListener("dispose",i);const r=e.get(n);void 0!==r&&(e.delete(n),r.dispose())}return{get:function r(o){if(o&&o.isTexture){const r=o.mapping;if(r===aBt||r===sBt){if(e.has(o))return n(e.get(o).texture,o.mapping);{const r=o.image;if(r&&r.height>0){const a=t.getRenderList(),s=t.getRenderTarget(),l=new UVt(r.height/2);return l.fromEquirectangularTexture(t,o),e.set(o,l),t.setRenderTarget(s),t.setRenderList(a),o.addEventListener("dispose",i),n(l.texture,o.mapping)}return null}}}return o},dispose:function o(){e=new WeakMap}}}function ajt(t){const e={};function n(n){if(void 0!==e[n])return e[n];let i;switch(n){case"WEBGL_depth_texture":i=t.getExtension("WEBGL_depth_texture")||t.getExtension("MOZ_WEBGL_depth_texture")||t.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":i=t.getExtension("EXT_texture_filter_anisotropic")||t.getExtension("MOZ_EXT_texture_filter_anisotropic")||t.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":i=t.getExtension("WEBGL_compressed_texture_s3tc")||t.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||t.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":i=t.getExtension("WEBGL_compressed_texture_pvrtc")||t.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:i=t.getExtension(n)}return e[n]=i,i}return{has:function(t){return null!==n(t)},init:function(t){t.isWebGL2?n("EXT_color_buffer_float"):(n("WEBGL_depth_texture"),n("OES_texture_float"),n("OES_texture_half_float"),n("OES_texture_half_float_linear"),n("OES_standard_derivatives"),n("OES_element_index_uint"),n("OES_vertex_array_object"),n("ANGLE_instanced_arrays")),n("OES_texture_float_linear"),n("EXT_color_buffer_half_float")},get:function(t){const e=n(t);return null===e&&console.warn("THREE.WebGLRenderer: "+t+" extension not supported."),e}}}function sjt(t,e,n,i){const r={},o=new WeakMap;function a(t){const s=t.target;null!==s.index&&e.remove(s.index);for(const t in s.attributes)e.remove(s.attributes[t]);s.removeEventListener("dispose",a),delete r[s.id];const l=o.get(s);l&&(e.remove(l),o.delete(s)),i.releaseStatesOfGeometry(s),!0===s.isInstancedBufferGeometry&&delete s._maxInstanceCount,n.memory.geometries--}function s(t){const n=[],i=t.index,r=t.attributes.position;let a=0;if(null!==i){const t=i.array;a=i.version;for(let e=0,i=t.length;e<i;e+=3){const i=t[e+0],r=t[e+1],o=t[e+2];n.push(i,r,r,o,o,i)}}else{a=r.version;for(let t=0,e=r.array.length/3-1;t<e;t+=3){const e=t+0,i=t+1,r=t+2;n.push(e,i,i,r,r,e)}}const s=new(iVt(n)>65535?QFt:ZFt)(n,1);s.version=a;const l=o.get(t);l&&e.remove(l),o.set(t,s)}return{get:function l(t,e){return!0===r[e.id]||(e.addEventListener("dispose",a),r[e.id]=!0,n.memory.geometries++),e},update:function c(t){const n=t.attributes;for(const t in n)e.update(n[t],34962);const i=t.morphAttributes;for(const t in i){const n=i[t];for(let t=0,i=n.length;t<i;t++)e.update(n[t],34962)}},getWireframeAttribute:function u(t){const e=o.get(t);if(e){const n=t.index;null!==n&&e.version<n.version&&s(t)}else s(t);return o.get(t)}}}function ljt(t,e,n,i){const r=i.isWebGL2;let o,a,s;this.setMode=function l(t){o=t},this.setIndex=function c(t){a=t.type,s=t.bytesPerElement},this.render=function u(e,i){t.drawElements(o,i,a,e*s),n.update(i,o,1)},this.renderInstances=function h(i,l,c){if(0===c)return;let u,h;if(r)u=t,h="drawElementsInstanced";else if(u=e.get("ANGLE_instanced_arrays"),h="drawElementsInstancedANGLE",null===u)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");u[h](o,l,a,i*s,c),n.update(l,o,c)}}function cjt(t){const e={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:e,programs:null,autoReset:!0,reset:function n(){e.frame++,e.calls=0,e.triangles=0,e.points=0,e.lines=0},update:function i(t,n,r){switch(e.calls++,n){case 4:e.triangles+=r*(t/3);break;case 1:e.lines+=r*(t/2);break;case 3:e.lines+=r*(t-1);break;case 2:e.lines+=r*t;break;case 0:e.points+=r*t;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",n)}}}}function ujt(t,e){return t[0]-e[0]}function hjt(t,e){return Math.abs(e[1])-Math.abs(t[1])}function djt(t){const e={},n=new Float32Array(8),i=[];for(let t=0;t<8;t++)i[t]=[t,0];return{update:function r(o,a,s,l){const c=o.morphTargetInfluences,u=void 0===c?0:c.length;let h=e[a.id];if(void 0===h){h=[];for(let t=0;t<u;t++)h[t]=[t,0];e[a.id]=h}for(let t=0;t<u;t++){const e=h[t];e[0]=t,e[1]=c[t]}h.sort(hjt);for(let t=0;t<8;t++)t<u&&h[t][1]?(i[t][0]=h[t][0],i[t][1]=h[t][1]):(i[t][0]=Number.MAX_SAFE_INTEGER,i[t][1]=0);i.sort(ujt);const d=s.morphTargets&&a.morphAttributes.position,p=s.morphNormals&&a.morphAttributes.normal;let f=0;for(let t=0;t<8;t++){const e=i[t],r=e[0],o=e[1];r!==Number.MAX_SAFE_INTEGER&&o?(d&&a.getAttribute("morphTarget"+t)!==d[r]&&a.setAttribute("morphTarget"+t,d[r]),p&&a.getAttribute("morphNormal"+t)!==p[r]&&a.setAttribute("morphNormal"+t,p[r]),n[t]=o,f+=o):(d&&!0===a.hasAttribute("morphTarget"+t)&&a.deleteAttribute("morphTarget"+t),p&&!0===a.hasAttribute("morphNormal"+t)&&a.deleteAttribute("morphNormal"+t),n[t]=0)}const m=a.morphTargetsRelative?1:1-f;l.getUniforms().setValue(t,"morphTargetBaseInfluence",m),l.getUniforms().setValue(t,"morphTargetInfluences",n)}}}function pjt(t,e,n,i){let r=new WeakMap;function o(t){const e=t.target;e.removeEventListener("dispose",o),n.remove(e.instanceMatrix),null!==e.instanceColor&&n.remove(e.instanceColor)}return{update:function a(t){const a=i.render.frame,s=e.get(t,t.geometry);return r.get(s)!==a&&(e.update(s),r.set(s,a)),t.isInstancedMesh&&(!1===t.hasEventListener("dispose",o)&&t.addEventListener("dispose",o),n.update(t.instanceMatrix,34962),null!==t.instanceColor&&n.update(t.instanceColor,34962)),s},dispose:function s(){r=new WeakMap}}}function fjt(t=null,e=1,n=1,i=1){pHt.call(this,null),this.image={data:t,width:e,height:n,depth:i},this.magFilter=pBt,this.minFilter=pBt,this.wrapR=hBt,this.generateMipmaps=!1,this.flipY=!1,this.needsUpdate=!0}function mjt(t=null,e=1,n=1,i=1){pHt.call(this,null),this.image={data:t,width:e,height:n,depth:i},this.magFilter=pBt,this.minFilter=pBt,this.wrapR=hBt,this.generateMipmaps=!1,this.flipY=!1,this.needsUpdate=!0}QVt.physical={uniforms:RVt([QVt.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new lHt(1,1)},clearcoatNormalMap:{value:null},sheen:{value:new HFt(0)},transmission:{value:0},transmissionMap:{value:null}}]),vertexShader:ZVt.meshphysical_vert,fragmentShader:ZVt.meshphysical_frag},(fjt.prototype=Object.create(pHt.prototype)).constructor=fjt,fjt.prototype.isDataTexture2DArray=!0,(mjt.prototype=Object.create(pHt.prototype)).constructor=mjt,mjt.prototype.isDataTexture3D=!0;const gjt=new pHt,_jt=new fjt,yjt=new mjt,vjt=new jVt,bjt=[],xjt=[],wjt=new Float32Array(16),Sjt=new Float32Array(9),Mjt=new Float32Array(4);function Ejt(t,e,n){const i=t[0];if(i<=0||i>0)return t;const r=e*n;let o=bjt[r];if(void 0===o&&(o=new Float32Array(r),bjt[r]=o),0!==e){i.toArray(o,0);for(let i=1,r=0;i!==e;++i)r+=n,t[i].toArray(o,r)}return o}function Tjt(t,e){if(t.length!==e.length)return!1;for(let n=0,i=t.length;n<i;n++)if(t[n]!==e[n])return!1;return!0}function Ajt(t,e){for(let n=0,i=e.length;n<i;n++)t[n]=e[n]}function Cjt(t,e){let n=xjt[e];void 0===n&&(n=new Int32Array(e),xjt[e]=n);for(let i=0;i!==e;++i)n[i]=t.allocateTextureUnit();return n}function kjt(t,e){const n=this.cache;n[0]!==e&&(t.uniform1f(this.addr,e),n[0]=e)}function Ljt(t,e){const n=this.cache;if(void 0!==e.x)n[0]===e.x&&n[1]===e.y||(t.uniform2f(this.addr,e.x,e.y),n[0]=e.x,n[1]=e.y);else{if(Tjt(n,e))return;t.uniform2fv(this.addr,e),Ajt(n,e)}}function Pjt(t,e){const n=this.cache;if(void 0!==e.x)n[0]===e.x&&n[1]===e.y&&n[2]===e.z||(t.uniform3f(this.addr,e.x,e.y,e.z),n[0]=e.x,n[1]=e.y,n[2]=e.z);else if(void 0!==e.r)n[0]===e.r&&n[1]===e.g&&n[2]===e.b||(t.uniform3f(this.addr,e.r,e.g,e.b),n[0]=e.r,n[1]=e.g,n[2]=e.b);else{if(Tjt(n,e))return;t.uniform3fv(this.addr,e),Ajt(n,e)}}function Ijt(t,e){const n=this.cache;if(void 0!==e.x)n[0]===e.x&&n[1]===e.y&&n[2]===e.z&&n[3]===e.w||(t.uniform4f(this.addr,e.x,e.y,e.z,e.w),n[0]=e.x,n[1]=e.y,n[2]=e.z,n[3]=e.w);else{if(Tjt(n,e))return;t.uniform4fv(this.addr,e),Ajt(n,e)}}function Njt(t,e){const n=this.cache,i=e.elements;if(void 0===i){if(Tjt(n,e))return;t.uniformMatrix2fv(this.addr,!1,e),Ajt(n,e)}else{if(Tjt(n,i))return;Mjt.set(i),t.uniformMatrix2fv(this.addr,!1,Mjt),Ajt(n,i)}}function Ojt(t,e){const n=this.cache,i=e.elements;if(void 0===i){if(Tjt(n,e))return;t.uniformMatrix3fv(this.addr,!1,e),Ajt(n,e)}else{if(Tjt(n,i))return;Sjt.set(i),t.uniformMatrix3fv(this.addr,!1,Sjt),Ajt(n,i)}}function Rjt(t,e){const n=this.cache,i=e.elements;if(void 0===i){if(Tjt(n,e))return;t.uniformMatrix4fv(this.addr,!1,e),Ajt(n,e)}else{if(Tjt(n,i))return;wjt.set(i),t.uniformMatrix4fv(this.addr,!1,wjt),Ajt(n,i)}}function zjt(t,e,n){const i=this.cache,r=n.allocateTextureUnit();i[0]!==r&&(t.uniform1i(this.addr,r),i[0]=r),n.safeSetTexture2D(e||gjt,r)}function Djt(t,e,n){const i=this.cache,r=n.allocateTextureUnit();i[0]!==r&&(t.uniform1i(this.addr,r),i[0]=r),n.setTexture2DArray(e||_jt,r)}function Bjt(t,e,n){const i=this.cache,r=n.allocateTextureUnit();i[0]!==r&&(t.uniform1i(this.addr,r),i[0]=r),n.setTexture3D(e||yjt,r)}function Hjt(t,e,n){const i=this.cache,r=n.allocateTextureUnit();i[0]!==r&&(t.uniform1i(this.addr,r),i[0]=r),n.safeSetTextureCube(e||vjt,r)}function Fjt(t,e){const n=this.cache;n[0]!==e&&(t.uniform1i(this.addr,e),n[0]=e)}function Vjt(t,e){const n=this.cache;Tjt(n,e)||(t.uniform2iv(this.addr,e),Ajt(n,e))}function jjt(t,e){const n=this.cache;Tjt(n,e)||(t.uniform3iv(this.addr,e),Ajt(n,e))}function Ujt(t,e){const n=this.cache;Tjt(n,e)||(t.uniform4iv(this.addr,e),Ajt(n,e))}function Gjt(t,e){const n=this.cache;n[0]!==e&&(t.uniform1ui(this.addr,e),n[0]=e)}function Wjt(t,e){t.uniform1fv(this.addr,e)}function qjt(t,e){t.uniform1iv(this.addr,e)}function Yjt(t,e){t.uniform2iv(this.addr,e)}function Xjt(t,e){t.uniform3iv(this.addr,e)}function $jt(t,e){t.uniform4iv(this.addr,e)}function Kjt(t,e){const n=Ejt(e,this.size,2);t.uniform2fv(this.addr,n)}function Zjt(t,e){const n=Ejt(e,this.size,3);t.uniform3fv(this.addr,n)}function Jjt(t,e){const n=Ejt(e,this.size,4);t.uniform4fv(this.addr,n)}function Qjt(t,e){const n=Ejt(e,this.size,4);t.uniformMatrix2fv(this.addr,!1,n)}function tUt(t,e){const n=Ejt(e,this.size,9);t.uniformMatrix3fv(this.addr,!1,n)}function eUt(t,e){const n=Ejt(e,this.size,16);t.uniformMatrix4fv(this.addr,!1,n)}function nUt(t,e,n){const i=e.length,r=Cjt(n,i);t.uniform1iv(this.addr,r);for(let t=0;t!==i;++t)n.safeSetTexture2D(e[t]||gjt,r[t])}function iUt(t,e,n){const i=e.length,r=Cjt(n,i);t.uniform1iv(this.addr,r);for(let t=0;t!==i;++t)n.safeSetTextureCube(e[t]||vjt,r[t])}function rUt(t,e,n){this.id=t,this.addr=n,this.cache=[],this.setValue=(function i(t){switch(t){case 5126:return kjt;case 35664:return Ljt;case 35665:return Pjt;case 35666:return Ijt;case 35674:return Njt;case 35675:return Ojt;case 35676:return Rjt;case 5124:case 35670:return Fjt;case 35667:case 35671:return Vjt;case 35668:case 35672:return jjt;case 35669:case 35673:return Ujt;case 5125:return Gjt;case 35678:case 36198:case 36298:case 36306:case 35682:return zjt;case 35679:case 36299:case 36307:return Bjt;case 35680:case 36300:case 36308:case 36293:return Hjt;case 36289:case 36303:case 36311:case 36292:return Djt}})(e.type)}function oUt(t,e,n){this.id=t,this.addr=n,this.cache=[],this.size=e.size,this.setValue=(function i(t){switch(t){case 5126:return Wjt;case 35664:return Kjt;case 35665:return Zjt;case 35666:return Jjt;case 35674:return Qjt;case 35675:return tUt;case 35676:return eUt;case 5124:case 35670:return qjt;case 35667:case 35671:return Yjt;case 35668:case 35672:return Xjt;case 35669:case 35673:return $jt;case 35678:case 36198:case 36298:case 36306:case 35682:return nUt;case 35680:case 36300:case 36308:case 36293:return iUt}})(e.type)}function aUt(t){this.id=t,this.seq=[],this.map={}}oUt.prototype.updateCache=function(t){const e=this.cache;t instanceof Float32Array&&e.length!==t.length&&(this.cache=new Float32Array(t.length)),Ajt(e,t)},aUt.prototype.setValue=function(t,e,n){const i=this.seq;for(let r=0,o=i.length;r!==o;++r){const o=i[r];o.setValue(t,e[o.id],n)}};const sUt=/(\w+)(\])?(\[|\.)?/g;function lUt(t,e){t.seq.push(e),t.map[e.id]=e}function cUt(t,e,n){const i=t.name,r=i.length;for(sUt.lastIndex=0;;){const o=sUt.exec(i),a=sUt.lastIndex;let s=o[1];const l=o[3];if("]"===o[2]&&(s|=0),void 0===l||"["===l&&a+2===r){lUt(n,void 0===l?new rUt(s,t,e):new oUt(s,t,e));break}{let t=n.map[s];void 0===t&&(t=new aUt(s),lUt(n,t)),n=t}}}function uUt(t,e){this.seq=[],this.map={};const n=t.getProgramParameter(e,35718);for(let i=0;i<n;++i){const n=t.getActiveUniform(e,i);cUt(n,t.getUniformLocation(e,n.name),this)}}function hUt(t,e,n){const i=t.createShader(e);return t.shaderSource(i,n),t.compileShader(i),i}uUt.prototype.setValue=function(t,e,n,i){const r=this.map[e];void 0!==r&&r.setValue(t,n,i)},uUt.prototype.setOptional=function(t,e,n){const i=e[n];void 0!==i&&this.setValue(t,n,i)},uUt.upload=function(t,e,n,i){for(let r=0,o=e.length;r!==o;++r){const o=e[r],a=n[o.id];!1!==a.needsUpdate&&o.setValue(t,a.value,i)}},uUt.seqWithValue=function(t,e){const n=[];for(let i=0,r=t.length;i!==r;++i){const r=t[i];r.id in e&&n.push(r)}return n};let dUt=0;function pUt(t){switch(t){case YBt:return["Linear","( value )"];case XBt:return["sRGB","( value )"];case KBt:return["RGBE","( value )"];case ZBt:return["RGBM","( value, 7.0 )"];case JBt:return["RGBM","( value, 16.0 )"];case QBt:return["RGBD","( value, 256.0 )"];case $Bt:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case 3003:return["LogLuv","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",t),["Linear","( value )"]}}function fUt(t,e,n){const i=t.getShaderParameter(e,35713),r=t.getShaderInfoLog(e).trim();return i&&""===r?"":"THREE.WebGLShader: gl.getShaderInfoLog() "+n+"\n"+r+(function o(t){const e=t.split("\n");for(let t=0;t<e.length;t++)e[t]=t+1+": "+e[t];return e.join("\n")})(t.getShaderSource(e))}function mUt(t,e){const n=pUt(e);return"vec4 "+t+"( vec4 value ) { return "+n[0]+"ToLinear"+n[1]+"; }"}function gUt(t,e){const n=pUt(e);return"vec4 "+t+"( vec4 value ) { return LinearTo"+n[0]+n[1]+"; }"}function _Ut(t,e){let n;switch(e){case 1:n="Linear";break;case 2:n="Reinhard";break;case 3:n="OptimizedCineon";break;case 4:n="ACESFilmic";break;case 5:n="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",e),n="Linear"}return"vec3 "+t+"( vec3 color ) { return "+n+"ToneMapping( color ); }"}function yUt(t){return""!==t}function vUt(t,e){return t.replace(/NUM_DIR_LIGHTS/g,e.numDirLights).replace(/NUM_SPOT_LIGHTS/g,e.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,e.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,e.numPointLights).replace(/NUM_HEMI_LIGHTS/g,e.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,e.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,e.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,e.numPointLightShadows)}function bUt(t,e){return t.replace(/NUM_CLIPPING_PLANES/g,e.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,e.numClippingPlanes-e.numClipIntersection)}const xUt=/^[ \t]*#include +<([\w\d./]+)>/gm;function wUt(t){return t.replace(xUt,SUt)}function SUt(t,e){const n=ZVt[e];if(void 0===n)throw new Error("Can not resolve #include <"+e+">");return wUt(n)}const MUt=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,EUt=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function TUt(t){return t.replace(EUt,CUt).replace(MUt,AUt)}function AUt(t,e,n,i){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),CUt(0,e,n,i)}function CUt(t,e,n,i){let r="";for(let t=parseInt(e);t<parseInt(n);t++)r+=i.replace(/\[\s*i\s*\]/g,"[ "+t+" ]").replace(/UNROLLED_LOOP_INDEX/g,t);return r}function kUt(t){let e="precision "+t.precision+" float;\nprecision "+t.precision+" int;";return"highp"===t.precision?e+="\n#define HIGH_PRECISION":"mediump"===t.precision?e+="\n#define MEDIUM_PRECISION":"lowp"===t.precision&&(e+="\n#define LOW_PRECISION"),e}function LUt(t,e,n,i){const r=t.getContext(),o=n.defines;let a=n.vertexShader,s=n.fragmentShader;const l=(function c(t){let e="SHADOWMAP_TYPE_BASIC";return 1===t.shadowMapType?e="SHADOWMAP_TYPE_PCF":2===t.shadowMapType?e="SHADOWMAP_TYPE_PCF_SOFT":3===t.shadowMapType&&(e="SHADOWMAP_TYPE_VSM"),e})(n),u=(function h(t){let e="ENVMAP_TYPE_CUBE";if(t.envMap)switch(t.envMapMode){case rBt:case oBt:e="ENVMAP_TYPE_CUBE";break;case lBt:case cBt:e="ENVMAP_TYPE_CUBE_UV"}return e})(n),d=(function p(t){let e="ENVMAP_MODE_REFLECTION";if(t.envMap)switch(t.envMapMode){case oBt:case cBt:e="ENVMAP_MODE_REFRACTION"}return e})(n),f=(function m(t){let e="ENVMAP_BLENDING_NONE";if(t.envMap)switch(t.combine){case 0:e="ENVMAP_BLENDING_MULTIPLY";break;case 1:e="ENVMAP_BLENDING_MIX";break;case 2:e="ENVMAP_BLENDING_ADD"}return e})(n),g=t.gammaFactor>0?t.gammaFactor:1,_=n.isWebGL2?"":(function y(t){return[t.extensionDerivatives||t.envMapCubeUV||t.bumpMap||t.tangentSpaceNormalMap||t.clearcoatNormalMap||t.flatShading||"physical"===t.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(t.extensionFragDepth||t.logarithmicDepthBuffer)&&t.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",t.extensionDrawBuffers&&t.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(t.extensionShaderTextureLOD||t.envMap)&&t.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(yUt).join("\n")})(n),v=(function b(t){const e=[];for(const n in t){const i=t[n];!1!==i&&e.push("#define "+n+" "+i)}return e.join("\n")})(o),x=r.createProgram();let w,S,M=n.glslVersion?"#version "+n.glslVersion+"\n":"";n.isRawShaderMaterial?(w=[v].filter(yUt).join("\n"),w.length>0&&(w+="\n"),S=[_,v].filter(yUt).join("\n"),S.length>0&&(S+="\n")):(w=[kUt(n),"#define SHADER_NAME "+n.shaderName,v,n.instancing?"#define USE_INSTANCING":"",n.instancingColor?"#define USE_INSTANCING_COLOR":"",n.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+g,"#define MAX_BONES "+n.maxBones,n.useFog&&n.fog?"#define USE_FOG":"",n.useFog&&n.fogExp2?"#define FOG_EXP2":"",n.map?"#define USE_MAP":"",n.envMap?"#define USE_ENVMAP":"",n.envMap?"#define "+d:"",n.lightMap?"#define USE_LIGHTMAP":"",n.aoMap?"#define USE_AOMAP":"",n.emissiveMap?"#define USE_EMISSIVEMAP":"",n.bumpMap?"#define USE_BUMPMAP":"",n.normalMap?"#define USE_NORMALMAP":"",n.normalMap&&n.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",n.normalMap&&n.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",n.clearcoatMap?"#define USE_CLEARCOATMAP":"",n.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",n.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",n.displacementMap&&n.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",n.specularMap?"#define USE_SPECULARMAP":"",n.roughnessMap?"#define USE_ROUGHNESSMAP":"",n.metalnessMap?"#define USE_METALNESSMAP":"",n.alphaMap?"#define USE_ALPHAMAP":"",n.transmissionMap?"#define USE_TRANSMISSIONMAP":"",n.vertexTangents?"#define USE_TANGENT":"",n.vertexColors?"#define USE_COLOR":"",n.vertexUvs?"#define USE_UV":"",n.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",n.flatShading?"#define FLAT_SHADED":"",n.skinning?"#define USE_SKINNING":"",n.useVertexTexture?"#define BONE_TEXTURE":"",n.morphTargets?"#define USE_MORPHTARGETS":"",n.morphNormals&&!1===n.flatShading?"#define USE_MORPHNORMALS":"",n.doubleSided?"#define DOUBLE_SIDED":"",n.flipSided?"#define FLIP_SIDED":"",n.shadowMapEnabled?"#define USE_SHADOWMAP":"",n.shadowMapEnabled?"#define "+l:"",n.sizeAttenuation?"#define USE_SIZEATTENUATION":"",n.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",n.logarithmicDepthBuffer&&n.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#ifdef USE_COLOR","\tattribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(yUt).join("\n"),S=[_,kUt(n),"#define SHADER_NAME "+n.shaderName,v,n.alphaTest?"#define ALPHATEST "+n.alphaTest+(n.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+g,n.useFog&&n.fog?"#define USE_FOG":"",n.useFog&&n.fogExp2?"#define FOG_EXP2":"",n.map?"#define USE_MAP":"",n.matcap?"#define USE_MATCAP":"",n.envMap?"#define USE_ENVMAP":"",n.envMap?"#define "+u:"",n.envMap?"#define "+d:"",n.envMap?"#define "+f:"",n.lightMap?"#define USE_LIGHTMAP":"",n.aoMap?"#define USE_AOMAP":"",n.emissiveMap?"#define USE_EMISSIVEMAP":"",n.bumpMap?"#define USE_BUMPMAP":"",n.normalMap?"#define USE_NORMALMAP":"",n.normalMap&&n.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",n.normalMap&&n.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",n.clearcoatMap?"#define USE_CLEARCOATMAP":"",n.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",n.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",n.specularMap?"#define USE_SPECULARMAP":"",n.roughnessMap?"#define USE_ROUGHNESSMAP":"",n.metalnessMap?"#define USE_METALNESSMAP":"",n.alphaMap?"#define USE_ALPHAMAP":"",n.sheen?"#define USE_SHEEN":"",n.transmissionMap?"#define USE_TRANSMISSIONMAP":"",n.vertexTangents?"#define USE_TANGENT":"",n.vertexColors||n.instancingColor?"#define USE_COLOR":"",n.vertexUvs?"#define USE_UV":"",n.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",n.gradientMap?"#define USE_GRADIENTMAP":"",n.flatShading?"#define FLAT_SHADED":"",n.doubleSided?"#define DOUBLE_SIDED":"",n.flipSided?"#define FLIP_SIDED":"",n.shadowMapEnabled?"#define USE_SHADOWMAP":"",n.shadowMapEnabled?"#define "+l:"",n.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",n.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",n.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",n.logarithmicDepthBuffer&&n.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(n.extensionShaderTextureLOD||n.envMap)&&n.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",0!==n.toneMapping?"#define TONE_MAPPING":"",0!==n.toneMapping?ZVt.tonemapping_pars_fragment:"",0!==n.toneMapping?_Ut("toneMapping",n.toneMapping):"",n.dithering?"#define DITHERING":"",ZVt.encodings_pars_fragment,n.map?mUt("mapTexelToLinear",n.mapEncoding):"",n.matcap?mUt("matcapTexelToLinear",n.matcapEncoding):"",n.envMap?mUt("envMapTexelToLinear",n.envMapEncoding):"",n.emissiveMap?mUt("emissiveMapTexelToLinear",n.emissiveMapEncoding):"",n.lightMap?mUt("lightMapTexelToLinear",n.lightMapEncoding):"",gUt("linearToOutputTexel",n.outputEncoding),n.depthPacking?"#define DEPTH_PACKING "+n.depthPacking:"","\n"].filter(yUt).join("\n")),a=wUt(a),a=vUt(a,n),a=bUt(a,n),s=wUt(s),s=vUt(s,n),s=bUt(s,n),a=TUt(a),s=TUt(s),n.isWebGL2&&!0!==n.isRawShaderMaterial&&(M="#version 300 es\n",w=["#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+w,S=["#define varying in",n.glslVersion===iHt?"":"out highp vec4 pc_fragColor;",n.glslVersion===iHt?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+S);const E=M+S+s,T=hUt(r,35633,M+w+a),A=hUt(r,35632,E);if(r.attachShader(x,T),r.attachShader(x,A),void 0!==n.index0AttributeName?r.bindAttribLocation(x,0,n.index0AttributeName):!0===n.morphTargets&&r.bindAttribLocation(x,0,"position"),r.linkProgram(x),t.debug.checkShaderErrors){const t=r.getProgramInfoLog(x).trim(),e=r.getShaderInfoLog(T).trim(),n=r.getShaderInfoLog(A).trim();let i=!0,o=!0;if(!1===r.getProgramParameter(x,35714)){i=!1;const e=fUt(r,T,"vertex"),n=fUt(r,A,"fragment");console.error("THREE.WebGLProgram: shader error: ",r.getError(),"35715",r.getProgramParameter(x,35715),"gl.getProgramInfoLog",t,e,n)}else""!==t?console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",t):""!==e&&""!==n||(o=!1);o&&(this.diagnostics={runnable:i,programLog:t,vertexShader:{log:e,prefix:w},fragmentShader:{log:n,prefix:S}})}let C,k;return r.deleteShader(T),r.deleteShader(A),this.getUniforms=function(){return void 0===C&&(C=new uUt(r,x)),C},this.getAttributes=function(){return void 0===k&&(k=(function t(e,n){const i={},r=e.getProgramParameter(n,35721);for(let t=0;t<r;t++){const r=e.getActiveAttrib(n,t).name;i[r]=e.getAttribLocation(n,r)}return i})(r,x)),k},this.destroy=function(){i.releaseStatesOfProgram(this),r.deleteProgram(x),this.program=void 0},this.name=n.shaderName,this.id=dUt++,this.cacheKey=e,this.usedTimes=1,this.program=x,this.vertexShader=T,this.fragmentShader=A,this}function PUt(t,e,n,i,r,o){const a=[],s=i.isWebGL2,l=i.logarithmicDepthBuffer,c=i.floatVertexTextures,u=i.maxVertexUniforms,h=i.vertexTextures;let d=i.precision;const p={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},f=["precision","isWebGL2","supportsVertexTextures","outputEncoding","instancing","instancingColor","map","mapEncoding","matcap","matcapEncoding","envMap","envMapMode","envMapEncoding","envMapCubeUV","lightMap","lightMapEncoding","aoMap","emissiveMap","emissiveMapEncoding","bumpMap","normalMap","objectSpaceNormalMap","tangentSpaceNormalMap","clearcoatMap","clearcoatRoughnessMap","clearcoatNormalMap","displacementMap","specularMap","roughnessMap","metalnessMap","gradientMap","alphaMap","combine","vertexColors","vertexTangents","vertexUvs","uvsVertexOnly","fog","useFog","fogExp2","flatShading","sizeAttenuation","logarithmicDepthBuffer","skinning","maxBones","useVertexTexture","morphTargets","morphNormals","maxMorphTargets","maxMorphNormals","premultipliedAlpha","numDirLights","numPointLights","numSpotLights","numHemiLights","numRectAreaLights","numDirLightShadows","numPointLightShadows","numSpotLightShadows","shadowMapEnabled","shadowMapType","toneMapping","physicallyCorrectLights","alphaTest","doubleSided","flipSided","numClippingPlanes","numClipIntersection","depthPacking","dithering","sheen","transmissionMap"];function m(t){let e;return t&&t.isTexture?e=t.encoding:t&&t.isWebGLRenderTarget?(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),e=t.texture.encoding):e=YBt,e}return{getParameters:function g(r,a,f,_,y){const v=_.fog,b=e.get(r.envMap||(r.isMeshStandardMaterial?_.environment:null)),x=p[r.type],w=y.isSkinnedMesh?(function S(t){const e=t.skeleton.bones;if(c)return 1024;{const t=Math.floor((u-20)/4),n=Math.min(t,e.length);return n<e.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+e.length+" bones. This GPU supports "+n+"."),0):n}})(y):0;let M,E;if(null!==r.precision&&(d=i.getMaxPrecision(r.precision),d!==r.precision&&console.warn("THREE.WebGLProgram.getParameters:",r.precision,"not supported, using",d,"instead.")),x){const t=QVt[x];M=t.vertexShader,E=t.fragmentShader}else M=r.vertexShader,E=r.fragmentShader;const T=t.getRenderTarget();return{isWebGL2:s,shaderID:x,shaderName:r.type,vertexShader:M,fragmentShader:E,defines:r.defines,isRawShaderMaterial:!0===r.isRawShaderMaterial,glslVersion:r.glslVersion,precision:d,instancing:!0===y.isInstancedMesh,instancingColor:!0===y.isInstancedMesh&&null!==y.instanceColor,supportsVertexTextures:h,outputEncoding:null!==T?m(T.texture):t.outputEncoding,map:!!r.map,mapEncoding:m(r.map),matcap:!!r.matcap,matcapEncoding:m(r.matcap),envMap:!!b,envMapMode:b&&b.mapping,envMapEncoding:m(b),envMapCubeUV:!!b&&(b.mapping===lBt||b.mapping===cBt),lightMap:!!r.lightMap,lightMapEncoding:m(r.lightMap),aoMap:!!r.aoMap,emissiveMap:!!r.emissiveMap,emissiveMapEncoding:m(r.emissiveMap),bumpMap:!!r.bumpMap,normalMap:!!r.normalMap,objectSpaceNormalMap:1===r.normalMapType,tangentSpaceNormalMap:0===r.normalMapType,clearcoatMap:!!r.clearcoatMap,clearcoatRoughnessMap:!!r.clearcoatRoughnessMap,clearcoatNormalMap:!!r.clearcoatNormalMap,displacementMap:!!r.displacementMap,roughnessMap:!!r.roughnessMap,metalnessMap:!!r.metalnessMap,specularMap:!!r.specularMap,alphaMap:!!r.alphaMap,gradientMap:!!r.gradientMap,sheen:!!r.sheen,transmissionMap:!!r.transmissionMap,combine:r.combine,vertexTangents:r.normalMap&&r.vertexTangents,vertexColors:r.vertexColors,vertexUvs:!!(r.map||r.bumpMap||r.normalMap||r.specularMap||r.alphaMap||r.emissiveMap||r.roughnessMap||r.metalnessMap||r.clearcoatMap||r.clearcoatRoughnessMap||r.clearcoatNormalMap||r.displacementMap||r.transmissionMap),uvsVertexOnly:!(r.map||r.bumpMap||r.normalMap||r.specularMap||r.alphaMap||r.emissiveMap||r.roughnessMap||r.metalnessMap||r.clearcoatNormalMap||r.transmissionMap||!r.displacementMap),fog:!!v,useFog:r.fog,fogExp2:v&&v.isFogExp2,flatShading:r.flatShading,sizeAttenuation:r.sizeAttenuation,logarithmicDepthBuffer:l,skinning:r.skinning&&w>0,maxBones:w,useVertexTexture:c,morphTargets:r.morphTargets,morphNormals:r.morphNormals,maxMorphTargets:t.maxMorphTargets,maxMorphNormals:t.maxMorphNormals,numDirLights:a.directional.length,numPointLights:a.point.length,numSpotLights:a.spot.length,numRectAreaLights:a.rectArea.length,numHemiLights:a.hemi.length,numDirLightShadows:a.directionalShadowMap.length,numPointLightShadows:a.pointShadowMap.length,numSpotLightShadows:a.spotShadowMap.length,numClippingPlanes:o.numPlanes,numClipIntersection:o.numIntersection,dithering:r.dithering,shadowMapEnabled:t.shadowMap.enabled&&f.length>0,shadowMapType:t.shadowMap.type,toneMapping:r.toneMapped?t.toneMapping:0,physicallyCorrectLights:t.physicallyCorrectLights,premultipliedAlpha:r.premultipliedAlpha,alphaTest:r.alphaTest,doubleSided:2===r.side,flipSided:1===r.side,depthPacking:void 0!==r.depthPacking&&r.depthPacking,index0AttributeName:r.index0AttributeName,extensionDerivatives:r.extensions&&r.extensions.derivatives,extensionFragDepth:r.extensions&&r.extensions.fragDepth,extensionDrawBuffers:r.extensions&&r.extensions.drawBuffers,extensionShaderTextureLOD:r.extensions&&r.extensions.shaderTextureLOD,rendererExtensionFragDepth:s||n.has("EXT_frag_depth"),rendererExtensionDrawBuffers:s||n.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:s||n.has("EXT_shader_texture_lod"),customProgramCacheKey:r.customProgramCacheKey()}},getProgramCacheKey:function _(e){const n=[];if(e.shaderID?n.push(e.shaderID):(n.push(e.fragmentShader),n.push(e.vertexShader)),void 0!==e.defines)for(const t in e.defines)n.push(t),n.push(e.defines[t]);if(!1===e.isRawShaderMaterial){for(let t=0;t<f.length;t++)n.push(e[f[t]]);n.push(t.outputEncoding),n.push(t.gammaFactor)}return n.push(e.customProgramCacheKey),n.join()},getUniforms:function y(t){const e=p[t.type];let n;return n=e?zVt.clone(QVt[e].uniforms):t.uniforms,n},acquireProgram:function v(e,n){let i;for(let t=0,e=a.length;t<e;t++){const e=a[t];if(e.cacheKey===n){i=e,++i.usedTimes;break}}return void 0===i&&(i=new LUt(t,n,e,r),a.push(i)),i},releaseProgram:function b(t){if(0==--t.usedTimes){const e=a.indexOf(t);a[e]=a[a.length-1],a.pop(),t.destroy()}},programs:a}}function IUt(){let t=new WeakMap;return{get:function e(n){let i=t.get(n);return void 0===i&&(i={},t.set(n,i)),i},remove:function n(e){t.delete(e)},update:function i(e,n,r){t.get(e)[n]=r},dispose:function r(){t=new WeakMap}}}function NUt(t,e){return t.groupOrder!==e.groupOrder?t.groupOrder-e.groupOrder:t.renderOrder!==e.renderOrder?t.renderOrder-e.renderOrder:t.program!==e.program?t.program.id-e.program.id:t.material.id!==e.material.id?t.material.id-e.material.id:t.z!==e.z?t.z-e.z:t.id-e.id}function OUt(t,e){return t.groupOrder!==e.groupOrder?t.groupOrder-e.groupOrder:t.renderOrder!==e.renderOrder?t.renderOrder-e.renderOrder:t.z!==e.z?e.z-t.z:t.id-e.id}function RUt(t){const e=[];let n=0;const i=[],r=[],o={id:-1};function a(i,r,a,s,l,c){let u=e[n];const h=t.get(a);return void 0===u?(u={id:i.id,object:i,geometry:r,material:a,program:h.program||o,groupOrder:s,renderOrder:i.renderOrder,z:l,group:c},e[n]=u):(u.id=i.id,u.object=i,u.geometry=r,u.material=a,u.program=h.program||o,u.groupOrder=s,u.renderOrder=i.renderOrder,u.z=l,u.group=c),n++,u}return{opaque:i,transparent:r,init:function s(){n=0,i.length=0,r.length=0},push:function l(t,e,n,o,s,c){const u=a(t,e,n,o,s,c);(!0===n.transparent?r:i).push(u)},unshift:function c(t,e,n,o,s,l){const c=a(t,e,n,o,s,l);(!0===n.transparent?r:i).unshift(c)},finish:function u(){for(let t=n,i=e.length;t<i;t++){const n=e[t];if(null===n.id)break;n.id=null,n.object=null,n.geometry=null,n.material=null,n.program=null,n.group=null}},sort:function h(t,e){i.length>1&&i.sort(t||NUt),r.length>1&&r.sort(e||OUt)}}}function zUt(t){let e=new WeakMap;return{get:function n(i,r){const o=e.get(i);let a;return void 0===o?(a=new RUt(t),e.set(i,new WeakMap),e.get(i).set(r,a)):(a=o.get(r),void 0===a&&(a=new RUt(t),o.set(r,a))),a},dispose:function i(){e=new WeakMap}}}function DUt(){const t={};return{get:function(e){if(void 0!==t[e.id])return t[e.id];let n;switch(e.type){case"DirectionalLight":n={direction:new yHt,color:new HFt};break;case"SpotLight":n={position:new yHt,direction:new yHt,color:new HFt,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":n={position:new yHt,color:new HFt,distance:0,decay:0};break;case"HemisphereLight":n={direction:new yHt,skyColor:new HFt,groundColor:new HFt};break;case"RectAreaLight":n={color:new HFt,position:new yHt,halfWidth:new yHt,halfHeight:new yHt}}return t[e.id]=n,n}}}let BUt=0;function HUt(t,e){return(e.castShadow?1:0)-(t.castShadow?1:0)}function FUt(t,e){const n=new DUt,i=(function r(){const t={};return{get:function(e){if(void 0!==t[e.id])return t[e.id];let n;switch(e.type){case"DirectionalLight":case"SpotLight":n={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new lHt};break;case"PointLight":n={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new lHt,shadowCameraNear:1,shadowCameraFar:1e3}}return t[e.id]=n,n}}})(),o={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let t=0;t<9;t++)o.probe.push(new yHt);const a=new yHt,s=new qHt,l=new qHt;return{setup:function c(r){let a=0,s=0,l=0;for(let t=0;t<9;t++)o.probe[t].set(0,0,0);let c=0,u=0,h=0,d=0,p=0,f=0,m=0,g=0;r.sort(HUt);for(let t=0,e=r.length;t<e;t++){const e=r[t],_=e.color,y=e.intensity,v=e.distance,b=e.shadow&&e.shadow.map?e.shadow.map.texture:null;if(e.isAmbientLight)a+=_.r*y,s+=_.g*y,l+=_.b*y;else if(e.isLightProbe)for(let t=0;t<9;t++)o.probe[t].addScaledVector(e.sh.coefficients[t],y);else if(e.isDirectionalLight){const t=n.get(e);if(t.color.copy(e.color).multiplyScalar(e.intensity),e.castShadow){const t=e.shadow,n=i.get(e);n.shadowBias=t.bias,n.shadowNormalBias=t.normalBias,n.shadowRadius=t.radius,n.shadowMapSize=t.mapSize,o.directionalShadow[c]=n,o.directionalShadowMap[c]=b,o.directionalShadowMatrix[c]=e.shadow.matrix,f++}o.directional[c]=t,c++}else if(e.isSpotLight){const t=n.get(e);if(t.position.setFromMatrixPosition(e.matrixWorld),t.color.copy(_).multiplyScalar(y),t.distance=v,t.coneCos=Math.cos(e.angle),t.penumbraCos=Math.cos(e.angle*(1-e.penumbra)),t.decay=e.decay,e.castShadow){const t=e.shadow,n=i.get(e);n.shadowBias=t.bias,n.shadowNormalBias=t.normalBias,n.shadowRadius=t.radius,n.shadowMapSize=t.mapSize,o.spotShadow[h]=n,o.spotShadowMap[h]=b,o.spotShadowMatrix[h]=e.shadow.matrix,g++}o.spot[h]=t,h++}else if(e.isRectAreaLight){const t=n.get(e);t.color.copy(_).multiplyScalar(y),t.halfWidth.set(.5*e.width,0,0),t.halfHeight.set(0,.5*e.height,0),o.rectArea[d]=t,d++}else if(e.isPointLight){const t=n.get(e);if(t.color.copy(e.color).multiplyScalar(e.intensity),t.distance=e.distance,t.decay=e.decay,e.castShadow){const t=e.shadow,n=i.get(e);n.shadowBias=t.bias,n.shadowNormalBias=t.normalBias,n.shadowRadius=t.radius,n.shadowMapSize=t.mapSize,n.shadowCameraNear=t.camera.near,n.shadowCameraFar=t.camera.far,o.pointShadow[u]=n,o.pointShadowMap[u]=b,o.pointShadowMatrix[u]=e.shadow.matrix,m++}o.point[u]=t,u++}else if(e.isHemisphereLight){const t=n.get(e);t.skyColor.copy(e.color).multiplyScalar(y),t.groundColor.copy(e.groundColor).multiplyScalar(y),o.hemi[p]=t,p++}}d>0&&(e.isWebGL2||!0===t.has("OES_texture_float_linear")?(o.rectAreaLTC1=JVt.LTC_FLOAT_1,o.rectAreaLTC2=JVt.LTC_FLOAT_2):!0===t.has("OES_texture_half_float_linear")?(o.rectAreaLTC1=JVt.LTC_HALF_1,o.rectAreaLTC2=JVt.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),o.ambient[0]=a,o.ambient[1]=s,o.ambient[2]=l;const _=o.hash;_.directionalLength===c&&_.pointLength===u&&_.spotLength===h&&_.rectAreaLength===d&&_.hemiLength===p&&_.numDirectionalShadows===f&&_.numPointShadows===m&&_.numSpotShadows===g||(o.directional.length=c,o.spot.length=h,o.rectArea.length=d,o.point.length=u,o.hemi.length=p,o.directionalShadow.length=f,o.directionalShadowMap.length=f,o.pointShadow.length=m,o.pointShadowMap.length=m,o.spotShadow.length=g,o.spotShadowMap.length=g,o.directionalShadowMatrix.length=f,o.pointShadowMatrix.length=m,o.spotShadowMatrix.length=g,_.directionalLength=c,_.pointLength=u,_.spotLength=h,_.rectAreaLength=d,_.hemiLength=p,_.numDirectionalShadows=f,_.numPointShadows=m,_.numSpotShadows=g,o.version=BUt++)},setupView:function u(t,e){let n=0,i=0,r=0,c=0,u=0;const h=e.matrixWorldInverse;for(let e=0,d=t.length;e<d;e++){const d=t[e];if(d.isDirectionalLight){const t=o.directional[n];t.direction.setFromMatrixPosition(d.matrixWorld),a.setFromMatrixPosition(d.target.matrixWorld),t.direction.sub(a),t.direction.transformDirection(h),n++}else if(d.isSpotLight){const t=o.spot[r];t.position.setFromMatrixPosition(d.matrixWorld),t.position.applyMatrix4(h),t.direction.setFromMatrixPosition(d.matrixWorld),a.setFromMatrixPosition(d.target.matrixWorld),t.direction.sub(a),t.direction.transformDirection(h),r++}else if(d.isRectAreaLight){const t=o.rectArea[c];t.position.setFromMatrixPosition(d.matrixWorld),t.position.applyMatrix4(h),l.identity(),s.copy(d.matrixWorld),s.premultiply(h),l.extractRotation(s),t.halfWidth.set(.5*d.width,0,0),t.halfHeight.set(0,.5*d.height,0),t.halfWidth.applyMatrix4(l),t.halfHeight.applyMatrix4(l),c++}else if(d.isPointLight){const t=o.point[i];t.position.setFromMatrixPosition(d.matrixWorld),t.position.applyMatrix4(h),i++}else if(d.isHemisphereLight){const t=o.hemi[u];t.direction.setFromMatrixPosition(d.matrixWorld),t.direction.transformDirection(h),t.direction.normalize(),u++}}},state:o}}function VUt(t,e){const n=new FUt(t,e),i=[],r=[];return{init:function o(){i.length=0,r.length=0},state:{lightsArray:i,shadowsArray:r,lights:n},setupLights:function a(){n.setup(i)},setupLightsView:function s(t){n.setupView(i,t)},pushLight:function l(t){i.push(t)},pushShadow:function c(t){r.push(t)}}}function jUt(t,e){let n=new WeakMap;return{get:function i(r,o=0){let a;return!1===n.has(r)?(a=new VUt(t,e),n.set(r,[]),n.get(r).push(a)):o>=n.get(r).length?(a=new VUt(t,e),n.get(r).push(a)):a=n.get(r)[o],a},dispose:function r(){n=new WeakMap}}}function UUt(t){jFt.call(this),this.type="MeshDepthMaterial",this.depthPacking=3200,this.skinning=!1,this.morphTargets=!1,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}function GUt(t){jFt.call(this),this.type="MeshDistanceMaterial",this.referencePosition=new yHt,this.nearDistance=1,this.farDistance=1e3,this.skinning=!1,this.morphTargets=!1,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}function WUt(t,e,n){let i=new YVt;const r=new lHt,o=new lHt,a=new mHt,s=[],l=[],c={},u={0:1,1:0,2:2},h=new DVt({defines:{SAMPLE_RATE:2/8,HALF_SAMPLE_RATE:1/8},uniforms:{shadow_pass:{value:null},resolution:{value:new lHt},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy ) / resolution ) );\n\tfor ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, i ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean * HALF_SAMPLE_RATE;\n\tsquared_mean = squared_mean * HALF_SAMPLE_RATE;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}"}),d=h.clone();d.defines.HORIZONTAL_PASS=1;const p=new pVt;p.setAttribute("position",new qFt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));const f=new PVt(p,h),m=this;function g(n,i){const r=e.update(f);h.uniforms.shadow_pass.value=n.map.texture,h.uniforms.resolution.value=n.mapSize,h.uniforms.radius.value=n.radius,t.setRenderTarget(n.mapPass),t.clear(),t.renderBufferDirect(i,null,r,h,f,null),d.uniforms.shadow_pass.value=n.mapPass.texture,d.uniforms.resolution.value=n.mapSize,d.uniforms.radius.value=n.radius,t.setRenderTarget(n.map),t.clear(),t.renderBufferDirect(i,null,r,d,f,null)}function _(t,e,n){const i=t<<0|e<<1|n<<2;let r=s[i];return void 0===r&&(r=new UUt({depthPacking:3201,morphTargets:t,skinning:e}),s[i]=r),r}function y(t,e,n){const i=t<<0|e<<1|n<<2;let r=l[i];return void 0===r&&(r=new GUt({morphTargets:t,skinning:e}),l[i]=r),r}function v(e,n,i,r,o,a,s){let l=null,h=_,d=e.customDepthMaterial;if(!0===r.isPointLight&&(h=y,d=e.customDistanceMaterial),void 0===d){let t=!1;!0===i.morphTargets&&(t=n.morphAttributes&&n.morphAttributes.position&&n.morphAttributes.position.length>0);let r=!1;!0===e.isSkinnedMesh&&(!0===i.skinning?r=!0:console.warn("THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:",e)),l=h(t,r,!0===e.isInstancedMesh)}else l=d;if(t.localClippingEnabled&&!0===i.clipShadows&&0!==i.clippingPlanes.length){const t=l.uuid,e=i.uuid;let n=c[t];void 0===n&&(n={},c[t]=n);let r=n[e];void 0===r&&(r=l.clone(),n[e]=r),l=r}return l.visible=i.visible,l.wireframe=i.wireframe,l.side=3===s?null!==i.shadowSide?i.shadowSide:i.side:null!==i.shadowSide?i.shadowSide:u[i.side],l.clipShadows=i.clipShadows,l.clippingPlanes=i.clippingPlanes,l.clipIntersection=i.clipIntersection,l.wireframeLinewidth=i.wireframeLinewidth,l.linewidth=i.linewidth,!0===r.isPointLight&&!0===l.isMeshDistanceMaterial&&(l.referencePosition.setFromMatrixPosition(r.matrixWorld),l.nearDistance=o,l.farDistance=a),l}function b(n,r,o,a,s){if(!1===n.visible)return;if(n.layers.test(r.layers)&&(n.isMesh||n.isLine||n.isPoints)&&(n.castShadow||n.receiveShadow&&3===s)&&(!n.frustumCulled||i.intersectsObject(n))){n.modelViewMatrix.multiplyMatrices(o.matrixWorldInverse,n.matrixWorld);const i=e.update(n),r=n.material;if(Array.isArray(r)){const e=i.groups;for(let l=0,c=e.length;l<c;l++){const c=e[l],u=r[c.materialIndex];if(u&&u.visible){const e=v(n,i,u,a,o.near,o.far,s);t.renderBufferDirect(o,null,i,e,n,c)}}}else if(r.visible){const e=v(n,i,r,a,o.near,o.far,s);t.renderBufferDirect(o,null,i,e,n,null)}}const l=n.children;for(let t=0,e=l.length;t<e;t++)b(l[t],r,o,a,s)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=1,this.render=function(e,s,l){if(!1===m.enabled)return;if(!1===m.autoUpdate&&!1===m.needsUpdate)return;if(0===e.length)return;const c=t.getRenderTarget(),u=t.getActiveCubeFace(),h=t.getActiveMipmapLevel(),d=t.state;d.setBlending(0),d.buffers.color.setClear(1,1,1,1),d.buffers.depth.setTest(!0),d.setScissorTest(!1);for(let c=0,u=e.length;c<u;c++){const u=e[c],h=u.shadow;if(void 0===h){console.warn("THREE.WebGLShadowMap:",u,"has no shadow.");continue}if(!1===h.autoUpdate&&!1===h.needsUpdate)continue;r.copy(h.mapSize);const p=h.getFrameExtents();if(r.multiply(p),o.copy(h.mapSize),(r.x>n||r.y>n)&&(r.x>n&&(o.x=Math.floor(n/p.x),r.x=o.x*p.x,h.mapSize.x=o.x),r.y>n&&(o.y=Math.floor(n/p.y),r.y=o.y*p.y,h.mapSize.y=o.y)),null===h.map&&!h.isPointLightShadow&&3===this.type){const t={minFilter:gBt,magFilter:gBt,format:TBt};h.map=new gHt(r.x,r.y,t),h.map.texture.name=u.name+".shadowMap",h.mapPass=new gHt(r.x,r.y,t),h.camera.updateProjectionMatrix()}null===h.map&&(h.map=new gHt(r.x,r.y,{minFilter:pBt,magFilter:pBt,format:TBt}),h.map.texture.name=u.name+".shadowMap",h.camera.updateProjectionMatrix()),t.setRenderTarget(h.map),t.clear();const f=h.getViewportCount();for(let t=0;t<f;t++){const e=h.getViewport(t);a.set(o.x*e.x,o.y*e.y,o.x*e.z,o.y*e.w),d.viewport(a),h.updateMatrices(u,t),i=h.getFrustum(),b(s,l,h.camera,u,this.type)}h.isPointLightShadow||3!==this.type||g(h,l),h.needsUpdate=!1}m.needsUpdate=!1,t.setRenderTarget(c,u,h)}}function qUt(t,e,n){const i=n.isWebGL2,r=new(function o(){let e=!1;const n=new mHt;let i=null;const r=new mHt(0,0,0,0);return{setMask:function(n){i===n||e||(t.colorMask(n,n,n,n),i=n)},setLocked:function(t){e=t},setClear:function(e,i,o,a,s){!0===s&&(e*=a,i*=a,o*=a),n.set(e,i,o,a),!1===r.equals(n)&&(t.clearColor(e,i,o,a),r.copy(n))},reset:function(){e=!1,i=null,r.set(-1,0,0,0)}}}),a=new(function s(){let e=!1,n=null,i=null,r=null;return{setTest:function(t){t?z(2929):D(2929)},setMask:function(i){n===i||e||(t.depthMask(i),n=i)},setFunc:function(e){if(i!==e){if(e)switch(e){case 0:t.depthFunc(512);break;case 1:t.depthFunc(519);break;case 2:t.depthFunc(513);break;case 3:t.depthFunc(515);break;case 4:t.depthFunc(514);break;case 5:t.depthFunc(518);break;case 6:t.depthFunc(516);break;case 7:t.depthFunc(517);break;default:t.depthFunc(515)}else t.depthFunc(515);i=e}},setLocked:function(t){e=t},setClear:function(e){r!==e&&(t.clearDepth(e),r=e)},reset:function(){e=!1,n=null,i=null,r=null}}}),l=new(function c(){let e=!1,n=null,i=null,r=null,o=null,a=null,s=null,l=null,c=null;return{setTest:function(t){e||(t?z(2960):D(2960))},setMask:function(i){n===i||e||(t.stencilMask(i),n=i)},setFunc:function(e,n,a){i===e&&r===n&&o===a||(t.stencilFunc(e,n,a),i=e,r=n,o=a)},setOp:function(e,n,i){a===e&&s===n&&l===i||(t.stencilOp(e,n,i),a=e,s=n,l=i)},setLocked:function(t){e=t},setClear:function(e){c!==e&&(t.clearStencil(e),c=e)},reset:function(){e=!1,n=null,i=null,r=null,o=null,a=null,s=null,l=null,c=null}}});let u={},h=null,d=null,p=null,f=null,m=null,g=null,_=null,y=null,v=null,b=!1,x=null,w=null,S=null,M=null,E=null;const T=t.getParameter(35661);let A=!1,C=0;const k=t.getParameter(7938);-1!==k.indexOf("WebGL")?(C=parseFloat(/^WebGL (\d)/.exec(k)[1]),A=C>=1):-1!==k.indexOf("OpenGL ES")&&(C=parseFloat(/^OpenGL ES (\d)/.exec(k)[1]),A=C>=2);let L=null,P={};const I=new mHt,N=new mHt;function O(e,n,i){const r=new Uint8Array(4),o=t.createTexture();t.bindTexture(e,o),t.texParameteri(e,10241,9728),t.texParameteri(e,10240,9728);for(let e=0;e<i;e++)t.texImage2D(n+e,0,6408,1,1,0,6408,5121,r);return o}const R={};function z(e){!0!==u[e]&&(t.enable(e),u[e]=!0)}function D(e){!1!==u[e]&&(t.disable(e),u[e]=!1)}R[3553]=O(3553,3553,1),R[34067]=O(34067,34069,6),r.setClear(0,0,0,1),a.setClear(1),l.setClear(0),z(2929),a.setFunc(3),V(!1),j(1),z(2884),F(0);const B={[nBt]:32774,101:32778,102:32779};if(i)B[103]=32775,B[104]=32776;else{const t=e.get("EXT_blend_minmax");null!==t&&(B[103]=t.MIN_EXT,B[104]=t.MAX_EXT)}const H={200:0,201:1,202:768,204:770,210:776,208:774,206:772,203:769,205:771,209:775,207:773};function F(e,n,i,r,o,a,s,l){if(0!==e){if(d||(z(3042),d=!0),5===e)o=o||n,a=a||i,s=s||r,n===f&&o===_||(t.blendEquationSeparate(B[n],B[o]),f=n,_=o),i===m&&r===g&&a===y&&s===v||(t.blendFuncSeparate(H[i],H[r],H[a],H[s]),m=i,g=r,y=a,v=s),p=e,b=null;else if(e!==p||l!==b){if(f===nBt&&_===nBt||(t.blendEquation(32774),f=nBt,_=nBt),l)switch(e){case 1:t.blendFuncSeparate(1,771,1,771);break;case 2:t.blendFunc(1,1);break;case 3:t.blendFuncSeparate(0,0,769,771);break;case 4:t.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",e)}else switch(e){case 1:t.blendFuncSeparate(770,771,1,771);break;case 2:t.blendFunc(770,1);break;case 3:t.blendFunc(0,769);break;case 4:t.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",e)}m=null,g=null,y=null,v=null,p=e,b=l}}else d&&(D(3042),d=!1)}function V(e){x!==e&&(t.frontFace(e?2304:2305),x=e)}function j(e){0!==e?(z(2884),e!==w&&t.cullFace(1===e?1029:2===e?1028:1032)):D(2884),w=e}function U(e,n,i){e?(z(32823),M===n&&E===i||(t.polygonOffset(n,i),M=n,E=i)):D(32823)}function G(e){void 0===e&&(e=33984+T-1),L!==e&&(t.activeTexture(e),L=e)}return{buffers:{color:r,depth:a,stencil:l},enable:z,disable:D,useProgram:function W(e){return h!==e&&(t.useProgram(e),h=e,!0)},setBlending:F,setMaterial:function q(t,e){2===t.side?D(2884):z(2884);let n=1===t.side;e&&(n=!n),V(n),1===t.blending&&!1===t.transparent?F(0):F(t.blending,t.blendEquation,t.blendSrc,t.blendDst,t.blendEquationAlpha,t.blendSrcAlpha,t.blendDstAlpha,t.premultipliedAlpha),a.setFunc(t.depthFunc),a.setTest(t.depthTest),a.setMask(t.depthWrite),r.setMask(t.colorWrite);const i=t.stencilWrite;l.setTest(i),i&&(l.setMask(t.stencilWriteMask),l.setFunc(t.stencilFunc,t.stencilRef,t.stencilFuncMask),l.setOp(t.stencilFail,t.stencilZFail,t.stencilZPass)),U(t.polygonOffset,t.polygonOffsetFactor,t.polygonOffsetUnits)},setFlipSided:V,setCullFace:j,setLineWidth:function Y(e){e!==S&&(A&&t.lineWidth(e),S=e)},setPolygonOffset:U,setScissorTest:function X(t){t?z(3089):D(3089)},activeTexture:G,bindTexture:function $(e,n){null===L&&G();let i=P[L];void 0===i&&(i={type:void 0,texture:void 0},P[L]=i),i.type===e&&i.texture===n||(t.bindTexture(e,n||R[e]),i.type=e,i.texture=n)},unbindTexture:function K(){const e=P[L];void 0!==e&&void 0!==e.type&&(t.bindTexture(e.type,null),e.type=void 0,e.texture=void 0)},compressedTexImage2D:function Z(){try{t.compressedTexImage2D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},texImage2D:function J(){try{t.texImage2D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},texImage3D:function Q(){try{t.texImage3D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},scissor:function tt(e){!1===I.equals(e)&&(t.scissor(e.x,e.y,e.z,e.w),I.copy(e))},viewport:function et(e){!1===N.equals(e)&&(t.viewport(e.x,e.y,e.z,e.w),N.copy(e))},reset:function nt(){u={},L=null,P={},h=null,d=null,p=null,f=null,m=null,g=null,_=null,y=null,v=null,b=!1,x=null,w=null,S=null,M=null,E=null,r.reset(),a.reset(),l.reset()}}}function YUt(t,e,n,i,r,o,a){const s=r.isWebGL2,l=r.maxTextures,c=r.maxCubemapSize,u=r.maxTextureSize,h=r.maxSamples,d=new WeakMap;let p,f=!1;try{f="undefined"!=typeof OffscreenCanvas&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch(t){}function m(t,e){return f?new OffscreenCanvas(t,e):document.createElementNS("http://www.w3.org/1999/xhtml","canvas")}function g(t,e,n,i){let r=1;if((t.width>i||t.height>i)&&(r=i/Math.max(t.width,t.height)),r<1||!0===e){if("undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap){const i=e?sHt.floorPowerOfTwo:Math.floor,o=i(r*t.width),a=i(r*t.height);void 0===p&&(p=m(o,a));const s=n?m(o,a):p;return s.width=o,s.height=a,s.getContext("2d").drawImage(t,0,0,o,a),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+t.width+"x"+t.height+") to ("+o+"x"+a+")."),s}return"data"in t&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+t.width+"x"+t.height+")."),t}return t}function _(t){return sHt.isPowerOfTwo(t.width)&&sHt.isPowerOfTwo(t.height)}function y(t,e){return t.generateMipmaps&&e&&t.minFilter!==pBt&&t.minFilter!==gBt}function v(e,n,r,o){t.generateMipmap(e),i.get(n).__maxMipLevel=Math.log(Math.max(r,o))*Math.LOG2E}function b(n,i,r){if(!1===s)return i;if(null!==n){if(void 0!==t[n])return t[n];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+n+"'")}let o=i;return 6403===i&&(5126===r&&(o=33326),5131===r&&(o=33325),5121===r&&(o=33321)),6407===i&&(5126===r&&(o=34837),5131===r&&(o=34843),5121===r&&(o=32849)),6408===i&&(5126===r&&(o=34836),5131===r&&(o=34842),5121===r&&(o=32856)),33325!==o&&33326!==o&&34842!==o&&34836!==o||e.get("EXT_color_buffer_float"),o}function x(t){return t===pBt||t===fBt||t===mBt?9728:9729}function w(e){const n=e.target;n.removeEventListener("dispose",w),(function r(e){const n=i.get(e);void 0!==n.__webglInit&&(t.deleteTexture(n.__webglTexture),i.remove(e))})(n),n.isVideoTexture&&d.delete(n),a.memory.textures--}function S(e){const n=e.target;n.removeEventListener("dispose",S),(function r(e){const n=i.get(e),r=i.get(e.texture);if(e){if(void 0!==r.__webglTexture&&t.deleteTexture(r.__webglTexture),e.depthTexture&&e.depthTexture.dispose(),e.isWebGLCubeRenderTarget)for(let e=0;e<6;e++)t.deleteFramebuffer(n.__webglFramebuffer[e]),n.__webglDepthbuffer&&t.deleteRenderbuffer(n.__webglDepthbuffer[e]);else t.deleteFramebuffer(n.__webglFramebuffer),n.__webglDepthbuffer&&t.deleteRenderbuffer(n.__webglDepthbuffer),n.__webglMultisampledFramebuffer&&t.deleteFramebuffer(n.__webglMultisampledFramebuffer),n.__webglColorRenderbuffer&&t.deleteRenderbuffer(n.__webglColorRenderbuffer),n.__webglDepthRenderbuffer&&t.deleteRenderbuffer(n.__webglDepthRenderbuffer);i.remove(e.texture),i.remove(e)}})(n),a.memory.textures--}let M=0;function E(t,e){const r=i.get(t);if(t.isVideoTexture&&(function o(t){const e=a.render.frame;d.get(t)!==e&&(d.set(t,e),t.update())})(t),t.version>0&&r.__version!==t.version){const n=t.image;if(void 0===n)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==n.complete)return void P(r,t,e);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}n.activeTexture(33984+e),n.bindTexture(3553,r.__webglTexture)}function T(e,r){const a=i.get(e);e.version>0&&a.__version!==e.version?(function l(e,i,r){if(6!==i.image.length)return;L(e,i),n.activeTexture(33984+r),n.bindTexture(34067,e.__webglTexture),t.pixelStorei(37440,i.flipY),t.pixelStorei(37441,i.premultiplyAlpha),t.pixelStorei(3317,i.unpackAlignment);const a=i&&(i.isCompressedTexture||i.image[0].isCompressedTexture),l=i.image[0]&&i.image[0].isDataTexture,u=[];for(let t=0;t<6;t++)u[t]=a||l?l?i.image[t].image:i.image[t]:g(i.image[t],!1,!0,c);const h=u[0],d=_(h)||s,p=o.convert(i.format),f=o.convert(i.type),m=b(i.internalFormat,p,f);let x;if(k(34067,i,d),a){for(let t=0;t<6;t++){x=u[t].mipmaps;for(let e=0;e<x.length;e++){const r=x[e];i.format!==TBt&&i.format!==EBt?null!==p?n.compressedTexImage2D(34069+t,e,m,r.width,r.height,0,r.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):n.texImage2D(34069+t,e,m,r.width,r.height,0,p,f,r.data)}}e.__maxMipLevel=x.length-1}else{x=i.mipmaps;for(let t=0;t<6;t++)if(l){n.texImage2D(34069+t,0,m,u[t].width,u[t].height,0,p,f,u[t].data);for(let e=0;e<x.length;e++){const i=x[e].image[t].image;n.texImage2D(34069+t,e+1,m,i.width,i.height,0,p,f,i.data)}}else{n.texImage2D(34069+t,0,m,p,f,u[t]);for(let e=0;e<x.length;e++)n.texImage2D(34069+t,e+1,m,p,f,x[e].image[t])}e.__maxMipLevel=x.length}y(i,d)&&v(34067,i,h.width,h.height),e.__version=i.version,i.onUpdate&&i.onUpdate(i)})(a,e,r):(n.activeTexture(33984+r),n.bindTexture(34067,a.__webglTexture))}const A={[uBt]:10497,[hBt]:33071,[dBt]:33648},C={[pBt]:9728,[fBt]:9984,[mBt]:9986,[gBt]:9729,[_Bt]:9985,[yBt]:9987};function k(n,o,a){a?(t.texParameteri(n,10242,A[o.wrapS]),t.texParameteri(n,10243,A[o.wrapT]),32879!==n&&35866!==n||t.texParameteri(n,32882,A[o.wrapR]),t.texParameteri(n,10240,C[o.magFilter]),t.texParameteri(n,10241,C[o.minFilter])):(t.texParameteri(n,10242,33071),t.texParameteri(n,10243,33071),32879!==n&&35866!==n||t.texParameteri(n,32882,33071),o.wrapS===hBt&&o.wrapT===hBt||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),t.texParameteri(n,10240,x(o.magFilter)),t.texParameteri(n,10241,x(o.minFilter)),o.minFilter!==pBt&&o.minFilter!==gBt&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter."));const l=e.get("EXT_texture_filter_anisotropic");if(l){if(o.type===wBt&&null===e.get("OES_texture_float_linear"))return;if(o.type===SBt&&null===(s||e.get("OES_texture_half_float_linear")))return;(o.anisotropy>1||i.get(o).__currentAnisotropy)&&(t.texParameterf(n,l.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(o.anisotropy,r.getMaxAnisotropy())),i.get(o).__currentAnisotropy=o.anisotropy)}}function L(e,n){void 0===e.__webglInit&&(e.__webglInit=!0,n.addEventListener("dispose",w),e.__webglTexture=t.createTexture(),a.memory.textures++)}function P(e,i,r){let a=3553;i.isDataTexture2DArray&&(a=35866),i.isDataTexture3D&&(a=32879),L(e,i),n.activeTexture(33984+r),n.bindTexture(a,e.__webglTexture),t.pixelStorei(37440,i.flipY),t.pixelStorei(37441,i.premultiplyAlpha),t.pixelStorei(3317,i.unpackAlignment);const l=(function c(t){return!s&&(t.wrapS!==hBt||t.wrapT!==hBt||t.minFilter!==pBt&&t.minFilter!==gBt)})(i)&&!1===_(i.image),h=g(i.image,l,!1,u),d=_(h)||s,p=o.convert(i.format);let f,m=o.convert(i.type),x=b(i.internalFormat,p,m);k(a,i,d);const w=i.mipmaps;if(i.isDepthTexture)x=6402,s?x=i.type===wBt?36012:i.type===xBt?33190:i.type===MBt?35056:33189:i.type===wBt&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),i.format===ABt&&6402===x&&i.type!==bBt&&i.type!==xBt&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),i.type=bBt,m=o.convert(i.type)),i.format===CBt&&6402===x&&(x=34041,i.type!==MBt&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),i.type=MBt,m=o.convert(i.type))),n.texImage2D(3553,0,x,h.width,h.height,0,p,m,null);else if(i.isDataTexture)if(w.length>0&&d){for(let t=0,e=w.length;t<e;t++)f=w[t],n.texImage2D(3553,t,x,f.width,f.height,0,p,m,f.data);i.generateMipmaps=!1,e.__maxMipLevel=w.length-1}else n.texImage2D(3553,0,x,h.width,h.height,0,p,m,h.data),e.__maxMipLevel=0;else if(i.isCompressedTexture){for(let t=0,e=w.length;t<e;t++)f=w[t],i.format!==TBt&&i.format!==EBt?null!==p?n.compressedTexImage2D(3553,t,x,f.width,f.height,0,f.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):n.texImage2D(3553,t,x,f.width,f.height,0,p,m,f.data);e.__maxMipLevel=w.length-1}else if(i.isDataTexture2DArray)n.texImage3D(35866,0,x,h.width,h.height,h.depth,0,p,m,h.data),e.__maxMipLevel=0;else if(i.isDataTexture3D)n.texImage3D(32879,0,x,h.width,h.height,h.depth,0,p,m,h.data),e.__maxMipLevel=0;else if(w.length>0&&d){for(let t=0,e=w.length;t<e;t++)f=w[t],n.texImage2D(3553,t,x,p,m,f);i.generateMipmaps=!1,e.__maxMipLevel=w.length-1}else n.texImage2D(3553,0,x,p,m,h),e.__maxMipLevel=0;y(i,d)&&v(a,i,h.width,h.height),e.__version=i.version,i.onUpdate&&i.onUpdate(i)}function I(e,r,a,s){const l=o.convert(r.texture.format),c=o.convert(r.texture.type),u=b(r.texture.internalFormat,l,c);n.texImage2D(s,0,u,r.width,r.height,0,l,c,null),t.bindFramebuffer(36160,e),t.framebufferTexture2D(36160,a,s,i.get(r.texture).__webglTexture,0),t.bindFramebuffer(36160,null)}function N(e,n,i){if(t.bindRenderbuffer(36161,e),n.depthBuffer&&!n.stencilBuffer){let r=33189;if(i){const e=n.depthTexture;e&&e.isDepthTexture&&(e.type===wBt?r=36012:e.type===xBt&&(r=33190));const i=O(n);t.renderbufferStorageMultisample(36161,i,r,n.width,n.height)}else t.renderbufferStorage(36161,r,n.width,n.height);t.framebufferRenderbuffer(36160,36096,36161,e)}else if(n.depthBuffer&&n.stencilBuffer){if(i){const e=O(n);t.renderbufferStorageMultisample(36161,e,35056,n.width,n.height)}else t.renderbufferStorage(36161,34041,n.width,n.height);t.framebufferRenderbuffer(36160,33306,36161,e)}else{const e=o.convert(n.texture.format),r=o.convert(n.texture.type),a=b(n.texture.internalFormat,e,r);if(i){const e=O(n);t.renderbufferStorageMultisample(36161,e,a,n.width,n.height)}else t.renderbufferStorage(36161,a,n.width,n.height)}t.bindRenderbuffer(36161,null)}function O(t){return s&&t.isWebGLMultisampleRenderTarget?Math.min(h,t.samples):0}let R=!1,z=!1;this.allocateTextureUnit=function D(){const t=M;return t>=l&&console.warn("THREE.WebGLTextures: Trying to use "+t+" texture units while this GPU supports only "+l),M+=1,t},this.resetTextureUnits=function B(){M=0},this.setTexture2D=E,this.setTexture2DArray=function H(t,e){const r=i.get(t);t.version>0&&r.__version!==t.version?P(r,t,e):(n.activeTexture(33984+e),n.bindTexture(35866,r.__webglTexture))},this.setTexture3D=function F(t,e){const r=i.get(t);t.version>0&&r.__version!==t.version?P(r,t,e):(n.activeTexture(33984+e),n.bindTexture(32879,r.__webglTexture))},this.setTextureCube=T,this.setupRenderTarget=function V(e){const r=i.get(e),l=i.get(e.texture);e.addEventListener("dispose",S),l.__webglTexture=t.createTexture(),a.memory.textures++;const c=!0===e.isWebGLCubeRenderTarget,u=!0===e.isWebGLMultisampleRenderTarget,h=_(e)||s;if(!s||e.texture.format!==EBt||e.texture.type!==wBt&&e.texture.type!==SBt||(e.texture.format=TBt,console.warn("THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.")),c){r.__webglFramebuffer=[];for(let e=0;e<6;e++)r.__webglFramebuffer[e]=t.createFramebuffer()}else if(r.__webglFramebuffer=t.createFramebuffer(),u)if(s){r.__webglMultisampledFramebuffer=t.createFramebuffer(),r.__webglColorRenderbuffer=t.createRenderbuffer(),t.bindRenderbuffer(36161,r.__webglColorRenderbuffer);const n=o.convert(e.texture.format),i=o.convert(e.texture.type),a=b(e.texture.internalFormat,n,i),s=O(e);t.renderbufferStorageMultisample(36161,s,a,e.width,e.height),t.bindFramebuffer(36160,r.__webglMultisampledFramebuffer),t.framebufferRenderbuffer(36160,36064,36161,r.__webglColorRenderbuffer),t.bindRenderbuffer(36161,null),e.depthBuffer&&(r.__webglDepthRenderbuffer=t.createRenderbuffer(),N(r.__webglDepthRenderbuffer,e,!0)),t.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(c){n.bindTexture(34067,l.__webglTexture),k(34067,e.texture,h);for(let t=0;t<6;t++)I(r.__webglFramebuffer[t],e,36064,34069+t);y(e.texture,h)&&v(34067,e.texture,e.width,e.height),n.bindTexture(34067,null)}else n.bindTexture(3553,l.__webglTexture),k(3553,e.texture,h),I(r.__webglFramebuffer,e,36064,3553),y(e.texture,h)&&v(3553,e.texture,e.width,e.height),n.bindTexture(3553,null);e.depthBuffer&&(function d(e){const n=i.get(e),r=!0===e.isWebGLCubeRenderTarget;if(e.depthTexture){if(r)throw new Error("target.depthTexture not supported in Cube render targets");!(function o(e,n){if(n&&n.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(t.bindFramebuffer(36160,e),!n.depthTexture||!n.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");i.get(n.depthTexture).__webglTexture&&n.depthTexture.image.width===n.width&&n.depthTexture.image.height===n.height||(n.depthTexture.image.width=n.width,n.depthTexture.image.height=n.height,n.depthTexture.needsUpdate=!0),E(n.depthTexture,0);const r=i.get(n.depthTexture).__webglTexture;if(n.depthTexture.format===ABt)t.framebufferTexture2D(36160,36096,3553,r,0);else{if(n.depthTexture.format!==CBt)throw new Error("Unknown depthTexture format");t.framebufferTexture2D(36160,33306,3553,r,0)}})(n.__webglFramebuffer,e)}else if(r){n.__webglDepthbuffer=[];for(let i=0;i<6;i++)t.bindFramebuffer(36160,n.__webglFramebuffer[i]),n.__webglDepthbuffer[i]=t.createRenderbuffer(),N(n.__webglDepthbuffer[i],e,!1)}else t.bindFramebuffer(36160,n.__webglFramebuffer),n.__webglDepthbuffer=t.createRenderbuffer(),N(n.__webglDepthbuffer,e,!1);t.bindFramebuffer(36160,null)})(e)},this.updateRenderTargetMipmap=function j(t){const e=t.texture;if(y(e,_(t)||s)){const r=t.isWebGLCubeRenderTarget?34067:3553,o=i.get(e).__webglTexture;n.bindTexture(r,o),v(r,e,t.width,t.height),n.bindTexture(r,null)}},this.updateMultisampleRenderTarget=function U(e){if(e.isWebGLMultisampleRenderTarget)if(s){const n=i.get(e);t.bindFramebuffer(36008,n.__webglMultisampledFramebuffer),t.bindFramebuffer(36009,n.__webglFramebuffer);const r=e.width,o=e.height;let a=16384;e.depthBuffer&&(a|=256),e.stencilBuffer&&(a|=1024),t.blitFramebuffer(0,0,r,o,0,0,r,o,a,9728),t.bindFramebuffer(36160,n.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.safeSetTexture2D=function G(t,e){t&&t.isWebGLRenderTarget&&(!1===R&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),R=!0),t=t.texture),E(t,e)},this.safeSetTextureCube=function W(t,e){t&&t.isWebGLCubeRenderTarget&&(!1===z&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),z=!0),t=t.texture),T(t,e)}}function XUt(t,e,n){const i=n.isWebGL2;return{convert:function r(t){let n;if(t===vBt)return 5121;if(1017===t)return 32819;if(1018===t)return 32820;if(1019===t)return 33635;if(1010===t)return 5120;if(1011===t)return 5122;if(t===bBt)return 5123;if(1013===t)return 5124;if(t===xBt)return 5125;if(t===wBt)return 5126;if(t===SBt)return i?5131:(n=e.get("OES_texture_half_float"),null!==n?n.HALF_FLOAT_OES:null);if(1021===t)return 6406;if(t===EBt)return 6407;if(t===TBt)return 6408;if(1024===t)return 6409;if(1025===t)return 6410;if(t===ABt)return 6402;if(t===CBt)return 34041;if(1028===t)return 6403;if(1029===t)return 36244;if(1030===t)return 33319;if(1031===t)return 33320;if(1032===t)return 36248;if(1033===t)return 36249;if(t===kBt||t===LBt||t===PBt||t===IBt){if(n=e.get("WEBGL_compressed_texture_s3tc"),null===n)return null;if(t===kBt)return n.COMPRESSED_RGB_S3TC_DXT1_EXT;if(t===LBt)return n.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(t===PBt)return n.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(t===IBt)return n.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(t===NBt||t===OBt||t===RBt||t===zBt){if(n=e.get("WEBGL_compressed_texture_pvrtc"),null===n)return null;if(t===NBt)return n.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(t===OBt)return n.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(t===RBt)return n.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(t===zBt)return n.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(36196===t)return n=e.get("WEBGL_compressed_texture_etc1"),null!==n?n.COMPRESSED_RGB_ETC1_WEBGL:null;if((t===DBt||t===BBt)&&(n=e.get("WEBGL_compressed_texture_etc"),null!==n)){if(t===DBt)return n.COMPRESSED_RGB8_ETC2;if(t===BBt)return n.COMPRESSED_RGBA8_ETC2_EAC}return 37808===t||37809===t||37810===t||37811===t||37812===t||37813===t||37814===t||37815===t||37816===t||37817===t||37818===t||37819===t||37820===t||37821===t||37840===t||37841===t||37842===t||37843===t||37844===t||37845===t||37846===t||37847===t||37848===t||37849===t||37850===t||37851===t||37852===t||37853===t?(n=e.get("WEBGL_compressed_texture_astc"),null!==n?t:null):36492===t?(n=e.get("EXT_texture_compression_bptc"),null!==n?t:null):t===MBt?i?34042:(n=e.get("WEBGL_depth_texture"),null!==n?n.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}function $Ut(t=[]){HVt.call(this),this.cameras=t}function KUt(){_Ft.call(this),this.type="Group"}function ZUt(){this._targetRay=null,this._grip=null,this._hand=null}function JUt(t,e){const n=this;let i=null,r=1,o=null,a="local-floor",s=null;const l=[],c=new Map,u=new HVt;u.layers.enable(1),u.viewport=new mHt;const h=new HVt;h.layers.enable(2),h.viewport=new mHt;const d=[u,h],p=new $Ut;p.layers.enable(1),p.layers.enable(2);let f=null,m=null;function g(t){const e=c.get(t.inputSource);e&&e.dispatchEvent({type:t.type,data:t.inputSource})}function _(){c.forEach((function(t,e){t.disconnect(e)})),c.clear(),f=null,m=null,t.setFramebuffer(null),t.setRenderTarget(t.getRenderTarget()),S.stop(),n.isPresenting=!1,n.dispatchEvent({type:"sessionend"})}function y(t){const e=i.inputSources;for(let t=0;t<l.length;t++)c.set(e[t],l[t]);for(let e=0;e<t.removed.length;e++){const n=t.removed[e],i=c.get(n);i&&(i.dispatchEvent({type:"disconnected",data:n}),c.delete(n))}for(let e=0;e<t.added.length;e++){const n=t.added[e],i=c.get(n);i&&i.dispatchEvent({type:"connected",data:n})}}this.enabled=!1,this.isPresenting=!1,this.getController=function(t){let e=l[t];return void 0===e&&(e=new ZUt,l[t]=e),e.getTargetRaySpace()},this.getControllerGrip=function(t){let e=l[t];return void 0===e&&(e=new ZUt,l[t]=e),e.getGripSpace()},this.getHand=function(t){let e=l[t];return void 0===e&&(e=new ZUt,l[t]=e),e.getHandSpace()},this.setFramebufferScaleFactor=function(t){r=t,!0===n.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(t){a=t,!0===n.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return o},this.getSession=function(){return i},this.setSession=async function(t){if(i=t,null!==i){i.addEventListener("select",g),i.addEventListener("selectstart",g),i.addEventListener("selectend",g),i.addEventListener("squeeze",g),i.addEventListener("squeezestart",g),i.addEventListener("squeezeend",g),i.addEventListener("end",_),i.addEventListener("inputsourceschange",y);const t=e.getContextAttributes();!0!==t.xrCompatible&&await e.makeXRCompatible();const s=new XRWebGLLayer(i,e,{antialias:t.antialias,alpha:t.alpha,depth:t.depth,stencil:t.stencil,framebufferScaleFactor:r});i.updateRenderState({baseLayer:s}),o=await i.requestReferenceSpace(a),S.setContext(i),S.start(),n.isPresenting=!0,n.dispatchEvent({type:"sessionstart"})}};const v=new yHt,b=new yHt;function x(t,e){null===e?t.matrixWorld.copy(t.matrix):t.matrixWorld.multiplyMatrices(e.matrixWorld,t.matrix),t.matrixWorldInverse.copy(t.matrixWorld).invert()}this.getCamera=function(t){p.near=h.near=u.near=t.near,p.far=h.far=u.far=t.far,f===p.near&&m===p.far||(i.updateRenderState({depthNear:p.near,depthFar:p.far}),f=p.near,m=p.far);const e=t.parent,n=p.cameras;x(p,e);for(let t=0;t<n.length;t++)x(n[t],e);t.matrixWorld.copy(p.matrixWorld),t.matrix.copy(p.matrix),t.matrix.decompose(t.position,t.quaternion,t.scale);const r=t.children;for(let t=0,e=r.length;t<e;t++)r[t].updateMatrixWorld(!0);return 2===n.length?(function o(t,e,n){v.setFromMatrixPosition(e.matrixWorld),b.setFromMatrixPosition(n.matrixWorld);const i=v.distanceTo(b),r=e.projectionMatrix.elements,o=n.projectionMatrix.elements,a=r[14]/(r[10]-1),s=r[14]/(r[10]+1),l=(r[9]+1)/r[5],c=(r[9]-1)/r[5],u=(r[8]-1)/r[0],h=(o[8]+1)/o[0],d=a*u,p=a*h,f=i/(-u+h),m=f*-u;e.matrixWorld.decompose(t.position,t.quaternion,t.scale),t.translateX(m),t.translateZ(f),t.matrixWorld.compose(t.position,t.quaternion,t.scale),t.matrixWorldInverse.copy(t.matrixWorld).invert();const g=a+f,_=s+f;t.projectionMatrix.makePerspective(d-m,p+(i-m),l*s/_*g,c*s/_*g,g,_)})(p,u,h):p.projectionMatrix.copy(u.projectionMatrix),p};let w=null;const S=new XVt;S.setAnimationLoop((function M(e,n){if(s=n.getViewerPose(o),null!==s){const e=s.views,n=i.renderState.baseLayer;t.setFramebuffer(n.framebuffer);let r=!1;e.length!==p.cameras.length&&(p.cameras.length=0,r=!0);for(let t=0;t<e.length;t++){const i=e[t],o=n.getViewport(i),a=d[t];a.matrix.fromArray(i.transform.matrix),a.projectionMatrix.fromArray(i.projectionMatrix),a.viewport.set(o.x,o.y,o.width,o.height),0===t&&p.matrix.copy(a.matrix),!0===r&&p.cameras.push(a)}}const r=i.inputSources;for(let t=0;t<l.length;t++)l[t].update(r[t],n,o);w&&w(e,n)})),this.setAnimationLoop=function(t){w=t},this.dispose=function(){}}function QUt(t){function e(e,n){e.opacity.value=n.opacity,n.color&&e.diffuse.value.copy(n.color),n.emissive&&e.emissive.value.copy(n.emissive).multiplyScalar(n.emissiveIntensity),n.map&&(e.map.value=n.map),n.alphaMap&&(e.alphaMap.value=n.alphaMap),n.specularMap&&(e.specularMap.value=n.specularMap);const i=t.get(n).envMap;if(i){e.envMap.value=i,e.flipEnvMap.value=i.isCubeTexture&&i._needsFlipEnvMap?-1:1,e.reflectivity.value=n.reflectivity,e.refractionRatio.value=n.refractionRatio;const r=t.get(i).__maxMipLevel;void 0!==r&&(e.maxMipLevel.value=r)}let r,o;n.lightMap&&(e.lightMap.value=n.lightMap,e.lightMapIntensity.value=n.lightMapIntensity),n.aoMap&&(e.aoMap.value=n.aoMap,e.aoMapIntensity.value=n.aoMapIntensity),n.map?r=n.map:n.specularMap?r=n.specularMap:n.displacementMap?r=n.displacementMap:n.normalMap?r=n.normalMap:n.bumpMap?r=n.bumpMap:n.roughnessMap?r=n.roughnessMap:n.metalnessMap?r=n.metalnessMap:n.alphaMap?r=n.alphaMap:n.emissiveMap?r=n.emissiveMap:n.clearcoatMap?r=n.clearcoatMap:n.clearcoatNormalMap?r=n.clearcoatNormalMap:n.clearcoatRoughnessMap&&(r=n.clearcoatRoughnessMap),void 0!==r&&(r.isWebGLRenderTarget&&(r=r.texture),!0===r.matrixAutoUpdate&&r.updateMatrix(),e.uvTransform.value.copy(r.matrix)),n.aoMap?o=n.aoMap:n.lightMap&&(o=n.lightMap),void 0!==o&&(o.isWebGLRenderTarget&&(o=o.texture),!0===o.matrixAutoUpdate&&o.updateMatrix(),e.uv2Transform.value.copy(o.matrix))}function n(e,n){e.roughness.value=n.roughness,e.metalness.value=n.metalness,n.roughnessMap&&(e.roughnessMap.value=n.roughnessMap),n.metalnessMap&&(e.metalnessMap.value=n.metalnessMap),n.emissiveMap&&(e.emissiveMap.value=n.emissiveMap),n.bumpMap&&(e.bumpMap.value=n.bumpMap,e.bumpScale.value=n.bumpScale,1===n.side&&(e.bumpScale.value*=-1)),n.normalMap&&(e.normalMap.value=n.normalMap,e.normalScale.value.copy(n.normalScale),1===n.side&&e.normalScale.value.negate()),n.displacementMap&&(e.displacementMap.value=n.displacementMap,e.displacementScale.value=n.displacementScale,e.displacementBias.value=n.displacementBias),t.get(n).envMap&&(e.envMapIntensity.value=n.envMapIntensity)}return{refreshFogUniforms:function i(t,e){t.fogColor.value.copy(e.color),e.isFog?(t.fogNear.value=e.near,t.fogFar.value=e.far):e.isFogExp2&&(t.fogDensity.value=e.density)},refreshMaterialUniforms:function r(t,i,o,a){i.isMeshBasicMaterial?e(t,i):i.isMeshLambertMaterial?(e(t,i),(function s(t,e){e.emissiveMap&&(t.emissiveMap.value=e.emissiveMap)})(t,i)):i.isMeshToonMaterial?(e(t,i),(function l(t,e){e.gradientMap&&(t.gradientMap.value=e.gradientMap),e.emissiveMap&&(t.emissiveMap.value=e.emissiveMap),e.bumpMap&&(t.bumpMap.value=e.bumpMap,t.bumpScale.value=e.bumpScale,1===e.side&&(t.bumpScale.value*=-1)),e.normalMap&&(t.normalMap.value=e.normalMap,t.normalScale.value.copy(e.normalScale),1===e.side&&t.normalScale.value.negate()),e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias)})(t,i)):i.isMeshPhongMaterial?(e(t,i),(function c(t,e){t.specular.value.copy(e.specular),t.shininess.value=Math.max(e.shininess,1e-4),e.emissiveMap&&(t.emissiveMap.value=e.emissiveMap),e.bumpMap&&(t.bumpMap.value=e.bumpMap,t.bumpScale.value=e.bumpScale,1===e.side&&(t.bumpScale.value*=-1)),e.normalMap&&(t.normalMap.value=e.normalMap,t.normalScale.value.copy(e.normalScale),1===e.side&&t.normalScale.value.negate()),e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias)})(t,i)):i.isMeshStandardMaterial?(e(t,i),i.isMeshPhysicalMaterial?(function u(t,e){n(t,e),t.reflectivity.value=e.reflectivity,t.clearcoat.value=e.clearcoat,t.clearcoatRoughness.value=e.clearcoatRoughness,e.sheen&&t.sheen.value.copy(e.sheen),e.clearcoatMap&&(t.clearcoatMap.value=e.clearcoatMap),e.clearcoatRoughnessMap&&(t.clearcoatRoughnessMap.value=e.clearcoatRoughnessMap),e.clearcoatNormalMap&&(t.clearcoatNormalScale.value.copy(e.clearcoatNormalScale),t.clearcoatNormalMap.value=e.clearcoatNormalMap,1===e.side&&t.clearcoatNormalScale.value.negate()),t.transmission.value=e.transmission,e.transmissionMap&&(t.transmissionMap.value=e.transmissionMap)})(t,i):n(t,i)):i.isMeshMatcapMaterial?(e(t,i),(function h(t,e){e.matcap&&(t.matcap.value=e.matcap),e.bumpMap&&(t.bumpMap.value=e.bumpMap,t.bumpScale.value=e.bumpScale,1===e.side&&(t.bumpScale.value*=-1)),e.normalMap&&(t.normalMap.value=e.normalMap,t.normalScale.value.copy(e.normalScale),1===e.side&&t.normalScale.value.negate()),e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias)})(t,i)):i.isMeshDepthMaterial?(e(t,i),(function d(t,e){e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias)})(t,i)):i.isMeshDistanceMaterial?(e(t,i),(function p(t,e){e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias),t.referencePosition.value.copy(e.referencePosition),t.nearDistance.value=e.nearDistance,t.farDistance.value=e.farDistance})(t,i)):i.isMeshNormalMaterial?(e(t,i),(function f(t,e){e.bumpMap&&(t.bumpMap.value=e.bumpMap,t.bumpScale.value=e.bumpScale,1===e.side&&(t.bumpScale.value*=-1)),e.normalMap&&(t.normalMap.value=e.normalMap,t.normalScale.value.copy(e.normalScale),1===e.side&&t.normalScale.value.negate()),e.displacementMap&&(t.displacementMap.value=e.displacementMap,t.displacementScale.value=e.displacementScale,t.displacementBias.value=e.displacementBias)})(t,i)):i.isLineBasicMaterial?((function m(t,e){t.diffuse.value.copy(e.color),t.opacity.value=e.opacity})(t,i),i.isLineDashedMaterial&&(function g(t,e){t.dashSize.value=e.dashSize,t.totalSize.value=e.dashSize+e.gapSize,t.scale.value=e.scale})(t,i)):i.isPointsMaterial?(function _(t,e,n,i){let r;t.diffuse.value.copy(e.color),t.opacity.value=e.opacity,t.size.value=e.size*n,t.scale.value=.5*i,e.map&&(t.map.value=e.map),e.alphaMap&&(t.alphaMap.value=e.alphaMap),e.map?r=e.map:e.alphaMap&&(r=e.alphaMap),void 0!==r&&(!0===r.matrixAutoUpdate&&r.updateMatrix(),t.uvTransform.value.copy(r.matrix))})(t,i,o,a):i.isSpriteMaterial?(function y(t,e){let n;t.diffuse.value.copy(e.color),t.opacity.value=e.opacity,t.rotation.value=e.rotation,e.map&&(t.map.value=e.map),e.alphaMap&&(t.alphaMap.value=e.alphaMap),e.map?n=e.map:e.alphaMap&&(n=e.alphaMap),void 0!==n&&(!0===n.matrixAutoUpdate&&n.updateMatrix(),t.uvTransform.value.copy(n.matrix))})(t,i):i.isShadowMaterial?(t.color.value.copy(i.color),t.opacity.value=i.opacity):i.isShaderMaterial&&(i.uniformsNeedUpdate=!1)}}}function tGt(t){const e=void 0!==(t=t||{}).canvas?t.canvas:(function n(){const t=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");return t.style.display="block",t})(),i=void 0!==t.context?t.context:null,r=void 0!==t.alpha&&t.alpha,o=void 0===t.depth||t.depth,a=void 0===t.stencil||t.stencil,s=void 0!==t.antialias&&t.antialias,l=void 0===t.premultipliedAlpha||t.premultipliedAlpha,c=void 0!==t.preserveDrawingBuffer&&t.preserveDrawingBuffer,u=void 0!==t.powerPreference?t.powerPreference:"default",h=void 0!==t.failIfMajorPerformanceCaveat&&t.failIfMajorPerformanceCaveat;let d=null,p=null;const f=[];this.domElement=e,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.gammaFactor=2,this.outputEncoding=YBt,this.physicallyCorrectLights=!1,this.toneMapping=0,this.toneMappingExposure=1,this.maxMorphTargets=8,this.maxMorphNormals=4;const m=this;let g=!1,_=null,y=0,v=0,b=null,x=null,w=-1,S=null;const M=new mHt,E=new mHt;let T=null,A=e.width,C=e.height,k=1,L=null,P=null;const I=new mHt(0,0,A,C),N=new mHt(0,0,A,C);let O=!1;const R=new YVt;let z=!1,D=!1;const B=new qHt,H=new yHt,F={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function V(){return null===b?k:1}let j,U,G,W,q,Y,X,$,K,Z,J,Q,tt,et,nt,it,rt,ot,at,st,lt,ct=i;function ut(t,n){for(let i=0;i<t.length;i++){const r=e.getContext(t[i],n);if(null!==r)return r}return null}try{const t={alpha:r,depth:o,stencil:a,antialias:s,premultipliedAlpha:l,preserveDrawingBuffer:c,powerPreference:u,failIfMajorPerformanceCaveat:h};if(e.addEventListener("webglcontextlost",ft,!1),e.addEventListener("webglcontextrestored",mt,!1),null===ct){const e=["webgl2","webgl","experimental-webgl"];if(!0===m.isWebGL1Renderer&&e.shift(),ct=ut(e,t),null===ct)throw ut(e)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===ct.getShaderPrecisionFormat&&(ct.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(t){throw console.error("THREE.WebGLRenderer: "+t.message),t}function ht(){j=new ajt(ct),U=new ijt(ct,j,t),j.init(U),st=new XUt(ct,j,U),G=new qUt(ct,j,U),G.scissor(E.copy(N).multiplyScalar(k).floor()),G.viewport(M.copy(I).multiplyScalar(k).floor()),W=new cjt(ct),q=new IUt,Y=new YUt(ct,j,G,q,U,st,W),X=new ojt(m),$=new $Vt(ct,U),lt=new ejt(ct,j,$,U),K=new sjt(ct,$,W,lt),Z=new pjt(ct,K,$,W),rt=new djt(ct),nt=new rjt(q),J=new PUt(m,X,j,U,lt,nt),Q=new QUt(q),tt=new zUt(q),et=new jUt(j,U),it=new tjt(m,X,G,Z,l),ot=new njt(ct,j,W,U),at=new ljt(ct,j,W,U),W.programs=J.programs,m.capabilities=U,m.extensions=j,m.properties=q,m.renderLists=tt,m.state=G,m.info=W}ht();const dt=new JUt(m,ct);this.xr=dt;const pt=new WUt(m,Z,U.maxTextureSize);function ft(t){t.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),g=!0}function mt(){console.log("THREE.WebGLRenderer: Context Restored."),g=!1,ht()}function gt(t){const e=t.target;e.removeEventListener("dispose",gt),(function n(t){_t(t),q.remove(t)})(e)}function _t(t){const e=q.get(t).program;void 0!==e&&J.releaseProgram(e)}this.shadowMap=pt,this.getContext=function(){return ct},this.getContextAttributes=function(){return ct.getContextAttributes()},this.forceContextLoss=function(){const t=j.get("WEBGL_lose_context");t&&t.loseContext()},this.forceContextRestore=function(){const t=j.get("WEBGL_lose_context");t&&t.restoreContext()},this.getPixelRatio=function(){return k},this.setPixelRatio=function(t){void 0!==t&&(k=t,this.setSize(A,C,!1))},this.getSize=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getsize() now requires a Vector2 as an argument"),t=new lHt),t.set(A,C)},this.setSize=function(t,n,i){dt.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(A=t,C=n,e.width=Math.floor(t*k),e.height=Math.floor(n*k),!1!==i&&(e.style.width=t+"px",e.style.height=n+"px"),this.setViewport(0,0,t,n))},this.getDrawingBufferSize=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument"),t=new lHt),t.set(A*k,C*k).floor()},this.setDrawingBufferSize=function(t,n,i){A=t,C=n,k=i,e.width=Math.floor(t*i),e.height=Math.floor(n*i),this.setViewport(0,0,t,n)},this.getCurrentViewport=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument"),t=new mHt),t.copy(M)},this.getViewport=function(t){return t.copy(I)},this.setViewport=function(t,e,n,i){t.isVector4?I.set(t.x,t.y,t.z,t.w):I.set(t,e,n,i),G.viewport(M.copy(I).multiplyScalar(k).floor())},this.getScissor=function(t){return t.copy(N)},this.setScissor=function(t,e,n,i){t.isVector4?N.set(t.x,t.y,t.z,t.w):N.set(t,e,n,i),G.scissor(E.copy(N).multiplyScalar(k).floor())},this.getScissorTest=function(){return O},this.setScissorTest=function(t){G.setScissorTest(O=t)},this.setOpaqueSort=function(t){L=t},this.setTransparentSort=function(t){P=t},this.getClearColor=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getClearColor() now requires a Color as an argument"),t=new HFt),t.copy(it.getClearColor())},this.setClearColor=function(){it.setClearColor.apply(it,arguments)},this.getClearAlpha=function(){return it.getClearAlpha()},this.setClearAlpha=function(){it.setClearAlpha.apply(it,arguments)},this.clear=function(t,e,n){let i=0;(void 0===t||t)&&(i|=16384),(void 0===e||e)&&(i|=256),(void 0===n||n)&&(i|=1024),ct.clear(i)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){e.removeEventListener("webglcontextlost",ft,!1),e.removeEventListener("webglcontextrestored",mt,!1),tt.dispose(),et.dispose(),q.dispose(),X.dispose(),Z.dispose(),lt.dispose(),dt.dispose(),vt.stop()},this.renderBufferImmediate=function(t,e){lt.initAttributes();const n=q.get(t);t.hasPositions&&!n.position&&(n.position=ct.createBuffer()),t.hasNormals&&!n.normal&&(n.normal=ct.createBuffer()),t.hasUvs&&!n.uv&&(n.uv=ct.createBuffer()),t.hasColors&&!n.color&&(n.color=ct.createBuffer());const i=e.getAttributes();t.hasPositions&&(ct.bindBuffer(34962,n.position),ct.bufferData(34962,t.positionArray,35048),lt.enableAttribute(i.position),ct.vertexAttribPointer(i.position,3,5126,!1,0,0)),t.hasNormals&&(ct.bindBuffer(34962,n.normal),ct.bufferData(34962,t.normalArray,35048),lt.enableAttribute(i.normal),ct.vertexAttribPointer(i.normal,3,5126,!1,0,0)),t.hasUvs&&(ct.bindBuffer(34962,n.uv),ct.bufferData(34962,t.uvArray,35048),lt.enableAttribute(i.uv),ct.vertexAttribPointer(i.uv,2,5126,!1,0,0)),t.hasColors&&(ct.bindBuffer(34962,n.color),ct.bufferData(34962,t.colorArray,35048),lt.enableAttribute(i.color),ct.vertexAttribPointer(i.color,3,5126,!1,0,0)),lt.disableUnusedAttributes(),ct.drawArrays(4,0,t.count),t.count=0},this.renderBufferDirect=function(t,e,n,i,r,o){null===e&&(e=F);const a=r.isMesh&&r.matrixWorld.determinant()<0,s=Mt(t,e,i,r);G.setMaterial(i,a);let l=n.index;const c=n.attributes.position;if(null===l){if(void 0===c||0===c.count)return}else if(0===l.count)return;let u,h=1;!0===i.wireframe&&(l=K.getWireframeAttribute(n),h=2),(i.morphTargets||i.morphNormals)&&rt.update(r,n,i,s),lt.setup(r,i,s,n,l);let d=ot;null!==l&&(u=$.get(l),d=at,d.setIndex(u));const p=null!==l?l.count:c.count,f=n.drawRange.start*h,m=n.drawRange.count*h,g=null!==o?o.start*h:0,_=null!==o?o.count*h:1/0,y=Math.max(f,g),v=Math.min(p,f+m,g+_)-1,b=Math.max(0,v-y+1);if(0!==b){if(r.isMesh)!0===i.wireframe?(G.setLineWidth(i.wireframeLinewidth*V()),d.setMode(1)):d.setMode(4);else if(r.isLine){let t=i.linewidth;void 0===t&&(t=1),G.setLineWidth(t*V()),d.setMode(r.isLineSegments?1:r.isLineLoop?2:3)}else r.isPoints?d.setMode(0):r.isSprite&&d.setMode(4);if(r.isInstancedMesh)d.renderInstances(y,b,r.count);else if(n.isInstancedBufferGeometry){const t=Math.min(n.instanceCount,n._maxInstanceCount);d.renderInstances(y,b,t)}else d.render(y,b)}},this.compile=function(t,e){p=et.get(t),p.init(),t.traverseVisible((function(t){t.isLight&&t.layers.test(e.layers)&&(p.pushLight(t),t.castShadow&&p.pushShadow(t))})),p.setupLights();const n=new WeakMap;t.traverse((function(e){const i=e.material;if(i)if(Array.isArray(i))for(let r=0;r<i.length;r++){const o=i[r];!1===n.has(o)&&(St(o,t,e),n.set(o))}else!1===n.has(i)&&(St(i,t,e),n.set(i))}))};let yt=null;const vt=new XVt;function bt(t,e,n,i){if(!1===t.visible)return;if(t.layers.test(e.layers))if(t.isGroup)n=t.renderOrder;else if(t.isLOD)!0===t.autoUpdate&&t.update(e);else if(t.isLight)p.pushLight(t),t.castShadow&&p.pushShadow(t);else if(t.isSprite){if(!t.frustumCulled||R.intersectsSprite(t)){i&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(B);const e=Z.update(t),r=t.material;r.visible&&d.push(t,e,r,n,H.z,null)}}else if(t.isImmediateRenderObject)i&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(B),d.push(t,null,t.material,n,H.z,null);else if((t.isMesh||t.isLine||t.isPoints)&&(t.isSkinnedMesh&&t.skeleton.frame!==W.render.frame&&(t.skeleton.update(),t.skeleton.frame=W.render.frame),!t.frustumCulled||R.intersectsObject(t))){i&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(B);const e=Z.update(t),r=t.material;if(Array.isArray(r)){const i=e.groups;for(let o=0,a=i.length;o<a;o++){const a=i[o],s=r[a.materialIndex];s&&s.visible&&d.push(t,e,s,n,H.z,a)}}else r.visible&&d.push(t,e,r,n,H.z,null)}const r=t.children;for(let t=0,o=r.length;t<o;t++)bt(r[t],e,n,i)}function xt(t,e,n){const i=!0===e.isScene?e.overrideMaterial:null;for(let r=0,o=t.length;r<o;r++){const o=t[r],a=o.object,s=o.geometry,l=null===i?o.material:i,c=o.group;if(n.isArrayCamera){const t=n.cameras;for(let n=0,i=t.length;n<i;n++){const i=t[n];a.layers.test(i.layers)&&(G.viewport(M.copy(i.viewport)),p.setupLightsView(i),wt(a,e,i,s,l,c))}}else wt(a,e,n,s,l,c)}}function wt(t,e,n,i,r,o){if(t.onBeforeRender(m,e,n,i,r,o),t.modelViewMatrix.multiplyMatrices(n.matrixWorldInverse,t.matrixWorld),t.normalMatrix.getNormalMatrix(t.modelViewMatrix),t.isImmediateRenderObject){const i=Mt(n,e,r,t);G.setMaterial(r),lt.reset(),(function a(t,e){t.render((function(t){m.renderBufferImmediate(t,e)}))})(t,i)}else m.renderBufferDirect(n,e,i,r,t,o);t.onAfterRender(m,e,n,i,r,o)}function St(t,e,n){!0!==e.isScene&&(e=F);const i=q.get(t),r=p.state.lights,o=r.state.version,a=J.getParameters(t,r.state,p.state.shadowsArray,e,n),s=J.getProgramCacheKey(a);let l=i.program,c=!0;if(i.environment=t.isMeshStandardMaterial?e.environment:null,i.fog=e.fog,i.envMap=X.get(t.envMap||i.environment),void 0===l)t.addEventListener("dispose",gt);else if(l.cacheKey!==s)_t(t);else if(i.lightsStateVersion!==o)c=!1;else{if(void 0!==a.shaderID)return;c=!1}c&&(a.uniforms=J.getUniforms(t),t.onBeforeCompile(a,m),l=J.acquireProgram(a,s),i.program=l,i.uniforms=a.uniforms,i.outputEncoding=a.outputEncoding);const u=i.uniforms;(t.isShaderMaterial||t.isRawShaderMaterial)&&!0!==t.clipping||(i.numClippingPlanes=nt.numPlanes,i.numIntersection=nt.numIntersection,u.clippingPlanes=nt.uniform),i.needsLights=(function h(t){return t.isMeshLambertMaterial||t.isMeshToonMaterial||t.isMeshPhongMaterial||t.isMeshStandardMaterial||t.isShadowMaterial||t.isShaderMaterial&&!0===t.lights})(t),i.lightsStateVersion=o,i.needsLights&&(u.ambientLightColor.value=r.state.ambient,u.lightProbe.value=r.state.probe,u.directionalLights.value=r.state.directional,u.directionalLightShadows.value=r.state.directionalShadow,u.spotLights.value=r.state.spot,u.spotLightShadows.value=r.state.spotShadow,u.rectAreaLights.value=r.state.rectArea,u.ltc_1.value=r.state.rectAreaLTC1,u.ltc_2.value=r.state.rectAreaLTC2,u.pointLights.value=r.state.point,u.pointLightShadows.value=r.state.pointShadow,u.hemisphereLights.value=r.state.hemi,u.directionalShadowMap.value=r.state.directionalShadowMap,u.directionalShadowMatrix.value=r.state.directionalShadowMatrix,u.spotShadowMap.value=r.state.spotShadowMap,u.spotShadowMatrix.value=r.state.spotShadowMatrix,u.pointShadowMap.value=r.state.pointShadowMap,u.pointShadowMatrix.value=r.state.pointShadowMatrix);const d=i.program.getUniforms(),f=uUt.seqWithValue(d.seq,u);i.uniformsList=f}function Mt(t,e,n,i){!0!==e.isScene&&(e=F),Y.resetTextureUnits();const r=e.fog,o=n.isMeshStandardMaterial?e.environment:null,a=null===b?m.outputEncoding:b.texture.encoding,s=X.get(n.envMap||o),l=q.get(n),c=p.state.lights;!0!==z||!0!==D&&t===S||nt.setState(n,t,t===S&&n.id===w),n.version===l.__version?n.fog&&l.fog!==r||l.environment!==o||l.needsLights&&l.lightsStateVersion!==c.state.version?St(n,e,i):void 0===l.numClippingPlanes||l.numClippingPlanes===nt.numPlanes&&l.numIntersection===nt.numIntersection?(l.outputEncoding!==a||l.envMap!==s)&&St(n,e,i):St(n,e,i):(St(n,e,i),l.__version=n.version);let u=!1,h=!1,d=!1;const f=l.program,g=f.getUniforms(),_=l.uniforms;if(G.useProgram(f.program)&&(u=!0,h=!0,d=!0),n.id!==w&&(w=n.id,h=!0),u||S!==t){if(g.setValue(ct,"projectionMatrix",t.projectionMatrix),U.logarithmicDepthBuffer&&g.setValue(ct,"logDepthBufFC",2/(Math.log(t.far+1)/Math.LN2)),S!==t&&(S=t,h=!0,d=!0),n.isShaderMaterial||n.isMeshPhongMaterial||n.isMeshToonMaterial||n.isMeshStandardMaterial||n.envMap){const e=g.map.cameraPosition;void 0!==e&&e.setValue(ct,H.setFromMatrixPosition(t.matrixWorld))}(n.isMeshPhongMaterial||n.isMeshToonMaterial||n.isMeshLambertMaterial||n.isMeshBasicMaterial||n.isMeshStandardMaterial||n.isShaderMaterial)&&g.setValue(ct,"isOrthographic",!0===t.isOrthographicCamera),(n.isMeshPhongMaterial||n.isMeshToonMaterial||n.isMeshLambertMaterial||n.isMeshBasicMaterial||n.isMeshStandardMaterial||n.isShaderMaterial||n.isShadowMaterial||n.skinning)&&g.setValue(ct,"viewMatrix",t.matrixWorldInverse)}if(n.skinning){g.setOptional(ct,i,"bindMatrix"),g.setOptional(ct,i,"bindMatrixInverse");const t=i.skeleton;if(t){const e=t.bones;if(U.floatVertexTextures){if(null===t.boneTexture){let n=Math.sqrt(4*e.length);n=sHt.ceilPowerOfTwo(n),n=Math.max(n,4);const i=new Float32Array(n*n*4);i.set(t.boneMatrices);const r=new GVt(i,n,n,TBt,wBt);t.boneMatrices=i,t.boneTexture=r,t.boneTextureSize=n}g.setValue(ct,"boneTexture",t.boneTexture,Y),g.setValue(ct,"boneTextureSize",t.boneTextureSize)}else g.setOptional(ct,t,"boneMatrices")}}return(h||l.receiveShadow!==i.receiveShadow)&&(l.receiveShadow=i.receiveShadow,g.setValue(ct,"receiveShadow",i.receiveShadow)),h&&(g.setValue(ct,"toneMappingExposure",m.toneMappingExposure),l.needsLights&&(function y(t,e){t.ambientLightColor.needsUpdate=e,t.lightProbe.needsUpdate=e,t.directionalLights.needsUpdate=e,t.directionalLightShadows.needsUpdate=e,t.pointLights.needsUpdate=e,t.pointLightShadows.needsUpdate=e,t.spotLights.needsUpdate=e,t.spotLightShadows.needsUpdate=e,t.rectAreaLights.needsUpdate=e,t.hemisphereLights.needsUpdate=e})(_,d),r&&n.fog&&Q.refreshFogUniforms(_,r),Q.refreshMaterialUniforms(_,n,k,C),uUt.upload(ct,l.uniformsList,_,Y)),n.isShaderMaterial&&!0===n.uniformsNeedUpdate&&(uUt.upload(ct,l.uniformsList,_,Y),n.uniformsNeedUpdate=!1),n.isSpriteMaterial&&g.setValue(ct,"center",i.center),g.setValue(ct,"modelViewMatrix",i.modelViewMatrix),g.setValue(ct,"normalMatrix",i.normalMatrix),g.setValue(ct,"modelMatrix",i.matrixWorld),f}vt.setAnimationLoop((function Et(t){dt.isPresenting||yt&&yt(t)})),"undefined"!=typeof window&&vt.setContext(window),this.setAnimationLoop=function(t){yt=t,dt.setAnimationLoop(t),null===t?vt.stop():vt.start()},this.render=function(t,e){let n,i;if(void 0!==arguments[2]&&(console.warn("THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead."),n=arguments[2]),void 0!==arguments[3]&&(console.warn("THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead."),i=arguments[3]),void 0!==e&&!0!==e.isCamera)return void console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");if(!0===g)return;lt.resetDefaultState(),w=-1,S=null,!0===t.autoUpdate&&t.updateMatrixWorld(),null===e.parent&&e.updateMatrixWorld(),!0===dt.enabled&&!0===dt.isPresenting&&(e=dt.getCamera(e)),!0===t.isScene&&t.onBeforeRender(m,t,e,n||b),p=et.get(t,f.length),p.init(),f.push(p),B.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),R.setFromProjectionMatrix(B),D=this.localClippingEnabled,z=nt.init(this.clippingPlanes,D,e),d=tt.get(t,e),d.init(),bt(t,e,0,m.sortObjects),d.finish(),!0===m.sortObjects&&d.sort(L,P),!0===z&&nt.beginShadows();const r=p.state.shadowsArray;pt.render(r,t,e),p.setupLights(),p.setupLightsView(e),!0===z&&nt.endShadows(),!0===this.info.autoReset&&this.info.reset(),void 0!==n&&this.setRenderTarget(n),it.render(d,t,e,i);const o=d.opaque,a=d.transparent;o.length>0&&xt(o,t,e),a.length>0&&xt(a,t,e),!0===t.isScene&&t.onAfterRender(m,t,e),null!==b&&(Y.updateRenderTargetMipmap(b),Y.updateMultisampleRenderTarget(b)),G.buffers.depth.setTest(!0),G.buffers.depth.setMask(!0),G.buffers.color.setMask(!0),G.setPolygonOffset(!1),f.pop(),p=f.length>0?f[f.length-1]:null,d=null},this.setFramebuffer=function(t){_!==t&&null===b&&ct.bindFramebuffer(36160,t),_=t},this.getActiveCubeFace=function(){return y},this.getActiveMipmapLevel=function(){return v},this.getRenderList=function(){return d},this.setRenderList=function(t){d=t},this.getRenderTarget=function(){return b},this.setRenderTarget=function(t,e=0,n=0){b=t,y=e,v=n,t&&void 0===q.get(t).__webglFramebuffer&&Y.setupRenderTarget(t);let i=_,r=!1;if(t){const n=q.get(t).__webglFramebuffer;t.isWebGLCubeRenderTarget?(i=n[e],r=!0):i=t.isWebGLMultisampleRenderTarget?q.get(t).__webglMultisampledFramebuffer:n,M.copy(t.viewport),E.copy(t.scissor),T=t.scissorTest}else M.copy(I).multiplyScalar(k).floor(),E.copy(N).multiplyScalar(k).floor(),T=O;if(x!==i&&(ct.bindFramebuffer(36160,i),x=i),G.viewport(M),G.scissor(E),G.setScissorTest(T),r){const i=q.get(t.texture);ct.framebufferTexture2D(36160,36064,34069+e,i.__webglTexture,n)}},this.readRenderTargetPixels=function(t,e,n,i,r,o,a){if(!t||!t.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let s=q.get(t).__webglFramebuffer;if(t.isWebGLCubeRenderTarget&&void 0!==a&&(s=s[a]),s){let a=!1;s!==x&&(ct.bindFramebuffer(36160,s),a=!0);try{const s=t.texture,l=s.format,c=s.type;if(l!==TBt&&st.convert(l)!==ct.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");const u=c===SBt&&(j.has("EXT_color_buffer_half_float")||U.isWebGL2&&j.has("EXT_color_buffer_float"));if(!(c===vBt||st.convert(c)===ct.getParameter(35738)||c===wBt&&(U.isWebGL2||j.has("OES_texture_float")||j.has("WEBGL_color_buffer_float"))||u))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===ct.checkFramebufferStatus(36160)?e>=0&&e<=t.width-i&&n>=0&&n<=t.height-r&&ct.readPixels(e,n,i,r,st.convert(l),st.convert(c),o):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{a&&ct.bindFramebuffer(36160,x)}}},this.copyFramebufferToTexture=function(t,e,n=0){const i=Math.pow(2,-n),r=Math.floor(e.image.width*i),o=Math.floor(e.image.height*i),a=st.convert(e.format);Y.setTexture2D(e,0),ct.copyTexImage2D(3553,n,a,t.x,t.y,r,o,0),G.unbindTexture()},this.copyTextureToTexture=function(t,e,n,i=0){const r=e.image.width,o=e.image.height,a=st.convert(n.format),s=st.convert(n.type);Y.setTexture2D(n,0),ct.pixelStorei(37440,n.flipY),ct.pixelStorei(37441,n.premultiplyAlpha),ct.pixelStorei(3317,n.unpackAlignment),e.isDataTexture?ct.texSubImage2D(3553,i,t.x,t.y,r,o,a,s,e.image.data):e.isCompressedTexture?ct.compressedTexSubImage2D(3553,i,t.x,t.y,e.mipmaps[0].width,e.mipmaps[0].height,a,e.mipmaps[0].data):ct.texSubImage2D(3553,i,t.x,t.y,a,s,e.image),0===i&&n.generateMipmaps&&ct.generateMipmap(3553),G.unbindTexture()},this.initTexture=function(t){Y.setTexture2D(t,0),G.unbindTexture()},this.resetState=function(){G.reset(),lt.reset()},"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function eGt(t){tGt.call(this,t)}(UUt.prototype=Object.create(jFt.prototype)).constructor=UUt,UUt.prototype.isMeshDepthMaterial=!0,UUt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.depthPacking=t.depthPacking,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this},(GUt.prototype=Object.create(jFt.prototype)).constructor=GUt,GUt.prototype.isMeshDistanceMaterial=!0,GUt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this},$Ut.prototype=Object.assign(Object.create(HVt.prototype),{constructor:$Ut,isArrayCamera:!0}),KUt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:KUt,isGroup:!0}),Object.assign(ZUt.prototype,{constructor:ZUt,getHandSpace:function(){return null===this._hand&&(this._hand=new KUt,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand},getTargetRaySpace:function(){return null===this._targetRay&&(this._targetRay=new KUt,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1),this._targetRay},getGripSpace:function(){return null===this._grip&&(this._grip=new KUt,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1),this._grip},dispatchEvent:function(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this},disconnect:function(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this},update:function(t,e,n){let i=null,r=null,o=null;const a=this._targetRay,s=this._grip,l=this._hand;if(t&&"visible-blurred"!==e.session.visibilityState)if(l&&t.hand){o=!0;for(const i of t.hand.values()){const t=e.getJointPose(i,n);if(void 0===l.joints[i.jointName]){const t=new KUt;t.matrixAutoUpdate=!1,t.visible=!1,l.joints[i.jointName]=t,l.add(t)}const r=l.joints[i.jointName];null!==t&&(r.matrix.fromArray(t.transform.matrix),r.matrix.decompose(r.position,r.rotation,r.scale),r.jointRadius=t.radius),r.visible=null!==t}const i=l.joints["index-finger-tip"].position.distanceTo(l.joints["thumb-tip"].position),r=.02,a=.005;l.inputState.pinching&&i>r+a?(l.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!l.inputState.pinching&&i<=r-a&&(l.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==a&&(i=e.getPose(t.targetRaySpace,n),null!==i&&(a.matrix.fromArray(i.transform.matrix),a.matrix.decompose(a.position,a.rotation,a.scale))),null!==s&&t.gripSpace&&(r=e.getPose(t.gripSpace,n),null!==r&&(s.matrix.fromArray(r.transform.matrix),s.matrix.decompose(s.position,s.rotation,s.scale)));return null!==a&&(a.visible=null!==i),null!==s&&(s.visible=null!==r),null!==l&&(l.visible=null!==o),this}}),Object.assign(JUt.prototype,rHt.prototype),eGt.prototype=Object.assign(Object.create(tGt.prototype),{constructor:eGt,isWebGL1Renderer:!0});class nGt{constructor(t,e){Object.defineProperty(this,"isFogExp2",{value:!0}),this.name="",this.color=new HFt(t),this.density=void 0!==e?e:25e-5}clone(){return new nGt(this.color,this.density)}toJSON(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}}class iGt{constructor(t,e,n){Object.defineProperty(this,"isFog",{value:!0}),this.name="",this.color=new HFt(t),this.near=void 0!==e?e:1,this.far=void 0!==n?n:1e3}clone(){return new iGt(this.color,this.near,this.far)}toJSON(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}}class rGt extends _Ft{constructor(){super(),Object.defineProperty(this,"isScene",{value:!0}),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,e){return super.copy(t,e),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){const e=super.toJSON(t);return null!==this.background&&(e.object.background=this.background.toJSON(t)),null!==this.environment&&(e.object.environment=this.environment.toJSON(t)),null!==this.fog&&(e.object.fog=this.fog.toJSON()),e}}function oGt(t,e){this.array=t,this.stride=e,this.count=void 0!==t?t.length/e:0,this.usage=eHt,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=sHt.generateUUID()}Object.defineProperty(oGt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(oGt.prototype,{isInterleavedBuffer:!0,onUploadCallback:function(){},setUsage:function(t){return this.usage=t,this},copy:function(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this},copyAt:function(t,e,n){t*=this.stride,n*=e.stride;for(let i=0,r=this.stride;i<r;i++)this.array[t+i]=e.array[n+i];return this},set:function(t,e=0){return this.array.set(t,e),this},clone:function(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=sHt.generateUUID()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);const e=new oGt(new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),this.stride);return e.setUsage(this.usage),e},onUpload:function(t){return this.onUploadCallback=t,this},toJSON:function(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=sHt.generateUUID()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}});const aGt=new yHt;function sGt(t,e,n,i){this.name="",this.data=t,this.itemSize=e,this.offset=n,this.normalized=!0===i}function lGt(t){jFt.call(this),this.type="SpriteMaterial",this.color=new HFt(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}let cGt;Object.defineProperties(sGt.prototype,{count:{get:function(){return this.data.count}},array:{get:function(){return this.data.array}},needsUpdate:{set:function(t){this.data.needsUpdate=t}}}),Object.assign(sGt.prototype,{isInterleavedBufferAttribute:!0,applyMatrix4:function(t){for(let e=0,n=this.data.count;e<n;e++)aGt.x=this.getX(e),aGt.y=this.getY(e),aGt.z=this.getZ(e),aGt.applyMatrix4(t),this.setXYZ(e,aGt.x,aGt.y,aGt.z);return this},setX:function(t,e){return this.data.array[t*this.data.stride+this.offset]=e,this},setY:function(t,e){return this.data.array[t*this.data.stride+this.offset+1]=e,this},setZ:function(t,e){return this.data.array[t*this.data.stride+this.offset+2]=e,this},setW:function(t,e){return this.data.array[t*this.data.stride+this.offset+3]=e,this},getX:function(t){return this.data.array[t*this.data.stride+this.offset]},getY:function(t){return this.data.array[t*this.data.stride+this.offset+1]},getZ:function(t){return this.data.array[t*this.data.stride+this.offset+2]},getW:function(t){return this.data.array[t*this.data.stride+this.offset+3]},setXY:function(t,e,n){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=n,this},setXYZ:function(t,e,n,i){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=n,this.data.array[t+2]=i,this},setXYZW:function(t,e,n,i,r){return this.data.array[(t=t*this.data.stride+this.offset)+0]=e,this.data.array[t+1]=n,this.data.array[t+2]=i,this.data.array[t+3]=r,this},clone:function(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");const t=[];for(let e=0;e<this.count;e++){const n=e*this.data.stride+this.offset;for(let e=0;e<this.itemSize;e++)t.push(this.data.array[n+e])}return new qFt(new this.array.constructor(t),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new sGt(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)},toJSON:function(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");const t=[];for(let e=0;e<this.count;e++){const n=e*this.data.stride+this.offset;for(let e=0;e<this.itemSize;e++)t.push(this.data.array[n+e])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:t,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}}),(lGt.prototype=Object.create(jFt.prototype)).constructor=lGt,lGt.prototype.isSpriteMaterial=!0,lGt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this};const uGt=new yHt,hGt=new yHt,dGt=new yHt,pGt=new lHt,fGt=new lHt,mGt=new qHt,gGt=new yHt,_Gt=new yHt,yGt=new yHt,vGt=new lHt,bGt=new lHt,xGt=new lHt;function wGt(t){if(_Ft.call(this),this.type="Sprite",void 0===cGt){cGt=new pVt;const t=new oGt(new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),5);cGt.setIndex([0,1,2,0,2,3]),cGt.setAttribute("position",new sGt(t,3,0,!1)),cGt.setAttribute("uv",new sGt(t,2,3,!1))}this.geometry=cGt,this.material=void 0!==t?t:new lGt,this.center=new lHt(.5,.5)}function SGt(t,e,n,i,r,o){pGt.subVectors(t,n).addScalar(.5).multiply(i),void 0!==r?(fGt.x=o*pGt.x-r*pGt.y,fGt.y=r*pGt.x+o*pGt.y):fGt.copy(pGt),t.copy(e),t.x+=fGt.x,t.y+=fGt.y,t.applyMatrix4(mGt)}wGt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:wGt,isSprite:!0,raycast:function(t,e){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),hGt.setFromMatrixScale(this.matrixWorld),mGt.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),dGt.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&hGt.multiplyScalar(-dGt.z);const n=this.material.rotation;let i,r;0!==n&&(r=Math.cos(n),i=Math.sin(n));const o=this.center;SGt(gGt.set(-.5,-.5,0),dGt,o,hGt,i,r),SGt(_Gt.set(.5,-.5,0),dGt,o,hGt,i,r),SGt(yGt.set(.5,.5,0),dGt,o,hGt,i,r),vGt.set(0,0),bGt.set(1,0),xGt.set(1,1);let a=t.ray.intersectTriangle(gGt,_Gt,yGt,!1,uGt);if(null===a&&(SGt(_Gt.set(-.5,.5,0),dGt,o,hGt,i,r),bGt.set(0,1),a=t.ray.intersectTriangle(gGt,yGt,_Gt,!1,uGt),null===a))return;const s=t.ray.origin.distanceTo(uGt);s<t.near||s>t.far||e.push({distance:s,point:uGt.clone(),uv:IFt.getUV(uGt,gGt,_Gt,yGt,vGt,bGt,xGt,new lHt),face:null,object:this})},copy:function(t){return _Ft.prototype.copy.call(this,t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}});const MGt=new yHt,EGt=new yHt;function TGt(){_Ft.call(this),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]}}),this.autoUpdate=!0}TGt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:TGt,isLOD:!0,copy:function(t){_Ft.prototype.copy.call(this,t,!1);const e=t.levels;for(let t=0,n=e.length;t<n;t++){const n=e[t];this.addLevel(n.object.clone(),n.distance)}return this.autoUpdate=t.autoUpdate,this},addLevel:function(t,e=0){e=Math.abs(e);const n=this.levels;let i;for(i=0;i<n.length&&!(e<n[i].distance);i++);return n.splice(i,0,{distance:e,object:t}),this.add(t),this},getCurrentLevel:function(){return this._currentLevel},getObjectForDistance:function(t){const e=this.levels;if(e.length>0){let n,i;for(n=1,i=e.length;n<i&&!(t<e[n].distance);n++);return e[n-1].object}return null},raycast:function(t,e){if(this.levels.length>0){MGt.setFromMatrixPosition(this.matrixWorld);const n=t.ray.origin.distanceTo(MGt);this.getObjectForDistance(n).raycast(t,e)}},update:function(t){const e=this.levels;if(e.length>1){MGt.setFromMatrixPosition(t.matrixWorld),EGt.setFromMatrixPosition(this.matrixWorld);const n=MGt.distanceTo(EGt)/t.zoom;let i,r;for(e[0].object.visible=!0,i=1,r=e.length;i<r&&n>=e[i].distance;i++)e[i-1].object.visible=!1,e[i].object.visible=!0;for(this._currentLevel=i-1;i<r;i++)e[i].object.visible=!1}},toJSON:function(t){const e=_Ft.prototype.toJSON.call(this,t);!1===this.autoUpdate&&(e.object.autoUpdate=!1),e.object.levels=[];const n=this.levels;for(let t=0,i=n.length;t<i;t++){const i=n[t];e.object.levels.push({object:i.object.uuid,distance:i.distance})}return e}});const AGt=new yHt,CGt=new mHt,kGt=new mHt,LGt=new yHt,PGt=new qHt;function IGt(t,e){t&&t.isGeometry&&console.error("THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead."),PVt.call(this,t,e),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new qHt,this.bindMatrixInverse=new qHt}function NGt(){_Ft.call(this),this.type="Bone"}IGt.prototype=Object.assign(Object.create(PVt.prototype),{constructor:IGt,isSkinnedMesh:!0,copy:function(t){return PVt.prototype.copy.call(this,t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this},bind:function(t,e){this.skeleton=t,void 0===e&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),e=this.matrixWorld),this.bindMatrix.copy(e),this.bindMatrixInverse.copy(e).invert()},pose:function(){this.skeleton.pose()},normalizeSkinWeights:function(){const t=new mHt,e=this.geometry.attributes.skinWeight;for(let n=0,i=e.count;n<i;n++){t.x=e.getX(n),t.y=e.getY(n),t.z=e.getZ(n),t.w=e.getW(n);const i=1/t.manhattanLength();i!==1/0?t.multiplyScalar(i):t.set(1,0,0,0),e.setXYZW(n,t.x,t.y,t.z,t.w)}},updateMatrixWorld:function(t){PVt.prototype.updateMatrixWorld.call(this,t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)},boneTransform:function(t,e){const n=this.skeleton,i=this.geometry;CGt.fromBufferAttribute(i.attributes.skinIndex,t),kGt.fromBufferAttribute(i.attributes.skinWeight,t),AGt.fromBufferAttribute(i.attributes.position,t).applyMatrix4(this.bindMatrix),e.set(0,0,0);for(let t=0;t<4;t++){const i=kGt.getComponent(t);if(0!==i){const r=CGt.getComponent(t);PGt.multiplyMatrices(n.bones[r].matrixWorld,n.boneInverses[r]),e.addScaledVector(LGt.copy(AGt).applyMatrix4(PGt),i)}}return e.applyMatrix4(this.bindMatrixInverse)}}),NGt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:NGt,isBone:!0});const OGt=new qHt,RGt=new qHt;function zGt(t=[],e=[]){this.uuid=sHt.generateUUID(),this.bones=t.slice(0),this.boneInverses=e,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}Object.assign(zGt.prototype,{init:function(){const t=this.bones,e=this.boneInverses;if(this.boneMatrices=new Float32Array(16*t.length),0===e.length)this.calculateInverses();else if(t.length!==e.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let t=0,e=this.bones.length;t<e;t++)this.boneInverses.push(new qHt)}},calculateInverses:function(){this.boneInverses.length=0;for(let t=0,e=this.bones.length;t<e;t++){const e=new qHt;this.bones[t]&&e.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(e)}},pose:function(){for(let t=0,e=this.bones.length;t<e;t++){const e=this.bones[t];e&&e.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,e=this.bones.length;t<e;t++){const e=this.bones[t];e&&(e.parent&&e.parent.isBone?(e.matrix.copy(e.parent.matrixWorld).invert(),e.matrix.multiply(e.matrixWorld)):e.matrix.copy(e.matrixWorld),e.matrix.decompose(e.position,e.quaternion,e.scale))}},update:function(){const t=this.bones,e=this.boneInverses,n=this.boneMatrices,i=this.boneTexture;for(let i=0,r=t.length;i<r;i++)OGt.multiplyMatrices(t[i]?t[i].matrixWorld:RGt,e[i]),OGt.toArray(n,16*i);null!==i&&(i.needsUpdate=!0)},clone:function(){return new zGt(this.bones,this.boneInverses)},getBoneByName:function(t){for(let e=0,n=this.bones.length;e<n;e++){const n=this.bones[e];if(n.name===t)return n}},dispose:function(){null!==this.boneTexture&&(this.boneTexture.dispose(),this.boneTexture=null)},fromJSON:function(t,e){this.uuid=t.uuid;for(let n=0,i=t.bones.length;n<i;n++){const i=t.bones[n];let r=e[i];void 0===r&&(console.warn("THREE.Skeleton: No bone found with UUID:",i),r=new NGt),this.bones.push(r),this.boneInverses.push((new qHt).fromArray(t.boneInverses[n]))}return this.init(),this},toJSON:function(){const t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;const e=this.bones,n=this.boneInverses;for(let i=0,r=e.length;i<r;i++)t.bones.push(e[i].uuid),t.boneInverses.push(n[i].toArray());return t}});const DGt=new qHt,BGt=new qHt,HGt=[],FGt=new PVt;function VGt(t,e,n){PVt.call(this,t,e),this.instanceMatrix=new qFt(new Float32Array(16*n),16),this.instanceColor=null,this.count=n,this.frustumCulled=!1}function jGt(t){jFt.call(this),this.type="LineBasicMaterial",this.color=new HFt(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.morphTargets=!1,this.setValues(t)}VGt.prototype=Object.assign(Object.create(PVt.prototype),{constructor:VGt,isInstancedMesh:!0,copy:function(t){return PVt.prototype.copy.call(this,t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this},getColorAt:function(t,e){e.fromArray(this.instanceColor.array,3*t)},getMatrixAt:function(t,e){e.fromArray(this.instanceMatrix.array,16*t)},raycast:function(t,e){const n=this.matrixWorld,i=this.count;if(FGt.geometry=this.geometry,FGt.material=this.material,void 0!==FGt.material)for(let r=0;r<i;r++){this.getMatrixAt(r,DGt),BGt.multiplyMatrices(n,DGt),FGt.matrixWorld=BGt,FGt.raycast(t,HGt);for(let t=0,n=HGt.length;t<n;t++){const n=HGt[t];n.instanceId=r,n.object=this,e.push(n)}HGt.length=0}},setColorAt:function(t,e){null===this.instanceColor&&(this.instanceColor=new qFt(new Float32Array(3*this.count),3)),e.toArray(this.instanceColor.array,3*t)},setMatrixAt:function(t,e){e.toArray(this.instanceMatrix.array,16*t)},updateMorphTargets:function(){},dispose:function(){this.dispatchEvent({type:"dispose"})}}),(jGt.prototype=Object.create(jFt.prototype)).constructor=jGt,jGt.prototype.isLineBasicMaterial=!0,jGt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this.morphTargets=t.morphTargets,this};const UGt=new yHt,GGt=new yHt,WGt=new qHt,qGt=new WHt,YGt=new DHt;function XGt(t=new pVt,e=new jGt){_Ft.call(this),this.type="Line",this.geometry=t,this.material=e,this.updateMorphTargets()}XGt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:XGt,isLine:!0,copy:function(t){return _Ft.prototype.copy.call(this,t),this.material=t.material,this.geometry=t.geometry,this},computeLineDistances:function(){const t=this.geometry;if(t.isBufferGeometry)if(null===t.index){const e=t.attributes.position,n=[0];for(let t=1,i=e.count;t<i;t++)UGt.fromBufferAttribute(e,t-1),GGt.fromBufferAttribute(e,t),n[t]=n[t-1],n[t]+=UGt.distanceTo(GGt);t.setAttribute("lineDistance",new eVt(n,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this},raycast:function(t,e){const n=this.geometry,i=this.matrixWorld,r=t.params.Line.threshold;if(null===n.boundingSphere&&n.computeBoundingSphere(),YGt.copy(n.boundingSphere),YGt.applyMatrix4(i),YGt.radius+=r,!1===t.ray.intersectsSphere(YGt))return;WGt.copy(i).invert(),qGt.copy(t.ray).applyMatrix4(WGt);const o=r/((this.scale.x+this.scale.y+this.scale.z)/3),a=o*o,s=new yHt,l=new yHt,c=new yHt,u=new yHt,h=this.isLineSegments?2:1;if(n.isBufferGeometry){const i=n.index,r=n.attributes.position;if(null!==i){const n=i.array;for(let i=0,o=n.length-1;i<o;i+=h){const o=n[i+1];if(s.fromBufferAttribute(r,n[i]),l.fromBufferAttribute(r,o),qGt.distanceSqToSegment(s,l,u,c)>a)continue;u.applyMatrix4(this.matrixWorld);const h=t.ray.origin.distanceTo(u);h<t.near||h>t.far||e.push({distance:h,point:c.clone().applyMatrix4(this.matrixWorld),index:i,face:null,faceIndex:null,object:this})}}else for(let n=0,i=r.count-1;n<i;n+=h){if(s.fromBufferAttribute(r,n),l.fromBufferAttribute(r,n+1),qGt.distanceSqToSegment(s,l,u,c)>a)continue;u.applyMatrix4(this.matrixWorld);const i=t.ray.origin.distanceTo(u);i<t.near||i>t.far||e.push({distance:i,point:c.clone().applyMatrix4(this.matrixWorld),index:n,face:null,faceIndex:null,object:this})}}else n.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const e=t.morphAttributes,n=Object.keys(e);if(n.length>0){const t=e[n[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let e=0,n=t.length;e<n;e++){const n=t[e].name||String(e);this.morphTargetInfluences.push(0),this.morphTargetDictionary[n]=e}}}}else{const e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}});const $Gt=new yHt,KGt=new yHt;function ZGt(t,e){XGt.call(this,t,e),this.type="LineSegments"}function JGt(t,e){XGt.call(this,t,e),this.type="LineLoop"}function QGt(t){jFt.call(this),this.type="PointsMaterial",this.color=new HFt(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.morphTargets=!1,this.setValues(t)}ZGt.prototype=Object.assign(Object.create(XGt.prototype),{constructor:ZGt,isLineSegments:!0,computeLineDistances:function(){const t=this.geometry;if(t.isBufferGeometry)if(null===t.index){const e=t.attributes.position,n=[];for(let t=0,i=e.count;t<i;t+=2)$Gt.fromBufferAttribute(e,t),KGt.fromBufferAttribute(e,t+1),n[t]=0===t?0:n[t-1],n[t+1]=n[t]+$Gt.distanceTo(KGt);t.setAttribute("lineDistance",new eVt(n,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}}),JGt.prototype=Object.assign(Object.create(XGt.prototype),{constructor:JGt,isLineLoop:!0}),(QGt.prototype=Object.create(jFt.prototype)).constructor=QGt,QGt.prototype.isPointsMaterial=!0,QGt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this.morphTargets=t.morphTargets,this};const tWt=new qHt,eWt=new WHt,nWt=new DHt,iWt=new yHt;function rWt(t=new pVt,e=new QGt){_Ft.call(this),this.type="Points",this.geometry=t,this.material=e,this.updateMorphTargets()}function oWt(t,e,n,i,r,o,a){const s=eWt.distanceSqToPoint(t);if(s<n){const n=new yHt;eWt.closestPointToPoint(t,n),n.applyMatrix4(i);const l=r.ray.origin.distanceTo(n);if(l<r.near||l>r.far)return;o.push({distance:l,distanceToRay:Math.sqrt(s),point:n,index:e,face:null,object:a})}}function aWt(t,e,n,i,r,o,a,s,l){pHt.call(this,t,e,n,i,r,o,a,s,l),this.format=void 0!==a?a:EBt,this.minFilter=void 0!==o?o:gBt,this.magFilter=void 0!==r?r:gBt,this.generateMipmaps=!1;const c=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback((function e(){c.needsUpdate=!0,t.requestVideoFrameCallback(e)}))}function sWt(t,e,n,i,r,o,a,s,l,c,u,h){pHt.call(this,null,o,a,s,l,c,i,r,u,h),this.image={width:e,height:n},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}function lWt(t,e,n,i,r,o,a,s,l){pHt.call(this,t,e,n,i,r,o,a,s,l),this.needsUpdate=!0}function cWt(t,e,n,i,r,o,a,s,l,c){if((c=void 0!==c?c:ABt)!==ABt&&c!==CBt)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===n&&c===ABt&&(n=bBt),void 0===n&&c===CBt&&(n=MBt),pHt.call(this,null,i,r,o,a,s,c,n,l),this.image={width:t,height:e},this.magFilter=void 0!==a?a:pBt,this.minFilter=void 0!==s?s:pBt,this.flipY=!1,this.generateMipmaps=!1}rWt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:rWt,isPoints:!0,copy:function(t){return _Ft.prototype.copy.call(this,t),this.material=t.material,this.geometry=t.geometry,this},raycast:function(t,e){const n=this.geometry,i=this.matrixWorld,r=t.params.Points.threshold;if(null===n.boundingSphere&&n.computeBoundingSphere(),nWt.copy(n.boundingSphere),nWt.applyMatrix4(i),nWt.radius+=r,!1===t.ray.intersectsSphere(nWt))return;tWt.copy(i).invert(),eWt.copy(t.ray).applyMatrix4(tWt);const o=r/((this.scale.x+this.scale.y+this.scale.z)/3),a=o*o;if(n.isBufferGeometry){const r=n.index,o=n.attributes.position;if(null!==r){const n=r.array;for(let r=0,s=n.length;r<s;r++){const s=n[r];iWt.fromBufferAttribute(o,s),oWt(iWt,s,a,i,t,e,this)}}else for(let n=0,r=o.count;n<r;n++)iWt.fromBufferAttribute(o,n),oWt(iWt,n,a,i,t,e,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const e=t.morphAttributes,n=Object.keys(e);if(n.length>0){const t=e[n[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let e=0,n=t.length;e<n;e++){const n=t[e].name||String(e);this.morphTargetInfluences.push(0),this.morphTargetDictionary[n]=e}}}}else{const e=t.morphTargets;void 0!==e&&e.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}),aWt.prototype=Object.assign(Object.create(pHt.prototype),{constructor:aWt,clone:function(){return new this.constructor(this.image).copy(this)},isVideoTexture:!0,update:function(){const t=this.image;0=="requestVideoFrameCallback"in t&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}),(sWt.prototype=Object.create(pHt.prototype)).constructor=sWt,sWt.prototype.isCompressedTexture=!0,(lWt.prototype=Object.create(pHt.prototype)).constructor=lWt,lWt.prototype.isCanvasTexture=!0,(cWt.prototype=Object.create(pHt.prototype)).constructor=cWt,cWt.prototype.isDepthTexture=!0;class uWt extends pVt{constructor(t=1,e=8,n=0,i=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:e,thetaStart:n,thetaLength:i},e=Math.max(3,e);const r=[],o=[],a=[],s=[],l=new yHt,c=new lHt;o.push(0,0,0),a.push(0,0,1),s.push(.5,.5);for(let r=0,u=3;r<=e;r++,u+=3){const h=n+r/e*i;l.x=t*Math.cos(h),l.y=t*Math.sin(h),o.push(l.x,l.y,l.z),a.push(0,0,1),c.x=(o[u]/t+1)/2,c.y=(o[u+1]/t+1)/2,s.push(c.x,c.y)}for(let t=1;t<=e;t++)r.push(t,t+1,0);this.setIndex(r),this.setAttribute("position",new eVt(o,3)),this.setAttribute("normal",new eVt(a,3)),this.setAttribute("uv",new eVt(s,2))}}class hWt extends pVt{constructor(t=1,e=1,n=1,i=8,r=1,o=!1,a=0,s=2*Math.PI){super(),this.type="CylinderGeometry",this.parameters={radiusTop:t,radiusBottom:e,height:n,radialSegments:i,heightSegments:r,openEnded:o,thetaStart:a,thetaLength:s};const l=this;i=Math.floor(i),r=Math.floor(r);const c=[],u=[],h=[],d=[];let p=0;const f=[],m=n/2;let g=0;function _(n){const r=p,o=new lHt,f=new yHt;let _=0;const y=!0===n?t:e,v=!0===n?1:-1;for(let t=1;t<=i;t++)u.push(0,m*v,0),h.push(0,v,0),d.push(.5,.5),p++;const b=p;for(let t=0;t<=i;t++){const e=t/i*s+a,n=Math.cos(e),r=Math.sin(e);f.x=y*r,f.y=m*v,f.z=y*n,u.push(f.x,f.y,f.z),h.push(0,v,0),o.x=.5*n+.5,o.y=.5*r*v+.5,d.push(o.x,o.y),p++}for(let t=0;t<i;t++){const e=r+t,i=b+t;!0===n?c.push(i,i+1,e):c.push(i+1,i,e),_+=3}l.addGroup(g,_,!0===n?1:2),g+=_}!(function y(){const o=new yHt,_=new yHt;let y=0;const v=(e-t)/n;for(let l=0;l<=r;l++){const c=[],g=l/r,y=g*(e-t)+t;for(let t=0;t<=i;t++){const e=t/i,r=e*s+a,l=Math.sin(r),f=Math.cos(r);_.x=y*l,_.y=-g*n+m,_.z=y*f,u.push(_.x,_.y,_.z),o.set(l,v,f).normalize(),h.push(o.x,o.y,o.z),d.push(e,1-g),c.push(p++)}f.push(c)}for(let t=0;t<i;t++)for(let e=0;e<r;e++){const n=f[e+1][t],i=f[e+1][t+1],r=f[e][t+1];c.push(f[e][t],n,r),c.push(n,i,r),y+=6}l.addGroup(g,y,0),g+=y})(),!1===o&&(t>0&&_(!0),e>0&&_(!1)),this.setIndex(c),this.setAttribute("position",new eVt(u,3)),this.setAttribute("normal",new eVt(h,3)),this.setAttribute("uv",new eVt(d,2))}}class dWt extends hWt{constructor(t=1,e=1,n=8,i=1,r=!1,o=0,a=2*Math.PI){super(0,t,e,n,i,r,o,a),this.type="ConeGeometry",this.parameters={radius:t,height:e,radialSegments:n,heightSegments:i,openEnded:r,thetaStart:o,thetaLength:a}}}class pWt extends pVt{constructor(t,e,n=1,i=0){super(),this.type="PolyhedronGeometry",this.parameters={vertices:t,indices:e,radius:n,detail:i};const r=[],o=[];function a(t,e,n,i){const r=i+1,o=[];for(let i=0;i<=r;i++){o[i]=[];const a=t.clone().lerp(n,i/r),s=e.clone().lerp(n,i/r),l=r-i;for(let t=0;t<=l;t++)o[i][t]=0===t&&i===r?a:a.clone().lerp(s,t/l)}for(let t=0;t<r;t++)for(let e=0;e<2*(r-t)-1;e++){const n=Math.floor(e/2);e%2==0?(s(o[t][n+1]),s(o[t+1][n]),s(o[t][n])):(s(o[t][n+1]),s(o[t+1][n+1]),s(o[t+1][n]))}}function s(t){r.push(t.x,t.y,t.z)}function l(e,n){const i=3*e;n.x=t[i+0],n.y=t[i+1],n.z=t[i+2]}function c(t,e,n,i){i<0&&1===t.x&&(o[e]=t.x-1),0===n.x&&0===n.z&&(o[e]=i/2/Math.PI+.5)}function u(t){return Math.atan2(t.z,-t.x)}!(function h(t){const n=new yHt,i=new yHt,r=new yHt;for(let o=0;o<e.length;o+=3)l(e[o+0],n),l(e[o+1],i),l(e[o+2],r),a(n,i,r,t)})(i),(function d(t){const e=new yHt;for(let n=0;n<r.length;n+=3)e.x=r[n+0],e.y=r[n+1],e.z=r[n+2],e.normalize().multiplyScalar(t),r[n+0]=e.x,r[n+1]=e.y,r[n+2]=e.z})(n),(function p(){const t=new yHt;for(let n=0;n<r.length;n+=3){t.x=r[n+0],t.y=r[n+1],t.z=r[n+2];const i=u(t)/2/Math.PI+.5,a=(e=t,Math.atan2(-e.y,Math.sqrt(e.x*e.x+e.z*e.z))/Math.PI+.5);o.push(i,1-a)}var e;(function n(){const t=new yHt,e=new yHt,n=new yHt,i=new yHt,a=new lHt,s=new lHt,l=new lHt;for(let h=0,d=0;h<r.length;h+=9,d+=6){t.set(r[h+0],r[h+1],r[h+2]),e.set(r[h+3],r[h+4],r[h+5]),n.set(r[h+6],r[h+7],r[h+8]),a.set(o[d+0],o[d+1]),s.set(o[d+2],o[d+3]),l.set(o[d+4],o[d+5]),i.copy(t).add(e).add(n).divideScalar(3);const p=u(i);c(a,d+0,t,p),c(s,d+2,e,p),c(l,d+4,n,p)}})(),(function i(){for(let t=0;t<o.length;t+=6){const e=o[t+0],n=o[t+2],i=o[t+4],r=Math.max(e,n,i),a=Math.min(e,n,i);r>.9&&a<.1&&(e<.2&&(o[t+0]+=1),n<.2&&(o[t+2]+=1),i<.2&&(o[t+4]+=1))}})()})(),this.setAttribute("position",new eVt(r,3)),this.setAttribute("normal",new eVt(r.slice(),3)),this.setAttribute("uv",new eVt(o,2)),0===i?this.computeVertexNormals():this.normalizeNormals()}}class fWt extends pWt{constructor(t=1,e=0){const n=(1+Math.sqrt(5))/2,i=1/n;super([-1,-1,-1,-1,-1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,0,-i,-n,0,-i,n,0,i,-n,0,i,n,-i,-n,0,-i,n,0,i,-n,0,i,n,0,-n,0,-i,n,0,-i,-n,0,i,n,0,i],[3,11,7,3,7,15,3,15,13,7,19,17,7,17,6,7,6,15,17,4,8,17,8,10,17,10,6,8,0,16,8,16,2,8,2,10,0,12,1,0,1,18,0,18,16,6,10,2,6,2,13,6,13,15,2,16,18,2,18,3,2,3,13,18,1,9,18,9,11,18,11,3,4,14,12,4,12,0,4,0,8,11,9,5,11,5,19,11,19,7,19,5,14,19,14,4,19,4,17,1,12,14,1,14,5,1,5,9],t,e),this.type="DodecahedronGeometry",this.parameters={radius:t,detail:e}}}const mWt=new yHt,gWt=new yHt,_Wt=new yHt,yWt=new IFt;class vWt extends pVt{constructor(t,e){if(super(),this.type="EdgesGeometry",this.parameters={thresholdAngle:e},e=void 0!==e?e:1,!0===t.isGeometry)return void console.error("THREE.EdgesGeometry no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");const n=Math.pow(10,4),i=Math.cos(sHt.DEG2RAD*e),r=t.getIndex(),o=t.getAttribute("position"),a=r?r.count:o.count,s=[0,0,0],l=["a","b","c"],c=new Array(3),u={},h=[];for(let t=0;t<a;t+=3){r?(s[0]=r.getX(t),s[1]=r.getX(t+1),s[2]=r.getX(t+2)):(s[0]=t,s[1]=t+1,s[2]=t+2);const{a:e,b:a,c:d}=yWt;if(e.fromBufferAttribute(o,s[0]),a.fromBufferAttribute(o,s[1]),d.fromBufferAttribute(o,s[2]),yWt.getNormal(_Wt),c[0]=`${Math.round(e.x*n)},${Math.round(e.y*n)},${Math.round(e.z*n)}`,c[1]=`${Math.round(a.x*n)},${Math.round(a.y*n)},${Math.round(a.z*n)}`,c[2]=`${Math.round(d.x*n)},${Math.round(d.y*n)},${Math.round(d.z*n)}`,c[0]!==c[1]&&c[1]!==c[2]&&c[2]!==c[0])for(let t=0;t<3;t++){const e=(t+1)%3,n=c[t],r=c[e],o=yWt[l[t]],a=yWt[l[e]],d=`${n}_${r}`,p=`${r}_${n}`;p in u&&u[p]?(_Wt.dot(u[p].normal)<=i&&(h.push(o.x,o.y,o.z),h.push(a.x,a.y,a.z)),u[p]=null):d in u||(u[d]={index0:s[t],index1:s[e],normal:_Wt.clone()})}}for(const t in u)if(u[t]){const{index0:e,index1:n}=u[t];mWt.fromBufferAttribute(o,e),gWt.fromBufferAttribute(o,n),h.push(mWt.x,mWt.y,mWt.z),h.push(gWt.x,gWt.y,gWt.z)}this.setAttribute("position",new eVt(h,3))}}function bWt(t,e,n,i,r){let o,a;if(r===(function s(t,e,n,i){let r=0;for(let o=e,a=n-i;o<n;o+=i)r+=(t[a]-t[o])*(t[o+1]+t[a+1]),a=o;return r})(t,e,n,i)>0)for(o=e;o<n;o+=i)a=VWt(o,t[o],t[o+1],a);else for(o=n-i;o>=e;o-=i)a=VWt(o,t[o],t[o+1],a);return a&&RWt(a,a.next)&&(jWt(a),a=a.next),a}function xWt(t,e){if(!t)return t;e||(e=t);let n,i=t;do{if(n=!1,i.steiner||!RWt(i,i.next)&&0!==OWt(i.prev,i,i.next))i=i.next;else{if(jWt(i),i=e=i.prev,i===i.next)break;n=!0}}while(n||i!==e);return e}function wWt(t,e,n,i,r,o,a){if(!t)return;!a&&o&&(function s(t,e,n,i){let r=t;do{null===r.z&&(r.z=LWt(r.x,r.y,e,n,i)),r.prevZ=r.prev,r.nextZ=r.next,r=r.next}while(r!==t);r.prevZ.nextZ=null,r.prevZ=null,(function o(t){let e,n,i,r,o,a,s,l,c=1;do{for(n=t,t=null,o=null,a=0;n;){for(a++,i=n,s=0,e=0;e<c&&(s++,i=i.nextZ,i);e++);for(l=c;s>0||l>0&&i;)0!==s&&(0===l||!i||n.z<=i.z)?(r=n,n=n.nextZ,s--):(r=i,i=i.nextZ,l--),o?o.nextZ=r:t=r,r.prevZ=o,o=r;n=i}o.nextZ=null,c*=2}while(a>1)})(r)})(t,i,r,o);let l,c,u=t;for(;t.prev!==t.next;)if(l=t.prev,c=t.next,o?MWt(t,i,r,o):SWt(t))e.push(l.i/n),e.push(t.i/n),e.push(c.i/n),jWt(t),t=c.next,u=c.next;else if((t=c)===u){a?1===a?wWt(t=EWt(xWt(t),e,n),e,n,i,r,o,2):2===a&&TWt(t,e,n,i,r,o):wWt(xWt(t),e,n,i,r,o,1);break}}function SWt(t){const e=t.prev,n=t,i=t.next;if(OWt(e,n,i)>=0)return!1;let r=t.next.next;for(;r!==t.prev;){if(IWt(e.x,e.y,n.x,n.y,i.x,i.y,r.x,r.y)&&OWt(r.prev,r,r.next)>=0)return!1;r=r.next}return!0}function MWt(t,e,n,i){const r=t.prev,o=t,a=t.next;if(OWt(r,o,a)>=0)return!1;const s=r.x>o.x?r.x>a.x?r.x:a.x:o.x>a.x?o.x:a.x,l=r.y>o.y?r.y>a.y?r.y:a.y:o.y>a.y?o.y:a.y,c=LWt(r.x<o.x?r.x<a.x?r.x:a.x:o.x<a.x?o.x:a.x,r.y<o.y?r.y<a.y?r.y:a.y:o.y<a.y?o.y:a.y,e,n,i),u=LWt(s,l,e,n,i);let h=t.prevZ,d=t.nextZ;for(;h&&h.z>=c&&d&&d.z<=u;){if(h!==t.prev&&h!==t.next&&IWt(r.x,r.y,o.x,o.y,a.x,a.y,h.x,h.y)&&OWt(h.prev,h,h.next)>=0)return!1;if(h=h.prevZ,d!==t.prev&&d!==t.next&&IWt(r.x,r.y,o.x,o.y,a.x,a.y,d.x,d.y)&&OWt(d.prev,d,d.next)>=0)return!1;d=d.nextZ}for(;h&&h.z>=c;){if(h!==t.prev&&h!==t.next&&IWt(r.x,r.y,o.x,o.y,a.x,a.y,h.x,h.y)&&OWt(h.prev,h,h.next)>=0)return!1;h=h.prevZ}for(;d&&d.z<=u;){if(d!==t.prev&&d!==t.next&&IWt(r.x,r.y,o.x,o.y,a.x,a.y,d.x,d.y)&&OWt(d.prev,d,d.next)>=0)return!1;d=d.nextZ}return!0}function EWt(t,e,n){let i=t;do{const r=i.prev,o=i.next.next;!RWt(r,o)&&zWt(r,i,i.next,o)&&HWt(r,o)&&HWt(o,r)&&(e.push(r.i/n),e.push(i.i/n),e.push(o.i/n),jWt(i),jWt(i.next),i=t=o),i=i.next}while(i!==t);return xWt(i)}function TWt(t,e,n,i,r,o){let a=t;do{let t=a.next.next;for(;t!==a.prev;){if(a.i!==t.i&&NWt(a,t)){let s=FWt(a,t);return a=xWt(a,a.next),s=xWt(s,s.next),wWt(a,e,n,i,r,o),void wWt(s,e,n,i,r,o)}t=t.next}a=a.next}while(a!==t)}function AWt(t,e){return t.x-e.x}function CWt(t,e){if(e=(function n(t,e){let n=e;const i=t.x,r=t.y;let o,a=-1/0;do{if(r<=n.y&&r>=n.next.y&&n.next.y!==n.y){const t=n.x+(r-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(t<=i&&t>a){if(a=t,t===i){if(r===n.y)return n;if(r===n.next.y)return n.next}o=n.x<n.next.x?n:n.next}}n=n.next}while(n!==e);if(!o)return null;if(i===a)return o;const s=o,l=o.x,c=o.y;let u,h=1/0;n=o;do{i>=n.x&&n.x>=l&&i!==n.x&&IWt(r<c?i:a,r,l,c,r<c?a:i,r,n.x,n.y)&&(u=Math.abs(r-n.y)/(i-n.x),HWt(n,t)&&(u<h||u===h&&(n.x>o.x||n.x===o.x&&kWt(o,n)))&&(o=n,h=u)),n=n.next}while(n!==s);return o})(t,e)){const n=FWt(e,t);xWt(e,e.next),xWt(n,n.next)}}function kWt(t,e){return OWt(t.prev,t,e.prev)<0&&OWt(e.next,t,t.next)<0}function LWt(t,e,n,i,r){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-n)*r)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-i)*r)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function PWt(t){let e=t,n=t;do{(e.x<n.x||e.x===n.x&&e.y<n.y)&&(n=e),e=e.next}while(e!==t);return n}function IWt(t,e,n,i,r,o,a,s){return(r-a)*(e-s)-(t-a)*(o-s)>=0&&(t-a)*(i-s)-(n-a)*(e-s)>=0&&(n-a)*(o-s)-(r-a)*(i-s)>=0}function NWt(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!(function n(t,e){let n=t;do{if(n.i!==t.i&&n.next.i!==t.i&&n.i!==e.i&&n.next.i!==e.i&&zWt(n,n.next,t,e))return!0;n=n.next}while(n!==t);return!1})(t,e)&&(HWt(t,e)&&HWt(e,t)&&(function i(t,e){let n=t,i=!1;const r=(t.x+e.x)/2,o=(t.y+e.y)/2;do{n.y>o!=n.next.y>o&&n.next.y!==n.y&&r<(n.next.x-n.x)*(o-n.y)/(n.next.y-n.y)+n.x&&(i=!i),n=n.next}while(n!==t);return i})(t,e)&&(OWt(t.prev,t,e.prev)||OWt(t,e.prev,e))||RWt(t,e)&&OWt(t.prev,t,t.next)>0&&OWt(e.prev,e,e.next)>0)}function OWt(t,e,n){return(e.y-t.y)*(n.x-e.x)-(e.x-t.x)*(n.y-e.y)}function RWt(t,e){return t.x===e.x&&t.y===e.y}function zWt(t,e,n,i){const r=BWt(OWt(t,e,n)),o=BWt(OWt(t,e,i)),a=BWt(OWt(n,i,t)),s=BWt(OWt(n,i,e));return r!==o&&a!==s||!(0!==r||!DWt(t,n,e))||!(0!==o||!DWt(t,i,e))||!(0!==a||!DWt(n,t,i))||!(0!==s||!DWt(n,e,i))}function DWt(t,e,n){return e.x<=Math.max(t.x,n.x)&&e.x>=Math.min(t.x,n.x)&&e.y<=Math.max(t.y,n.y)&&e.y>=Math.min(t.y,n.y)}function BWt(t){return t>0?1:t<0?-1:0}function HWt(t,e){return OWt(t.prev,t,t.next)<0?OWt(t,e,t.next)>=0&&OWt(t,t.prev,e)>=0:OWt(t,e,t.prev)<0||OWt(t,t.next,e)<0}function FWt(t,e){const n=new UWt(t.i,t.x,t.y),i=new UWt(e.i,e.x,e.y),r=t.next,o=e.prev;return t.next=e,e.prev=t,n.next=r,r.prev=n,i.next=n,n.prev=i,o.next=i,i.prev=o,i}function VWt(t,e,n,i){const r=new UWt(t,e,n);return i?(r.next=i.next,r.prev=i,i.next.prev=r,i.next=r):(r.prev=r,r.next=r),r}function jWt(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function UWt(t,e,n){this.i=t,this.x=e,this.y=n,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}const GWt={area:function(t){const e=t.length;let n=0;for(let i=e-1,r=0;r<e;i=r++)n+=t[i].x*t[r].y-t[r].x*t[i].y;return.5*n},isClockWise:function(t){return GWt.area(t)<0},triangulateShape:function(t,e){const n=[],i=[],r=[];WWt(t),qWt(n,t);let o=t.length;e.forEach(WWt);for(let t=0;t<e.length;t++)i.push(o),o+=e[t].length,qWt(n,e[t]);const a=(function(t,e,n){n=n||2;const i=e&&e.length,r=i?e[0]*n:t.length;let o=bWt(t,0,r,n,!0);const a=[];if(!o||o.next===o.prev)return a;let s,l,c,u,h,d,p;if(i&&(o=(function f(t,e,n,i){const r=[];let o,a,s,l,c;for(o=0,a=e.length;o<a;o++)s=e[o]*i,l=o<a-1?e[o+1]*i:t.length,c=bWt(t,s,l,i,!1),c===c.next&&(c.steiner=!0),r.push(PWt(c));for(r.sort(AWt),o=0;o<r.length;o++)CWt(r[o],n),n=xWt(n,n.next);return n})(t,e,o,n)),t.length>80*n){s=c=t[0],l=u=t[1];for(let e=n;e<r;e+=n)h=t[e],d=t[e+1],h<s&&(s=h),d<l&&(l=d),h>c&&(c=h),d>u&&(u=d);p=Math.max(c-s,u-l),p=0!==p?1/p:0}return wWt(o,a,n,s,l,p),a})(n,i);for(let t=0;t<a.length;t+=3)r.push(a.slice(t,t+3));return r}};function WWt(t){const e=t.length;e>2&&t[e-1].equals(t[0])&&t.pop()}function qWt(t,e){for(let n=0;n<e.length;n++)t.push(e[n].x),t.push(e[n].y)}class YWt extends pVt{constructor(t,e){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:e},t=Array.isArray(t)?t:[t];const n=this,i=[],r=[];for(let e=0,n=t.length;e<n;e++)o(t[e]);function o(t){const o=[],a=void 0!==e.curveSegments?e.curveSegments:12,s=void 0!==e.steps?e.steps:1;let l=void 0!==e.depth?e.depth:100,c=void 0===e.bevelEnabled||e.bevelEnabled,u=void 0!==e.bevelThickness?e.bevelThickness:6,h=void 0!==e.bevelSize?e.bevelSize:u-2,d=void 0!==e.bevelOffset?e.bevelOffset:0,p=void 0!==e.bevelSegments?e.bevelSegments:3;const f=e.extrudePath,m=void 0!==e.UVGenerator?e.UVGenerator:XWt;void 0!==e.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),l=e.amount);let g,_,y,v,b,x=!1;f&&(g=f.getSpacedPoints(s),x=!0,c=!1,_=f.computeFrenetFrames(s,!1),y=new yHt,v=new yHt,b=new yHt),c||(p=0,u=0,h=0,d=0);const w=t.extractPoints(a);let S=w.shape;const M=w.holes;if(!GWt.isClockWise(S)){S=S.reverse();for(let t=0,e=M.length;t<e;t++){const e=M[t];GWt.isClockWise(e)&&(M[t]=e.reverse())}}const E=GWt.triangulateShape(S,M),T=S;for(let t=0,e=M.length;t<e;t++)S=S.concat(M[t]);function A(t,e,n){return e||console.error("THREE.ExtrudeGeometry: vec does not exist"),e.clone().multiplyScalar(n).add(t)}const C=S.length,k=E.length;function L(t,e,n){let i,r,o;const a=t.x-e.x,s=t.y-e.y,l=n.x-t.x,c=n.y-t.y,u=a*a+s*s;if(Math.abs(a*c-s*l)>Number.EPSILON){const h=Math.sqrt(u),d=Math.sqrt(l*l+c*c),p=e.x-s/h,f=e.y+a/h,m=((n.x-c/d-p)*c-(n.y+l/d-f)*l)/(a*c-s*l);i=p+a*m-t.x,r=f+s*m-t.y;const g=i*i+r*r;if(g<=2)return new lHt(i,r);o=Math.sqrt(g/2)}else{let t=!1;a>Number.EPSILON?l>Number.EPSILON&&(t=!0):a<-Number.EPSILON?l<-Number.EPSILON&&(t=!0):Math.sign(s)===Math.sign(c)&&(t=!0),t?(i=-s,r=a,o=Math.sqrt(u)):(i=a,r=s,o=Math.sqrt(u/2))}return new lHt(i/o,r/o)}const P=[];for(let t=0,e=T.length,n=e-1,i=t+1;t<e;t++,n++,i++)n===e&&(n=0),i===e&&(i=0),P[t]=L(T[t],T[n],T[i]);const I=[];let N,O=P.concat();for(let t=0,e=M.length;t<e;t++){const e=M[t];N=[];for(let t=0,n=e.length,i=n-1,r=t+1;t<n;t++,i++,r++)i===n&&(i=0),r===n&&(r=0),N[t]=L(e[t],e[i],e[r]);I.push(N),O=O.concat(N)}for(let t=0;t<p;t++){const e=t/p,n=u*Math.cos(e*Math.PI/2),i=h*Math.sin(e*Math.PI/2)+d;for(let t=0,e=T.length;t<e;t++){const e=A(T[t],P[t],i);D(e.x,e.y,-n)}for(let t=0,e=M.length;t<e;t++){const e=M[t];N=I[t];for(let t=0,r=e.length;t<r;t++){const r=A(e[t],N[t],i);D(r.x,r.y,-n)}}}const R=h+d;for(let t=0;t<C;t++){const e=c?A(S[t],O[t],R):S[t];x?(v.copy(_.normals[0]).multiplyScalar(e.x),y.copy(_.binormals[0]).multiplyScalar(e.y),b.copy(g[0]).add(v).add(y),D(b.x,b.y,b.z)):D(e.x,e.y,0)}for(let t=1;t<=s;t++)for(let e=0;e<C;e++){const n=c?A(S[e],O[e],R):S[e];x?(v.copy(_.normals[t]).multiplyScalar(n.x),y.copy(_.binormals[t]).multiplyScalar(n.y),b.copy(g[t]).add(v).add(y),D(b.x,b.y,b.z)):D(n.x,n.y,l/s*t)}for(let t=p-1;t>=0;t--){const e=t/p,n=u*Math.cos(e*Math.PI/2),i=h*Math.sin(e*Math.PI/2)+d;for(let t=0,e=T.length;t<e;t++){const e=A(T[t],P[t],i);D(e.x,e.y,l+n)}for(let t=0,e=M.length;t<e;t++){const e=M[t];N=I[t];for(let t=0,r=e.length;t<r;t++){const r=A(e[t],N[t],i);x?D(r.x,r.y+g[s-1].y,g[s-1].x+n):D(r.x,r.y,l+n)}}}function z(t,e){let n=t.length;for(;--n>=0;){const i=n;let r=n-1;r<0&&(r=t.length-1);for(let t=0,n=s+2*p;t<n;t++){const n=C*t,o=C*(t+1);H(e+i+n,e+r+n,e+r+o,e+i+o)}}}function D(t,e,n){o.push(t),o.push(e),o.push(n)}function B(t,e,r){F(t),F(e),F(r);const o=i.length/3,a=m.generateTopUV(n,i,o-3,o-2,o-1);V(a[0]),V(a[1]),V(a[2])}function H(t,e,r,o){F(t),F(e),F(o),F(e),F(r),F(o);const a=i.length/3,s=m.generateSideWallUV(n,i,a-6,a-3,a-2,a-1);V(s[0]),V(s[1]),V(s[3]),V(s[1]),V(s[2]),V(s[3])}function F(t){i.push(o[3*t+0]),i.push(o[3*t+1]),i.push(o[3*t+2])}function V(t){r.push(t.x),r.push(t.y)}!(function j(){const t=i.length/3;if(c){let t=0,e=C*t;for(let t=0;t<k;t++){const n=E[t];B(n[2]+e,n[1]+e,n[0]+e)}t=s+2*p,e=C*t;for(let t=0;t<k;t++){const n=E[t];B(n[0]+e,n[1]+e,n[2]+e)}}else{for(let t=0;t<k;t++){const e=E[t];B(e[2],e[1],e[0])}for(let t=0;t<k;t++){const e=E[t];B(e[0]+C*s,e[1]+C*s,e[2]+C*s)}}n.addGroup(t,i.length/3-t,0)})(),(function U(){const t=i.length/3;let e=0;z(T,e),e+=T.length;for(let t=0,n=M.length;t<n;t++){const n=M[t];z(n,e),e+=n.length}n.addGroup(t,i.length/3-t,1)})()}this.setAttribute("position",new eVt(i,3)),this.setAttribute("uv",new eVt(r,2)),this.computeVertexNormals()}toJSON(){const t=pVt.prototype.toJSON.call(this);return(function e(t,n,i){if(i.shapes=[],Array.isArray(t))for(let e=0,n=t.length;e<n;e++)i.shapes.push(t[e].uuid);else i.shapes.push(t.uuid);return void 0!==n.extrudePath&&(i.options.extrudePath=n.extrudePath.toJSON()),i})(this.parameters.shapes,this.parameters.options,t)}}const XWt={generateTopUV:function(t,e,n,i,r){const o=e[3*i],a=e[3*i+1],s=e[3*r],l=e[3*r+1];return[new lHt(e[3*n],e[3*n+1]),new lHt(o,a),new lHt(s,l)]},generateSideWallUV:function(t,e,n,i,r,o){const a=e[3*n],s=e[3*n+1],l=e[3*n+2],c=e[3*i],u=e[3*i+1],h=e[3*i+2],d=e[3*r],p=e[3*r+1],f=e[3*r+2],m=e[3*o],g=e[3*o+1],_=e[3*o+2];return Math.abs(s-u)<.01?[new lHt(a,1-l),new lHt(c,1-h),new lHt(d,1-f),new lHt(m,1-_)]:[new lHt(s,1-l),new lHt(u,1-h),new lHt(p,1-f),new lHt(g,1-_)]}};class $Wt extends pWt{constructor(t=1,e=0){const n=(1+Math.sqrt(5))/2;super([-1,n,0,1,n,0,-1,-n,0,1,-n,0,0,-1,n,0,1,n,0,-1,-n,0,1,-n,n,0,-1,n,0,1,-n,0,-1,-n,0,1],[0,11,5,0,5,1,0,1,7,0,7,10,0,10,11,1,5,9,5,11,4,11,10,2,10,7,6,7,1,8,3,9,4,3,4,2,3,2,6,3,6,8,3,8,9,4,9,5,2,4,11,6,2,10,8,6,7,9,8,1],t,e),this.type="IcosahedronGeometry",this.parameters={radius:t,detail:e}}}class KWt extends pVt{constructor(t,e=12,n=0,i=2*Math.PI){super(),this.type="LatheGeometry",this.parameters={points:t,segments:e,phiStart:n,phiLength:i},e=Math.floor(e),i=sHt.clamp(i,0,2*Math.PI);const r=[],o=[],a=[],s=1/e,l=new yHt,c=new lHt;for(let r=0;r<=e;r++){const u=n+r*s*i,h=Math.sin(u),d=Math.cos(u);for(let n=0;n<=t.length-1;n++)l.x=t[n].x*h,l.y=t[n].y,l.z=t[n].x*d,o.push(l.x,l.y,l.z),c.x=r/e,c.y=n/(t.length-1),a.push(c.x,c.y)}for(let n=0;n<e;n++)for(let e=0;e<t.length-1;e++){const i=e+n*t.length,o=i+t.length,a=i+t.length+1,s=i+1;r.push(i,o,s),r.push(o,a,s)}if(this.setIndex(r),this.setAttribute("position",new eVt(o,3)),this.setAttribute("uv",new eVt(a,2)),this.computeVertexNormals(),i===2*Math.PI){const n=this.attributes.normal.array,i=new yHt,r=new yHt,o=new yHt,a=e*t.length*3;for(let e=0,s=0;e<t.length;e++,s+=3)i.x=n[s+0],i.y=n[s+1],i.z=n[s+2],r.x=n[a+s+0],r.y=n[a+s+1],r.z=n[a+s+2],o.addVectors(i,r).normalize(),n[s+0]=n[a+s+0]=o.x,n[s+1]=n[a+s+1]=o.y,n[s+2]=n[a+s+2]=o.z}}}class ZWt extends pWt{constructor(t=1,e=0){super([1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2],t,e),this.type="OctahedronGeometry",this.parameters={radius:t,detail:e}}}function JWt(t,e,n){pVt.call(this),this.type="ParametricGeometry",this.parameters={func:t,slices:e,stacks:n};const i=[],r=[],o=[],a=[],s=1e-5,l=new yHt,c=new yHt,u=new yHt,h=new yHt,d=new yHt;t.length<3&&console.error("THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.");const p=e+1;for(let i=0;i<=n;i++){const p=i/n;for(let n=0;n<=e;n++){const i=n/e;t(i,p,c),r.push(c.x,c.y,c.z),i-s>=0?(t(i-s,p,u),h.subVectors(c,u)):(t(i+s,p,u),h.subVectors(u,c)),p-s>=0?(t(i,p-s,u),d.subVectors(c,u)):(t(i,p+s,u),d.subVectors(u,c)),l.crossVectors(h,d).normalize(),o.push(l.x,l.y,l.z),a.push(i,p)}}for(let t=0;t<n;t++)for(let n=0;n<e;n++){const e=t*p+n+1,r=(t+1)*p+n+1,o=(t+1)*p+n;i.push(t*p+n,e,o),i.push(e,r,o)}this.setIndex(i),this.setAttribute("position",new eVt(r,3)),this.setAttribute("normal",new eVt(o,3)),this.setAttribute("uv",new eVt(a,2))}(JWt.prototype=Object.create(pVt.prototype)).constructor=JWt;class QWt extends pVt{constructor(t=.5,e=1,n=8,i=1,r=0,o=2*Math.PI){super(),this.type="RingGeometry",this.parameters={innerRadius:t,outerRadius:e,thetaSegments:n,phiSegments:i,thetaStart:r,thetaLength:o},n=Math.max(3,n);const a=[],s=[],l=[],c=[];let u=t;const h=(e-t)/(i=Math.max(1,i)),d=new yHt,p=new lHt;for(let t=0;t<=i;t++){for(let t=0;t<=n;t++){const i=r+t/n*o;d.x=u*Math.cos(i),d.y=u*Math.sin(i),s.push(d.x,d.y,d.z),l.push(0,0,1),p.x=(d.x/e+1)/2,p.y=(d.y/e+1)/2,c.push(p.x,p.y)}u+=h}for(let t=0;t<i;t++){const e=t*(n+1);for(let t=0;t<n;t++){const i=t+e,r=i+n+1,o=i+n+2,s=i+1;a.push(i,r,s),a.push(r,o,s)}}this.setIndex(a),this.setAttribute("position",new eVt(s,3)),this.setAttribute("normal",new eVt(l,3)),this.setAttribute("uv",new eVt(c,2))}}class tqt extends pVt{constructor(t,e=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:e};const n=[],i=[],r=[],o=[];let a=0,s=0;if(!1===Array.isArray(t))l(t);else for(let e=0;e<t.length;e++)l(t[e]),this.addGroup(a,s,e),a+=s,s=0;function l(t){const a=i.length/3,l=t.extractPoints(e);let c=l.shape;const u=l.holes;!1===GWt.isClockWise(c)&&(c=c.reverse());for(let t=0,e=u.length;t<e;t++){const e=u[t];!0===GWt.isClockWise(e)&&(u[t]=e.reverse())}const h=GWt.triangulateShape(c,u);for(let t=0,e=u.length;t<e;t++)c=c.concat(u[t]);for(let t=0,e=c.length;t<e;t++){const e=c[t];i.push(e.x,e.y,0),r.push(0,0,1),o.push(e.x,e.y)}for(let t=0,e=h.length;t<e;t++){const e=h[t];n.push(e[0]+a,e[1]+a,e[2]+a),s+=3}}this.setIndex(n),this.setAttribute("position",new eVt(i,3)),this.setAttribute("normal",new eVt(r,3)),this.setAttribute("uv",new eVt(o,2))}toJSON(){const t=pVt.prototype.toJSON.call(this);return(function e(t,n){if(n.shapes=[],Array.isArray(t))for(let e=0,i=t.length;e<i;e++)n.shapes.push(t[e].uuid);else n.shapes.push(t.uuid);return n})(this.parameters.shapes,t)}}class eqt extends pVt{constructor(t=1,e=8,n=6,i=0,r=2*Math.PI,o=0,a=Math.PI){super(),this.type="SphereGeometry",this.parameters={radius:t,widthSegments:e,heightSegments:n,phiStart:i,phiLength:r,thetaStart:o,thetaLength:a},e=Math.max(3,Math.floor(e)),n=Math.max(2,Math.floor(n));const s=Math.min(o+a,Math.PI);let l=0;const c=[],u=new yHt,h=new yHt,d=[],p=[],f=[],m=[];for(let d=0;d<=n;d++){const g=[],_=d/n;let y=0;0==d&&0==o?y=.5/e:d==n&&s==Math.PI&&(y=-.5/e);for(let n=0;n<=e;n++){const s=n/e;u.x=-t*Math.cos(i+s*r)*Math.sin(o+_*a),u.y=t*Math.cos(o+_*a),u.z=t*Math.sin(i+s*r)*Math.sin(o+_*a),p.push(u.x,u.y,u.z),h.copy(u).normalize(),f.push(h.x,h.y,h.z),m.push(s+y,1-_),g.push(l++)}c.push(g)}for(let t=0;t<n;t++)for(let i=0;i<e;i++){const e=c[t][i+1],r=c[t][i],a=c[t+1][i],l=c[t+1][i+1];(0!==t||o>0)&&d.push(e,r,l),(t!==n-1||s<Math.PI)&&d.push(r,a,l)}this.setIndex(d),this.setAttribute("position",new eVt(p,3)),this.setAttribute("normal",new eVt(f,3)),this.setAttribute("uv",new eVt(m,2))}}class nqt extends pWt{constructor(t=1,e=0){super([1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],[2,1,0,0,3,2,1,3,0,2,3,1],t,e),this.type="TetrahedronGeometry",this.parameters={radius:t,detail:e}}}class iqt extends YWt{constructor(t,e={}){const n=e.font;if(!n||!n.isFont)return console.error("THREE.TextGeometry: font parameter is not an instance of THREE.Font."),new pVt;const i=n.generateShapes(t,e.size);e.depth=void 0!==e.height?e.height:50,void 0===e.bevelThickness&&(e.bevelThickness=10),void 0===e.bevelSize&&(e.bevelSize=8),void 0===e.bevelEnabled&&(e.bevelEnabled=!1),super(i,e),this.type="TextGeometry"}}class rqt extends pVt{constructor(t=1,e=.4,n=8,i=6,r=2*Math.PI){super(),this.type="TorusGeometry",this.parameters={radius:t,tube:e,radialSegments:n,tubularSegments:i,arc:r},n=Math.floor(n),i=Math.floor(i);const o=[],a=[],s=[],l=[],c=new yHt,u=new yHt,h=new yHt;for(let o=0;o<=n;o++)for(let d=0;d<=i;d++){const p=d/i*r,f=o/n*Math.PI*2;u.x=(t+e*Math.cos(f))*Math.cos(p),u.y=(t+e*Math.cos(f))*Math.sin(p),u.z=e*Math.sin(f),a.push(u.x,u.y,u.z),c.x=t*Math.cos(p),c.y=t*Math.sin(p),h.subVectors(u,c).normalize(),s.push(h.x,h.y,h.z),l.push(d/i),l.push(o/n)}for(let t=1;t<=n;t++)for(let e=1;e<=i;e++){const n=(i+1)*(t-1)+e-1,r=(i+1)*(t-1)+e,a=(i+1)*t+e;o.push((i+1)*t+e-1,n,a),o.push(n,r,a)}this.setIndex(o),this.setAttribute("position",new eVt(a,3)),this.setAttribute("normal",new eVt(s,3)),this.setAttribute("uv",new eVt(l,2))}}class oqt extends pVt{constructor(t=1,e=.4,n=64,i=8,r=2,o=3){super(),this.type="TorusKnotGeometry",this.parameters={radius:t,tube:e,tubularSegments:n,radialSegments:i,p:r,q:o},n=Math.floor(n),i=Math.floor(i);const a=[],s=[],l=[],c=[],u=new yHt,h=new yHt,d=new yHt,p=new yHt,f=new yHt,m=new yHt,g=new yHt;for(let a=0;a<=n;++a){const y=a/n*r*Math.PI*2;_(y,r,o,t,d),_(y+.01,r,o,t,p),m.subVectors(p,d),g.addVectors(p,d),f.crossVectors(m,g),g.crossVectors(f,m),f.normalize(),g.normalize();for(let t=0;t<=i;++t){const r=t/i*Math.PI*2,o=-e*Math.cos(r),p=e*Math.sin(r);u.x=d.x+(o*g.x+p*f.x),u.y=d.y+(o*g.y+p*f.y),u.z=d.z+(o*g.z+p*f.z),s.push(u.x,u.y,u.z),h.subVectors(u,d).normalize(),l.push(h.x,h.y,h.z),c.push(a/n),c.push(t/i)}}for(let t=1;t<=n;t++)for(let e=1;e<=i;e++){const n=(i+1)*t+(e-1),r=(i+1)*t+e,o=(i+1)*(t-1)+e;a.push((i+1)*(t-1)+(e-1),n,o),a.push(n,r,o)}function _(t,e,n,i,r){const o=Math.cos(t),a=Math.sin(t),s=n/e*t,l=Math.cos(s);r.x=i*(2+l)*.5*o,r.y=i*(2+l)*a*.5,r.z=i*Math.sin(s)*.5}this.setIndex(a),this.setAttribute("position",new eVt(s,3)),this.setAttribute("normal",new eVt(l,3)),this.setAttribute("uv",new eVt(c,2))}}class aqt extends pVt{constructor(t,e=64,n=1,i=8,r=!1){super(),this.type="TubeGeometry",this.parameters={path:t,tubularSegments:e,radius:n,radialSegments:i,closed:r};const o=t.computeFrenetFrames(e,r);this.tangents=o.tangents,this.normals=o.normals,this.binormals=o.binormals;const a=new yHt,s=new yHt,l=new lHt;let c=new yHt;const u=[],h=[],d=[],p=[];function f(r){c=t.getPointAt(r/e,c);const l=o.normals[r],d=o.binormals[r];for(let t=0;t<=i;t++){const e=t/i*Math.PI*2,r=Math.sin(e),o=-Math.cos(e);s.x=o*l.x+r*d.x,s.y=o*l.y+r*d.y,s.z=o*l.z+r*d.z,s.normalize(),h.push(s.x,s.y,s.z),a.x=c.x+n*s.x,a.y=c.y+n*s.y,a.z=c.z+n*s.z,u.push(a.x,a.y,a.z)}}!(function m(){for(let t=0;t<e;t++)f(t);f(!1===r?e:0),(function t(){for(let t=0;t<=e;t++)for(let n=0;n<=i;n++)l.x=t/e,l.y=n/i,d.push(l.x,l.y)})(),(function n(){for(let t=1;t<=e;t++)for(let e=1;e<=i;e++){const n=(i+1)*t+(e-1),r=(i+1)*t+e,o=(i+1)*(t-1)+e;p.push((i+1)*(t-1)+(e-1),n,o),p.push(n,r,o)}})()})(),this.setIndex(p),this.setAttribute("position",new eVt(u,3)),this.setAttribute("normal",new eVt(h,3)),this.setAttribute("uv",new eVt(d,2))}toJSON(){const t=pVt.prototype.toJSON.call(this);return t.path=this.parameters.path.toJSON(),t}}class sqt extends pVt{constructor(t){if(super(),this.type="WireframeGeometry",!0===t.isGeometry)return void console.error("THREE.WireframeGeometry no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");const e=[],n=[0,0],i={},r=new yHt;if(null!==t.index){const o=t.attributes.position,a=t.index;let s=t.groups;0===s.length&&(s=[{start:0,count:a.count,materialIndex:0}]);for(let t=0,e=s.length;t<e;++t){const e=s[t],r=e.start;for(let t=r,o=r+e.count;t<o;t+=3)for(let e=0;e<3;e++){const r=a.getX(t+e),o=a.getX(t+(e+1)%3);n[0]=Math.min(r,o),n[1]=Math.max(r,o);const s=n[0]+","+n[1];void 0===i[s]&&(i[s]={index1:n[0],index2:n[1]})}}for(const t in i){const n=i[t];r.fromBufferAttribute(o,n.index1),e.push(r.x,r.y,r.z),r.fromBufferAttribute(o,n.index2),e.push(r.x,r.y,r.z)}}else{const n=t.attributes.position;for(let t=0,i=n.count/3;t<i;t++)for(let i=0;i<3;i++)r.fromBufferAttribute(n,3*t+i),e.push(r.x,r.y,r.z),r.fromBufferAttribute(n,3*t+(i+1)%3),e.push(r.x,r.y,r.z)}this.setAttribute("position",new eVt(e,3))}}var lqt=Object.freeze({__proto__:null,BoxGeometry:NVt,BoxBufferGeometry:NVt,CircleGeometry:uWt,CircleBufferGeometry:uWt,ConeGeometry:dWt,ConeBufferGeometry:dWt,CylinderGeometry:hWt,CylinderBufferGeometry:hWt,DodecahedronGeometry:fWt,DodecahedronBufferGeometry:fWt,EdgesGeometry:vWt,ExtrudeGeometry:YWt,ExtrudeBufferGeometry:YWt,IcosahedronGeometry:$Wt,IcosahedronBufferGeometry:$Wt,LatheGeometry:KWt,LatheBufferGeometry:KWt,OctahedronGeometry:ZWt,OctahedronBufferGeometry:ZWt,ParametricGeometry:JWt,ParametricBufferGeometry:JWt,PlaneGeometry:KVt,PlaneBufferGeometry:KVt,PolyhedronGeometry:pWt,PolyhedronBufferGeometry:pWt,RingGeometry:QWt,RingBufferGeometry:QWt,ShapeGeometry:tqt,ShapeBufferGeometry:tqt,SphereGeometry:eqt,SphereBufferGeometry:eqt,TetrahedronGeometry:nqt,TetrahedronBufferGeometry:nqt,TextGeometry:iqt,TextBufferGeometry:iqt,TorusGeometry:rqt,TorusBufferGeometry:rqt,TorusKnotGeometry:oqt,TorusKnotBufferGeometry:oqt,TubeGeometry:aqt,TubeBufferGeometry:aqt,WireframeGeometry:sqt});function cqt(t){jFt.call(this),this.type="ShadowMaterial",this.color=new HFt(0),this.transparent=!0,this.setValues(t)}function uqt(t){DVt.call(this,t),this.type="RawShaderMaterial"}function hqt(t){jFt.call(this),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new HFt(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new HFt(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new lHt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.vertexTangents=!1,this.setValues(t)}function dqt(t){hqt.call(this),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoat=0,this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new lHt(1,1),this.clearcoatNormalMap=null,this.reflectivity=.5,Object.defineProperty(this,"ior",{get:function(){return(1+.4*this.reflectivity)/(1-.4*this.reflectivity)},set:function(t){this.reflectivity=sHt.clamp(2.5*(t-1)/(t+1),0,1)}}),this.sheen=null,this.transmission=0,this.transmissionMap=null,this.setValues(t)}function pqt(t){jFt.call(this),this.type="MeshPhongMaterial",this.color=new HFt(16777215),this.specular=new HFt(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new HFt(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new lHt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function fqt(t){jFt.call(this),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new HFt(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new HFt(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new lHt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function mqt(t){jFt.call(this),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new lHt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function gqt(t){jFt.call(this),this.type="MeshLambertMaterial",this.color=new HFt(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new HFt(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function _qt(t){jFt.call(this),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new HFt(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new lHt(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function yqt(t){jGt.call(this),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}(cqt.prototype=Object.create(jFt.prototype)).constructor=cqt,cqt.prototype.isShadowMaterial=!0,cqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this},(uqt.prototype=Object.create(DVt.prototype)).constructor=uqt,uqt.prototype.isRawShaderMaterial=!0,(hqt.prototype=Object.create(jFt.prototype)).constructor=hqt,hqt.prototype.isMeshStandardMaterial=!0,hqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this.vertexTangents=t.vertexTangents,this},(dqt.prototype=Object.create(hqt.prototype)).constructor=dqt,dqt.prototype.isMeshPhysicalMaterial=!0,dqt.prototype.copy=function(t){return hqt.prototype.copy.call(this,t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.reflectivity=t.reflectivity,this.sheen=t.sheen?(this.sheen||new HFt).copy(t.sheen):null,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this},(pqt.prototype=Object.create(jFt.prototype)).constructor=pqt,pqt.prototype.isMeshPhongMaterial=!0,pqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(fqt.prototype=Object.create(jFt.prototype)).constructor=fqt,fqt.prototype.isMeshToonMaterial=!0,fqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(mqt.prototype=Object.create(jFt.prototype)).constructor=mqt,mqt.prototype.isMeshNormalMaterial=!0,mqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(gqt.prototype=Object.create(jFt.prototype)).constructor=gqt,gqt.prototype.isMeshLambertMaterial=!0,gqt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(_qt.prototype=Object.create(jFt.prototype)).constructor=_qt,_qt.prototype.isMeshMatcapMaterial=!0,_qt.prototype.copy=function(t){return jFt.prototype.copy.call(this,t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(yqt.prototype=Object.create(jGt.prototype)).constructor=yqt,yqt.prototype.isLineDashedMaterial=!0,yqt.prototype.copy=function(t){return jGt.prototype.copy.call(this,t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this};var vqt=Object.freeze({__proto__:null,ShadowMaterial:cqt,SpriteMaterial:lGt,RawShaderMaterial:uqt,ShaderMaterial:DVt,PointsMaterial:QGt,MeshPhysicalMaterial:dqt,MeshStandardMaterial:hqt,MeshPhongMaterial:pqt,MeshToonMaterial:fqt,MeshNormalMaterial:mqt,MeshLambertMaterial:gqt,MeshDepthMaterial:UUt,MeshDistanceMaterial:GUt,MeshBasicMaterial:UFt,MeshMatcapMaterial:_qt,LineDashedMaterial:yqt,LineBasicMaterial:jGt,Material:jFt});const bqt={arraySlice:function(t,e,n){return bqt.isTypedArray(t)?new t.constructor(t.subarray(e,void 0!==n?n:t.length)):t.slice(e,n)},convertArray:function(t,e,n){return!t||!n&&t.constructor===e?t:"number"==typeof e.BYTES_PER_ELEMENT?new e(t):Array.prototype.slice.call(t)},isTypedArray:function(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)},getKeyframeOrder:function(t){const e=t.length,n=new Array(e);for(let t=0;t!==e;++t)n[t]=t;return n.sort((function i(e,n){return t[e]-t[n]})),n},sortedArray:function(t,e,n){const i=t.length,r=new t.constructor(i);for(let o=0,a=0;a!==i;++o){const i=n[o]*e;for(let n=0;n!==e;++n)r[a++]=t[i+n]}return r},flattenJSON:function(t,e,n,i){let r=1,o=t[0];for(;void 0!==o&&void 0===o[i];)o=t[r++];if(void 0===o)return;let a=o[i];if(void 0!==a)if(Array.isArray(a))do{a=o[i],void 0!==a&&(e.push(o.time),n.push.apply(n,a)),o=t[r++]}while(void 0!==o);else if(void 0!==a.toArray)do{a=o[i],void 0!==a&&(e.push(o.time),a.toArray(n,n.length)),o=t[r++]}while(void 0!==o);else do{a=o[i],void 0!==a&&(e.push(o.time),n.push(a)),o=t[r++]}while(void 0!==o)},subclip:function(t,e,n,i,r=30){const o=t.clone();o.name=e;const a=[];for(let t=0;t<o.tracks.length;++t){const e=o.tracks[t],s=e.getValueSize(),l=[],c=[];for(let t=0;t<e.times.length;++t){const o=e.times[t]*r;if(!(o<n||o>=i)){l.push(e.times[t]);for(let n=0;n<s;++n)c.push(e.values[t*s+n])}}0!==l.length&&(e.times=bqt.convertArray(l,e.times.constructor),e.values=bqt.convertArray(c,e.values.constructor),a.push(e))}o.tracks=a;let s=1/0;for(let t=0;t<o.tracks.length;++t)s>o.tracks[t].times[0]&&(s=o.tracks[t].times[0]);for(let t=0;t<o.tracks.length;++t)o.tracks[t].shift(-1*s);return o.resetDuration(),o},makeClipAdditive:function(t,e=0,n=t,i=30){i<=0&&(i=30);const r=n.tracks.length,o=e/i;for(let e=0;e<r;++e){const i=n.tracks[e],r=i.ValueTypeName;if("bool"===r||"string"===r)continue;const a=t.tracks.find((function(t){return t.name===i.name&&t.ValueTypeName===r}));if(void 0===a)continue;let s=0;const l=i.getValueSize();i.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(s=l/3);let c=0;const u=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(c=u/3);const h=i.times.length-1;let d;if(o<=i.times[0])d=bqt.arraySlice(i.values,s,l-s);else if(o>=i.times[h]){const t=h*l+s;d=bqt.arraySlice(i.values,t,t+l-s)}else{const t=i.createInterpolant(),e=s,n=l-s;t.evaluate(o),d=bqt.arraySlice(t.resultBuffer,e,n)}"quaternion"===r&&(new _Ht).fromArray(d).normalize().conjugate().toArray(d);const p=a.times.length;for(let t=0;t<p;++t){const e=t*u+c;if("quaternion"===r)_Ht.multiplyQuaternionsFlat(a.values,e,d,0,a.values,e);else{const t=u-2*c;for(let n=0;n<t;++n)a.values[e+n]-=d[n]}}}return t.blendMode=qBt,t}};function xqt(t,e,n,i){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==i?i:new e.constructor(n),this.sampleValues=e,this.valueSize=n}function wqt(t,e,n,i){xqt.call(this,t,e,n,i),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0}function Sqt(t,e,n,i){xqt.call(this,t,e,n,i)}function Mqt(t,e,n,i){xqt.call(this,t,e,n,i)}function Eqt(t,e,n,i){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===e||0===e.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=bqt.convertArray(e,this.TimeBufferType),this.values=bqt.convertArray(n,this.ValueBufferType),this.setInterpolation(i||this.DefaultInterpolation)}function Tqt(t,e,n){Eqt.call(this,t,e,n)}function Aqt(t,e,n,i){Eqt.call(this,t,e,n,i)}function Cqt(t,e,n,i){Eqt.call(this,t,e,n,i)}function kqt(t,e,n,i){xqt.call(this,t,e,n,i)}function Lqt(t,e,n,i){Eqt.call(this,t,e,n,i)}function Pqt(t,e,n,i){Eqt.call(this,t,e,n,i)}function Iqt(t,e,n,i){Eqt.call(this,t,e,n,i)}function Nqt(t,e=-1,n,i=2500){this.name=t,this.tracks=n,this.duration=e,this.blendMode=i,this.uuid=sHt.generateUUID(),this.duration<0&&this.resetDuration()}function Oqt(t){if(void 0===t.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");const e=(function n(t){switch(t.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Cqt;case"vector":case"vector2":case"vector3":case"vector4":return Iqt;case"color":return Aqt;case"quaternion":return Lqt;case"bool":case"boolean":return Tqt;case"string":return Pqt}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+t)})(t.type);if(void 0===t.times){const e=[],n=[];bqt.flattenJSON(t.keys,e,n,"value"),t.times=e,t.values=n}return void 0!==e.parse?e.parse(t):new e(t.name,t.times,t.values,t.interpolation)}Object.assign(xqt.prototype,{evaluate:function(t){const e=this.parameterPositions;let n=this._cachedIndex,i=e[n],r=e[n-1];t:{e:{let o;n:{i:if(!(t<i)){for(let o=n+2;;){if(void 0===i){if(t<r)break i;return n=e.length,this._cachedIndex=n,this.afterEnd_(n-1,t,r)}if(n===o)break;if(r=i,i=e[++n],t<i)break e}o=e.length;break n}if(t>=r)break t;{const a=e[1];t<a&&(n=2,r=a);for(let o=n-2;;){if(void 0===r)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(n===o)break;if(i=r,r=e[--n-1],t>=r)break e}o=n,n=0}}for(;n<o;){const i=n+o>>>1;t<e[i]?o=i:n=i+1}if(i=e[n],r=e[n-1],void 0===r)return this._cachedIndex=0,this.beforeStart_(0,t,i);if(void 0===i)return n=e.length,this._cachedIndex=n,this.afterEnd_(n-1,r,t)}this._cachedIndex=n,this.intervalChanged_(n,r,i)}return this.interpolate_(n,r,t,i)},settings:null,DefaultSettings_:{},getSettings_:function(){return this.settings||this.DefaultSettings_},copySampleValue_:function(t){const e=this.resultBuffer,n=this.sampleValues,i=this.valueSize,r=t*i;for(let t=0;t!==i;++t)e[t]=n[r+t];return e},interpolate_:function(){throw new Error("call to abstract method")},intervalChanged_:function(){}}),Object.assign(xqt.prototype,{beforeStart_:xqt.prototype.copySampleValue_,afterEnd_:xqt.prototype.copySampleValue_}),wqt.prototype=Object.assign(Object.create(xqt.prototype),{constructor:wqt,DefaultSettings_:{endingStart:jBt,endingEnd:jBt},intervalChanged_:function(t,e,n){const i=this.parameterPositions;let r=t-2,o=t+1,a=i[r],s=i[o];if(void 0===a)switch(this.getSettings_().endingStart){case UBt:r=t,a=2*e-n;break;case GBt:r=i.length-2,a=e+i[r]-i[r+1];break;default:r=t,a=n}if(void 0===s)switch(this.getSettings_().endingEnd){case UBt:o=t,s=2*n-e;break;case GBt:o=1,s=n+i[1]-i[0];break;default:o=t-1,s=e}const l=.5*(n-e),c=this.valueSize;this._weightPrev=l/(e-a),this._weightNext=l/(s-n),this._offsetPrev=r*c,this._offsetNext=o*c},interpolate_:function(t,e,n,i){const r=this.resultBuffer,o=this.sampleValues,a=this.valueSize,s=t*a,l=s-a,c=this._offsetPrev,u=this._offsetNext,h=this._weightPrev,d=this._weightNext,p=(n-e)/(i-e),f=p*p,m=f*p,g=-h*m+2*h*f-h*p,_=(1+h)*m+(-1.5-2*h)*f+(-.5+h)*p+1,y=(-1-d)*m+(1.5+d)*f+.5*p,v=d*m-d*f;for(let t=0;t!==a;++t)r[t]=g*o[c+t]+_*o[l+t]+y*o[s+t]+v*o[u+t];return r}}),Sqt.prototype=Object.assign(Object.create(xqt.prototype),{constructor:Sqt,interpolate_:function(t,e,n,i){const r=this.resultBuffer,o=this.sampleValues,a=this.valueSize,s=t*a,l=s-a,c=(n-e)/(i-e),u=1-c;for(let t=0;t!==a;++t)r[t]=o[l+t]*u+o[s+t]*c;return r}}),Mqt.prototype=Object.assign(Object.create(xqt.prototype),{constructor:Mqt,interpolate_:function(t){return this.copySampleValue_(t-1)}}),Object.assign(Eqt,{toJSON:function(t){const e=t.constructor;let n;if(void 0!==e.toJSON)n=e.toJSON(t);else{n={name:t.name,times:bqt.convertArray(t.times,Array),values:bqt.convertArray(t.values,Array)};const e=t.getInterpolation();e!==t.DefaultInterpolation&&(n.interpolation=e)}return n.type=t.ValueTypeName,n}}),Object.assign(Eqt.prototype,{constructor:Eqt,TimeBufferType:Float32Array,ValueBufferType:Float32Array,DefaultInterpolation:FBt,InterpolantFactoryMethodDiscrete:function(t){return new Mqt(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodLinear:function(t){return new Sqt(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodSmooth:function(t){return new wqt(this.times,this.values,this.getValueSize(),t)},setInterpolation:function(t){let e;switch(t){case HBt:e=this.InterpolantFactoryMethodDiscrete;break;case FBt:e=this.InterpolantFactoryMethodLinear;break;case VBt:e=this.InterpolantFactoryMethodSmooth}if(void 0===e){const e="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(e);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",e),this}return this.createInterpolant=e,this},getInterpolation:function(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return HBt;case this.InterpolantFactoryMethodLinear:return FBt;case this.InterpolantFactoryMethodSmooth:return VBt}},getValueSize:function(){return this.values.length/this.times.length},shift:function(t){if(0!==t){const e=this.times;for(let n=0,i=e.length;n!==i;++n)e[n]+=t}return this},scale:function(t){if(1!==t){const e=this.times;for(let n=0,i=e.length;n!==i;++n)e[n]*=t}return this},trim:function(t,e){const n=this.times,i=n.length;let r=0,o=i-1;for(;r!==i&&n[r]<t;)++r;for(;-1!==o&&n[o]>e;)--o;if(++o,0!==r||o!==i){r>=o&&(o=Math.max(o,1),r=o-1);const t=this.getValueSize();this.times=bqt.arraySlice(n,r,o),this.values=bqt.arraySlice(this.values,r*t,o*t)}return this},validate:function(){let t=!0;const e=this.getValueSize();e-Math.floor(e)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);const n=this.times,i=this.values,r=n.length;0===r&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let o=null;for(let e=0;e!==r;e++){const i=n[e];if("number"==typeof i&&isNaN(i)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,e,i),t=!1;break}if(null!==o&&o>i){console.error("THREE.KeyframeTrack: Out of order keys.",this,e,i,o),t=!1;break}o=i}if(void 0!==i&&bqt.isTypedArray(i))for(let e=0,n=i.length;e!==n;++e){const n=i[e];if(isNaN(n)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,e,n),t=!1;break}}return t},optimize:function(){const t=bqt.arraySlice(this.times),e=bqt.arraySlice(this.values),n=this.getValueSize(),i=this.getInterpolation()===VBt,r=t.length-1;let o=1;for(let a=1;a<r;++a){let r=!1;const s=t[a];if(s!==t[a+1]&&(1!==a||s!==t[0]))if(i)r=!0;else{const t=a*n,i=t-n,o=t+n;for(let a=0;a!==n;++a){const n=e[t+a];if(n!==e[i+a]||n!==e[o+a]){r=!0;break}}}if(r){if(a!==o){t[o]=t[a];const i=a*n,r=o*n;for(let t=0;t!==n;++t)e[r+t]=e[i+t]}++o}}if(r>0){t[o]=t[r];for(let t=r*n,i=o*n,a=0;a!==n;++a)e[i+a]=e[t+a];++o}return o!==t.length?(this.times=bqt.arraySlice(t,0,o),this.values=bqt.arraySlice(e,0,o*n)):(this.times=t,this.values=e),this},clone:function(){const t=bqt.arraySlice(this.times,0),e=bqt.arraySlice(this.values,0),n=new(0,this.constructor)(this.name,t,e);return n.createInterpolant=this.createInterpolant,n}}),Tqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Tqt,ValueTypeName:"bool",ValueBufferType:Array,DefaultInterpolation:HBt,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0}),Aqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Aqt,ValueTypeName:"color"}),Cqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Cqt,ValueTypeName:"number"}),kqt.prototype=Object.assign(Object.create(xqt.prototype),{constructor:kqt,interpolate_:function(t,e,n,i){const r=this.resultBuffer,o=this.sampleValues,a=this.valueSize,s=(n-e)/(i-e);let l=t*a;for(let t=l+a;l!==t;l+=4)_Ht.slerpFlat(r,0,o,l-a,o,l,s);return r}}),Lqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Lqt,ValueTypeName:"quaternion",DefaultInterpolation:FBt,InterpolantFactoryMethodLinear:function(t){return new kqt(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodSmooth:void 0}),Pqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Pqt,ValueTypeName:"string",ValueBufferType:Array,DefaultInterpolation:HBt,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0}),Iqt.prototype=Object.assign(Object.create(Eqt.prototype),{constructor:Iqt,ValueTypeName:"vector"}),Object.assign(Nqt,{parse:function(t){const e=[],n=t.tracks,i=1/(t.fps||1);for(let t=0,r=n.length;t!==r;++t)e.push(Oqt(n[t]).scale(i));const r=new Nqt(t.name,t.duration,e,t.blendMode);return r.uuid=t.uuid,r},toJSON:function(t){const e=[],n=t.tracks,i={name:t.name,duration:t.duration,tracks:e,uuid:t.uuid,blendMode:t.blendMode};for(let t=0,i=n.length;t!==i;++t)e.push(Eqt.toJSON(n[t]));return i},CreateFromMorphTargetSequence:function(t,e,n,i){const r=e.length,o=[];for(let t=0;t<r;t++){let a=[],s=[];a.push((t+r-1)%r,t,(t+1)%r),s.push(0,1,0);const l=bqt.getKeyframeOrder(a);a=bqt.sortedArray(a,1,l),s=bqt.sortedArray(s,1,l),i||0!==a[0]||(a.push(r),s.push(s[0])),o.push(new Cqt(".morphTargetInfluences["+e[t].name+"]",a,s).scale(1/n))}return new Nqt(t,-1,o)},findByName:function(t,e){let n=t;if(!Array.isArray(t)){const e=t;n=e.geometry&&e.geometry.animations||e.animations}for(let t=0;t<n.length;t++)if(n[t].name===e)return n[t];return null},CreateClipsFromMorphTargetSequences:function(t,e,n){const i={},r=/^([\w-]*?)([\d]+)$/;for(let e=0,n=t.length;e<n;e++){const n=t[e],o=n.name.match(r);if(o&&o.length>1){const t=o[1];let e=i[t];e||(i[t]=e=[]),e.push(n)}}const o=[];for(const t in i)o.push(Nqt.CreateFromMorphTargetSequence(t,i[t],e,n));return o},parseAnimation:function(t,e){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;const n=function(t,e,n,i,r){if(0!==n.length){const o=[],a=[];bqt.flattenJSON(n,o,a,i),0!==o.length&&r.push(new t(e,o,a))}},i=[],r=t.name||"default",o=t.fps||30,a=t.blendMode;let s=t.length||-1;const l=t.hierarchy||[];for(let t=0;t<l.length;t++){const r=l[t].keys;if(r&&0!==r.length)if(r[0].morphTargets){const t={};let e;for(e=0;e<r.length;e++)if(r[e].morphTargets)for(let n=0;n<r[e].morphTargets.length;n++)t[r[e].morphTargets[n]]=-1;for(const n in t){const t=[],o=[];for(let i=0;i!==r[e].morphTargets.length;++i){const i=r[e];t.push(i.time),o.push(i.morphTarget===n?1:0)}i.push(new Cqt(".morphTargetInfluence["+n+"]",t,o))}s=t.length*(o||1)}else{const o=".bones["+e[t].name+"]";n(Iqt,o+".position",r,"pos",i),n(Lqt,o+".quaternion",r,"rot",i),n(Iqt,o+".scale",r,"scl",i)}}return 0===i.length?null:new Nqt(r,s,i,a)}}),Object.assign(Nqt.prototype,{resetDuration:function(){let t=0;for(let e=0,n=this.tracks.length;e!==n;++e){const n=this.tracks[e];t=Math.max(t,n.times[n.times.length-1])}return this.duration=t,this},trim:function(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this},validate:function(){let t=!0;for(let e=0;e<this.tracks.length;e++)t=t&&this.tracks[e].validate();return t},optimize:function(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this},clone:function(){const t=[];for(let e=0;e<this.tracks.length;e++)t.push(this.tracks[e].clone());return new Nqt(this.name,this.duration,t,this.blendMode)},toJSON:function(){return Nqt.toJSON(this)}});const Rqt={enabled:!1,files:{},add:function(t,e){!1!==this.enabled&&(this.files[t]=e)},get:function(t){if(!1!==this.enabled)return this.files[t]},remove:function(t){delete this.files[t]},clear:function(){this.files={}}};function zqt(t,e,n){const i=this;let r,o=!1,a=0,s=0;const l=[];this.onStart=void 0,this.onLoad=t,this.onProgress=e,this.onError=n,this.itemStart=function(t){s++,!1===o&&void 0!==i.onStart&&i.onStart(t,a,s),o=!0},this.itemEnd=function(t){a++,void 0!==i.onProgress&&i.onProgress(t,a,s),a===s&&(o=!1,void 0!==i.onLoad&&i.onLoad())},this.itemError=function(t){void 0!==i.onError&&i.onError(t)},this.resolveURL=function(t){return r?r(t):t},this.setURLModifier=function(t){return r=t,this},this.addHandler=function(t,e){return l.push(t,e),this},this.removeHandler=function(t){const e=l.indexOf(t);return-1!==e&&l.splice(e,2),this},this.getHandler=function(t){for(let e=0,n=l.length;e<n;e+=2){const n=l[e],i=l[e+1];if(n.global&&(n.lastIndex=0),n.test(t))return i}return null}}const Dqt=new zqt;function Bqt(t){this.manager=void 0!==t?t:Dqt,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}Object.assign(Bqt.prototype,{load:function(){},loadAsync:function(t,e){const n=this;return new Promise((function(i,r){n.load(t,i,e,r)}))},parse:function(){},setCrossOrigin:function(t){return this.crossOrigin=t,this},setWithCredentials:function(t){return this.withCredentials=t,this},setPath:function(t){return this.path=t,this},setResourcePath:function(t){return this.resourcePath=t,this},setRequestHeader:function(t){return this.requestHeader=t,this}});const Hqt={};function Fqt(t){Bqt.call(this,t)}function Vqt(t){Bqt.call(this,t)}function jqt(t){Bqt.call(this,t)}function Uqt(t){Bqt.call(this,t)}function Gqt(t){Bqt.call(this,t)}function Wqt(t){Bqt.call(this,t)}function qqt(t){Bqt.call(this,t)}function Yqt(){this.type="Curve",this.arcLengthDivisions=200}function Xqt(t,e,n,i,r,o,a,s){Yqt.call(this),this.type="EllipseCurve",this.aX=t||0,this.aY=e||0,this.xRadius=n||1,this.yRadius=i||1,this.aStartAngle=r||0,this.aEndAngle=o||2*Math.PI,this.aClockwise=a||!1,this.aRotation=s||0}function $qt(t,e,n,i,r,o){Xqt.call(this,t,e,n,n,i,r,o),this.type="ArcCurve"}function Kqt(){let t=0,e=0,n=0,i=0;function r(r,o,a,s){t=r,e=a,n=-3*r+3*o-2*a-s,i=2*r-2*o+a+s}return{initCatmullRom:function(t,e,n,i,o){r(e,n,o*(n-t),o*(i-e))},initNonuniformCatmullRom:function(t,e,n,i,o,a,s){let l=(e-t)/o-(n-t)/(o+a)+(n-e)/a,c=(n-e)/a-(i-e)/(a+s)+(i-n)/s;l*=a,c*=a,r(e,n,l,c)},calc:function(r){const o=r*r;return t+e*r+n*o+i*(o*r)}}}Fqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:Fqt,load:function(t,e,n,i){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const r=this,o=Rqt.get(t);if(void 0!==o)return r.manager.itemStart(t),setTimeout((function(){e&&e(o),r.manager.itemEnd(t)}),0),o;if(void 0!==Hqt[t])return void Hqt[t].push({onLoad:e,onProgress:n,onError:i});const a=t.match(/^data:(.*?)(;base64)?,(.*)$/);let s;if(a){const n=a[1],o=!!a[2];let s=a[3];s=decodeURIComponent(s),o&&(s=atob(s));try{let i;const o=(this.responseType||"").toLowerCase();switch(o){case"arraybuffer":case"blob":const t=new Uint8Array(s.length);for(let e=0;e<s.length;e++)t[e]=s.charCodeAt(e);i="blob"===o?new Blob([t.buffer],{type:n}):t.buffer;break;case"document":const e=new DOMParser;i=e.parseFromString(s,n);break;case"json":i=JSON.parse(s);break;default:i=s}setTimeout((function(){e&&e(i),r.manager.itemEnd(t)}),0)}catch(e){setTimeout((function(){i&&i(e),r.manager.itemError(t),r.manager.itemEnd(t)}),0)}}else{Hqt[t]=[],Hqt[t].push({onLoad:e,onProgress:n,onError:i}),s=new XMLHttpRequest,s.open("GET",t,!0),s.addEventListener("load",(function(e){const n=this.response,i=Hqt[t];if(delete Hqt[t],200===this.status||0===this.status){0===this.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),Rqt.add(t,n);for(let t=0,e=i.length;t<e;t++){const e=i[t];e.onLoad&&e.onLoad(n)}r.manager.itemEnd(t)}else{for(let t=0,n=i.length;t<n;t++){const n=i[t];n.onError&&n.onError(e)}r.manager.itemError(t),r.manager.itemEnd(t)}}),!1),s.addEventListener("progress",(function(e){const n=Hqt[t];for(let t=0,i=n.length;t<i;t++){const i=n[t];i.onProgress&&i.onProgress(e)}}),!1),s.addEventListener("error",(function(e){const n=Hqt[t];delete Hqt[t];for(let t=0,i=n.length;t<i;t++){const i=n[t];i.onError&&i.onError(e)}r.manager.itemError(t),r.manager.itemEnd(t)}),!1),s.addEventListener("abort",(function(e){const n=Hqt[t];delete Hqt[t];for(let t=0,i=n.length;t<i;t++){const i=n[t];i.onError&&i.onError(e)}r.manager.itemError(t),r.manager.itemEnd(t)}),!1),void 0!==this.responseType&&(s.responseType=this.responseType),void 0!==this.withCredentials&&(s.withCredentials=this.withCredentials),s.overrideMimeType&&s.overrideMimeType(void 0!==this.mimeType?this.mimeType:"text/plain");for(const t in this.requestHeader)s.setRequestHeader(t,this.requestHeader[t]);s.send(null)}return r.manager.itemStart(t),s},setResponseType:function(t){return this.responseType=t,this},setMimeType:function(t){return this.mimeType=t,this}}),Vqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:Vqt,load:function(t,e,n,i){const r=this,o=new Fqt(r.manager);o.setPath(r.path),o.setRequestHeader(r.requestHeader),o.setWithCredentials(r.withCredentials),o.load(t,(function(n){try{e(r.parse(JSON.parse(n)))}catch(e){i?i(e):console.error(e),r.manager.itemError(t)}}),n,i)},parse:function(t){const e=[];for(let n=0;n<t.length;n++){const i=Nqt.parse(t[n]);e.push(i)}return e}}),jqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:jqt,load:function(t,e,n,i){const r=this,o=[],a=new sWt,s=new Fqt(this.manager);s.setPath(this.path),s.setResponseType("arraybuffer"),s.setRequestHeader(this.requestHeader),s.setWithCredentials(r.withCredentials);let l=0;function c(c){s.load(t[c],(function(t){const n=r.parse(t,!0);o[c]={width:n.width,height:n.height,format:n.format,mipmaps:n.mipmaps},l+=1,6===l&&(1===n.mipmapCount&&(a.minFilter=gBt),a.image=o,a.format=n.format,a.needsUpdate=!0,e&&e(a))}),n,i)}if(Array.isArray(t))for(let e=0,n=t.length;e<n;++e)c(e);else s.load(t,(function(t){const n=r.parse(t,!0);if(n.isCubemap){const t=n.mipmaps.length/n.mipmapCount;for(let e=0;e<t;e++){o[e]={mipmaps:[]};for(let t=0;t<n.mipmapCount;t++)o[e].mipmaps.push(n.mipmaps[e*n.mipmapCount+t]),o[e].format=n.format,o[e].width=n.width,o[e].height=n.height}a.image=o}else a.image.width=n.width,a.image.height=n.height,a.mipmaps=n.mipmaps;1===n.mipmapCount&&(a.minFilter=gBt),a.format=n.format,a.needsUpdate=!0,e&&e(a)}),n,i);return a}}),Uqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:Uqt,load:function(t,e,n,i){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const r=this,o=Rqt.get(t);if(void 0!==o)return r.manager.itemStart(t),setTimeout((function(){e&&e(o),r.manager.itemEnd(t)}),0),o;const a=document.createElementNS("http://www.w3.org/1999/xhtml","img");function s(){a.removeEventListener("load",s,!1),a.removeEventListener("error",l,!1),Rqt.add(t,this),e&&e(this),r.manager.itemEnd(t)}function l(e){a.removeEventListener("load",s,!1),a.removeEventListener("error",l,!1),i&&i(e),r.manager.itemError(t),r.manager.itemEnd(t)}return a.addEventListener("load",s,!1),a.addEventListener("error",l,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(a.crossOrigin=this.crossOrigin),r.manager.itemStart(t),a.src=t,a}}),Gqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:Gqt,load:function(t,e,n,i){const r=new jVt,o=new Uqt(this.manager);o.setCrossOrigin(this.crossOrigin),o.setPath(this.path);let a=0;function s(n){o.load(t[n],(function(t){r.images[n]=t,a++,6===a&&(r.needsUpdate=!0,e&&e(r))}),void 0,i)}for(let e=0;e<t.length;++e)s(e);return r}}),Wqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:Wqt,load:function(t,e,n,i){const r=this,o=new GVt,a=new Fqt(this.manager);return a.setResponseType("arraybuffer"),a.setRequestHeader(this.requestHeader),a.setPath(this.path),a.setWithCredentials(r.withCredentials),a.load(t,(function(t){const n=r.parse(t);n&&(void 0!==n.image?o.image=n.image:void 0!==n.data&&(o.image.width=n.width,o.image.height=n.height,o.image.data=n.data),o.wrapS=void 0!==n.wrapS?n.wrapS:hBt,o.wrapT=void 0!==n.wrapT?n.wrapT:hBt,o.magFilter=void 0!==n.magFilter?n.magFilter:gBt,o.minFilter=void 0!==n.minFilter?n.minFilter:gBt,o.anisotropy=void 0!==n.anisotropy?n.anisotropy:1,void 0!==n.encoding&&(o.encoding=n.encoding),void 0!==n.flipY&&(o.flipY=n.flipY),void 0!==n.format&&(o.format=n.format),void 0!==n.type&&(o.type=n.type),void 0!==n.mipmaps&&(o.mipmaps=n.mipmaps,o.minFilter=yBt),1===n.mipmapCount&&(o.minFilter=gBt),o.needsUpdate=!0,e&&e(o,n))}),n,i),o}}),qqt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:qqt,load:function(t,e,n,i){const r=new pHt,o=new Uqt(this.manager);return o.setCrossOrigin(this.crossOrigin),o.setPath(this.path),o.load(t,(function(n){r.image=n;const i=t.search(/\.jpe?g($|\?)/i)>0||0===t.search(/^data\:image\/jpeg/);r.format=i?EBt:TBt,r.needsUpdate=!0,void 0!==e&&e(r)}),n,i),r}}),Object.assign(Yqt.prototype,{getPoint:function(){return console.warn("THREE.Curve: .getPoint() not implemented."),null},getPointAt:function(t,e){const n=this.getUtoTmapping(t);return this.getPoint(n,e)},getPoints:function(t=5){const e=[];for(let n=0;n<=t;n++)e.push(this.getPoint(n/t));return e},getSpacedPoints:function(t=5){const e=[];for(let n=0;n<=t;n++)e.push(this.getPointAt(n/t));return e},getLength:function(){const t=this.getLengths();return t[t.length-1]},getLengths:function(t){if(void 0===t&&(t=this.arcLengthDivisions),this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;const e=[];let n,i=this.getPoint(0),r=0;e.push(0);for(let o=1;o<=t;o++)n=this.getPoint(o/t),r+=n.distanceTo(i),e.push(r),i=n;return this.cacheArcLengths=e,e},updateArcLengths:function(){this.needsUpdate=!0,this.getLengths()},getUtoTmapping:function(t,e){const n=this.getLengths();let i=0;const r=n.length;let o;o=e||t*n[r-1];let a,s=0,l=r-1;for(;s<=l;)if(i=Math.floor(s+(l-s)/2),a=n[i]-o,a<0)s=i+1;else{if(!(a>0)){l=i;break}l=i-1}if(i=l,n[i]===o)return i/(r-1);const c=n[i];return(i+(o-c)/(n[i+1]-c))/(r-1)},getTangent:function(t,e){const n=1e-4;let i=t-n,r=t+n;i<0&&(i=0),r>1&&(r=1);const o=this.getPoint(i),a=this.getPoint(r),s=e||(o.isVector2?new lHt:new yHt);return s.copy(a).sub(o).normalize(),s},getTangentAt:function(t,e){const n=this.getUtoTmapping(t);return this.getTangent(n,e)},computeFrenetFrames:function(t,e){const n=new yHt,i=[],r=[],o=[],a=new yHt,s=new qHt;for(let e=0;e<=t;e++)i[e]=this.getTangentAt(e/t,new yHt),i[e].normalize();r[0]=new yHt,o[0]=new yHt;let l=Number.MAX_VALUE;const c=Math.abs(i[0].x),u=Math.abs(i[0].y),h=Math.abs(i[0].z);c<=l&&(l=c,n.set(1,0,0)),u<=l&&(l=u,n.set(0,1,0)),h<=l&&n.set(0,0,1),a.crossVectors(i[0],n).normalize(),r[0].crossVectors(i[0],a),o[0].crossVectors(i[0],r[0]);for(let e=1;e<=t;e++){if(r[e]=r[e-1].clone(),o[e]=o[e-1].clone(),a.crossVectors(i[e-1],i[e]),a.length()>Number.EPSILON){a.normalize();const t=Math.acos(sHt.clamp(i[e-1].dot(i[e]),-1,1));r[e].applyMatrix4(s.makeRotationAxis(a,t))}o[e].crossVectors(i[e],r[e])}if(!0===e){let e=Math.acos(sHt.clamp(r[0].dot(r[t]),-1,1));e/=t,i[0].dot(a.crossVectors(r[0],r[t]))>0&&(e=-e);for(let n=1;n<=t;n++)r[n].applyMatrix4(s.makeRotationAxis(i[n],e*n)),o[n].crossVectors(i[n],r[n])}return{tangents:i,normals:r,binormals:o}},clone:function(){return(new this.constructor).copy(this)},copy:function(t){return this.arcLengthDivisions=t.arcLengthDivisions,this},toJSON:function(){const t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t},fromJSON:function(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),(Xqt.prototype=Object.create(Yqt.prototype)).constructor=Xqt,Xqt.prototype.isEllipseCurve=!0,Xqt.prototype.getPoint=function(t,e){const n=e||new lHt,i=2*Math.PI;let r=this.aEndAngle-this.aStartAngle;const o=Math.abs(r)<Number.EPSILON;for(;r<0;)r+=i;for(;r>i;)r-=i;r<Number.EPSILON&&(r=o?0:i),!0!==this.aClockwise||o||(r===i?r=-i:r-=i);const a=this.aStartAngle+t*r;let s=this.aX+this.xRadius*Math.cos(a),l=this.aY+this.yRadius*Math.sin(a);if(0!==this.aRotation){const t=Math.cos(this.aRotation),e=Math.sin(this.aRotation),n=s-this.aX,i=l-this.aY;s=n*t-i*e+this.aX,l=n*e+i*t+this.aY}return n.set(s,l)},Xqt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this},Xqt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t},Xqt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this},($qt.prototype=Object.create(Xqt.prototype)).constructor=$qt,$qt.prototype.isArcCurve=!0;const Zqt=new yHt,Jqt=new Kqt,Qqt=new Kqt,tYt=new Kqt;function eYt(t=[],e=!1,n="centripetal",i=.5){Yqt.call(this),this.type="CatmullRomCurve3",this.points=t,this.closed=e,this.curveType=n,this.tension=i}function nYt(t,e,n,i,r){const o=.5*(i-e),a=.5*(r-n),s=t*t;return(2*n-2*i+o+a)*(t*s)+(-3*n+3*i-2*o-a)*s+o*t+n}function iYt(t,e,n,i){return(function r(t,e){const n=1-t;return n*n*e})(t,e)+(function o(t,e){return 2*(1-t)*t*e})(t,n)+(function a(t,e){return t*t*e})(t,i)}function rYt(t,e,n,i,r){return(function o(t,e){const n=1-t;return n*n*n*e})(t,e)+(function a(t,e){const n=1-t;return 3*n*n*t*e})(t,n)+(function s(t,e){return 3*(1-t)*t*t*e})(t,i)+(function l(t,e){return t*t*t*e})(t,r)}function oYt(t=new lHt,e=new lHt,n=new lHt,i=new lHt){Yqt.call(this),this.type="CubicBezierCurve",this.v0=t,this.v1=e,this.v2=n,this.v3=i}function aYt(t=new yHt,e=new yHt,n=new yHt,i=new yHt){Yqt.call(this),this.type="CubicBezierCurve3",this.v0=t,this.v1=e,this.v2=n,this.v3=i}function sYt(t=new lHt,e=new lHt){Yqt.call(this),this.type="LineCurve",this.v1=t,this.v2=e}function lYt(t=new yHt,e=new yHt){Yqt.call(this),this.type="LineCurve3",this.v1=t,this.v2=e}function cYt(t=new lHt,e=new lHt,n=new lHt){Yqt.call(this),this.type="QuadraticBezierCurve",this.v0=t,this.v1=e,this.v2=n}function uYt(t=new yHt,e=new yHt,n=new yHt){Yqt.call(this),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=e,this.v2=n}function hYt(t=[]){Yqt.call(this),this.type="SplineCurve",this.points=t}(eYt.prototype=Object.create(Yqt.prototype)).constructor=eYt,eYt.prototype.isCatmullRomCurve3=!0,eYt.prototype.getPoint=function(t,e=new yHt){const n=e,i=this.points,r=i.length,o=(r-(this.closed?0:1))*t;let a,s,l=Math.floor(o),c=o-l;this.closed?l+=l>0?0:(Math.floor(Math.abs(l)/r)+1)*r:0===c&&l===r-1&&(l=r-2,c=1),this.closed||l>0?a=i[(l-1)%r]:(Zqt.subVectors(i[0],i[1]).add(i[0]),a=Zqt);const u=i[l%r],h=i[(l+1)%r];if(this.closed||l+2<r?s=i[(l+2)%r]:(Zqt.subVectors(i[r-1],i[r-2]).add(i[r-1]),s=Zqt),"centripetal"===this.curveType||"chordal"===this.curveType){const t="chordal"===this.curveType?.5:.25;let e=Math.pow(a.distanceToSquared(u),t),n=Math.pow(u.distanceToSquared(h),t),i=Math.pow(h.distanceToSquared(s),t);n<1e-4&&(n=1),e<1e-4&&(e=n),i<1e-4&&(i=n),Jqt.initNonuniformCatmullRom(a.x,u.x,h.x,s.x,e,n,i),Qqt.initNonuniformCatmullRom(a.y,u.y,h.y,s.y,e,n,i),tYt.initNonuniformCatmullRom(a.z,u.z,h.z,s.z,e,n,i)}else"catmullrom"===this.curveType&&(Jqt.initCatmullRom(a.x,u.x,h.x,s.x,this.tension),Qqt.initCatmullRom(a.y,u.y,h.y,s.y,this.tension),tYt.initCatmullRom(a.z,u.z,h.z,s.z,this.tension));return n.set(Jqt.calc(c),Qqt.calc(c),tYt.calc(c)),n},eYt.prototype.copy=function(t){Yqt.prototype.copy.call(this,t),this.points=[];for(let e=0,n=t.points.length;e<n;e++)this.points.push(t.points[e].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this},eYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);t.points=[];for(let e=0,n=this.points.length;e<n;e++)t.points.push(this.points[e].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t},eYt.prototype.fromJSON=function(t){Yqt.prototype.fromJSON.call(this,t),this.points=[];for(let e=0,n=t.points.length;e<n;e++){const n=t.points[e];this.points.push((new yHt).fromArray(n))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this},(oYt.prototype=Object.create(Yqt.prototype)).constructor=oYt,oYt.prototype.isCubicBezierCurve=!0,oYt.prototype.getPoint=function(t,e=new lHt){const n=e,i=this.v0,r=this.v1,o=this.v2,a=this.v3;return n.set(rYt(t,i.x,r.x,o.x,a.x),rYt(t,i.y,r.y,o.y,a.y)),n},oYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this},oYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t},oYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this},(aYt.prototype=Object.create(Yqt.prototype)).constructor=aYt,aYt.prototype.isCubicBezierCurve3=!0,aYt.prototype.getPoint=function(t,e=new yHt){const n=e,i=this.v0,r=this.v1,o=this.v2,a=this.v3;return n.set(rYt(t,i.x,r.x,o.x,a.x),rYt(t,i.y,r.y,o.y,a.y),rYt(t,i.z,r.z,o.z,a.z)),n},aYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this},aYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t},aYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this},(sYt.prototype=Object.create(Yqt.prototype)).constructor=sYt,sYt.prototype.isLineCurve=!0,sYt.prototype.getPoint=function(t,e=new lHt){const n=e;return 1===t?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n},sYt.prototype.getPointAt=function(t,e){return this.getPoint(t,e)},sYt.prototype.getTangent=function(t,e){const n=e||new lHt;return n.copy(this.v2).sub(this.v1).normalize(),n},sYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v1.copy(t.v1),this.v2.copy(t.v2),this},sYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},sYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(lYt.prototype=Object.create(Yqt.prototype)).constructor=lYt,lYt.prototype.isLineCurve3=!0,lYt.prototype.getPoint=function(t,e=new yHt){const n=e;return 1===t?n.copy(this.v2):(n.copy(this.v2).sub(this.v1),n.multiplyScalar(t).add(this.v1)),n},lYt.prototype.getPointAt=function(t,e){return this.getPoint(t,e)},lYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v1.copy(t.v1),this.v2.copy(t.v2),this},lYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},lYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(cYt.prototype=Object.create(Yqt.prototype)).constructor=cYt,cYt.prototype.isQuadraticBezierCurve=!0,cYt.prototype.getPoint=function(t,e=new lHt){const n=e,i=this.v0,r=this.v1,o=this.v2;return n.set(iYt(t,i.x,r.x,o.x),iYt(t,i.y,r.y,o.y)),n},cYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this},cYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},cYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(uYt.prototype=Object.create(Yqt.prototype)).constructor=uYt,uYt.prototype.isQuadraticBezierCurve3=!0,uYt.prototype.getPoint=function(t,e=new yHt){const n=e,i=this.v0,r=this.v1,o=this.v2;return n.set(iYt(t,i.x,r.x,o.x),iYt(t,i.y,r.y,o.y),iYt(t,i.z,r.z,o.z)),n},uYt.prototype.copy=function(t){return Yqt.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this},uYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},uYt.prototype.fromJSON=function(t){return Yqt.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(hYt.prototype=Object.create(Yqt.prototype)).constructor=hYt,hYt.prototype.isSplineCurve=!0,hYt.prototype.getPoint=function(t,e=new lHt){const n=e,i=this.points,r=(i.length-1)*t,o=Math.floor(r),a=r-o,s=i[0===o?o:o-1],l=i[o],c=i[o>i.length-2?i.length-1:o+1],u=i[o>i.length-3?i.length-1:o+2];return n.set(nYt(a,s.x,l.x,c.x,u.x),nYt(a,s.y,l.y,c.y,u.y)),n},hYt.prototype.copy=function(t){Yqt.prototype.copy.call(this,t),this.points=[];for(let e=0,n=t.points.length;e<n;e++)this.points.push(t.points[e].clone());return this},hYt.prototype.toJSON=function(){const t=Yqt.prototype.toJSON.call(this);t.points=[];for(let e=0,n=this.points.length;e<n;e++)t.points.push(this.points[e].toArray());return t},hYt.prototype.fromJSON=function(t){Yqt.prototype.fromJSON.call(this,t),this.points=[];for(let e=0,n=t.points.length;e<n;e++){const n=t.points[e];this.points.push((new lHt).fromArray(n))}return this};var dYt=Object.freeze({__proto__:null,ArcCurve:$qt,CatmullRomCurve3:eYt,CubicBezierCurve:oYt,CubicBezierCurve3:aYt,EllipseCurve:Xqt,LineCurve:sYt,LineCurve3:lYt,QuadraticBezierCurve:cYt,QuadraticBezierCurve3:uYt,SplineCurve:hYt});function pYt(){Yqt.call(this),this.type="CurvePath",this.curves=[],this.autoClose=!1}function fYt(t){pYt.call(this),this.type="Path",this.currentPoint=new lHt,t&&this.setFromPoints(t)}function mYt(t){fYt.call(this,t),this.uuid=sHt.generateUUID(),this.type="Shape",this.holes=[]}function gYt(t,e=1){_Ft.call(this),this.type="Light",this.color=new HFt(t),this.intensity=e}function _Yt(t,e,n){gYt.call(this,t,n),this.type="HemisphereLight",this.position.copy(_Ft.DefaultUp),this.updateMatrix(),this.groundColor=new HFt(e)}function yYt(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.mapSize=new lHt(512,512),this.map=null,this.mapPass=null,this.matrix=new qHt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new YVt,this._frameExtents=new lHt(1,1),this._viewportCount=1,this._viewports=[new mHt(0,0,1,1)]}function vYt(){yYt.call(this,new HVt(50,1,.5,500)),this.focus=1}function bYt(t,e,n,i,r,o){gYt.call(this,t,e),this.type="SpotLight",this.position.copy(_Ft.DefaultUp),this.updateMatrix(),this.target=new _Ft,Object.defineProperty(this,"power",{get:function(){return this.intensity*Math.PI},set:function(t){this.intensity=t/Math.PI}}),this.distance=void 0!==n?n:0,this.angle=void 0!==i?i:Math.PI/3,this.penumbra=void 0!==r?r:0,this.decay=void 0!==o?o:1,this.shadow=new vYt}function xYt(){yYt.call(this,new HVt(90,1,.5,500)),this._frameExtents=new lHt(4,2),this._viewportCount=6,this._viewports=[new mHt(2,1,1,1),new mHt(0,1,1,1),new mHt(3,1,1,1),new mHt(1,1,1,1),new mHt(3,0,1,1),new mHt(1,0,1,1)],this._cubeDirections=[new yHt(1,0,0),new yHt(-1,0,0),new yHt(0,0,1),new yHt(0,0,-1),new yHt(0,1,0),new yHt(0,-1,0)],this._cubeUps=[new yHt(0,1,0),new yHt(0,1,0),new yHt(0,1,0),new yHt(0,1,0),new yHt(0,0,1),new yHt(0,0,-1)]}function wYt(t,e,n,i){gYt.call(this,t,e),this.type="PointLight",Object.defineProperty(this,"power",{get:function(){return 4*this.intensity*Math.PI},set:function(t){this.intensity=t/(4*Math.PI)}}),this.distance=void 0!==n?n:0,this.decay=void 0!==i?i:1,this.shadow=new xYt}function SYt(t=-1,e=1,n=1,i=-1,r=.1,o=2e3){BVt.call(this),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=e,this.top=n,this.bottom=i,this.near=r,this.far=o,this.updateProjectionMatrix()}function MYt(){yYt.call(this,new SYt(-5,5,5,-5,.5,500))}function EYt(t,e){gYt.call(this,t,e),this.type="DirectionalLight",this.position.copy(_Ft.DefaultUp),this.updateMatrix(),this.target=new _Ft,this.shadow=new MYt}function TYt(t,e){gYt.call(this,t,e),this.type="AmbientLight"}function AYt(t,e,n,i){gYt.call(this,t,e),this.type="RectAreaLight",this.width=void 0!==n?n:10,this.height=void 0!==i?i:10}pYt.prototype=Object.assign(Object.create(Yqt.prototype),{constructor:pYt,add:function(t){this.curves.push(t)},closePath:function(){const t=this.curves[0].getPoint(0),e=this.curves[this.curves.length-1].getPoint(1);t.equals(e)||this.curves.push(new sYt(e,t))},getPoint:function(t){const e=t*this.getLength(),n=this.getCurveLengths();let i=0;for(;i<n.length;){if(n[i]>=e){const t=n[i]-e,r=this.curves[i],o=r.getLength();return r.getPointAt(0===o?0:1-t/o)}i++}return null},getLength:function(){const t=this.getCurveLengths();return t[t.length-1]},updateArcLengths:function(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()},getCurveLengths:function(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;const t=[];let e=0;for(let n=0,i=this.curves.length;n<i;n++)e+=this.curves[n].getLength(),t.push(e);return this.cacheLengths=t,t},getSpacedPoints:function(t=40){const e=[];for(let n=0;n<=t;n++)e.push(this.getPoint(n/t));return this.autoClose&&e.push(e[0]),e},getPoints:function(t=12){const e=[];let n;for(let i=0,r=this.curves;i<r.length;i++){const o=r[i],a=o.getPoints(o&&o.isEllipseCurve?2*t:o&&(o.isLineCurve||o.isLineCurve3)?1:o&&o.isSplineCurve?t*o.points.length:t);for(let t=0;t<a.length;t++){const i=a[t];n&&n.equals(i)||(e.push(i),n=i)}}return this.autoClose&&e.length>1&&!e[e.length-1].equals(e[0])&&e.push(e[0]),e},copy:function(t){Yqt.prototype.copy.call(this,t),this.curves=[];for(let e=0,n=t.curves.length;e<n;e++)this.curves.push(t.curves[e].clone());return this.autoClose=t.autoClose,this},toJSON:function(){const t=Yqt.prototype.toJSON.call(this);t.autoClose=this.autoClose,t.curves=[];for(let e=0,n=this.curves.length;e<n;e++)t.curves.push(this.curves[e].toJSON());return t},fromJSON:function(t){Yqt.prototype.fromJSON.call(this,t),this.autoClose=t.autoClose,this.curves=[];for(let e=0,n=t.curves.length;e<n;e++){const n=t.curves[e];this.curves.push((new dYt[n.type]).fromJSON(n))}return this}}),fYt.prototype=Object.assign(Object.create(pYt.prototype),{constructor:fYt,setFromPoints:function(t){this.moveTo(t[0].x,t[0].y);for(let e=1,n=t.length;e<n;e++)this.lineTo(t[e].x,t[e].y);return this},moveTo:function(t,e){return this.currentPoint.set(t,e),this},lineTo:function(t,e){const n=new sYt(this.currentPoint.clone(),new lHt(t,e));return this.curves.push(n),this.currentPoint.set(t,e),this},quadraticCurveTo:function(t,e,n,i){const r=new cYt(this.currentPoint.clone(),new lHt(t,e),new lHt(n,i));return this.curves.push(r),this.currentPoint.set(n,i),this},bezierCurveTo:function(t,e,n,i,r,o){const a=new oYt(this.currentPoint.clone(),new lHt(t,e),new lHt(n,i),new lHt(r,o));return this.curves.push(a),this.currentPoint.set(r,o),this},splineThru:function(t){const e=new hYt([this.currentPoint.clone()].concat(t));return this.curves.push(e),this.currentPoint.copy(t[t.length-1]),this},arc:function(t,e,n,i,r,o){return this.absarc(t+this.currentPoint.x,e+this.currentPoint.y,n,i,r,o),this},absarc:function(t,e,n,i,r,o){return this.absellipse(t,e,n,n,i,r,o),this},ellipse:function(t,e,n,i,r,o,a,s){return this.absellipse(t+this.currentPoint.x,e+this.currentPoint.y,n,i,r,o,a,s),this},absellipse:function(t,e,n,i,r,o,a,s){const l=new Xqt(t,e,n,i,r,o,a,s);if(this.curves.length>0){const t=l.getPoint(0);t.equals(this.currentPoint)||this.lineTo(t.x,t.y)}this.curves.push(l);const c=l.getPoint(1);return this.currentPoint.copy(c),this},copy:function(t){return pYt.prototype.copy.call(this,t),this.currentPoint.copy(t.currentPoint),this},toJSON:function(){const t=pYt.prototype.toJSON.call(this);return t.currentPoint=this.currentPoint.toArray(),t},fromJSON:function(t){return pYt.prototype.fromJSON.call(this,t),this.currentPoint.fromArray(t.currentPoint),this}}),mYt.prototype=Object.assign(Object.create(fYt.prototype),{constructor:mYt,getPointsHoles:function(t){const e=[];for(let n=0,i=this.holes.length;n<i;n++)e[n]=this.holes[n].getPoints(t);return e},extractPoints:function(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}},copy:function(t){fYt.prototype.copy.call(this,t),this.holes=[];for(let e=0,n=t.holes.length;e<n;e++)this.holes.push(t.holes[e].clone());return this},toJSON:function(){const t=fYt.prototype.toJSON.call(this);t.uuid=this.uuid,t.holes=[];for(let e=0,n=this.holes.length;e<n;e++)t.holes.push(this.holes[e].toJSON());return t},fromJSON:function(t){fYt.prototype.fromJSON.call(this,t),this.uuid=t.uuid,this.holes=[];for(let e=0,n=t.holes.length;e<n;e++){const n=t.holes[e];this.holes.push((new fYt).fromJSON(n))}return this}}),gYt.prototype=Object.assign(Object.create(_Ft.prototype),{constructor:gYt,isLight:!0,copy:function(t){return _Ft.prototype.copy.call(this,t),this.color.copy(t.color),this.intensity=t.intensity,this},toJSON:function(t){const e=_Ft.prototype.toJSON.call(this,t);return e.object.color=this.color.getHex(),e.object.intensity=this.intensity,void 0!==this.groundColor&&(e.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(e.object.distance=this.distance),void 0!==this.angle&&(e.object.angle=this.angle),void 0!==this.decay&&(e.object.decay=this.decay),void 0!==this.penumbra&&(e.object.penumbra=this.penumbra),void 0!==this.shadow&&(e.object.shadow=this.shadow.toJSON()),e}}),_Yt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:_Yt,isHemisphereLight:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}),Object.assign(yYt.prototype,{_projScreenMatrix:new qHt,_lightPositionWorld:new yHt,_lookTarget:new yHt,getViewportCount:function(){return this._viewportCount},getFrustum:function(){return this._frustum},updateMatrices:function(t){const e=this.camera,n=this.matrix,i=this._projScreenMatrix,r=this._lookTarget,o=this._lightPositionWorld;o.setFromMatrixPosition(t.matrixWorld),e.position.copy(o),r.setFromMatrixPosition(t.target.matrixWorld),e.lookAt(r),e.updateMatrixWorld(),i.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(i),n.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),n.multiply(e.projectionMatrix),n.multiply(e.matrixWorldInverse)},getViewport:function(t){return this._viewports[t]},getFrameExtents:function(){return this._frameExtents},copy:function(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){const t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),512===this.mapSize.x&&512===this.mapSize.y||(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}}),vYt.prototype=Object.assign(Object.create(yYt.prototype),{constructor:vYt,isSpotLightShadow:!0,updateMatrices:function(t){const e=this.camera,n=2*sHt.RAD2DEG*t.angle*this.focus,i=this.mapSize.width/this.mapSize.height,r=t.distance||e.far;n===e.fov&&i===e.aspect&&r===e.far||(e.fov=n,e.aspect=i,e.far=r,e.updateProjectionMatrix()),yYt.prototype.updateMatrices.call(this,t)}}),bYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:bYt,isSpotLight:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}),xYt.prototype=Object.assign(Object.create(yYt.prototype),{constructor:xYt,isPointLightShadow:!0,updateMatrices:function(t,e=0){const n=this.camera,i=this.matrix,r=this._lightPositionWorld,o=this._lookTarget,a=this._projScreenMatrix;r.setFromMatrixPosition(t.matrixWorld),n.position.copy(r),o.copy(n.position),o.add(this._cubeDirections[e]),n.up.copy(this._cubeUps[e]),n.lookAt(o),n.updateMatrixWorld(),i.makeTranslation(-r.x,-r.y,-r.z),a.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(a)}}),wYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:wYt,isPointLight:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}),SYt.prototype=Object.assign(Object.create(BVt.prototype),{constructor:SYt,isOrthographicCamera:!0,copy:function(t,e){return BVt.prototype.copy.call(this,t,e),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this},setViewOffset:function(t,e,n,i,r,o){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=e,this.view.offsetX=n,this.view.offsetY=i,this.view.width=r,this.view.height=o,this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()},updateProjectionMatrix:function(){const t=(this.right-this.left)/(2*this.zoom),e=(this.top-this.bottom)/(2*this.zoom),n=(this.right+this.left)/2,i=(this.top+this.bottom)/2;let r=n-t,o=n+t,a=i+e,s=i-e;if(null!==this.view&&this.view.enabled){const t=(this.right-this.left)/this.view.fullWidth/this.zoom,e=(this.top-this.bottom)/this.view.fullHeight/this.zoom;r+=t*this.view.offsetX,o=r+t*this.view.width,a-=e*this.view.offsetY,s=a-e*this.view.height}this.projectionMatrix.makeOrthographic(r,o,a,s,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()},toJSON:function(t){const e=_Ft.prototype.toJSON.call(this,t);return e.object.zoom=this.zoom,e.object.left=this.left,e.object.right=this.right,e.object.top=this.top,e.object.bottom=this.bottom,e.object.near=this.near,e.object.far=this.far,null!==this.view&&(e.object.view=Object.assign({},this.view)),e}}),MYt.prototype=Object.assign(Object.create(yYt.prototype),{constructor:MYt,isDirectionalLightShadow:!0,updateMatrices:function(t){yYt.prototype.updateMatrices.call(this,t)}}),EYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:EYt,isDirectionalLight:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}),TYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:TYt,isAmbientLight:!0}),AYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:AYt,isRectAreaLight:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.width=t.width,this.height=t.height,this},toJSON:function(t){const e=gYt.prototype.toJSON.call(this,t);return e.object.width=this.width,e.object.height=this.height,e}});class CYt{constructor(){Object.defineProperty(this,"isSphericalHarmonics3",{value:!0}),this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new yHt)}set(t){for(let e=0;e<9;e++)this.coefficients[e].copy(t[e]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,e){const n=t.x,i=t.y,r=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.282095),e.addScaledVector(o[1],.488603*i),e.addScaledVector(o[2],.488603*r),e.addScaledVector(o[3],.488603*n),e.addScaledVector(o[4],n*i*1.092548),e.addScaledVector(o[5],i*r*1.092548),e.addScaledVector(o[6],.315392*(3*r*r-1)),e.addScaledVector(o[7],n*r*1.092548),e.addScaledVector(o[8],.546274*(n*n-i*i)),e}getIrradianceAt(t,e){const n=t.x,i=t.y,r=t.z,o=this.coefficients;return e.copy(o[0]).multiplyScalar(.886227),e.addScaledVector(o[1],1.023328*i),e.addScaledVector(o[2],1.023328*r),e.addScaledVector(o[3],1.023328*n),e.addScaledVector(o[4],.858086*n*i),e.addScaledVector(o[5],.858086*i*r),e.addScaledVector(o[6],.743125*r*r-.247708),e.addScaledVector(o[7],.858086*n*r),e.addScaledVector(o[8],.429043*(n*n-i*i)),e}add(t){for(let e=0;e<9;e++)this.coefficients[e].add(t.coefficients[e]);return this}addScaledSH(t,e){for(let n=0;n<9;n++)this.coefficients[n].addScaledVector(t.coefficients[n],e);return this}scale(t){for(let e=0;e<9;e++)this.coefficients[e].multiplyScalar(t);return this}lerp(t,e){for(let n=0;n<9;n++)this.coefficients[n].lerp(t.coefficients[n],e);return this}equals(t){for(let e=0;e<9;e++)if(!this.coefficients[e].equals(t.coefficients[e]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,e=0){const n=this.coefficients;for(let i=0;i<9;i++)n[i].fromArray(t,e+3*i);return this}toArray(t=[],e=0){const n=this.coefficients;for(let i=0;i<9;i++)n[i].toArray(t,e+3*i);return t}static getBasisAt(t,e){const n=t.x,i=t.y,r=t.z;e[0]=.282095,e[1]=.488603*i,e[2]=.488603*r,e[3]=.488603*n,e[4]=1.092548*n*i,e[5]=1.092548*i*r,e[6]=.315392*(3*r*r-1),e[7]=1.092548*n*r,e[8]=.546274*(n*n-i*i)}}function kYt(t,e){gYt.call(this,void 0,e),this.type="LightProbe",this.sh=void 0!==t?t:new CYt}function LYt(t){Bqt.call(this,t),this.textures={}}kYt.prototype=Object.assign(Object.create(gYt.prototype),{constructor:kYt,isLightProbe:!0,copy:function(t){return gYt.prototype.copy.call(this,t),this.sh.copy(t.sh),this},fromJSON:function(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this},toJSON:function(t){const e=gYt.prototype.toJSON.call(this,t);return e.object.sh=this.sh.toArray(),e}}),LYt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:LYt,load:function(t,e,n,i){const r=this,o=new Fqt(r.manager);o.setPath(r.path),o.setRequestHeader(r.requestHeader),o.setWithCredentials(r.withCredentials),o.load(t,(function(n){try{e(r.parse(JSON.parse(n)))}catch(e){i?i(e):console.error(e),r.manager.itemError(t)}}),n,i)},parse:function(t){const e=this.textures;function n(t){return void 0===e[t]&&console.warn("THREE.MaterialLoader: Undefined texture",t),e[t]}const i=new vqt[t.type];if(void 0!==t.uuid&&(i.uuid=t.uuid),void 0!==t.name&&(i.name=t.name),void 0!==t.color&&void 0!==i.color&&i.color.setHex(t.color),void 0!==t.roughness&&(i.roughness=t.roughness),void 0!==t.metalness&&(i.metalness=t.metalness),void 0!==t.sheen&&(i.sheen=(new HFt).setHex(t.sheen)),void 0!==t.emissive&&void 0!==i.emissive&&i.emissive.setHex(t.emissive),void 0!==t.specular&&void 0!==i.specular&&i.specular.setHex(t.specular),void 0!==t.shininess&&(i.shininess=t.shininess),void 0!==t.clearcoat&&(i.clearcoat=t.clearcoat),void 0!==t.clearcoatRoughness&&(i.clearcoatRoughness=t.clearcoatRoughness),void 0!==t.fog&&(i.fog=t.fog),void 0!==t.flatShading&&(i.flatShading=t.flatShading),void 0!==t.blending&&(i.blending=t.blending),void 0!==t.combine&&(i.combine=t.combine),void 0!==t.side&&(i.side=t.side),void 0!==t.opacity&&(i.opacity=t.opacity),void 0!==t.transparent&&(i.transparent=t.transparent),void 0!==t.alphaTest&&(i.alphaTest=t.alphaTest),void 0!==t.depthTest&&(i.depthTest=t.depthTest),void 0!==t.depthWrite&&(i.depthWrite=t.depthWrite),void 0!==t.colorWrite&&(i.colorWrite=t.colorWrite),void 0!==t.stencilWrite&&(i.stencilWrite=t.stencilWrite),void 0!==t.stencilWriteMask&&(i.stencilWriteMask=t.stencilWriteMask),void 0!==t.stencilFunc&&(i.stencilFunc=t.stencilFunc),void 0!==t.stencilRef&&(i.stencilRef=t.stencilRef),void 0!==t.stencilFuncMask&&(i.stencilFuncMask=t.stencilFuncMask),void 0!==t.stencilFail&&(i.stencilFail=t.stencilFail),void 0!==t.stencilZFail&&(i.stencilZFail=t.stencilZFail),void 0!==t.stencilZPass&&(i.stencilZPass=t.stencilZPass),void 0!==t.wireframe&&(i.wireframe=t.wireframe),void 0!==t.wireframeLinewidth&&(i.wireframeLinewidth=t.wireframeLinewidth),void 0!==t.wireframeLinecap&&(i.wireframeLinecap=t.wireframeLinecap),void 0!==t.wireframeLinejoin&&(i.wireframeLinejoin=t.wireframeLinejoin),void 0!==t.rotation&&(i.rotation=t.rotation),1!==t.linewidth&&(i.linewidth=t.linewidth),void 0!==t.dashSize&&(i.dashSize=t.dashSize),void 0!==t.gapSize&&(i.gapSize=t.gapSize),void 0!==t.scale&&(i.scale=t.scale),void 0!==t.polygonOffset&&(i.polygonOffset=t.polygonOffset),void 0!==t.polygonOffsetFactor&&(i.polygonOffsetFactor=t.polygonOffsetFactor),void 0!==t.polygonOffsetUnits&&(i.polygonOffsetUnits=t.polygonOffsetUnits),void 0!==t.skinning&&(i.skinning=t.skinning),void 0!==t.morphTargets&&(i.morphTargets=t.morphTargets),void 0!==t.morphNormals&&(i.morphNormals=t.morphNormals),void 0!==t.dithering&&(i.dithering=t.dithering),void 0!==t.vertexTangents&&(i.vertexTangents=t.vertexTangents),void 0!==t.visible&&(i.visible=t.visible),void 0!==t.toneMapped&&(i.toneMapped=t.toneMapped),void 0!==t.userData&&(i.userData=t.userData),void 0!==t.vertexColors&&(i.vertexColors="number"==typeof t.vertexColors?t.vertexColors>0:t.vertexColors),void 0!==t.uniforms)for(const e in t.uniforms){const r=t.uniforms[e];switch(i.uniforms[e]={},r.type){case"t":i.uniforms[e].value=n(r.value);break;case"c":i.uniforms[e].value=(new HFt).setHex(r.value);break;case"v2":i.uniforms[e].value=(new lHt).fromArray(r.value);break;case"v3":i.uniforms[e].value=(new yHt).fromArray(r.value);break;case"v4":i.uniforms[e].value=(new mHt).fromArray(r.value);break;case"m3":i.uniforms[e].value=(new cHt).fromArray(r.value);break;case"m4":i.uniforms[e].value=(new qHt).fromArray(r.value);break;default:i.uniforms[e].value=r.value}}if(void 0!==t.defines&&(i.defines=t.defines),void 0!==t.vertexShader&&(i.vertexShader=t.vertexShader),void 0!==t.fragmentShader&&(i.fragmentShader=t.fragmentShader),void 0!==t.extensions)for(const e in t.extensions)i.extensions[e]=t.extensions[e];if(void 0!==t.shading&&(i.flatShading=1===t.shading),void 0!==t.size&&(i.size=t.size),void 0!==t.sizeAttenuation&&(i.sizeAttenuation=t.sizeAttenuation),void 0!==t.map&&(i.map=n(t.map)),void 0!==t.matcap&&(i.matcap=n(t.matcap)),void 0!==t.alphaMap&&(i.alphaMap=n(t.alphaMap)),void 0!==t.bumpMap&&(i.bumpMap=n(t.bumpMap)),void 0!==t.bumpScale&&(i.bumpScale=t.bumpScale),void 0!==t.normalMap&&(i.normalMap=n(t.normalMap)),void 0!==t.normalMapType&&(i.normalMapType=t.normalMapType),void 0!==t.normalScale){let e=t.normalScale;!1===Array.isArray(e)&&(e=[e,e]),i.normalScale=(new lHt).fromArray(e)}return void 0!==t.displacementMap&&(i.displacementMap=n(t.displacementMap)),void 0!==t.displacementScale&&(i.displacementScale=t.displacementScale),void 0!==t.displacementBias&&(i.displacementBias=t.displacementBias),void 0!==t.roughnessMap&&(i.roughnessMap=n(t.roughnessMap)),void 0!==t.metalnessMap&&(i.metalnessMap=n(t.metalnessMap)),void 0!==t.emissiveMap&&(i.emissiveMap=n(t.emissiveMap)),void 0!==t.emissiveIntensity&&(i.emissiveIntensity=t.emissiveIntensity),void 0!==t.specularMap&&(i.specularMap=n(t.specularMap)),void 0!==t.envMap&&(i.envMap=n(t.envMap)),void 0!==t.envMapIntensity&&(i.envMapIntensity=t.envMapIntensity),void 0!==t.reflectivity&&(i.reflectivity=t.reflectivity),void 0!==t.refractionRatio&&(i.refractionRatio=t.refractionRatio),void 0!==t.lightMap&&(i.lightMap=n(t.lightMap)),void 0!==t.lightMapIntensity&&(i.lightMapIntensity=t.lightMapIntensity),void 0!==t.aoMap&&(i.aoMap=n(t.aoMap)),void 0!==t.aoMapIntensity&&(i.aoMapIntensity=t.aoMapIntensity),void 0!==t.gradientMap&&(i.gradientMap=n(t.gradientMap)),void 0!==t.clearcoatMap&&(i.clearcoatMap=n(t.clearcoatMap)),void 0!==t.clearcoatRoughnessMap&&(i.clearcoatRoughnessMap=n(t.clearcoatRoughnessMap)),void 0!==t.clearcoatNormalMap&&(i.clearcoatNormalMap=n(t.clearcoatNormalMap)),void 0!==t.clearcoatNormalScale&&(i.clearcoatNormalScale=(new lHt).fromArray(t.clearcoatNormalScale)),void 0!==t.transmission&&(i.transmission=t.transmission),void 0!==t.transmissionMap&&(i.transmissionMap=n(t.transmissionMap)),i},setTextures:function(t){return this.textures=t,this}});const PYt={decodeText:function(t){if("undefined"!=typeof TextDecoder)return(new TextDecoder).decode(t);let e="";for(let n=0,i=t.length;n<i;n++)e+=String.fromCharCode(t[n]);try{return decodeURIComponent(escape(e))}catch(t){return e}},extractUrlBase:function(t){const e=t.lastIndexOf("/");return-1===e?"./":t.substr(0,e+1)}};function IYt(){pVt.call(this),this.type="InstancedBufferGeometry",this.instanceCount=1/0}function NYt(t,e,n,i){"number"==typeof n&&(i=n,n=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),qFt.call(this,t,e,n),this.meshPerAttribute=i||1}function OYt(t){Bqt.call(this,t)}IYt.prototype=Object.assign(Object.create(pVt.prototype),{constructor:IYt,isInstancedBufferGeometry:!0,copy:function(t){return pVt.prototype.copy.call(this,t),this.instanceCount=t.instanceCount,this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){const t=pVt.prototype.toJSON.call(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}),NYt.prototype=Object.assign(Object.create(qFt.prototype),{constructor:NYt,isInstancedBufferAttribute:!0,copy:function(t){return qFt.prototype.copy.call(this,t),this.meshPerAttribute=t.meshPerAttribute,this},toJSON:function(){const t=qFt.prototype.toJSON.call(this);return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}}),OYt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:OYt,load:function(t,e,n,i){const r=this,o=new Fqt(r.manager);o.setPath(r.path),o.setRequestHeader(r.requestHeader),o.setWithCredentials(r.withCredentials),o.load(t,(function(n){try{e(r.parse(JSON.parse(n)))}catch(e){i?i(e):console.error(e),r.manager.itemError(t)}}),n,i)},parse:function(t){const e={},n={};function i(t,i){if(void 0!==e[i])return e[i];const r=t.interleavedBuffers[i],o=(function a(t,e){if(void 0!==n[e])return n[e];const i=new Uint32Array(t.arrayBuffers[e]).buffer;return n[e]=i,i})(t,r.buffer),s=new oGt(oVt(r.type,o),r.stride);return s.uuid=r.uuid,e[i]=s,s}const r=t.isInstancedBufferGeometry?new IYt:new pVt,o=t.data.index;if(void 0!==o){const t=oVt(o.type,o.array);r.setIndex(new qFt(t,1))}const a=t.data.attributes;for(const e in a){const n=a[e];let o;if(n.isInterleavedBufferAttribute)o=new sGt(i(t.data,n.data),n.itemSize,n.offset,n.normalized);else{const t=oVt(n.type,n.array);o=new(n.isInstancedBufferAttribute?NYt:qFt)(t,n.itemSize,n.normalized)}void 0!==n.name&&(o.name=n.name),r.setAttribute(e,o)}const s=t.data.morphAttributes;if(s)for(const e in s){const n=s[e],o=[];for(let e=0,r=n.length;e<r;e++){const r=n[e];let a;a=r.isInterleavedBufferAttribute?new sGt(i(t.data,r.data),r.itemSize,r.offset,r.normalized):new qFt(oVt(r.type,r.array),r.itemSize,r.normalized),void 0!==r.name&&(a.name=r.name),o.push(a)}r.morphAttributes[e]=o}t.data.morphTargetsRelative&&(r.morphTargetsRelative=!0);const l=t.data.groups||t.data.drawcalls||t.data.offsets;if(void 0!==l)for(let t=0,e=l.length;t!==e;++t){const e=l[t];r.addGroup(e.start,e.count,e.materialIndex)}const c=t.data.boundingSphere;if(void 0!==c){const t=new yHt;void 0!==c.center&&t.fromArray(c.center),r.boundingSphere=new DHt(t,c.radius)}return t.name&&(r.name=t.name),t.userData&&(r.userData=t.userData),r}});const RYt={UVMapping:iBt,CubeReflectionMapping:rBt,CubeRefractionMapping:oBt,EquirectangularReflectionMapping:aBt,EquirectangularRefractionMapping:sBt,CubeUVReflectionMapping:lBt,CubeUVRefractionMapping:cBt},zYt={RepeatWrapping:uBt,ClampToEdgeWrapping:hBt,MirroredRepeatWrapping:dBt},DYt={NearestFilter:pBt,NearestMipmapNearestFilter:fBt,NearestMipmapLinearFilter:mBt,LinearFilter:gBt,LinearMipmapNearestFilter:_Bt,LinearMipmapLinearFilter:yBt};function BYt(t){"undefined"==typeof createImageBitmap&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),"undefined"==typeof fetch&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),Bqt.call(this,t),this.options={premultiplyAlpha:"none"}}function HYt(){this.type="ShapePath",this.color=new HFt,this.subPaths=[],this.currentPath=null}BYt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:BYt,isImageBitmapLoader:!0,setOptions:function t(e){return this.options=e,this},load:function(t,e,n,i){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const r=this,o=Rqt.get(t);if(void 0!==o)return r.manager.itemStart(t),setTimeout((function(){e&&e(o),r.manager.itemEnd(t)}),0),o;const a={};a.credentials="anonymous"===this.crossOrigin?"same-origin":"include",fetch(t,a).then((function(t){return t.blob()})).then((function(t){return createImageBitmap(t,r.options)})).then((function(n){Rqt.add(t,n),e&&e(n),r.manager.itemEnd(t)})).catch((function(e){i&&i(e),r.manager.itemError(t),r.manager.itemEnd(t)})),r.manager.itemStart(t)}}),Object.assign(HYt.prototype,{moveTo:function(t,e){return this.currentPath=new fYt,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,e),this},lineTo:function(t,e){return this.currentPath.lineTo(t,e),this},quadraticCurveTo:function(t,e,n,i){return this.currentPath.quadraticCurveTo(t,e,n,i),this},bezierCurveTo:function(t,e,n,i,r,o){return this.currentPath.bezierCurveTo(t,e,n,i,r,o),this},splineThru:function(t){return this.currentPath.splineThru(t),this},toShapes:function(t,e){function n(t){const e=[];for(let n=0,i=t.length;n<i;n++){const i=t[n],r=new mYt;r.curves=i.curves,e.push(r)}return e}function i(t,e){const n=e.length;let i=!1;for(let r=n-1,o=0;o<n;r=o++){let n=e[r],a=e[o],s=a.x-n.x,l=a.y-n.y;if(Math.abs(l)>Number.EPSILON){if(l<0&&(n=e[o],s=-s,a=e[r],l=-l),t.y<n.y||t.y>a.y)continue;if(t.y===n.y){if(t.x===n.x)return!0}else{const e=l*(t.x-n.x)-s*(t.y-n.y);if(0===e)return!0;if(e<0)continue;i=!i}}else{if(t.y!==n.y)continue;if(a.x<=t.x&&t.x<=n.x||n.x<=t.x&&t.x<=a.x)return!0}}return i}const r=GWt.isClockWise,o=this.subPaths;if(0===o.length)return[];if(!0===e)return n(o);let a,s,l;const c=[];if(1===o.length)return s=o[0],l=new mYt,l.curves=s.curves,c.push(l),c;let u=!r(o[0].getPoints());u=t?!u:u;const h=[],d=[];let p,f,m=[],g=0;d[g]=void 0,m[g]=[];for(let e=0,n=o.length;e<n;e++)s=o[e],p=s.getPoints(),a=r(p),a=t?!a:a,a?(!u&&d[g]&&g++,d[g]={s:new mYt,p:p},d[g].s.curves=s.curves,u&&g++,m[g]=[]):m[g].push({h:s,p:p[0]});if(!d[0])return n(o);if(d.length>1){let t=!1;const e=[];for(let t=0,e=d.length;t<e;t++)h[t]=[];for(let n=0,r=d.length;n<r;n++){const r=m[n];for(let o=0;o<r.length;o++){const a=r[o];let s=!0;for(let r=0;r<d.length;r++)i(a.p,d[r].p)&&(n!==r&&e.push({froms:n,tos:r,hole:o}),s?(s=!1,h[r].push(a)):t=!0);s&&h[n].push(a)}}e.length>0&&(t||(m=h))}for(let t=0,e=d.length;t<e;t++){l=d[t].s,c.push(l),f=m[t];for(let t=0,e=f.length;t<e;t++)l.holes.push(f[t].h)}return c}});class FYt{constructor(t){Object.defineProperty(this,"isFont",{value:!0}),this.type="Font",this.data=t}generateShapes(t,e=100){const n=[],i=(function r(t,e,n){const i=Array.from?Array.from(t):String(t).split(""),r=e/n.resolution,o=(n.boundingBox.yMax-n.boundingBox.yMin+n.underlineThickness)*r,a=[];let s=0,l=0;for(let t=0;t<i.length;t++){const e=i[t];if("\n"===e)s=0,l-=o;else{const t=VYt(e,r,s,l,n);s+=t.offsetX,a.push(t.path)}}return a})(t,e,this.data);for(let t=0,e=i.length;t<e;t++)Array.prototype.push.apply(n,i[t].toShapes());return n}}function VYt(t,e,n,i,r){const o=r.glyphs[t]||r.glyphs["?"];if(!o)return void console.error('THREE.Font: character "'+t+'" does not exists in font family '+r.familyName+".");const a=new HYt;let s,l,c,u,h,d,p,f;if(o.o){const t=o._cachedOutline||(o._cachedOutline=o.o.split(" "));for(let r=0,o=t.length;r<o;)switch(t[r++]){case"m":s=t[r++]*e+n,l=t[r++]*e+i,a.moveTo(s,l);break;case"l":s=t[r++]*e+n,l=t[r++]*e+i,a.lineTo(s,l);break;case"q":c=t[r++]*e+n,u=t[r++]*e+i,h=t[r++]*e+n,d=t[r++]*e+i,a.quadraticCurveTo(h,d,c,u);break;case"b":c=t[r++]*e+n,u=t[r++]*e+i,h=t[r++]*e+n,d=t[r++]*e+i,p=t[r++]*e+n,f=t[r++]*e+i,a.bezierCurveTo(h,d,p,f,c,u)}}return{offsetX:o.ha*e,path:a}}function jYt(t){Bqt.call(this,t)}let UYt;jYt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:jYt,load:function(t,e,n,i){const r=this,o=new Fqt(this.manager);o.setPath(this.path),o.setRequestHeader(this.requestHeader),o.setWithCredentials(r.withCredentials),o.load(t,(function(t){let n;try{n=JSON.parse(t)}catch(e){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),n=JSON.parse(t.substring(65,t.length-2))}const i=r.parse(n);e&&e(i)}),n,i)},parse:function(t){return new FYt(t)}});const GYt={getContext:function(){return void 0===UYt&&(UYt=new(window.AudioContext||window.webkitAudioContext)),UYt},setContext:function(t){UYt=t}};function WYt(t){Bqt.call(this,t)}function qYt(t,e,n){kYt.call(this,void 0,n);const i=(new HFt).set(t),r=(new HFt).set(e),o=new yHt(i.r,i.g,i.b),a=new yHt(r.r,r.g,r.b),s=Math.sqrt(Math.PI),l=s*Math.sqrt(.75);this.sh.coefficients[0].copy(o).add(a).multiplyScalar(s),this.sh.coefficients[1].copy(o).sub(a).multiplyScalar(l)}function YYt(t,e){kYt.call(this,void 0,e);const n=(new HFt).set(t);this.sh.coefficients[0].set(n.r,n.g,n.b).multiplyScalar(2*Math.sqrt(Math.PI))}WYt.prototype=Object.assign(Object.create(Bqt.prototype),{constructor:WYt,load:function(t,e,n,i){const r=this,o=new Fqt(r.manager);o.setResponseType("arraybuffer"),o.setPath(r.path),o.setRequestHeader(r.requestHeader),o.setWithCredentials(r.withCredentials),o.load(t,(function(n){try{const t=n.slice(0);GYt.getContext().decodeAudioData(t,(function(t){e(t)}))}catch(e){i?i(e):console.error(e),r.manager.itemError(t)}}),n,i)}}),qYt.prototype=Object.assign(Object.create(kYt.prototype),{constructor:qYt,isHemisphereLightProbe:!0,copy:function(t){return kYt.prototype.copy.call(this,t),this},toJSON:function(t){return kYt.prototype.toJSON.call(this,t)}}),YYt.prototype=Object.assign(Object.create(kYt.prototype),{constructor:YYt,isAmbientLightProbe:!0,copy:function(t){return kYt.prototype.copy.call(this,t),this},toJSON:function(t){return kYt.prototype.toJSON.call(this,t)}});const XYt=new qHt,$Yt=new qHt;function KYt(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new HVt,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new HVt,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}Object.assign(KYt.prototype,{update:function(t){const e=this._cache;if(e.focus!==t.focus||e.fov!==t.fov||e.aspect!==t.aspect*this.aspect||e.near!==t.near||e.far!==t.far||e.zoom!==t.zoom||e.eyeSep!==this.eyeSep){e.focus=t.focus,e.fov=t.fov,e.aspect=t.aspect*this.aspect,e.near=t.near,e.far=t.far,e.zoom=t.zoom,e.eyeSep=this.eyeSep;const n=t.projectionMatrix.clone(),i=e.eyeSep/2,r=i*e.near/e.focus,o=e.near*Math.tan(sHt.DEG2RAD*e.fov*.5)/e.zoom;let a,s;$Yt.elements[12]=-i,XYt.elements[12]=i,a=-o*e.aspect+r,s=o*e.aspect+r,n.elements[0]=2*e.near/(s-a),n.elements[8]=(s+a)/(s-a),this.cameraL.projectionMatrix.copy(n),a=-o*e.aspect-r,s=o*e.aspect-r,n.elements[0]=2*e.near/(s-a),n.elements[8]=(s+a)/(s-a),this.cameraR.projectionMatrix.copy(n)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply($Yt),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(XYt)}});class ZYt{constructor(t){this.autoStart=void 0===t||t,this.startTime=0,this.oldTime=0,this.elapsedTime=0,this.running=!1}start(){this.startTime=JYt(),this.oldTime=this.startTime,this.elapsedTime=0,this.running=!0}stop(){this.getElapsedTime(),this.running=!1,this.autoStart=!1}getElapsedTime(){return this.getDelta(),this.elapsedTime}getDelta(){let t=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){const e=JYt();t=(e-this.oldTime)/1e3,this.oldTime=e,this.elapsedTime+=t}return t}}function JYt(){return("undefined"==typeof performance?Date:performance).now()}const QYt=new yHt,tXt=new _Ht,eXt=new yHt,nXt=new yHt;class iXt extends _Ft{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;const e=this.context.createBufferSource();return e.buffer=this.buffer,e.loop=this.loop,e.loopStart=this.loopStart,e.loopEnd=this.loopEnd,e.onended=this.onEnded.bind(this),e.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=e,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,e=this.filters.length;t<e;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}const rXt=new yHt,oXt=new _Ht,aXt=new yHt,sXt=new yHt;class lXt{constructor(t,e=2048){this.analyser=t.context.createAnalyser(),this.analyser.fftSize=e,this.data=new Uint8Array(this.analyser.frequencyBinCount),t.getOutput().connect(this.analyser)}getFrequencyData(){return this.analyser.getByteFrequencyData(this.data),this.data}getAverageFrequency(){let t=0;const e=this.getFrequencyData();for(let n=0;n<e.length;n++)t+=e[n];return t/e.length}}function cXt(t,e,n){let i,r,o;switch(this.binding=t,this.valueSize=n,e){case"quaternion":i=this._slerp,r=this._slerpAdditive,o=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*n),this._workIndex=5;break;case"string":case"bool":i=this._select,r=this._select,o=this._setAdditiveIdentityOther,this.buffer=new Array(5*n);break;default:i=this._lerp,r=this._lerpAdditive,o=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*n)}this._mixBufferRegion=i,this._mixBufferRegionAdditive=r,this._setIdentity=o,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}Object.assign(cXt.prototype,{accumulate:function(t,e){const n=this.buffer,i=this.valueSize,r=t*i+i;let o=this.cumulativeWeight;if(0===o){for(let t=0;t!==i;++t)n[r+t]=n[t];o=e}else o+=e,this._mixBufferRegion(n,r,0,e/o,i);this.cumulativeWeight=o},accumulateAdditive:function(t){const e=this.buffer,n=this.valueSize,i=n*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(e,i,0,t,n),this.cumulativeWeightAdditive+=t},apply:function(t){const e=this.valueSize,n=this.buffer,i=t*e+e,r=this.cumulativeWeight,o=this.cumulativeWeightAdditive,a=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,r<1&&this._mixBufferRegion(n,i,e*this._origIndex,1-r,e),o>0&&this._mixBufferRegionAdditive(n,i,this._addIndex*e,1,e);for(let t=e,r=e+e;t!==r;++t)if(n[t]!==n[t+e]){a.setValue(n,i);break}},saveOriginalState:function(){const t=this.buffer,e=this.valueSize,n=e*this._origIndex;this.binding.getValue(t,n);for(let i=e,r=n;i!==r;++i)t[i]=t[n+i%e];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0},restoreOriginalState:function(){this.binding.setValue(this.buffer,3*this.valueSize)},_setAdditiveIdentityNumeric:function(){const t=this._addIndex*this.valueSize,e=t+this.valueSize;for(let n=t;n<e;n++)this.buffer[n]=0},_setAdditiveIdentityQuaternion:function(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1},_setAdditiveIdentityOther:function(){const t=this._origIndex*this.valueSize,e=this._addIndex*this.valueSize;for(let n=0;n<this.valueSize;n++)this.buffer[e+n]=this.buffer[t+n]},_select:function(t,e,n,i,r){if(i>=.5)for(let i=0;i!==r;++i)t[e+i]=t[n+i]},_slerp:function(t,e,n,i){_Ht.slerpFlat(t,e,t,e,t,n,i)},_slerpAdditive:function(t,e,n,i,r){const o=this._workIndex*r;_Ht.multiplyQuaternionsFlat(t,o,t,e,t,n),_Ht.slerpFlat(t,e,t,e,t,o,i)},_lerp:function(t,e,n,i,r){const o=1-i;for(let a=0;a!==r;++a){const r=e+a;t[r]=t[r]*o+t[n+a]*i}},_lerpAdditive:function(t,e,n,i,r){for(let o=0;o!==r;++o){const r=e+o;t[r]=t[r]+t[n+o]*i}}});const uXt=new RegExp("[\\[\\]\\.:\\/]","g"),hXt="[^\\[\\]\\.:\\/]",dXt="[^"+"\\[\\]\\.:\\/".replace("\\.","")+"]",pXt=/((?:WC+[\/:])*)/.source.replace("WC",hXt),fXt=/(WCOD+)?/.source.replace("WCOD",dXt),mXt=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",hXt),gXt=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",hXt),_Xt=new RegExp("^"+pXt+fXt+mXt+gXt+"$"),yXt=["material","materials","bones"];function vXt(t,e,n){const i=n||bXt.parseTrackName(e);this._targetGroup=t,this._bindings=t.subscribe_(e,i)}function bXt(t,e,n){this.path=e,this.parsedPath=n||bXt.parseTrackName(e),this.node=bXt.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t}function xXt(){this.uuid=sHt.generateUUID(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;const t={};this._indicesByUUID=t;for(let e=0,n=arguments.length;e!==n;++e)t[arguments[e].uuid]=e;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};const e=this;this.stats={objects:{get total(){return e._objects.length},get inUse(){return this.total-e.nCachedObjects_}},get bindingsPerObject(){return e._bindings.length}}}Object.assign(vXt.prototype,{getValue:function(t,e){this.bind();const n=this._bindings[this._targetGroup.nCachedObjects_];void 0!==n&&n.getValue(t,e)},setValue:function(t,e){const n=this._bindings;for(let i=this._targetGroup.nCachedObjects_,r=n.length;i!==r;++i)n[i].setValue(t,e)},bind:function(){const t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,n=t.length;e!==n;++e)t[e].bind()},unbind:function(){const t=this._bindings;for(let e=this._targetGroup.nCachedObjects_,n=t.length;e!==n;++e)t[e].unbind()}}),Object.assign(bXt,{Composite:vXt,create:function(t,e,n){return t&&t.isAnimationObjectGroup?new bXt.Composite(t,e,n):new bXt(t,e,n)},sanitizeNodeName:function(t){return t.replace(/\s/g,"_").replace(uXt,"")},parseTrackName:function(t){const e=_Xt.exec(t);if(!e)throw new Error("PropertyBinding: Cannot parse trackName: "+t);const n={nodeName:e[2],objectName:e[3],objectIndex:e[4],propertyName:e[5],propertyIndex:e[6]},i=n.nodeName&&n.nodeName.lastIndexOf(".");if(void 0!==i&&-1!==i){const t=n.nodeName.substring(i+1);-1!==yXt.indexOf(t)&&(n.nodeName=n.nodeName.substring(0,i),n.objectName=t)}if(null===n.propertyName||0===n.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return n},findNode:function(t,e){if(!e||""===e||"."===e||-1===e||e===t.name||e===t.uuid)return t;if(t.skeleton){const n=t.skeleton.getBoneByName(e);if(void 0!==n)return n}if(t.children){const n=function(t){for(let i=0;i<t.length;i++){const r=t[i];if(r.name===e||r.uuid===e)return r;const o=n(r.children);if(o)return o}return null},i=n(t.children);if(i)return i}return null}}),Object.assign(bXt.prototype,{_getValue_unavailable:function(){},_setValue_unavailable:function(){},BindingType:{Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Versioning:{None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},GetterByBindingType:[function t(e,n){e[n]=this.node[this.propertyName]},function t(e,n){const i=this.resolvedProperty;for(let t=0,r=i.length;t!==r;++t)e[n++]=i[t]},function t(e,n){e[n]=this.resolvedProperty[this.propertyIndex]},function t(e,n){this.resolvedProperty.toArray(e,n)}],SetterByBindingTypeAndVersioning:[[function t(e,n){this.targetObject[this.propertyName]=e[n]},function t(e,n){this.targetObject[this.propertyName]=e[n],this.targetObject.needsUpdate=!0},function t(e,n){this.targetObject[this.propertyName]=e[n],this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(e,n){const i=this.resolvedProperty;for(let t=0,r=i.length;t!==r;++t)i[t]=e[n++]},function t(e,n){const i=this.resolvedProperty;for(let t=0,r=i.length;t!==r;++t)i[t]=e[n++];this.targetObject.needsUpdate=!0},function t(e,n){const i=this.resolvedProperty;for(let t=0,r=i.length;t!==r;++t)i[t]=e[n++];this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(e,n){this.resolvedProperty[this.propertyIndex]=e[n]},function t(e,n){this.resolvedProperty[this.propertyIndex]=e[n],this.targetObject.needsUpdate=!0},function t(e,n){this.resolvedProperty[this.propertyIndex]=e[n],this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(e,n){this.resolvedProperty.fromArray(e,n)},function t(e,n){this.resolvedProperty.fromArray(e,n),this.targetObject.needsUpdate=!0},function t(e,n){this.resolvedProperty.fromArray(e,n),this.targetObject.matrixWorldNeedsUpdate=!0}]],getValue:function t(e,n){this.bind(),this.getValue(e,n)},setValue:function t(e,n){this.bind(),this.setValue(e,n)},bind:function(){let t=this.node;const e=this.parsedPath,n=e.objectName,i=e.propertyName;let r=e.propertyIndex;if(t||(t=bXt.findNode(this.rootNode,e.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(n){let i=e.objectIndex;switch(n){case"materials":if(!t.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!t.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);t=t.material.materials;break;case"bones":if(!t.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);t=t.skeleton.bones;for(let e=0;e<t.length;e++)if(t[e].name===i){i=e;break}break;default:if(void 0===t[n])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);t=t[n]}if(void 0!==i){if(void 0===t[i])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);t=t[i]}}const o=t[i];if(void 0===o)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+e.nodeName+"."+i+" but it wasn't found.",t);let a=this.Versioning.None;this.targetObject=t,void 0!==t.needsUpdate?a=this.Versioning.NeedsUpdate:void 0!==t.matrixWorldNeedsUpdate&&(a=this.Versioning.MatrixWorldNeedsUpdate);let s=this.BindingType.Direct;if(void 0!==r){if("morphTargetInfluences"===i){if(!t.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!t.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!t.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==t.morphTargetDictionary[r]&&(r=t.morphTargetDictionary[r])}s=this.BindingType.ArrayElement,this.resolvedProperty=o,this.propertyIndex=r}else void 0!==o.fromArray&&void 0!==o.toArray?(s=this.BindingType.HasFromToArray,this.resolvedProperty=o):Array.isArray(o)?(s=this.BindingType.EntireArray,this.resolvedProperty=o):this.propertyName=i;this.getValue=this.GetterByBindingType[s],this.setValue=this.SetterByBindingTypeAndVersioning[s][a]},unbind:function(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}),Object.assign(bXt.prototype,{_getValue_unbound:bXt.prototype.getValue,_setValue_unbound:bXt.prototype.setValue}),Object.assign(xXt.prototype,{isAnimationObjectGroup:!0,add:function(){const t=this._objects,e=this._indicesByUUID,n=this._paths,i=this._parsedPaths,r=this._bindings,o=r.length;let a,s=t.length,l=this.nCachedObjects_;for(let c=0,u=arguments.length;c!==u;++c){const u=arguments[c],h=u.uuid;let d=e[h];if(void 0===d){d=s++,e[h]=d,t.push(u);for(let t=0,e=o;t!==e;++t)r[t].push(new bXt(u,n[t],i[t]))}else if(d<l){a=t[d];const s=--l,c=t[s];e[c.uuid]=d,t[d]=c,e[h]=s,t[s]=u;for(let t=0,e=o;t!==e;++t){const e=r[t];let o=e[d];e[d]=e[s],void 0===o&&(o=new bXt(u,n[t],i[t])),e[s]=o}}else t[d]!==a&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=l},remove:function(){const t=this._objects,e=this._indicesByUUID,n=this._bindings,i=n.length;let r=this.nCachedObjects_;for(let o=0,a=arguments.length;o!==a;++o){const a=arguments[o],s=a.uuid,l=e[s];if(void 0!==l&&l>=r){const o=r++,c=t[o];e[c.uuid]=l,t[l]=c,e[s]=o,t[o]=a;for(let t=0,e=i;t!==e;++t){const e=n[t],i=e[l];e[l]=e[o],e[o]=i}}}this.nCachedObjects_=r},uncache:function(){const t=this._objects,e=this._indicesByUUID,n=this._bindings,i=n.length;let r=this.nCachedObjects_,o=t.length;for(let a=0,s=arguments.length;a!==s;++a){const s=arguments[a].uuid,l=e[s];if(void 0!==l)if(delete e[s],l<r){const a=--r,s=t[a],c=--o,u=t[c];e[s.uuid]=l,t[l]=s,e[u.uuid]=a,t[a]=u,t.pop();for(let t=0,e=i;t!==e;++t){const e=n[t],i=e[c];e[l]=e[a],e[a]=i,e.pop()}}else{const r=--o,a=t[r];r>0&&(e[a.uuid]=l),t[l]=a,t.pop();for(let t=0,e=i;t!==e;++t){const e=n[t];e[l]=e[r],e.pop()}}}this.nCachedObjects_=r},subscribe_:function(t,e){const n=this._bindingsIndicesByPath;let i=n[t];const r=this._bindings;if(void 0!==i)return r[i];const o=this._paths,a=this._parsedPaths,s=this._objects,l=this.nCachedObjects_,c=new Array(s.length);i=r.length,n[t]=i,o.push(t),a.push(e),r.push(c);for(let n=l,i=s.length;n!==i;++n)c[n]=new bXt(s[n],t,e);return c},unsubscribe_:function(t){const e=this._bindingsIndicesByPath,n=e[t];if(void 0!==n){const i=this._paths,r=this._parsedPaths,o=this._bindings,a=o.length-1,s=o[a];e[t[a]]=n,o[n]=s,o.pop(),r[n]=r[a],r.pop(),i[n]=i[a],i.pop()}}});class wXt{constructor(t,e,n=null,i=e.blendMode){this._mixer=t,this._clip=e,this._localRoot=n,this.blendMode=i;const r=e.tracks,o=r.length,a=new Array(o),s={endingStart:jBt,endingEnd:jBt};for(let t=0;t!==o;++t){const e=r[t].createInterpolant(null);a[t]=e,e.settings=s}this._interpolantSettings=s,this._interpolants=a,this._propertyBindings=new Array(o),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,e){return this.loop=t,this.repetitions=e,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,e,n){if(t.fadeOut(e),this.fadeIn(e),n){const n=this._clip.duration,i=t._clip.duration,r=n/i;t.warp(1,i/n,e),this.warp(r,1,e)}return this}crossFadeTo(t,e,n){return t.crossFadeFrom(this,e,n)}stopFading(){const t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,e,n){const i=this._mixer,r=i.time,o=this.timeScale;let a=this._timeScaleInterpolant;null===a&&(a=i._lendControlInterpolant(),this._timeScaleInterpolant=a);const s=a.parameterPositions,l=a.sampleValues;return s[0]=r,s[1]=r+n,l[0]=t/o,l[1]=e/o,this}stopWarping(){const t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,e,n,i){if(!this.enabled)return void this._updateWeight(t);const r=this._startTime;if(null!==r){const i=(t-r)*n;if(i<0||0===n)return;this._startTime=null,e=n*i}e*=this._updateTimeScale(t);const o=this._updateTime(e),a=this._updateWeight(t);if(a>0){const t=this._interpolants,e=this._propertyBindings;switch(this.blendMode){case qBt:for(let n=0,i=t.length;n!==i;++n)t[n].evaluate(o),e[n].accumulateAdditive(a);break;case WBt:default:for(let n=0,r=t.length;n!==r;++n)t[n].evaluate(o),e[n].accumulate(i,a)}}}_updateWeight(t){let e=0;if(this.enabled){e=this.weight;const n=this._weightInterpolant;if(null!==n){const i=n.evaluate(t)[0];e*=i,t>n.parameterPositions[1]&&(this.stopFading(),0===i&&(this.enabled=!1))}}return this._effectiveWeight=e,e}_updateTimeScale(t){let e=0;if(!this.paused){e=this.timeScale;const n=this._timeScaleInterpolant;null!==n&&(e*=n.evaluate(t)[0],t>n.parameterPositions[1]&&(this.stopWarping(),0===e?this.paused=!0:this.timeScale=e))}return this._effectiveTimeScale=e,e}_updateTime(t){const e=this._clip.duration,n=this.loop;let i=this.time+t,r=this._loopCount;const o=2202===n;if(0===t)return-1===r?i:o&&1==(1&r)?e-i:i;if(2200===n){-1===r&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(i>=e)i=e;else{if(!(i<0)){this.time=i;break t}i=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===r&&(t>=0?(r=0,this._setEndings(!0,0===this.repetitions,o)):this._setEndings(0===this.repetitions,!0,o)),i>=e||i<0){const n=Math.floor(i/e);i-=e*n,r+=Math.abs(n);const a=this.repetitions-r;if(a<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,i=t>0?e:0,this.time=i,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===a){const e=t<0;this._setEndings(e,!e,o)}else this._setEndings(!1,!1,o);this._loopCount=r,this.time=i,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:n})}}else this.time=i;if(o&&1==(1&r))return e-i}return i}_setEndings(t,e,n){const i=this._interpolantSettings;n?(i.endingStart=UBt,i.endingEnd=UBt):(i.endingStart=t?this.zeroSlopeAtStart?UBt:jBt:GBt,i.endingEnd=e?this.zeroSlopeAtEnd?UBt:jBt:GBt)}_scheduleFading(t,e,n){const i=this._mixer,r=i.time;let o=this._weightInterpolant;null===o&&(o=i._lendControlInterpolant(),this._weightInterpolant=o);const a=o.parameterPositions,s=o.sampleValues;return a[0]=r,s[0]=e,a[1]=r+t,s[1]=n,this}}function SXt(t){this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}SXt.prototype=Object.assign(Object.create(rHt.prototype),{constructor:SXt,_bindAction:function(t,e){const n=t._localRoot||this._root,i=t._clip.tracks,r=i.length,o=t._propertyBindings,a=t._interpolants,s=n.uuid,l=this._bindingsByRootAndName;let c=l[s];void 0===c&&(c={},l[s]=c);for(let t=0;t!==r;++t){const r=i[t],l=r.name;let u=c[l];if(void 0!==u)o[t]=u;else{if(u=o[t],void 0!==u){null===u._cacheIndex&&(++u.referenceCount,this._addInactiveBinding(u,s,l));continue}u=new cXt(bXt.create(n,l,e&&e._propertyBindings[t].binding.parsedPath),r.ValueTypeName,r.getValueSize()),++u.referenceCount,this._addInactiveBinding(u,s,l),o[t]=u}a[t].resultBuffer=u.buffer}},_activateAction:function(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){const e=(t._localRoot||this._root).uuid,n=t._clip.uuid,i=this._actionsByClip[n];this._bindAction(t,i&&i.knownActions[0]),this._addInactiveAction(t,n,e)}const e=t._propertyBindings;for(let t=0,n=e.length;t!==n;++t){const n=e[t];0==n.useCount++&&(this._lendBinding(n),n.saveOriginalState())}this._lendAction(t)}},_deactivateAction:function(t){if(this._isActiveAction(t)){const e=t._propertyBindings;for(let t=0,n=e.length;t!==n;++t){const n=e[t];0==--n.useCount&&(n.restoreOriginalState(),this._takeBackBinding(n))}this._takeBackAction(t)}},_initMemoryManager:function(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;const t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}},_isActiveAction:function(t){const e=t._cacheIndex;return null!==e&&e<this._nActiveActions},_addInactiveAction:function(t,e,n){const i=this._actions,r=this._actionsByClip;let o=r[e];if(void 0===o)o={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,r[e]=o;else{const e=o.knownActions;t._byClipCacheIndex=e.length,e.push(t)}t._cacheIndex=i.length,i.push(t),o.actionByRoot[n]=t},_removeInactiveAction:function(t){const e=this._actions,n=e[e.length-1],i=t._cacheIndex;n._cacheIndex=i,e[i]=n,e.pop(),t._cacheIndex=null;const r=t._clip.uuid,o=this._actionsByClip,a=o[r],s=a.knownActions,l=s[s.length-1],c=t._byClipCacheIndex;l._byClipCacheIndex=c,s[c]=l,s.pop(),t._byClipCacheIndex=null,delete a.actionByRoot[(t._localRoot||this._root).uuid],0===s.length&&delete o[r],this._removeInactiveBindingsForAction(t)},_removeInactiveBindingsForAction:function(t){const e=t._propertyBindings;for(let t=0,n=e.length;t!==n;++t){const n=e[t];0==--n.referenceCount&&this._removeInactiveBinding(n)}},_lendAction:function(t){const e=this._actions,n=t._cacheIndex,i=this._nActiveActions++,r=e[i];t._cacheIndex=i,e[i]=t,r._cacheIndex=n,e[n]=r},_takeBackAction:function(t){const e=this._actions,n=t._cacheIndex,i=--this._nActiveActions,r=e[i];t._cacheIndex=i,e[i]=t,r._cacheIndex=n,e[n]=r},_addInactiveBinding:function(t,e,n){const i=this._bindingsByRootAndName,r=this._bindings;let o=i[e];void 0===o&&(o={},i[e]=o),o[n]=t,t._cacheIndex=r.length,r.push(t)},_removeInactiveBinding:function(t){const e=this._bindings,n=t.binding,i=n.rootNode.uuid,r=n.path,o=this._bindingsByRootAndName,a=o[i],s=e[e.length-1],l=t._cacheIndex;s._cacheIndex=l,e[l]=s,e.pop(),delete a[r],0===Object.keys(a).length&&delete o[i]},_lendBinding:function(t){const e=this._bindings,n=t._cacheIndex,i=this._nActiveBindings++,r=e[i];t._cacheIndex=i,e[i]=t,r._cacheIndex=n,e[n]=r},_takeBackBinding:function(t){const e=this._bindings,n=t._cacheIndex,i=--this._nActiveBindings,r=e[i];t._cacheIndex=i,e[i]=t,r._cacheIndex=n,e[n]=r},_lendControlInterpolant:function(){const t=this._controlInterpolants,e=this._nActiveControlInterpolants++;let n=t[e];return void 0===n&&(n=new Sqt(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),n.__cacheIndex=e,t[e]=n),n},_takeBackControlInterpolant:function(t){const e=this._controlInterpolants,n=t.__cacheIndex,i=--this._nActiveControlInterpolants,r=e[i];t.__cacheIndex=i,e[i]=t,r.__cacheIndex=n,e[n]=r},_controlInterpolantsResultBuffer:new Float32Array(1),clipAction:function(t,e,n){const i=e||this._root,r=i.uuid;let o="string"==typeof t?Nqt.findByName(i,t):t;const a=null!==o?o.uuid:t,s=this._actionsByClip[a];let l=null;if(void 0===n&&(n=null!==o?o.blendMode:WBt),void 0!==s){const t=s.actionByRoot[r];if(void 0!==t&&t.blendMode===n)return t;l=s.knownActions[0],null===o&&(o=l._clip)}if(null===o)return null;const c=new wXt(this,o,e,n);return this._bindAction(c,l),this._addInactiveAction(c,a,r),c},existingAction:function(t,e){const n=e||this._root,i=n.uuid,r="string"==typeof t?Nqt.findByName(n,t):t,o=this._actionsByClip[r?r.uuid:t];return void 0!==o&&o.actionByRoot[i]||null},stopAllAction:function(){const t=this._actions;for(let e=this._nActiveActions-1;e>=0;--e)t[e].stop();return this},update:function(t){const e=this._actions,n=this._nActiveActions,i=this.time+=t*=this.timeScale,r=Math.sign(t),o=this._accuIndex^=1;for(let a=0;a!==n;++a)e[a]._update(i,t,r,o);const a=this._bindings,s=this._nActiveBindings;for(let t=0;t!==s;++t)a[t].apply(o);return this},setTime:function(t){this.time=0;for(let t=0;t<this._actions.length;t++)this._actions[t].time=0;return this.update(t)},getRoot:function(){return this._root},uncacheClip:function(t){const e=this._actions,n=t.uuid,i=this._actionsByClip,r=i[n];if(void 0!==r){const t=r.knownActions;for(let n=0,i=t.length;n!==i;++n){const i=t[n];this._deactivateAction(i);const r=i._cacheIndex,o=e[e.length-1];i._cacheIndex=null,i._byClipCacheIndex=null,o._cacheIndex=r,e[r]=o,e.pop(),this._removeInactiveBindingsForAction(i)}delete i[n]}},uncacheRoot:function(t){const e=t.uuid,n=this._actionsByClip;for(const t in n){const i=n[t].actionByRoot[e];void 0!==i&&(this._deactivateAction(i),this._removeInactiveAction(i))}const i=this._bindingsByRootAndName[e];if(void 0!==i)for(const t in i){const e=i[t];e.restoreOriginalState(),this._removeInactiveBinding(e)}},uncacheAction:function(t,e){const n=this.existingAction(t,e);null!==n&&(this._deactivateAction(n),this._removeInactiveAction(n))}});class MXt{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new MXt(void 0===this.value.clone?this.value:this.value.clone())}}function EXt(t,e,n){oGt.call(this,t,e),this.meshPerAttribute=n||1}function TXt(t,e,n,i,r){this.buffer=t,this.type=e,this.itemSize=n,this.elementSize=i,this.count=r,this.version=0}function AXt(t,e,n,i){this.ray=new WHt(t,e),this.near=n||0,this.far=i||1/0,this.camera=null,this.layers=new iFt,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}},Object.defineProperties(this.params,{PointCloud:{get:function(){return console.warn("THREE.Raycaster: params.PointCloud has been renamed to params.Points."),this.Points}}})}function CXt(t,e){return t.distance-e.distance}function kXt(t,e,n,i){if(t.layers.test(e.layers)&&t.raycast(e,n),!0===i){const i=t.children;for(let t=0,r=i.length;t<r;t++)kXt(i[t],e,n,!0)}}EXt.prototype=Object.assign(Object.create(oGt.prototype),{constructor:EXt,isInstancedInterleavedBuffer:!0,copy:function(t){return oGt.prototype.copy.call(this,t),this.meshPerAttribute=t.meshPerAttribute,this},clone:function(t){const e=oGt.prototype.clone.call(this,t);return e.meshPerAttribute=this.meshPerAttribute,e},toJSON:function(t){const e=oGt.prototype.toJSON.call(this,t);return e.isInstancedInterleavedBuffer=!0,e.meshPerAttribute=this.meshPerAttribute,e}}),Object.defineProperty(TXt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(TXt.prototype,{isGLBufferAttribute:!0,setBuffer:function(t){return this.buffer=t,this},setType:function(t,e){return this.type=t,this.elementSize=e,this},setItemSize:function(t){return this.itemSize=t,this},setCount:function(t){return this.count=t,this}}),Object.assign(AXt.prototype,{set:function(t,e){this.ray.set(t,e)},setFromCamera:function(t,e){e&&e.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(e.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(e).sub(this.ray.origin).normalize(),this.camera=e):e&&e.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(e.near+e.far)/(e.near-e.far)).unproject(e),this.ray.direction.set(0,0,-1).transformDirection(e.matrixWorld),this.camera=e):console.error("THREE.Raycaster: Unsupported camera type: "+e.type)},intersectObject:function(t,e,n){const i=n||[];return kXt(t,this,i,e),i.sort(CXt),i},intersectObjects:function(t,e,n){const i=n||[];if(!1===Array.isArray(t))return console.warn("THREE.Raycaster.intersectObjects: objects is not an Array."),i;for(let n=0,r=t.length;n<r;n++)kXt(t[n],this,i,e);return i.sort(CXt),i}});class LXt{constructor(t=1,e=0,n=0){return this.radius=t,this.phi=e,this.theta=n,this}set(t,e,n){return this.radius=t,this.phi=e,this.theta=n,this}clone(){return(new this.constructor).copy(this)}copy(t){return this.radius=t.radius,this.phi=t.phi,this.theta=t.theta,this}makeSafe(){const t=1e-6;return this.phi=Math.max(t,Math.min(Math.PI-t,this.phi)),this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,e,n){return this.radius=Math.sqrt(t*t+e*e+n*n),0===this.radius?(this.theta=0,this.phi=0):(this.theta=Math.atan2(t,n),this.phi=Math.acos(sHt.clamp(e/this.radius,-1,1))),this}}const PXt=new lHt;class IXt{constructor(t,e){Object.defineProperty(this,"isBox2",{value:!0}),this.min=void 0!==t?t:new lHt(1/0,1/0),this.max=void 0!==e?e:new lHt(-1/0,-1/0)}set(t,e){return this.min.copy(t),this.max.copy(e),this}setFromPoints(t){this.makeEmpty();for(let e=0,n=t.length;e<n;e++)this.expandByPoint(t[e]);return this}setFromCenterAndSize(t,e){const n=PXt.copy(e).multiplyScalar(.5);return this.min.copy(t).sub(n),this.max.copy(t).add(n),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return void 0===t&&(console.warn("THREE.Box2: .getCenter() target is now required"),t=new lHt),this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return void 0===t&&(console.warn("THREE.Box2: .getSize() target is now required"),t=new lHt),this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,e){return void 0===e&&(console.warn("THREE.Box2: .getParameter() target is now required"),e=new lHt),e.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,e){return void 0===e&&(console.warn("THREE.Box2: .clampPoint() target is now required"),e=new lHt),e.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return PXt.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}const NXt=new yHt,OXt=new yHt;class RXt{constructor(t,e){this.start=void 0!==t?t:new yHt,this.end=void 0!==e?e:new yHt}set(t,e){return this.start.copy(t),this.end.copy(e),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.start.copy(t.start),this.end.copy(t.end),this}getCenter(t){return void 0===t&&(console.warn("THREE.Line3: .getCenter() target is now required"),t=new yHt),t.addVectors(this.start,this.end).multiplyScalar(.5)}delta(t){return void 0===t&&(console.warn("THREE.Line3: .delta() target is now required"),t=new yHt),t.subVectors(this.end,this.start)}distanceSq(){return this.start.distanceToSquared(this.end)}distance(){return this.start.distanceTo(this.end)}at(t,e){return void 0===e&&(console.warn("THREE.Line3: .at() target is now required"),e=new yHt),this.delta(e).multiplyScalar(t).add(this.start)}closestPointToPointParameter(t,e){NXt.subVectors(t,this.start),OXt.subVectors(this.end,this.start);const n=OXt.dot(OXt);let i=OXt.dot(NXt)/n;return e&&(i=sHt.clamp(i,0,1)),i}closestPointToPoint(t,e,n){const i=this.closestPointToPointParameter(t,e);return void 0===n&&(console.warn("THREE.Line3: .closestPointToPoint() target is now required"),n=new yHt),this.delta(n).multiplyScalar(i).add(this.start)}applyMatrix4(t){return this.start.applyMatrix4(t),this.end.applyMatrix4(t),this}equals(t){return t.start.equals(this.start)&&t.end.equals(this.end)}}function zXt(t){_Ft.call(this),this.material=t,this.render=function(){},this.hasPositions=!1,this.hasNormals=!1,this.hasColors=!1,this.hasUvs=!1,this.positionArray=null,this.normalArray=null,this.colorArray=null,this.uvArray=null,this.count=0}(zXt.prototype=Object.create(_Ft.prototype)).constructor=zXt,zXt.prototype.isImmediateRenderObject=!0;const DXt=new yHt,BXt=new yHt,HXt=new qHt,FXt=new qHt;class VXt extends ZGt{constructor(t){const e=jXt(t),n=new pVt,i=[],r=[],o=new HFt(0,0,1),a=new HFt(0,1,0);for(let t=0;t<e.length;t++){const n=e[t];n.parent&&n.parent.isBone&&(i.push(0,0,0),i.push(0,0,0),r.push(o.r,o.g,o.b),r.push(a.r,a.g,a.b))}n.setAttribute("position",new eVt(i,3)),n.setAttribute("color",new eVt(r,3)),super(n,new jGt({vertexColors:!0,depthTest:!1,depthWrite:!1,toneMapped:!1,transparent:!0})),this.type="SkeletonHelper",this.isSkeletonHelper=!0,this.root=t,this.bones=e,this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1}updateMatrixWorld(t){const e=this.bones,n=this.geometry,i=n.getAttribute("position");FXt.copy(this.root.matrixWorld).invert();for(let t=0,n=0;t<e.length;t++){const r=e[t];r.parent&&r.parent.isBone&&(HXt.multiplyMatrices(FXt,r.matrixWorld),BXt.setFromMatrixPosition(HXt),i.setXYZ(n,BXt.x,BXt.y,BXt.z),HXt.multiplyMatrices(FXt,r.parent.matrixWorld),BXt.setFromMatrixPosition(HXt),i.setXYZ(n+1,BXt.x,BXt.y,BXt.z),n+=2)}n.getAttribute("position").needsUpdate=!0,super.updateMatrixWorld(t)}}function jXt(t){const e=[];t&&t.isBone&&e.push(t);for(let n=0;n<t.children.length;n++)e.push.apply(e,jXt(t.children[n]));return e}const UXt=new yHt,GXt=new HFt,WXt=new HFt;class qXt extends ZGt{constructor(t=10,e=10,n=4473924,i=8947848){n=new HFt(n),i=new HFt(i);const r=e/2,o=t/e,a=t/2,s=[],l=[];for(let t=0,c=0,u=-a;t<=e;t++,u+=o){s.push(-a,0,u,a,0,u),s.push(u,0,-a,u,0,a);const e=t===r?n:i;e.toArray(l,c),c+=3,e.toArray(l,c),c+=3,e.toArray(l,c),c+=3,e.toArray(l,c),c+=3}const c=new pVt;c.setAttribute("position",new eVt(s,3)),c.setAttribute("color",new eVt(l,3)),super(c,new jGt({vertexColors:!0,toneMapped:!1})),this.type="GridHelper"}}const YXt=new yHt,XXt=new yHt,$Xt=new yHt,KXt=new yHt,ZXt=new BVt;function JXt(t,e,n,i,r,o,a){KXt.set(r,o,a).unproject(i);const s=e[t];if(void 0!==s){const t=n.getAttribute("position");for(let e=0,n=s.length;e<n;e++)t.setXYZ(s[e],KXt.x,KXt.y,KXt.z)}}const QXt=new xHt;class t$t extends ZGt{constructor(t,e=16776960){const n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new Float32Array(24),r=new pVt;r.setIndex(new qFt(n,1)),r.setAttribute("position",new qFt(i,3)),super(r,new jGt({color:e,toneMapped:!1})),this.object=t,this.type="BoxHelper",this.matrixAutoUpdate=!1,this.update()}update(t){if(void 0!==t&&console.warn("THREE.BoxHelper: .update() has no longer arguments."),void 0!==this.object&&QXt.setFromObject(this.object),QXt.isEmpty())return;const e=QXt.min,n=QXt.max,i=this.geometry.attributes.position,r=i.array;r[0]=n.x,r[1]=n.y,r[2]=n.z,r[3]=e.x,r[4]=n.y,r[5]=n.z,r[6]=e.x,r[7]=e.y,r[8]=n.z,r[9]=n.x,r[10]=e.y,r[11]=n.z,r[12]=n.x,r[13]=n.y,r[14]=e.z,r[15]=e.x,r[16]=n.y,r[17]=e.z,r[18]=e.x,r[19]=e.y,r[20]=e.z,r[21]=n.x,r[22]=e.y,r[23]=e.z,i.needsUpdate=!0,this.geometry.computeBoundingSphere()}setFromObject(t){return this.object=t,this.update(),this}copy(t){return ZGt.prototype.copy.call(this,t),this.object=t.object,this}}const e$t=new yHt;let n$t,i$t;class r$t extends ZGt{constructor(t=1){const e=[0,0,0,t,0,0,0,0,0,0,t,0,0,0,0,0,0,t],n=new pVt;n.setAttribute("position",new eVt(e,3)),n.setAttribute("color",new eVt([1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],3)),super(n,new jGt({vertexColors:!0,toneMapped:!1})),this.type="AxesHelper"}}const o$t=new Float32Array(1),a$t=new Int32Array(o$t.buffer),s$t={toHalfFloat:function(t){o$t[0]=t;const e=a$t[0];let n=e>>16&32768,i=e>>12&2047;const r=e>>23&255;return r<103?n:r>142?(n|=31744,n|=(255==r?0:1)&&8388607&e,n):r<113?(i|=2048,n|=(i>>114-r)+(i>>113-r&1),n):(n|=r-112<<10|i>>1,n+=1&i,n)}},l$t=Math.pow(2,8),c$t=[.125,.215,.35,.446,.526,.582],u$t=5+c$t.length,h$t={[YBt]:0,[XBt]:1,[KBt]:2,[ZBt]:3,[JBt]:4,[QBt]:5,[$Bt]:6},d$t=new UFt({side:1,depthWrite:!1,depthTest:!1}),p$t=new PVt(new NVt,d$t),f$t=new SYt,{_lodPlanes:m$t,_sizeLods:g$t,_sigmas:_$t}=E$t(),y$t=new HFt;let v$t=null;const b$t=(1+Math.sqrt(5))/2,x$t=1/b$t,w$t=[new yHt(1,1,1),new yHt(-1,1,1),new yHt(1,1,-1),new yHt(-1,1,-1),new yHt(0,b$t,x$t),new yHt(0,b$t,-x$t),new yHt(x$t,0,b$t),new yHt(-x$t,0,b$t),new yHt(b$t,x$t,0),new yHt(-b$t,x$t,0)];function S$t(t){const e=Math.max(t.r,t.g,t.b),n=Math.min(Math.max(Math.ceil(Math.log2(e)),-128),127);return t.multiplyScalar(Math.pow(2,-n)),(n+128)/255}function M$t(t){return void 0!==t&&t.type===vBt&&(t.encoding===YBt||t.encoding===XBt||t.encoding===$Bt)}function E$t(){const t=[],e=[],n=[];let i=8;for(let r=0;r<u$t;r++){const o=Math.pow(2,i);e.push(o);let a=1/o;r>4?a=c$t[r-8+4-1]:0==r&&(a=0),n.push(a);const s=1/(o-1),l=-s/2,c=1+s/2,u=[l,l,c,l,c,c,l,l,c,c,l,c],h=6,d=6,p=3,f=2,m=1,g=new Float32Array(p*d*h),_=new Float32Array(f*d*h),y=new Float32Array(m*d*h);for(let t=0;t<h;t++){const e=t%3*2/3-1,n=t>2?0:-1;g.set([e,n,0,e+2/3,n,0,e+2/3,n+1,0,e,n,0,e+2/3,n+1,0,e,n+1,0],p*d*t),_.set(u,f*d*t),y.set([t,t,t,t,t,t],m*d*t)}const v=new pVt;v.setAttribute("position",new qFt(g,p)),v.setAttribute("uv",new qFt(_,f)),v.setAttribute("faceIndex",new qFt(y,m)),t.push(v),i>4&&i--}return{_lodPlanes:t,_sizeLods:e,_sigmas:n}}function T$t(t){const e=new gHt(3*l$t,3*l$t,t);return e.texture.mapping=lBt,e.texture.name="PMREM.cubeUv",e.scissorTest=!0,e}function A$t(t,e,n,i,r){t.viewport.set(e,n,i,r),t.scissor.set(e,n,i,r)}function C$t(){return new uqt({name:"EquirectangularToCubeUV",uniforms:{envMap:{value:null},texelSize:{value:new lHt(1,1)},inputEncoding:{value:h$t[3e3]},outputEncoding:{value:h$t[3e3]}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t\n\n\t\tuniform int inputEncoding;\n\t\tuniform int outputEncoding;\n\n\t\t#include <encodings_pars_fragment>\n\n\t\tvec4 inputTexelToLinear( vec4 value ) {\n\n\t\t\tif ( inputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( inputEncoding == 1 ) {\n\n\t\t\t\treturn sRGBToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 2 ) {\n\n\t\t\t\treturn RGBEToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 3 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 7.0 );\n\n\t\t\t} else if ( inputEncoding == 4 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 16.0 );\n\n\t\t\t} else if ( inputEncoding == 5 ) {\n\n\t\t\t\treturn RGBDToLinear( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn GammaToLinear( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 linearToOutputTexel( vec4 value ) {\n\n\t\t\tif ( outputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( outputEncoding == 1 ) {\n\n\t\t\t\treturn LinearTosRGB( value );\n\n\t\t\t} else if ( outputEncoding == 2 ) {\n\n\t\t\t\treturn LinearToRGBE( value );\n\n\t\t\t} else if ( outputEncoding == 3 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 7.0 );\n\n\t\t\t} else if ( outputEncoding == 4 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 16.0 );\n\n\t\t\t} else if ( outputEncoding == 5 ) {\n\n\t\t\t\treturn LinearToRGBD( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn LinearToGamma( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 envMapTexelToLinear( vec4 color ) {\n\n\t\t\treturn inputTexelToLinear( color );\n\n\t\t}\n\t\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function k$t(){return new uqt({name:"CubemapToCubeUV",uniforms:{envMap:{value:null},inputEncoding:{value:h$t[3e3]},outputEncoding:{value:h$t[3e3]}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\t\n\n\t\tuniform int inputEncoding;\n\t\tuniform int outputEncoding;\n\n\t\t#include <encodings_pars_fragment>\n\n\t\tvec4 inputTexelToLinear( vec4 value ) {\n\n\t\t\tif ( inputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( inputEncoding == 1 ) {\n\n\t\t\t\treturn sRGBToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 2 ) {\n\n\t\t\t\treturn RGBEToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 3 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 7.0 );\n\n\t\t\t} else if ( inputEncoding == 4 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 16.0 );\n\n\t\t\t} else if ( inputEncoding == 5 ) {\n\n\t\t\t\treturn RGBDToLinear( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn GammaToLinear( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 linearToOutputTexel( vec4 value ) {\n\n\t\t\tif ( outputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( outputEncoding == 1 ) {\n\n\t\t\t\treturn LinearTosRGB( value );\n\n\t\t\t} else if ( outputEncoding == 2 ) {\n\n\t\t\t\treturn LinearToRGBE( value );\n\n\t\t\t} else if ( outputEncoding == 3 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 7.0 );\n\n\t\t\t} else if ( outputEncoding == 4 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 16.0 );\n\n\t\t\t} else if ( outputEncoding == 5 ) {\n\n\t\t\t\treturn LinearToRGBD( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn LinearToGamma( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 envMapTexelToLinear( vec4 color ) {\n\n\t\t\treturn inputTexelToLinear( color );\n\n\t\t}\n\t\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb = envMapTexelToLinear( textureCube( envMap, vec3( - vOutputDirection.x, vOutputDirection.yz ) ) ).rgb;\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})}function L$t(t){console.warn("THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead."),eYt.call(this,t),this.type="catmullrom",this.closed=!0}function P$t(t){console.warn("THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead."),eYt.call(this,t),this.type="catmullrom"}function I$t(t){console.warn("THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead."),eYt.call(this,t),this.type="catmullrom"}Yqt.create=function(t,e){return console.log("THREE.Curve.create() has been deprecated"),t.prototype=Object.create(Yqt.prototype),t.prototype.constructor=t,t.prototype.getPoint=e,t},Object.assign(fYt.prototype,{fromPoints:function(t){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(t)}}),L$t.prototype=Object.create(eYt.prototype),P$t.prototype=Object.create(eYt.prototype),I$t.prototype=Object.create(eYt.prototype),Object.assign(I$t.prototype,{initFromArray:function(){console.error("THREE.Spline: .initFromArray() has been removed.")},getControlPointsArray:function(){console.error("THREE.Spline: .getControlPointsArray() has been removed.")},reparametrizeByArcLength:function(){console.error("THREE.Spline: .reparametrizeByArcLength() has been removed.")}}),qXt.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")},VXt.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")},Object.assign(Bqt.prototype,{extractUrlBase:function(t){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),PYt.extractUrlBase(t)}}),Bqt.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},Object.assign(IXt.prototype,{center:function(t){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(t)},empty:function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},isIntersectionBox:function(t){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},size:function(t){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(t)}}),Object.assign(xHt.prototype,{center:function(t){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(t)},empty:function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},isIntersectionBox:function(t){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},isIntersectionSphere:function(t){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(t)},size:function(t){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(t)}}),Object.assign(DHt.prototype,{empty:function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()}}),YVt.prototype.setFromMatrix=function(t){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(t)},RXt.prototype.center=function(t){return console.warn("THREE.Line3: .center() has been renamed to .getCenter()."),this.getCenter(t)},Object.assign(sHt,{random16:function(){return console.warn("THREE.Math: .random16() has been deprecated. Use Math.random() instead."),Math.random()},nearestPowerOfTwo:function(t){return console.warn("THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo()."),sHt.floorPowerOfTwo(t)},nextPowerOfTwo:function(t){return console.warn("THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo()."),sHt.ceilPowerOfTwo(t)}}),Object.assign(cHt.prototype,{flattenToArrayOffset:function(t,e){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(t,e)},multiplyVector3:function(t){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),t.applyMatrix3(this)},multiplyVector3Array:function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},applyToBufferAttribute:function(t){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),t.applyMatrix3(this)},applyToVector3Array:function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},getInverse:function(t){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(t).invert()}}),Object.assign(qHt.prototype,{extractPosition:function(t){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(t)},flattenToArrayOffset:function(t,e){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(t,e)},getPosition:function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new yHt).setFromMatrixColumn(this,3)},setRotationFromQuaternion:function(t){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(t)},multiplyToArray:function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},multiplyVector3:function(t){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},multiplyVector4:function(t){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},multiplyVector3Array:function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},rotateAxis:function(t){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),t.transformDirection(this)},crossVector:function(t){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},translate:function(){console.error("THREE.Matrix4: .translate() has been removed.")},rotateX:function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},rotateY:function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},rotateZ:function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},rotateByAxis:function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},applyToBufferAttribute:function(t){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},applyToVector3Array:function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},makeFrustum:function(t,e,n,i,r,o){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(t,e,i,n,r,o)},getInverse:function(t){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(t).invert()}}),xFt.prototype.isIntersectionLine=function(t){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(t)},Object.assign(_Ht.prototype,{multiplyVector3:function(t){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),t.applyQuaternion(this)},inverse:function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()}}),Object.assign(WHt.prototype,{isIntersectionBox:function(t){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},isIntersectionPlane:function(t){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(t)},isIntersectionSphere:function(t){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(t)}}),Object.assign(IFt.prototype,{area:function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},barycoordFromPoint:function(t,e){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(t,e)},midpoint:function(t){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(t)},normal:function(t){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(t)},plane:function(t){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(t)}}),Object.assign(IFt,{barycoordFromPoint:function(t,e,n,i,r){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),IFt.getBarycoord(t,e,n,i,r)},normal:function(t,e,n,i){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),IFt.getNormal(t,e,n,i)}}),Object.assign(mYt.prototype,{extractAllPoints:function(t){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(t)},extrude:function(t){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new YWt(this,t)},makeGeometry:function(t){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new tqt(this,t)}}),Object.assign(lHt.prototype,{fromAttribute:function(t,e,n){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,e,n)},distanceToManhattan:function(t){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(t)},lengthManhattan:function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign(yHt.prototype,{setEulerFromRotationMatrix:function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},setEulerFromQuaternion:function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},getPositionFromMatrix:function(t){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(t)},getScaleFromMatrix:function(t){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(t)},getColumnFromMatrix:function(t,e){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(e,t)},applyProjection:function(t){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(t)},fromAttribute:function(t,e,n){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,e,n)},distanceToManhattan:function(t){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(t)},lengthManhattan:function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign(mHt.prototype,{fromAttribute:function(t,e,n){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,e,n)},lengthManhattan:function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign(_Ft.prototype,{getChildByName:function(t){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(t)},renderDepth:function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},translate:function(t,e){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(e,t)},getWorldRotation:function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},applyMatrix:function(t){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(t)}}),Object.defineProperties(_Ft.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(t){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=t}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),Object.assign(PVt.prototype,{setDrawMode:function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}),Object.defineProperties(PVt.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),Object.defineProperties(TGt.prototype,{objects:{get:function(){return console.warn("THREE.LOD: .objects has been renamed to .levels."),this.levels}}}),Object.defineProperty(zGt.prototype,"useVertexTexture",{get:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")},set:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")}}),IGt.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},Object.defineProperty(Yqt.prototype,"__arcLengthDivisions",{get:function(){return console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions."),this.arcLengthDivisions},set:function(t){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions."),this.arcLengthDivisions=t}}),HVt.prototype.setLens=function(t,e){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==e&&(this.filmGauge=e),this.setFocalLength(t)},Object.defineProperties(gYt.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(t){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=t}},shadowCameraLeft:{set:function(t){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=t}},shadowCameraRight:{set:function(t){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=t}},shadowCameraTop:{set:function(t){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=t}},shadowCameraBottom:{set:function(t){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=t}},shadowCameraNear:{set:function(t){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=t}},shadowCameraFar:{set:function(t){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=t}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(t){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=t}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(t){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=t}},shadowMapHeight:{set:function(t){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=t}}}),Object.defineProperties(qFt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===nHt},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(nHt)}}}),Object.assign(qFt.prototype,{setDynamic:function(t){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===t?nHt:eHt),this},copyIndicesArray:function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},setArray:function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}}),Object.assign(pVt.prototype,{addIndex:function(t){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(t)},addAttribute:function(t,e){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),e&&e.isBufferAttribute||e&&e.isInterleavedBufferAttribute?"index"===t?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(e),this):this.setAttribute(t,e):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(t,new qFt(arguments[1],arguments[2])))},addDrawCall:function(t,e,n){void 0!==n&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(t,e)},clearDrawCalls:function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},computeOffsets:function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},removeAttribute:function(t){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(t)},applyMatrix:function(t){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(t)}}),Object.defineProperties(pVt.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),Object.defineProperties(IYt.prototype,{maxInstancedCount:{get:function(){return console.warn("THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount."),this.instanceCount},set:function(t){console.warn("THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount."),this.instanceCount=t}}}),Object.defineProperties(AXt.prototype,{linePrecision:{get:function(){return console.warn("THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead."),this.params.Line.threshold},set:function(t){console.warn("THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead."),this.params.Line.threshold=t}}}),Object.defineProperties(oGt.prototype,{dynamic:{get:function(){return console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead."),this.usage===nHt},set:function(t){console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead."),this.setUsage(t)}}}),Object.assign(oGt.prototype,{setDynamic:function(t){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===t?nHt:eHt),this},setArray:function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}}),Object.assign(YWt.prototype,{getArrays:function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},addShapeList:function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},addShape:function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")}}),Object.assign(rGt.prototype,{dispose:function(){console.error("THREE.Scene: .dispose() has been removed.")}}),Object.defineProperties(MXt.prototype,{dynamic:{set:function(){console.warn("THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.")}},onUpdate:{value:function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this}}}),Object.defineProperties(jFt.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new HFt}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(t){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===t}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(t){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=t}}}),Object.defineProperties(pqt.prototype,{metal:{get:function(){return console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead."),!1},set:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead")}}}),Object.defineProperties(dqt.prototype,{transparency:{get:function(){return console.warn("THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission."),this.transmission},set:function(t){console.warn("THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission."),this.transmission=t}}}),Object.defineProperties(DVt.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(t){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=t}}}),Object.assign(tGt.prototype,{clearTarget:function(t,e,n,i){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(t),this.clear(e,n,i)},animate:function(t){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(t)},getCurrentRenderTarget:function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},getMaxAnisotropy:function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},getPrecision:function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},resetGLState:function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},supportsFloatTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},supportsHalfFloatTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},supportsStandardDerivatives:function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},supportsCompressedTextureS3TC:function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},supportsCompressedTexturePVRTC:function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},supportsBlendMinMax:function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},supportsVertexTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},supportsInstancedArrays:function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},enableScissorTest:function(t){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(t)},initMaterial:function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},addPrePlugin:function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},addPostPlugin:function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},updateShadowMap:function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},setFaceCulling:function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},allocTextureUnit:function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},setTexture:function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},setTexture2D:function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},setTextureCube:function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},getActiveMipMapLevel:function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()}}),Object.defineProperties(tGt.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(t){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=t}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(t){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=t}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(t){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===t?XBt:YBt}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}}}),Object.defineProperties(WUt.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(gHt.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(t){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=t}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(t){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=t}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(t){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=t}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(t){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=t}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(t){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=t}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(t){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=t}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(t){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=t}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(t){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=t}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(t){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=t}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(t){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=t}}}),Object.defineProperties(iXt.prototype,{load:{value:function(t){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");const e=this;return(new WYt).load(t,(function(t){e.setBuffer(t)})),this}},startTime:{set:function(){console.warn("THREE.Audio: .startTime is now .play( delay ).")}}}),lXt.prototype.getData=function(){return console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData()."),this.getFrequencyData()},VVt.prototype.updateCubeMap=function(t,e){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(t,e)},VVt.prototype.clear=function(t,e,n,i){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(t,e,n,i)};const N$t={merge:function(t,e,n){let i;console.warn("THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead."),e.isMesh&&(e.matrixAutoUpdate&&e.updateMatrix(),i=e.matrix,e=e.geometry),t.merge(e,i,n)},center:function(t){return console.warn("THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead."),t.center()}};hHt.crossOrigin=void 0,hHt.loadTexture=function(t,e,n,i){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");const r=new qqt;r.setCrossOrigin(this.crossOrigin);const o=r.load(t,n,void 0,i);return e&&(o.mapping=e),o},hHt.loadTextureCube=function(t,e,n,i){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");const r=new Gqt;r.setCrossOrigin(this.crossOrigin);const o=r.load(t,n,void 0,i);return e&&(o.mapping=e),o},hHt.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},hHt.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};const O$t={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},detach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js")}};"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:QDt}})),"undefined"!=typeof window&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__=QDt);var R$t=Object.freeze({__proto__:null,ACESFilmicToneMapping:4,AddEquation:nBt,AddOperation:2,AdditiveAnimationBlendMode:qBt,AdditiveBlending:2,AlphaFormat:1021,AlwaysDepth:1,AlwaysStencilFunc:519,AmbientLight:TYt,AmbientLightProbe:YYt,AnimationClip:Nqt,AnimationLoader:Vqt,AnimationMixer:SXt,AnimationObjectGroup:xXt,AnimationUtils:bqt,ArcCurve:$qt,ArrayCamera:$Ut,ArrowHelper:class extends _Ft{constructor(t,e,n,i,r,o){super(),this.type="ArrowHelper",void 0===t&&(t=new yHt(0,0,1)),void 0===e&&(e=new yHt(0,0,0)),void 0===n&&(n=1),void 0===i&&(i=16776960),void 0===r&&(r=.2*n),void 0===o&&(o=.2*r),void 0===n$t&&(n$t=new pVt,n$t.setAttribute("position",new eVt([0,0,0,0,1,0],3)),i$t=new hWt(0,.5,1,5,1),i$t.translate(0,-.5,0)),this.position.copy(e),this.line=new XGt(n$t,new jGt({color:i,toneMapped:!1})),this.line.matrixAutoUpdate=!1,this.add(this.line),this.cone=new PVt(i$t,new UFt({color:i,toneMapped:!1})),this.cone.matrixAutoUpdate=!1,this.add(this.cone),this.setDirection(t),this.setLength(n,r,o)}setDirection(t){if(t.y>.99999)this.quaternion.set(0,0,0,1);else if(t.y<-.99999)this.quaternion.set(1,0,0,0);else{e$t.set(t.z,0,-t.x).normalize();const e=Math.acos(t.y);this.quaternion.setFromAxisAngle(e$t,e)}}setLength(t,e,n){void 0===e&&(e=.2*t),void 0===n&&(n=.2*e),this.line.scale.set(1,Math.max(1e-4,t-e),1),this.line.updateMatrix(),this.cone.scale.set(n,e,n),this.cone.position.y=t,this.cone.updateMatrix()}setColor(t){this.line.material.color.set(t),this.cone.material.color.set(t)}copy(t){return super.copy(t,!1),this.line.copy(t.line),this.cone.copy(t.cone),this}},Audio:iXt,AudioAnalyser:lXt,AudioContext:GYt,AudioListener:class extends _Ft{constructor(){super(),this.type="AudioListener",this.context=GYt.getContext(),this.gain=this.context.createGain(),this.gain.connect(this.context.destination),this.filter=null,this.timeDelta=0,this._clock=new ZYt}getInput(){return this.gain}removeFilter(){return null!==this.filter&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null),this}getFilter(){return this.filter}setFilter(t){return null!==this.filter?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination),this.filter=t,this.gain.connect(this.filter),this.filter.connect(this.context.destination),this}getMasterVolume(){return this.gain.gain.value}setMasterVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}updateMatrixWorld(t){super.updateMatrixWorld(t);const e=this.context.listener,n=this.up;if(this.timeDelta=this._clock.getDelta(),this.matrixWorld.decompose(QYt,tXt,eXt),nXt.set(0,0,-1).applyQuaternion(tXt),e.positionX){const t=this.context.currentTime+this.timeDelta;e.positionX.linearRampToValueAtTime(QYt.x,t),e.positionY.linearRampToValueAtTime(QYt.y,t),e.positionZ.linearRampToValueAtTime(QYt.z,t),e.forwardX.linearRampToValueAtTime(nXt.x,t),e.forwardY.linearRampToValueAtTime(nXt.y,t),e.forwardZ.linearRampToValueAtTime(nXt.z,t),e.upX.linearRampToValueAtTime(n.x,t),e.upY.linearRampToValueAtTime(n.y,t),e.upZ.linearRampToValueAtTime(n.z,t)}else e.setPosition(QYt.x,QYt.y,QYt.z),e.setOrientation(nXt.x,nXt.y,nXt.z,n.x,n.y,n.z)}},AudioLoader:WYt,AxesHelper:r$t,AxisHelper:function z$t(t){return console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper."),new r$t(t)},BackSide:1,BasicDepthPacking:3200,BasicShadowMap:0,BinaryTextureLoader:function D$t(t){return console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader."),new Wqt(t)},Bone:NGt,BooleanKeyframeTrack:Tqt,BoundingBoxHelper:function B$t(t,e){return console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead."),new t$t(t,e)},Box2:IXt,Box3:xHt,Box3Helper:class extends ZGt{constructor(t,e=16776960){const n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),i=new pVt;i.setIndex(new qFt(n,1)),i.setAttribute("position",new eVt([1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],3)),super(i,new jGt({color:e,toneMapped:!1})),this.box=t,this.type="Box3Helper",this.geometry.computeBoundingSphere()}updateMatrixWorld(t){const e=this.box;e.isEmpty()||(e.getCenter(this.position),e.getSize(this.scale),this.scale.multiplyScalar(.5),super.updateMatrixWorld(t))}},BoxBufferGeometry:NVt,BoxGeometry:NVt,BoxHelper:t$t,BufferAttribute:qFt,BufferGeometry:pVt,BufferGeometryLoader:OYt,ByteType:1010,Cache:Rqt,Camera:BVt,CameraHelper:class extends ZGt{constructor(t){const e=new pVt,n=new jGt({color:16777215,vertexColors:!0,toneMapped:!1}),i=[],r=[],o={},a=new HFt(16755200),s=new HFt(16711680),l=new HFt(43775),c=new HFt(16777215),u=new HFt(3355443);function h(t,e,n){d(t,n),d(e,n)}function d(t,e){i.push(0,0,0),r.push(e.r,e.g,e.b),void 0===o[t]&&(o[t]=[]),o[t].push(i.length/3-1)}h("n1","n2",a),h("n2","n4",a),h("n4","n3",a),h("n3","n1",a),h("f1","f2",a),h("f2","f4",a),h("f4","f3",a),h("f3","f1",a),h("n1","f1",a),h("n2","f2",a),h("n3","f3",a),h("n4","f4",a),h("p","n1",s),h("p","n2",s),h("p","n3",s),h("p","n4",s),h("u1","u2",l),h("u2","u3",l),h("u3","u1",l),h("c","t",c),h("p","c",u),h("cn1","cn2",u),h("cn3","cn4",u),h("cf1","cf2",u),h("cf3","cf4",u),e.setAttribute("position",new eVt(i,3)),e.setAttribute("color",new eVt(r,3)),super(e,n),this.type="CameraHelper",this.camera=t,this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.pointMap=o,this.update()}update(){const t=this.geometry,e=this.pointMap;ZXt.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse),JXt("c",e,t,ZXt,0,0,-1),JXt("t",e,t,ZXt,0,0,1),JXt("n1",e,t,ZXt,-1,-1,-1),JXt("n2",e,t,ZXt,1,-1,-1),JXt("n3",e,t,ZXt,-1,1,-1),JXt("n4",e,t,ZXt,1,1,-1),JXt("f1",e,t,ZXt,-1,-1,1),JXt("f2",e,t,ZXt,1,-1,1),JXt("f3",e,t,ZXt,-1,1,1),JXt("f4",e,t,ZXt,1,1,1),JXt("u1",e,t,ZXt,.7,1.1,-1),JXt("u2",e,t,ZXt,-.7,1.1,-1),JXt("u3",e,t,ZXt,0,2,-1),JXt("cf1",e,t,ZXt,-1,0,1),JXt("cf2",e,t,ZXt,1,0,1),JXt("cf3",e,t,ZXt,0,-1,1),JXt("cf4",e,t,ZXt,0,1,1),JXt("cn1",e,t,ZXt,-1,0,-1),JXt("cn2",e,t,ZXt,1,0,-1),JXt("cn3",e,t,ZXt,0,-1,-1),JXt("cn4",e,t,ZXt,0,1,-1),t.getAttribute("position").needsUpdate=!0}},CanvasRenderer:function H$t(){console.error("THREE.CanvasRenderer has been removed")},CanvasTexture:lWt,CatmullRomCurve3:eYt,CineonToneMapping:3,CircleBufferGeometry:uWt,CircleGeometry:uWt,ClampToEdgeWrapping:hBt,Clock:ZYt,ClosedSplineCurve3:L$t,Color:HFt,ColorKeyframeTrack:Aqt,CompressedTexture:sWt,CompressedTextureLoader:jqt,ConeBufferGeometry:dWt,ConeGeometry:dWt,CubeCamera:VVt,CubeReflectionMapping:rBt,CubeRefractionMapping:oBt,CubeTexture:jVt,CubeTextureLoader:Gqt,CubeUVReflectionMapping:lBt,CubeUVRefractionMapping:cBt,CubicBezierCurve:oYt,CubicBezierCurve3:aYt,CubicInterpolant:wqt,CullFaceBack:1,CullFaceFront:2,CullFaceFrontBack:3,CullFaceNone:0,Curve:Yqt,CurvePath:pYt,CustomBlending:5,CustomToneMapping:5,CylinderBufferGeometry:hWt,CylinderGeometry:hWt,Cylindrical:class{constructor(t,e,n){return this.radius=void 0!==t?t:1,this.theta=void 0!==e?e:0,this.y=void 0!==n?n:0,this}set(t,e,n){return this.radius=t,this.theta=e,this.y=n,this}clone(){return(new this.constructor).copy(this)}copy(t){return this.radius=t.radius,this.theta=t.theta,this.y=t.y,this}setFromVector3(t){return this.setFromCartesianCoords(t.x,t.y,t.z)}setFromCartesianCoords(t,e,n){return this.radius=Math.sqrt(t*t+n*n),this.theta=Math.atan2(t,n),this.y=e,this}},DataTexture:GVt,DataTexture2DArray:fjt,DataTexture3D:mjt,DataTextureLoader:Wqt,DataUtils:s$t,DecrementStencilOp:7683,DecrementWrapStencilOp:34056,DefaultLoadingManager:Dqt,DepthFormat:ABt,DepthStencilFormat:CBt,DepthTexture:cWt,DirectionalLight:EYt,DirectionalLightHelper:class extends _Ft{constructor(t,e,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n,void 0===e&&(e=1);let i=new pVt;i.setAttribute("position",new eVt([-e,e,0,e,e,0,e,-e,0,-e,-e,0,-e,e,0],3));const r=new jGt({fog:!1,toneMapped:!1});this.lightPlane=new XGt(i,r),this.add(this.lightPlane),i=new pVt,i.setAttribute("position",new eVt([0,0,0,0,0,1],3)),this.targetLine=new XGt(i,r),this.add(this.targetLine),this.update()}dispose(){this.lightPlane.geometry.dispose(),this.lightPlane.material.dispose(),this.targetLine.geometry.dispose(),this.targetLine.material.dispose()}update(){YXt.setFromMatrixPosition(this.light.matrixWorld),XXt.setFromMatrixPosition(this.light.target.matrixWorld),$Xt.subVectors(XXt,YXt),this.lightPlane.lookAt(XXt),void 0!==this.color?(this.lightPlane.material.color.set(this.color),this.targetLine.material.color.set(this.color)):(this.lightPlane.material.color.copy(this.light.color),this.targetLine.material.color.copy(this.light.color)),this.targetLine.lookAt(XXt),this.targetLine.scale.z=$Xt.length()}},DiscreteInterpolant:Mqt,DodecahedronBufferGeometry:fWt,DodecahedronGeometry:fWt,DoubleSide:2,DstAlphaFactor:206,DstColorFactor:208,DynamicBufferAttribute:function F$t(t,e){return console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead."),new qFt(t,e).setUsage(nHt)},DynamicCopyUsage:35050,DynamicDrawUsage:nHt,DynamicReadUsage:35049,EdgesGeometry:vWt,EdgesHelper:function V$t(t,e){return console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead."),new ZGt(new vWt(t.geometry),new jGt({color:void 0!==e?e:16777215}))},EllipseCurve:Xqt,EqualDepth:4,EqualStencilFunc:514,EquirectangularReflectionMapping:aBt,EquirectangularRefractionMapping:sBt,Euler:tFt,EventDispatcher:rHt,ExtrudeBufferGeometry:YWt,ExtrudeGeometry:YWt,Face3:FFt,Face4:function j$t(t,e,n,i,r,o,a){return console.warn("THREE.Face4 has been removed. A THREE.Face3 will be created instead."),new FFt(t,e,n,r,o,a)},FaceColors:1,FileLoader:Fqt,FlatShading:1,Float16BufferAttribute:tVt,Float32Attribute:function U$t(t,e){return console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead."),new eVt(t,e)},Float32BufferAttribute:eVt,Float64Attribute:function G$t(t,e){return console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead."),new nVt(t,e)},Float64BufferAttribute:nVt,FloatType:wBt,Fog:iGt,FogExp2:nGt,Font:FYt,FontLoader:jYt,FrontSide:0,Frustum:YVt,GLBufferAttribute:TXt,GLSL1:"100",GLSL3:iHt,GammaEncoding:$Bt,GeometryUtils:N$t,GreaterDepth:6,GreaterEqualDepth:5,GreaterEqualStencilFunc:518,GreaterStencilFunc:516,GridHelper:qXt,Group:KUt,HalfFloatType:SBt,HemisphereLight:_Yt,HemisphereLightHelper:class extends _Ft{constructor(t,e,n){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=n;const i=new ZWt(e);i.rotateY(.5*Math.PI),this.material=new UFt({wireframe:!0,fog:!1,toneMapped:!1}),void 0===this.color&&(this.material.vertexColors=!0);const r=i.getAttribute("position"),o=new Float32Array(3*r.count);i.setAttribute("color",new qFt(o,3)),this.add(new PVt(i,this.material)),this.update()}dispose(){this.children[0].geometry.dispose(),this.children[0].material.dispose()}update(){const t=this.children[0];if(void 0!==this.color)this.material.color.set(this.color);else{const e=t.geometry.getAttribute("color");GXt.copy(this.light.color),WXt.copy(this.light.groundColor);for(let t=0,n=e.count;t<n;t++){const i=t<n/2?GXt:WXt;e.setXYZ(t,i.r,i.g,i.b)}e.needsUpdate=!0}t.lookAt(UXt.setFromMatrixPosition(this.light.matrixWorld).negate())}},HemisphereLightProbe:qYt,IcosahedronBufferGeometry:$Wt,IcosahedronGeometry:$Wt,ImageBitmapLoader:BYt,ImageLoader:Uqt,ImageUtils:hHt,ImmediateRenderObject:zXt,IncrementStencilOp:7682,IncrementWrapStencilOp:34055,InstancedBufferAttribute:NYt,InstancedBufferGeometry:IYt,InstancedInterleavedBuffer:EXt,InstancedMesh:VGt,Int16Attribute:function W$t(t,e){return console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead."),new KFt(t,e)},Int16BufferAttribute:KFt,Int32Attribute:function q$t(t,e){return console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead."),new JFt(t,e)},Int32BufferAttribute:JFt,Int8Attribute:function Y$t(t,e){return console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead."),new YFt(t,e)},Int8BufferAttribute:YFt,IntType:1013,InterleavedBuffer:oGt,InterleavedBufferAttribute:sGt,Interpolant:xqt,InterpolateDiscrete:HBt,InterpolateLinear:FBt,InterpolateSmooth:VBt,InvertStencilOp:5386,JSONLoader:function X$t(){console.error("THREE.JSONLoader has been removed.")},KeepStencilOp:tHt,KeyframeTrack:Eqt,LOD:TGt,LatheBufferGeometry:KWt,LatheGeometry:KWt,Layers:iFt,LensFlare:function $$t(){console.error("THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js")},LessDepth:2,LessEqualDepth:3,LessEqualStencilFunc:515,LessStencilFunc:513,Light:gYt,LightProbe:kYt,Line:XGt,Line3:RXt,LineBasicMaterial:jGt,LineCurve:sYt,LineCurve3:lYt,LineDashedMaterial:yqt,LineLoop:JGt,LinePieces:1,LineSegments:ZGt,LineStrip:0,LinearEncoding:YBt,LinearFilter:gBt,LinearInterpolant:Sqt,LinearMipMapLinearFilter:1008,LinearMipMapNearestFilter:1007,LinearMipmapLinearFilter:yBt,LinearMipmapNearestFilter:_Bt,LinearToneMapping:1,Loader:Bqt,LoaderUtils:PYt,LoadingManager:zqt,LogLuvEncoding:3003,LoopOnce:2200,LoopPingPong:2202,LoopRepeat:2201,LuminanceAlphaFormat:1025,LuminanceFormat:1024,MOUSE:tBt,Material:jFt,MaterialLoader:LYt,Math:sHt,MathUtils:sHt,Matrix3:cHt,Matrix4:qHt,MaxEquation:104,Mesh:PVt,MeshBasicMaterial:UFt,MeshDepthMaterial:UUt,MeshDistanceMaterial:GUt,MeshFaceMaterial:function K$t(t){return console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead."),t},MeshLambertMaterial:gqt,MeshMatcapMaterial:_qt,MeshNormalMaterial:mqt,MeshPhongMaterial:pqt,MeshPhysicalMaterial:dqt,MeshStandardMaterial:hqt,MeshToonMaterial:fqt,MinEquation:103,MirroredRepeatWrapping:dBt,MixOperation:1,MultiMaterial:function Z$t(t=[]){return console.warn("THREE.MultiMaterial has been removed. Use an Array instead."),t.isMultiMaterial=!0,t.materials=t,t.clone=function(){return t.slice()},t},MultiplyBlending:4,MultiplyOperation:0,NearestFilter:pBt,NearestMipMapLinearFilter:1005,NearestMipMapNearestFilter:1004,NearestMipmapLinearFilter:mBt,NearestMipmapNearestFilter:fBt,NeverDepth:0,NeverStencilFunc:512,NoBlending:0,NoColors:0,NoToneMapping:0,NormalAnimationBlendMode:WBt,NormalBlending:1,NotEqualDepth:7,NotEqualStencilFunc:517,NumberKeyframeTrack:Cqt,Object3D:_Ft,ObjectLoader:class extends Bqt{constructor(t){super(t)}load(t,e,n,i){const r=this,o=""===this.path?PYt.extractUrlBase(t):this.path;this.resourcePath=this.resourcePath||o;const a=new Fqt(this.manager);a.setPath(this.path),a.setRequestHeader(this.requestHeader),a.setWithCredentials(this.withCredentials),a.load(t,(function(n){let o=null;try{o=JSON.parse(n)}catch(e){return void 0!==i&&i(e),void console.error("THREE:ObjectLoader: Can't parse "+t+".",e.message)}const a=o.metadata;void 0!==a&&void 0!==a.type&&"geometry"!==a.type.toLowerCase()?r.parse(o,e):console.error("THREE.ObjectLoader: Can't load "+t)}),n,i)}parse(t,e){const n=this.parseAnimations(t.animations),i=this.parseShapes(t.shapes),r=this.parseGeometries(t.geometries,i),o=this.parseImages(t.images,(function(){void 0!==e&&e(l)})),a=this.parseTextures(t.textures,o),s=this.parseMaterials(t.materials,a),l=this.parseObject(t.object,r,s,n),c=this.parseSkeletons(t.skeletons,l);if(this.bindSkeletons(l,c),void 0!==e){let t=!1;for(const e in o)if(o[e]instanceof HTMLImageElement){t=!0;break}!1===t&&e(l)}return l}parseShapes(t){const e={};if(void 0!==t)for(let n=0,i=t.length;n<i;n++){const i=(new mYt).fromJSON(t[n]);e[i.uuid]=i}return e}parseSkeletons(t,e){const n={},i={};if(e.traverse((function(t){t.isBone&&(i[t.uuid]=t)})),void 0!==t)for(let e=0,r=t.length;e<r;e++){const r=(new zGt).fromJSON(t[e],i);n[r.uuid]=r}return n}parseGeometries(t,e){const n={};let i;if(void 0!==t){const r=new OYt;for(let o=0,a=t.length;o<a;o++){let a;const s=t[o];switch(s.type){case"PlaneGeometry":case"PlaneBufferGeometry":a=new lqt[s.type](s.width,s.height,s.widthSegments,s.heightSegments);break;case"BoxGeometry":case"BoxBufferGeometry":a=new lqt[s.type](s.width,s.height,s.depth,s.widthSegments,s.heightSegments,s.depthSegments);break;case"CircleGeometry":case"CircleBufferGeometry":a=new lqt[s.type](s.radius,s.segments,s.thetaStart,s.thetaLength);break;case"CylinderGeometry":case"CylinderBufferGeometry":a=new lqt[s.type](s.radiusTop,s.radiusBottom,s.height,s.radialSegments,s.heightSegments,s.openEnded,s.thetaStart,s.thetaLength);break;case"ConeGeometry":case"ConeBufferGeometry":a=new lqt[s.type](s.radius,s.height,s.radialSegments,s.heightSegments,s.openEnded,s.thetaStart,s.thetaLength);break;case"SphereGeometry":case"SphereBufferGeometry":a=new lqt[s.type](s.radius,s.widthSegments,s.heightSegments,s.phiStart,s.phiLength,s.thetaStart,s.thetaLength);break;case"DodecahedronGeometry":case"DodecahedronBufferGeometry":case"IcosahedronGeometry":case"IcosahedronBufferGeometry":case"OctahedronGeometry":case"OctahedronBufferGeometry":case"TetrahedronGeometry":case"TetrahedronBufferGeometry":a=new lqt[s.type](s.radius,s.detail);break;case"RingGeometry":case"RingBufferGeometry":a=new lqt[s.type](s.innerRadius,s.outerRadius,s.thetaSegments,s.phiSegments,s.thetaStart,s.thetaLength);break;case"TorusGeometry":case"TorusBufferGeometry":a=new lqt[s.type](s.radius,s.tube,s.radialSegments,s.tubularSegments,s.arc);break;case"TorusKnotGeometry":case"TorusKnotBufferGeometry":a=new lqt[s.type](s.radius,s.tube,s.tubularSegments,s.radialSegments,s.p,s.q);break;case"TubeGeometry":case"TubeBufferGeometry":a=new lqt[s.type]((new dYt[s.path.type]).fromJSON(s.path),s.tubularSegments,s.radius,s.radialSegments,s.closed);break;case"LatheGeometry":case"LatheBufferGeometry":a=new lqt[s.type](s.points,s.segments,s.phiStart,s.phiLength);break;case"PolyhedronGeometry":case"PolyhedronBufferGeometry":a=new lqt[s.type](s.vertices,s.indices,s.radius,s.details);break;case"ShapeGeometry":case"ShapeBufferGeometry":i=[];for(let t=0,n=s.shapes.length;t<n;t++)i.push(e[s.shapes[t]]);a=new lqt[s.type](i,s.curveSegments);break;case"ExtrudeGeometry":case"ExtrudeBufferGeometry":i=[];for(let t=0,n=s.shapes.length;t<n;t++)i.push(e[s.shapes[t]]);const t=s.options.extrudePath;void 0!==t&&(s.options.extrudePath=(new dYt[t.type]).fromJSON(t)),a=new lqt[s.type](i,s.options);break;case"BufferGeometry":case"InstancedBufferGeometry":a=r.parse(s);break;case"Geometry":console.error('THREE.ObjectLoader: Loading "Geometry" is not supported anymore.');break;default:console.warn('THREE.ObjectLoader: Unsupported geometry type "'+s.type+'"');continue}a.uuid=s.uuid,void 0!==s.name&&(a.name=s.name),!0===a.isBufferGeometry&&void 0!==s.userData&&(a.userData=s.userData),n[s.uuid]=a}}return n}parseMaterials(t,e){const n={},i={};if(void 0!==t){const r=new LYt;r.setTextures(e);for(let e=0,o=t.length;e<o;e++){const o=t[e];if("MultiMaterial"===o.type){const t=[];for(let e=0;e<o.materials.length;e++){const i=o.materials[e];void 0===n[i.uuid]&&(n[i.uuid]=r.parse(i)),t.push(n[i.uuid])}i[o.uuid]=t}else void 0===n[o.uuid]&&(n[o.uuid]=r.parse(o)),i[o.uuid]=n[o.uuid]}}return i}parseAnimations(t){const e={};if(void 0!==t)for(let n=0;n<t.length;n++){const i=Nqt.parse(t[n]);e[i.uuid]=i}return e}parseImages(t,e){const n=this,i={};let r;function o(t){if("string"==typeof t){const e=t;return(function e(t){return n.manager.itemStart(t),r.load(t,(function(){n.manager.itemEnd(t)}),void 0,(function(){n.manager.itemError(t),n.manager.itemEnd(t)}))})(/^(\/\/)|([a-z]+:(\/\/)?)/i.test(e)?e:n.resourcePath+e)}return t.data?{data:oVt(t.type,t.data),width:t.width,height:t.height}:null}if(void 0!==t&&t.length>0){const n=new zqt(e);r=new Uqt(n),r.setCrossOrigin(this.crossOrigin);for(let e=0,n=t.length;e<n;e++){const n=t[e],r=n.url;if(Array.isArray(r)){i[n.uuid]=[];for(let t=0,e=r.length;t<e;t++){const e=o(r[t]);null!==e&&(e instanceof HTMLImageElement?i[n.uuid].push(e):i[n.uuid].push(new GVt(e.data,e.width,e.height)))}}else{const t=o(n.url);null!==t&&(i[n.uuid]=t)}}}return i}parseTextures(t,e){function n(t,e){return"number"==typeof t?t:(console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",t),e[t])}const i={};if(void 0!==t)for(let r=0,o=t.length;r<o;r++){const o=t[r];let a;void 0===o.image&&console.warn('THREE.ObjectLoader: No "image" specified for',o.uuid),void 0===e[o.image]&&console.warn("THREE.ObjectLoader: Undefined image",o.image);const s=e[o.image];Array.isArray(s)?(a=new jVt(s),6===s.length&&(a.needsUpdate=!0)):(a=s&&s.data?new GVt(s.data,s.width,s.height):new pHt(s),s&&(a.needsUpdate=!0)),a.uuid=o.uuid,void 0!==o.name&&(a.name=o.name),void 0!==o.mapping&&(a.mapping=n(o.mapping,RYt)),void 0!==o.offset&&a.offset.fromArray(o.offset),void 0!==o.repeat&&a.repeat.fromArray(o.repeat),void 0!==o.center&&a.center.fromArray(o.center),void 0!==o.rotation&&(a.rotation=o.rotation),void 0!==o.wrap&&(a.wrapS=n(o.wrap[0],zYt),a.wrapT=n(o.wrap[1],zYt)),void 0!==o.format&&(a.format=o.format),void 0!==o.type&&(a.type=o.type),void 0!==o.encoding&&(a.encoding=o.encoding),void 0!==o.minFilter&&(a.minFilter=n(o.minFilter,DYt)),void 0!==o.magFilter&&(a.magFilter=n(o.magFilter,DYt)),void 0!==o.anisotropy&&(a.anisotropy=o.anisotropy),void 0!==o.flipY&&(a.flipY=o.flipY),void 0!==o.premultiplyAlpha&&(a.premultiplyAlpha=o.premultiplyAlpha),void 0!==o.unpackAlignment&&(a.unpackAlignment=o.unpackAlignment),i[o.uuid]=a}return i}parseObject(t,e,n,i){let r,o,a;function s(t){return void 0===e[t]&&console.warn("THREE.ObjectLoader: Undefined geometry",t),e[t]}function l(t){if(void 0!==t){if(Array.isArray(t)){const e=[];for(let i=0,r=t.length;i<r;i++){const r=t[i];void 0===n[r]&&console.warn("THREE.ObjectLoader: Undefined material",r),e.push(n[r])}return e}return void 0===n[t]&&console.warn("THREE.ObjectLoader: Undefined material",t),n[t]}}switch(t.type){case"Scene":r=new rGt,void 0!==t.background&&Number.isInteger(t.background)&&(r.background=new HFt(t.background)),void 0!==t.fog&&("Fog"===t.fog.type?r.fog=new iGt(t.fog.color,t.fog.near,t.fog.far):"FogExp2"===t.fog.type&&(r.fog=new nGt(t.fog.color,t.fog.density)));break;case"PerspectiveCamera":r=new HVt(t.fov,t.aspect,t.near,t.far),void 0!==t.focus&&(r.focus=t.focus),void 0!==t.zoom&&(r.zoom=t.zoom),void 0!==t.filmGauge&&(r.filmGauge=t.filmGauge),void 0!==t.filmOffset&&(r.filmOffset=t.filmOffset),void 0!==t.view&&(r.view=Object.assign({},t.view));break;case"OrthographicCamera":r=new SYt(t.left,t.right,t.top,t.bottom,t.near,t.far),void 0!==t.zoom&&(r.zoom=t.zoom),void 0!==t.view&&(r.view=Object.assign({},t.view));break;case"AmbientLight":r=new TYt(t.color,t.intensity);break;case"DirectionalLight":r=new EYt(t.color,t.intensity);break;case"PointLight":r=new wYt(t.color,t.intensity,t.distance,t.decay);break;case"RectAreaLight":r=new AYt(t.color,t.intensity,t.width,t.height);break;case"SpotLight":r=new bYt(t.color,t.intensity,t.distance,t.angle,t.penumbra,t.decay);break;case"HemisphereLight":r=new _Yt(t.color,t.groundColor,t.intensity);break;case"LightProbe":r=(new kYt).fromJSON(t);break;case"SkinnedMesh":o=s(t.geometry),a=l(t.material),r=new IGt(o,a),void 0!==t.bindMode&&(r.bindMode=t.bindMode),void 0!==t.bindMatrix&&r.bindMatrix.fromArray(t.bindMatrix),void 0!==t.skeleton&&(r.skeleton=t.skeleton);break;case"Mesh":o=s(t.geometry),a=l(t.material),r=new PVt(o,a);break;case"InstancedMesh":o=s(t.geometry),a=l(t.material);const e=t.instanceMatrix;r=new VGt(o,a,t.count),r.instanceMatrix=new qFt(new Float32Array(e.array),16);break;case"LOD":r=new TGt;break;case"Line":r=new XGt(s(t.geometry),l(t.material));break;case"LineLoop":r=new JGt(s(t.geometry),l(t.material));break;case"LineSegments":r=new ZGt(s(t.geometry),l(t.material));break;case"PointCloud":case"Points":r=new rWt(s(t.geometry),l(t.material));break;case"Sprite":r=new wGt(l(t.material));break;case"Group":r=new KUt;break;case"Bone":r=new NGt;break;default:r=new _Ft}if(r.uuid=t.uuid,void 0!==t.name&&(r.name=t.name),void 0!==t.matrix?(r.matrix.fromArray(t.matrix),void 0!==t.matrixAutoUpdate&&(r.matrixAutoUpdate=t.matrixAutoUpdate),r.matrixAutoUpdate&&r.matrix.decompose(r.position,r.quaternion,r.scale)):(void 0!==t.position&&r.position.fromArray(t.position),void 0!==t.rotation&&r.rotation.fromArray(t.rotation),void 0!==t.quaternion&&r.quaternion.fromArray(t.quaternion),void 0!==t.scale&&r.scale.fromArray(t.scale)),void 0!==t.castShadow&&(r.castShadow=t.castShadow),void 0!==t.receiveShadow&&(r.receiveShadow=t.receiveShadow),t.shadow&&(void 0!==t.shadow.bias&&(r.shadow.bias=t.shadow.bias),void 0!==t.shadow.normalBias&&(r.shadow.normalBias=t.shadow.normalBias),void 0!==t.shadow.radius&&(r.shadow.radius=t.shadow.radius),void 0!==t.shadow.mapSize&&r.shadow.mapSize.fromArray(t.shadow.mapSize),void 0!==t.shadow.camera&&(r.shadow.camera=this.parseObject(t.shadow.camera))),void 0!==t.visible&&(r.visible=t.visible),void 0!==t.frustumCulled&&(r.frustumCulled=t.frustumCulled),void 0!==t.renderOrder&&(r.renderOrder=t.renderOrder),void 0!==t.userData&&(r.userData=t.userData),void 0!==t.layers&&(r.layers.mask=t.layers),void 0!==t.children){const o=t.children;for(let t=0;t<o.length;t++)r.add(this.parseObject(o[t],e,n,i))}if(void 0!==t.animations){const e=t.animations;for(let t=0;t<e.length;t++)r.animations.push(i[e[t]])}if("LOD"===t.type){void 0!==t.autoUpdate&&(r.autoUpdate=t.autoUpdate);const e=t.levels;for(let t=0;t<e.length;t++){const n=e[t],i=r.getObjectByProperty("uuid",n.object);void 0!==i&&r.addLevel(i,n.distance)}}return r}bindSkeletons(t,e){0!==Object.keys(e).length&&t.traverse((function(t){if(!0===t.isSkinnedMesh&&void 0!==t.skeleton){const n=e[t.skeleton];void 0===n?console.warn("THREE.ObjectLoader: No skeleton found with UUID:",t.skeleton):t.bind(n,t.bindMatrix)}}))}setTexturePath(t){return console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath()."),this.setResourcePath(t)}},ObjectSpaceNormalMap:1,OctahedronBufferGeometry:ZWt,OctahedronGeometry:ZWt,OneFactor:201,OneMinusDstAlphaFactor:207,OneMinusDstColorFactor:209,OneMinusSrcAlphaFactor:205,OneMinusSrcColorFactor:203,OrthographicCamera:SYt,PCFShadowMap:1,PCFSoftShadowMap:2,PMREMGenerator:class{constructor(t){this._renderer=t,this._pingPongRenderTarget=null,this._blurMaterial=(function e(t){return new uqt({name:"SphericalGaussianBlur",defines:{n:t},uniforms:{envMap:{value:null},samples:{value:1},weights:{value:new Float32Array(t)},latitudinal:{value:!1},dTheta:{value:0},mipInt:{value:0},poleAxis:{value:new yHt(0,1,0)},inputEncoding:{value:h$t[3e3]},outputEncoding:{value:h$t[3e3]}},vertexShader:"\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t",fragmentShader:"\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t\n\n\t\tuniform int inputEncoding;\n\t\tuniform int outputEncoding;\n\n\t\t#include <encodings_pars_fragment>\n\n\t\tvec4 inputTexelToLinear( vec4 value ) {\n\n\t\t\tif ( inputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( inputEncoding == 1 ) {\n\n\t\t\t\treturn sRGBToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 2 ) {\n\n\t\t\t\treturn RGBEToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 3 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 7.0 );\n\n\t\t\t} else if ( inputEncoding == 4 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 16.0 );\n\n\t\t\t} else if ( inputEncoding == 5 ) {\n\n\t\t\t\treturn RGBDToLinear( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn GammaToLinear( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 linearToOutputTexel( vec4 value ) {\n\n\t\t\tif ( outputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( outputEncoding == 1 ) {\n\n\t\t\t\treturn LinearTosRGB( value );\n\n\t\t\t} else if ( outputEncoding == 2 ) {\n\n\t\t\t\treturn LinearToRGBE( value );\n\n\t\t\t} else if ( outputEncoding == 3 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 7.0 );\n\n\t\t\t} else if ( outputEncoding == 4 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 16.0 );\n\n\t\t\t} else if ( outputEncoding == 5 ) {\n\n\t\t\t\treturn LinearToRGBD( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn LinearToGamma( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 envMapTexelToLinear( vec4 color ) {\n\n\t\t\treturn inputTexelToLinear( color );\n\n\t\t}\n\t\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t",blending:0,depthTest:!1,depthWrite:!1})})(20),this._equirectShader=null,this._cubemapShader=null,this._compileMaterial(this._blurMaterial)}fromScene(t,e=0,n=.1,i=100){v$t=this._renderer.getRenderTarget();const r=this._allocateTargets();return this._sceneToCubeUV(t,n,i,r),e>0&&this._blur(r,0,0,e),this._applyPMREM(r),this._cleanup(r),r}fromEquirectangular(t){return this._fromTexture(t)}fromCubemap(t){return this._fromTexture(t)}compileCubemapShader(){null===this._cubemapShader&&(this._cubemapShader=k$t(),this._compileMaterial(this._cubemapShader))}compileEquirectangularShader(){null===this._equirectShader&&(this._equirectShader=C$t(),this._compileMaterial(this._equirectShader))}dispose(){this._blurMaterial.dispose(),null!==this._cubemapShader&&this._cubemapShader.dispose(),null!==this._equirectShader&&this._equirectShader.dispose();for(let t=0;t<m$t.length;t++)m$t[t].dispose()}_cleanup(t){this._pingPongRenderTarget.dispose(),this._renderer.setRenderTarget(v$t),t.scissorTest=!1,A$t(t,0,0,t.width,t.height)}_fromTexture(t){v$t=this._renderer.getRenderTarget();const e=this._allocateTargets(t);return this._textureToCubeUV(t,e),this._applyPMREM(e),this._cleanup(e),e}_allocateTargets(t){const e={magFilter:pBt,minFilter:pBt,generateMipmaps:!1,type:vBt,format:1023,encoding:M$t(t)?t.encoding:KBt,depthBuffer:!1},n=T$t(e);return n.depthBuffer=!t,this._pingPongRenderTarget=T$t(e),n}_compileMaterial(t){const e=new PVt(m$t[0],t);this._renderer.compile(e,f$t)}_sceneToCubeUV(t,e,n,i){const r=new HVt(90,1,e,n),o=[1,-1,1,1,1,1],a=[1,1,1,-1,-1,-1],s=this._renderer,l=s.autoClear,c=s.outputEncoding,u=s.toneMapping;s.getClearColor(y$t),s.toneMapping=0,s.outputEncoding=YBt,s.autoClear=!1;let h=!1;const d=t.background;if(d){if(d.isColor){d$t.color.copy(d).convertSRGBToLinear(),t.background=null;const e=S$t(d$t.color);d$t.opacity=e,h=!0}}else{d$t.color.copy(y$t).convertSRGBToLinear();const t=S$t(d$t.color);d$t.opacity=t,h=!0}for(let e=0;e<6;e++){const n=e%3;0==n?(r.up.set(0,o[e],0),r.lookAt(a[e],0,0)):1==n?(r.up.set(0,0,o[e]),r.lookAt(0,a[e],0)):(r.up.set(0,o[e],0),r.lookAt(0,0,a[e])),A$t(i,n*l$t,e>2?l$t:0,l$t,l$t),s.setRenderTarget(i),h&&s.render(p$t,r),s.render(t,r)}s.toneMapping=u,s.outputEncoding=c,s.autoClear=l}_textureToCubeUV(t,e){const n=this._renderer;t.isCubeTexture?null==this._cubemapShader&&(this._cubemapShader=k$t()):null==this._equirectShader&&(this._equirectShader=C$t());const i=t.isCubeTexture?this._cubemapShader:this._equirectShader,r=new PVt(m$t[0],i),o=i.uniforms;o.envMap.value=t,t.isCubeTexture||o.texelSize.value.set(1/t.image.width,1/t.image.height),o.inputEncoding.value=h$t[t.encoding],o.outputEncoding.value=h$t[e.texture.encoding],A$t(e,0,0,3*l$t,2*l$t),n.setRenderTarget(e),n.render(r,f$t)}_applyPMREM(t){const e=this._renderer,n=e.autoClear;e.autoClear=!1;for(let e=1;e<u$t;e++){const n=Math.sqrt(_$t[e]*_$t[e]-_$t[e-1]*_$t[e-1]);this._blur(t,e-1,e,n,w$t[(e-1)%w$t.length])}e.autoClear=n}_blur(t,e,n,i,r){const o=this._pingPongRenderTarget;this._halfBlur(t,o,e,n,i,"latitudinal",r),this._halfBlur(o,t,n,n,i,"longitudinal",r)}_halfBlur(t,e,n,i,r,o,a){const s=this._renderer,l=this._blurMaterial;"latitudinal"!==o&&"longitudinal"!==o&&console.error("blur direction must be either latitudinal or longitudinal!");const c=new PVt(m$t[i],l),u=l.uniforms,h=g$t[n]-1,d=isFinite(r)?Math.PI/(2*h):2*Math.PI/39,p=r/d,f=isFinite(r)?1+Math.floor(3*p):20;f>20&&console.warn(`sigmaRadians, ${r}, is too large and will clip, as it requested ${f} samples when the maximum is set to 20`);const m=[];let g=0;for(let t=0;t<20;++t){const e=t/p,n=Math.exp(-e*e/2);m.push(n),0==t?g+=n:t<f&&(g+=2*n)}for(let t=0;t<m.length;t++)m[t]=m[t]/g;u.envMap.value=t.texture,u.samples.value=f,u.weights.value=m,u.latitudinal.value="latitudinal"===o,a&&(u.poleAxis.value=a),u.dTheta.value=d,u.mipInt.value=8-n,u.inputEncoding.value=h$t[t.texture.encoding],u.outputEncoding.value=h$t[t.texture.encoding];const _=g$t[i];A$t(e,3*Math.max(0,l$t-2*_),(0===i?0:2*l$t)+2*_*(i>4?i-8+4:0),3*_,2*_),s.setRenderTarget(e),s.render(c,f$t)}},ParametricBufferGeometry:JWt,ParametricGeometry:JWt,Particle:function J$t(t){return console.warn("THREE.Particle has been renamed to THREE.Sprite."),new wGt(t)},ParticleBasicMaterial:function Q$t(t){return console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial."),new QGt(t)},ParticleSystem:function tKt(t,e){return console.warn("THREE.ParticleSystem has been renamed to THREE.Points."),new rWt(t,e)},ParticleSystemMaterial:function eKt(t){return console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial."),new QGt(t)},Path:fYt,PerspectiveCamera:HVt,Plane:xFt,PlaneBufferGeometry:KVt,PlaneGeometry:KVt,PlaneHelper:class extends XGt{constructor(t,e=1,n=16776960){const i=n,r=new pVt;r.setAttribute("position",new eVt([1,-1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,1,0,0,1,0,0,0],3)),r.computeBoundingSphere(),super(r,new jGt({color:i,toneMapped:!1})),this.type="PlaneHelper",this.plane=t,this.size=e;const o=new pVt;o.setAttribute("position",new eVt([1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],3)),o.computeBoundingSphere(),this.add(new PVt(o,new UFt({color:i,opacity:.2,transparent:!0,depthWrite:!1,toneMapped:!1})))}updateMatrixWorld(t){let e=-this.plane.constant;Math.abs(e)<1e-8&&(e=1e-8),this.scale.set(.5*this.size,.5*this.size,e),this.children[0].material.side=e<0?1:0,this.lookAt(this.plane.normal),super.updateMatrixWorld(t)}},PointCloud:function nKt(t,e){return console.warn("THREE.PointCloud has been renamed to THREE.Points."),new rWt(t,e)},PointCloudMaterial:function iKt(t){return console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial."),new QGt(t)},PointLight:wYt,PointLightHelper:class extends PVt{constructor(t,e,n){super(new eqt(e,4,2),new UFt({wireframe:!0,fog:!1,toneMapped:!1})),this.light=t,this.light.updateMatrixWorld(),this.color=n,this.type="PointLightHelper",this.matrix=this.light.matrixWorld,this.matrixAutoUpdate=!1,this.update()}dispose(){this.geometry.dispose(),this.material.dispose()}update(){void 0!==this.color?this.material.color.set(this.color):this.material.color.copy(this.light.color)}},Points:rWt,PointsMaterial:QGt,PolarGridHelper:class extends ZGt{constructor(t=10,e=16,n=8,i=64,r=4473924,o=8947848){r=new HFt(r),o=new HFt(o);const a=[],s=[];for(let n=0;n<=e;n++){const i=n/e*(2*Math.PI),l=Math.sin(i)*t,c=Math.cos(i)*t;a.push(0,0,0),a.push(l,0,c);const u=1&n?r:o;s.push(u.r,u.g,u.b),s.push(u.r,u.g,u.b)}for(let e=0;e<=n;e++){const l=1&e?r:o,c=t-t/n*e;for(let t=0;t<i;t++){let e=t/i*(2*Math.PI),n=Math.sin(e)*c,r=Math.cos(e)*c;a.push(n,0,r),s.push(l.r,l.g,l.b),e=(t+1)/i*(2*Math.PI),n=Math.sin(e)*c,r=Math.cos(e)*c,a.push(n,0,r),s.push(l.r,l.g,l.b)}}const l=new pVt;l.setAttribute("position",new eVt(a,3)),l.setAttribute("color",new eVt(s,3)),super(l,new jGt({vertexColors:!0,toneMapped:!1})),this.type="PolarGridHelper"}},PolyhedronBufferGeometry:pWt,PolyhedronGeometry:pWt,PositionalAudio:class extends iXt{constructor(t){super(t),this.panner=this.context.createPanner(),this.panner.panningModel="HRTF",this.panner.connect(this.gain)}getOutput(){return this.panner}getRefDistance(){return this.panner.refDistance}setRefDistance(t){return this.panner.refDistance=t,this}getRolloffFactor(){return this.panner.rolloffFactor}setRolloffFactor(t){return this.panner.rolloffFactor=t,this}getDistanceModel(){return this.panner.distanceModel}setDistanceModel(t){return this.panner.distanceModel=t,this}getMaxDistance(){return this.panner.maxDistance}setMaxDistance(t){return this.panner.maxDistance=t,this}setDirectionalCone(t,e,n){return this.panner.coneInnerAngle=t,this.panner.coneOuterAngle=e,this.panner.coneOuterGain=n,this}updateMatrixWorld(t){if(super.updateMatrixWorld(t),!0===this.hasPlaybackControl&&!1===this.isPlaying)return;this.matrixWorld.decompose(rXt,oXt,aXt),sXt.set(0,0,1).applyQuaternion(oXt);const e=this.panner;if(e.positionX){const t=this.context.currentTime+this.listener.timeDelta;e.positionX.linearRampToValueAtTime(rXt.x,t),e.positionY.linearRampToValueAtTime(rXt.y,t),e.positionZ.linearRampToValueAtTime(rXt.z,t),e.orientationX.linearRampToValueAtTime(sXt.x,t),e.orientationY.linearRampToValueAtTime(sXt.y,t),e.orientationZ.linearRampToValueAtTime(sXt.z,t)}else e.setPosition(rXt.x,rXt.y,rXt.z),e.setOrientation(sXt.x,sXt.y,sXt.z)}},PropertyBinding:bXt,PropertyMixer:cXt,QuadraticBezierCurve:cYt,QuadraticBezierCurve3:uYt,Quaternion:_Ht,QuaternionKeyframeTrack:Lqt,QuaternionLinearInterpolant:kqt,REVISION:QDt,RGBADepthPacking:3201,RGBAFormat:TBt,RGBAIntegerFormat:1033,RGBA_ASTC_10x10_Format:37819,RGBA_ASTC_10x5_Format:37816,RGBA_ASTC_10x6_Format:37817,RGBA_ASTC_10x8_Format:37818,RGBA_ASTC_12x10_Format:37820,RGBA_ASTC_12x12_Format:37821,RGBA_ASTC_4x4_Format:37808,RGBA_ASTC_5x4_Format:37809,RGBA_ASTC_5x5_Format:37810,RGBA_ASTC_6x5_Format:37811,RGBA_ASTC_6x6_Format:37812,RGBA_ASTC_8x5_Format:37813,RGBA_ASTC_8x6_Format:37814,RGBA_ASTC_8x8_Format:37815,RGBA_BPTC_Format:36492,RGBA_ETC2_EAC_Format:BBt,RGBA_PVRTC_2BPPV1_Format:zBt,RGBA_PVRTC_4BPPV1_Format:RBt,RGBA_S3TC_DXT1_Format:LBt,RGBA_S3TC_DXT3_Format:PBt,RGBA_S3TC_DXT5_Format:IBt,RGBDEncoding:QBt,RGBEEncoding:KBt,RGBEFormat:1023,RGBFormat:EBt,RGBIntegerFormat:1032,RGBM16Encoding:JBt,RGBM7Encoding:ZBt,RGB_ETC1_Format:36196,RGB_ETC2_Format:DBt,RGB_PVRTC_2BPPV1_Format:OBt,RGB_PVRTC_4BPPV1_Format:NBt,RGB_S3TC_DXT1_Format:kBt,RGFormat:1030,RGIntegerFormat:1031,RawShaderMaterial:uqt,Ray:WHt,Raycaster:AXt,RectAreaLight:AYt,RedFormat:1028,RedIntegerFormat:1029,ReinhardToneMapping:2,RepeatWrapping:uBt,ReplaceStencilOp:7681,ReverseSubtractEquation:102,RingBufferGeometry:QWt,RingGeometry:QWt,SRGB8_ALPHA8_ASTC_10x10_Format:37851,SRGB8_ALPHA8_ASTC_10x5_Format:37848,SRGB8_ALPHA8_ASTC_10x6_Format:37849,SRGB8_ALPHA8_ASTC_10x8_Format:37850,SRGB8_ALPHA8_ASTC_12x10_Format:37852,SRGB8_ALPHA8_ASTC_12x12_Format:37853,SRGB8_ALPHA8_ASTC_4x4_Format:37840,SRGB8_ALPHA8_ASTC_5x4_Format:37841,SRGB8_ALPHA8_ASTC_5x5_Format:37842,SRGB8_ALPHA8_ASTC_6x5_Format:37843,SRGB8_ALPHA8_ASTC_6x6_Format:37844,SRGB8_ALPHA8_ASTC_8x5_Format:37845,SRGB8_ALPHA8_ASTC_8x6_Format:37846,SRGB8_ALPHA8_ASTC_8x8_Format:37847,Scene:rGt,SceneUtils:O$t,ShaderChunk:ZVt,ShaderLib:QVt,ShaderMaterial:DVt,ShadowMaterial:cqt,Shape:mYt,ShapeBufferGeometry:tqt,ShapeGeometry:tqt,ShapePath:HYt,ShapeUtils:GWt,ShortType:1011,Skeleton:zGt,SkeletonHelper:VXt,SkinnedMesh:IGt,SmoothShading:2,Sphere:DHt,SphereBufferGeometry:eqt,SphereGeometry:eqt,Spherical:LXt,SphericalHarmonics3:CYt,Spline:I$t,SplineCurve:hYt,SplineCurve3:P$t,SpotLight:bYt,SpotLightHelper:class extends _Ft{constructor(t,e){super(),this.light=t,this.light.updateMatrixWorld(),this.matrix=t.matrixWorld,this.matrixAutoUpdate=!1,this.color=e;const n=new pVt,i=[0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,1,0,0,0,0,1,1,0,0,0,0,-1,1];for(let t=0,e=1,n=32;t<n;t++,e++){const r=t/n*Math.PI*2,o=e/n*Math.PI*2;i.push(Math.cos(r),Math.sin(r),1,Math.cos(o),Math.sin(o),1)}n.setAttribute("position",new eVt(i,3));const r=new jGt({fog:!1,toneMapped:!1});this.cone=new ZGt(n,r),this.add(this.cone),this.update()}dispose(){this.cone.geometry.dispose(),this.cone.material.dispose()}update(){this.light.updateMatrixWorld();const t=this.light.distance?this.light.distance:1e3,e=t*Math.tan(this.light.angle);this.cone.scale.set(e,e,t),DXt.setFromMatrixPosition(this.light.target.matrixWorld),this.cone.lookAt(DXt),void 0!==this.color?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)}},Sprite:wGt,SpriteMaterial:lGt,SrcAlphaFactor:204,SrcAlphaSaturateFactor:210,SrcColorFactor:202,StaticCopyUsage:35046,StaticDrawUsage:eHt,StaticReadUsage:35045,StereoCamera:KYt,StreamCopyUsage:35042,StreamDrawUsage:35040,StreamReadUsage:35041,StringKeyframeTrack:Pqt,SubtractEquation:101,SubtractiveBlending:3,TOUCH:eBt,TangentSpaceNormalMap:0,TetrahedronBufferGeometry:nqt,TetrahedronGeometry:nqt,TextBufferGeometry:iqt,TextGeometry:iqt,Texture:pHt,TextureLoader:qqt,TorusBufferGeometry:rqt,TorusGeometry:rqt,TorusKnotBufferGeometry:oqt,TorusKnotGeometry:oqt,Triangle:IFt,TriangleFanDrawMode:2,TriangleStripDrawMode:1,TrianglesDrawMode:0,TubeBufferGeometry:aqt,TubeGeometry:aqt,UVMapping:iBt,Uint16Attribute:function rKt(t,e){return console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead."),new ZFt(t,e)},Uint16BufferAttribute:ZFt,Uint32Attribute:function oKt(t,e){return console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead."),new QFt(t,e)},Uint32BufferAttribute:QFt,Uint8Attribute:function aKt(t,e){return console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead."),new XFt(t,e)},Uint8BufferAttribute:XFt,Uint8ClampedAttribute:function sKt(t,e){return console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead."),new $Ft(t,e)},Uint8ClampedBufferAttribute:$Ft,Uniform:MXt,UniformsLib:JVt,UniformsUtils:zVt,UnsignedByteType:vBt,UnsignedInt248Type:MBt,UnsignedIntType:xBt,UnsignedShort4444Type:1017,UnsignedShort5551Type:1018,UnsignedShort565Type:1019,UnsignedShortType:bBt,VSMShadowMap:3,Vector2:lHt,Vector3:yHt,Vector4:mHt,VectorKeyframeTrack:Iqt,Vertex:function lKt(t,e,n){return console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead."),new yHt(t,e,n)},VertexColors:2,VideoTexture:aWt,WebGL1Renderer:eGt,WebGLCubeRenderTarget:UVt,WebGLMultisampleRenderTarget:class extends gHt{constructor(t,e,n){super(t,e,n),Object.defineProperty(this,"isWebGLMultisampleRenderTarget",{value:!0}),this.samples=4}copy(t){return super.copy.call(this,t),this.samples=t.samples,this}},WebGLRenderTarget:gHt,WebGLRenderTargetCube:function cKt(t,e,n){return console.warn("THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options )."),new UVt(t,n)},WebGLRenderer:tGt,WebGLUtils:XUt,WireframeGeometry:sqt,WireframeHelper:function uKt(t,e){return console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead."),new ZGt(new sqt(t.geometry),new jGt({color:void 0!==e?e:16777215}))},WrapAroundEnding:GBt,XHRLoader:function hKt(t){return console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader."),new Fqt(t)},ZeroCurvatureEnding:jBt,ZeroFactor:200,ZeroSlopeEnding:UBt,ZeroStencilOp:0,sRGBEncoding:XBt}),dKt=function(t,e){var n,i,r,o,a,s;void 0===e&&console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.'),e===document&&console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'),this.object=t,this.domElement=e,this.enabled=!0,this.target=new yHt,this.minDistance=0,this.maxDistance=1/0,this.minZoom=0,this.maxZoom=1/0,this.minPolarAngle=0,this.maxPolarAngle=Math.PI,this.minAzimuthAngle=-1/0,this.maxAzimuthAngle=1/0,this.enableDamping=!1,this.dampingFactor=.05,this.enableZoom=!0,this.zoomSpeed=1,this.enableRotate=!0,this.rotateSpeed=1,this.enablePan=!0,this.panSpeed=1,this.screenSpacePanning=!0,this.keyPanSpeed=7,this.autoRotate=!1,this.autoRotateSpeed=2,this.keys={LEFT:37,UP:38,RIGHT:39,BOTTOM:40},this.mouseButtons={LEFT:tBt.ROTATE,MIDDLE:tBt.DOLLY,RIGHT:tBt.PAN},this.touches={ONE:eBt.ROTATE,TWO:eBt.DOLLY_PAN},this.target0=this.target.clone(),this.position0=this.object.position.clone(),this.zoom0=this.object.zoom,this._domElementKeyEvents=null,this.getPolarAngle=function(){return m.phi},this.getAzimuthalAngle=function(){return m.theta},this.listenToKeyEvents=function(t){t.addEventListener("keydown",K),this._domElementKeyEvents=t},this.saveState=function(){l.target0.copy(l.target),l.position0.copy(l.object.position),l.zoom0=l.object.zoom},this.reset=function(){l.target.copy(l.target0),l.object.position.copy(l.position0),l.object.zoom=l.zoom0,l.object.updateProjectionMatrix(),l.dispatchEvent(c),l.update(),p=d.NONE},this.update=(n=new yHt,i=(new _Ht).setFromUnitVectors(t.up,new yHt(0,1,0)),r=i.clone().invert(),o=new yHt,a=new _Ht,s=2*Math.PI,function t(){var e=l.object.position;n.copy(e).sub(l.target),n.applyQuaternion(i),m.setFromVector3(n),l.autoRotate&&p===d.NONE&&L((function u(){return 2*Math.PI/60/60*l.autoRotateSpeed})()),l.enableDamping?(m.theta+=g.theta*l.dampingFactor,m.phi+=g.phi*l.dampingFactor):(m.theta+=g.theta,m.phi+=g.phi);var h=l.minAzimuthAngle,b=l.maxAzimuthAngle;return isFinite(h)&&isFinite(b)&&(h<-Math.PI?h+=s:h>Math.PI&&(h-=s),b<-Math.PI?b+=s:b>Math.PI&&(b-=s),m.theta=h<=b?Math.max(h,Math.min(b,m.theta)):m.theta>(h+b)/2?Math.max(h,m.theta):Math.min(b,m.theta)),m.phi=Math.max(l.minPolarAngle,Math.min(l.maxPolarAngle,m.phi)),m.makeSafe(),m.radius*=_,m.radius=Math.max(l.minDistance,Math.min(l.maxDistance,m.radius)),!0===l.enableDamping?l.target.addScaledVector(y,l.dampingFactor):l.target.add(y),n.setFromSpherical(m),n.applyQuaternion(r),e.copy(l.target).add(n),l.object.lookAt(l.target),!0===l.enableDamping?(g.theta*=1-l.dampingFactor,g.phi*=1-l.dampingFactor,y.multiplyScalar(1-l.dampingFactor)):(g.set(0,0,0),y.set(0,0,0)),_=1,!!(v||o.distanceToSquared(l.object.position)>f||8*(1-a.dot(l.object.quaternion))>f)&&(l.dispatchEvent(c),o.copy(l.object.position),a.copy(l.object.quaternion),v=!1,!0)}),this.dispose=function(){l.domElement.removeEventListener("contextmenu",tt),l.domElement.removeEventListener("pointerdown",q),l.domElement.removeEventListener("wheel",$),l.domElement.removeEventListener("touchstart",Z),l.domElement.removeEventListener("touchend",Q),l.domElement.removeEventListener("touchmove",J),l.domElement.ownerDocument.removeEventListener("pointermove",Y),l.domElement.ownerDocument.removeEventListener("pointerup",X),null!==l._domElementKeyEvents&&l._domElementKeyEvents.removeEventListener("keydown",K)};var l=this,c={type:"change"},u={type:"start"},h={type:"end"},d={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},p=d.NONE,f=1e-6,m=new LXt,g=new LXt,_=1,y=new yHt,v=!1,b=new lHt,x=new lHt,w=new lHt,S=new lHt,M=new lHt,E=new lHt,T=new lHt,A=new lHt,C=new lHt;function k(){return Math.pow(.95,l.zoomSpeed)}function L(t){g.theta-=t}function P(t){g.phi-=t}var I,N=(I=new yHt,function t(e,n){I.setFromMatrixColumn(n,0),I.multiplyScalar(-e),y.add(I)}),O=(function(){var t=new yHt;return function e(n,i){!0===l.screenSpacePanning?t.setFromMatrixColumn(i,1):(t.setFromMatrixColumn(i,0),t.crossVectors(l.object.up,t)),t.multiplyScalar(n),y.add(t)}})(),R=(function(){var t=new yHt;return function e(n,i){var r=l.domElement;if(l.object.isPerspectiveCamera){t.copy(l.object.position).sub(l.target);var o=t.length();o*=Math.tan(l.object.fov/2*Math.PI/180),N(2*n*o/r.clientHeight,l.object.matrix),O(2*i*o/r.clientHeight,l.object.matrix)}else l.object.isOrthographicCamera?(N(n*(l.object.right-l.object.left)/l.object.zoom/r.clientWidth,l.object.matrix),O(i*(l.object.top-l.object.bottom)/l.object.zoom/r.clientHeight,l.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),l.enablePan=!1)}})();function z(t){l.object.isPerspectiveCamera?_/=t:l.object.isOrthographicCamera?(l.object.zoom=Math.max(l.minZoom,Math.min(l.maxZoom,l.object.zoom*t)),l.object.updateProjectionMatrix(),v=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),l.enableZoom=!1)}function D(t){l.object.isPerspectiveCamera?_*=t:l.object.isOrthographicCamera?(l.object.zoom=Math.max(l.minZoom,Math.min(l.maxZoom,l.object.zoom/t)),l.object.updateProjectionMatrix(),v=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),l.enableZoom=!1)}function B(t){b.set(t.clientX,t.clientY)}function H(t){S.set(t.clientX,t.clientY)}function F(t){1==t.touches.length?b.set(t.touches[0].pageX,t.touches[0].pageY):b.set(.5*(t.touches[0].pageX+t.touches[1].pageX),.5*(t.touches[0].pageY+t.touches[1].pageY))}function V(t){1==t.touches.length?S.set(t.touches[0].pageX,t.touches[0].pageY):S.set(.5*(t.touches[0].pageX+t.touches[1].pageX),.5*(t.touches[0].pageY+t.touches[1].pageY))}function j(t){var e=t.touches[0].pageX-t.touches[1].pageX,n=t.touches[0].pageY-t.touches[1].pageY,i=Math.sqrt(e*e+n*n);T.set(0,i)}function U(t){1==t.touches.length?x.set(t.touches[0].pageX,t.touches[0].pageY):x.set(.5*(t.touches[0].pageX+t.touches[1].pageX),.5*(t.touches[0].pageY+t.touches[1].pageY)),w.subVectors(x,b).multiplyScalar(l.rotateSpeed);var e=l.domElement;L(2*Math.PI*w.x/e.clientHeight),P(2*Math.PI*w.y/e.clientHeight),b.copy(x)}function G(t){1==t.touches.length?M.set(t.touches[0].pageX,t.touches[0].pageY):M.set(.5*(t.touches[0].pageX+t.touches[1].pageX),.5*(t.touches[0].pageY+t.touches[1].pageY)),E.subVectors(M,S).multiplyScalar(l.panSpeed),R(E.x,E.y),S.copy(M)}function W(t){var e=t.touches[0].pageX-t.touches[1].pageX,n=t.touches[0].pageY-t.touches[1].pageY,i=Math.sqrt(e*e+n*n);A.set(0,i),C.set(0,Math.pow(A.y/T.y,l.zoomSpeed)),z(C.y),T.copy(A)}function q(t){if(!1!==l.enabled)switch(t.pointerType){case"mouse":case"pen":!(function e(t){var e;switch(t.preventDefault(),l.domElement.focus?l.domElement.focus():window.focus(),t.button){case 0:e=l.mouseButtons.LEFT;break;case 1:e=l.mouseButtons.MIDDLE;break;case 2:e=l.mouseButtons.RIGHT;break;default:e=-1}switch(e){case tBt.DOLLY:if(!1===l.enableZoom)return;!(function n(t){T.set(t.clientX,t.clientY)})(t),p=d.DOLLY;break;case tBt.ROTATE:if(t.ctrlKey||t.metaKey||t.shiftKey){if(!1===l.enablePan)return;H(t),p=d.PAN}else{if(!1===l.enableRotate)return;B(t),p=d.ROTATE}break;case tBt.PAN:if(t.ctrlKey||t.metaKey||t.shiftKey){if(!1===l.enableRotate)return;B(t),p=d.ROTATE}else{if(!1===l.enablePan)return;H(t),p=d.PAN}break;default:p=d.NONE}p!==d.NONE&&(l.domElement.ownerDocument.addEventListener("pointermove",Y),l.domElement.ownerDocument.addEventListener("pointerup",X),l.dispatchEvent(u))})(t)}}function Y(t){if(!1!==l.enabled)switch(t.pointerType){case"mouse":case"pen":!(function e(t){if(!1!==l.enabled)switch(t.preventDefault(),p){case d.ROTATE:if(!1===l.enableRotate)return;!(function e(t){x.set(t.clientX,t.clientY),w.subVectors(x,b).multiplyScalar(l.rotateSpeed);var e=l.domElement;L(2*Math.PI*w.x/e.clientHeight),P(2*Math.PI*w.y/e.clientHeight),b.copy(x),l.update()})(t);break;case d.DOLLY:if(!1===l.enableZoom)return;!(function n(t){A.set(t.clientX,t.clientY),C.subVectors(A,T),C.y>0?z(k()):C.y<0&&D(k()),T.copy(A),l.update()})(t);break;case d.PAN:if(!1===l.enablePan)return;!(function i(t){M.set(t.clientX,t.clientY),E.subVectors(M,S).multiplyScalar(l.panSpeed),R(E.x,E.y),S.copy(M),l.update()})(t)}})(t)}}function X(t){switch(t.pointerType){case"mouse":case"pen":!(function e(t){l.domElement.ownerDocument.removeEventListener("pointermove",Y),l.domElement.ownerDocument.removeEventListener("pointerup",X),!1!==l.enabled&&(l.dispatchEvent(h),p=d.NONE)})()}}function $(t){!1===l.enabled||!1===l.enableZoom||p!==d.NONE&&p!==d.ROTATE||(t.preventDefault(),t.stopPropagation(),l.dispatchEvent(u),(function e(t){t.deltaY<0?D(k()):t.deltaY>0&&z(k()),l.update()})(t),l.dispatchEvent(h))}function K(t){!1!==l.enabled&&!1!==l.enablePan&&(function e(t){var e=!1;switch(t.keyCode){case l.keys.UP:R(0,l.keyPanSpeed),e=!0;break;case l.keys.BOTTOM:R(0,-l.keyPanSpeed),e=!0;break;case l.keys.LEFT:R(l.keyPanSpeed,0),e=!0;break;case l.keys.RIGHT:R(-l.keyPanSpeed,0),e=!0}e&&(t.preventDefault(),l.update())})(t)}function Z(t){if(!1!==l.enabled){switch(t.preventDefault(),t.touches.length){case 1:switch(l.touches.ONE){case eBt.ROTATE:if(!1===l.enableRotate)return;F(t),p=d.TOUCH_ROTATE;break;case eBt.PAN:if(!1===l.enablePan)return;V(t),p=d.TOUCH_PAN;break;default:p=d.NONE}break;case 2:switch(l.touches.TWO){case eBt.DOLLY_PAN:if(!1===l.enableZoom&&!1===l.enablePan)return;!(function e(t){l.enableZoom&&j(t),l.enablePan&&V(t)})(t),p=d.TOUCH_DOLLY_PAN;break;case eBt.DOLLY_ROTATE:if(!1===l.enableZoom&&!1===l.enableRotate)return;!(function n(t){l.enableZoom&&j(t),l.enableRotate&&F(t)})(t),p=d.TOUCH_DOLLY_ROTATE;break;default:p=d.NONE}break;default:p=d.NONE}p!==d.NONE&&l.dispatchEvent(u)}}function J(t){if(!1!==l.enabled)switch(t.preventDefault(),t.stopPropagation(),p){case d.TOUCH_ROTATE:if(!1===l.enableRotate)return;U(t),l.update();break;case d.TOUCH_PAN:if(!1===l.enablePan)return;G(t),l.update();break;case d.TOUCH_DOLLY_PAN:if(!1===l.enableZoom&&!1===l.enablePan)return;!(function e(t){l.enableZoom&&W(t),l.enablePan&&G(t)})(t),l.update();break;case d.TOUCH_DOLLY_ROTATE:if(!1===l.enableZoom&&!1===l.enableRotate)return;!(function n(t){l.enableZoom&&W(t),l.enableRotate&&U(t)})(t),l.update();break;default:p=d.NONE}}function Q(t){!1!==l.enabled&&(l.dispatchEvent(h),p=d.NONE)}function tt(t){!1!==l.enabled&&t.preventDefault()}l.domElement.addEventListener("contextmenu",tt),l.domElement.addEventListener("pointerdown",q),l.domElement.addEventListener("wheel",$),l.domElement.addEventListener("touchstart",Z),l.domElement.addEventListener("touchend",Q),l.domElement.addEventListener("touchmove",J),this.update()};(dKt.prototype=Object.create(rHt.prototype)).constructor=dKt;var pKt=function(t,e){dKt.call(this,t,e),this.screenSpacePanning=!1,this.mouseButtons.LEFT=tBt.PAN,this.mouseButtons.RIGHT=tBt.ROTATE,this.touches.ONE=eBt.PAN,this.touches.TWO=eBt.DOLLY_ROTATE};(pKt.prototype=Object.create(rHt.prototype)).constructor=pKt;class fKt extends rHt{constructor(t){super(),this._lastMesh=null,this._clock=new ZYt,this._canvasSize=null,this._layersConfig=null,this._runColor=t}_isObject(t){return"object"==typeof t&&null!=t&&!Array.isArray(t)}_applyDefaults(t,e){let n={};const i=[t,e];for(let t=0;t<i.length;t++){const e=i[t];for(let t in e){const i=t in n;this._isObject(e[t])?n[t]=this._applyDefaults(n[t]||{},e[t]):i||(n[t]=e[t])}}return n}_createLayers(){if(this._layersConfig&&this._scene&&this._lastMesh){if(this._layersConfig.showBoundingBox){var t=new t$t(this._lastMesh,new HFt("rgb(0, 0, 255)"));this._scene.add(t)}if(this._layersConfig.showAxes){var e=new r$t(5);this._scene.add(e)}}}setLayersConfig(t){this._layersConfig=this._applyDefaults(t,this._layersConfig||{})}_createWorld(t,e){if(this.isReady())return;this._scene=new rGt;var n=new R$t[t.camera.cls](t.camera.fov,this._canvasSize.width/this._canvasSize.height,t.camera.near,t.camera.far);this._camera=n;var i=new dKt(n,e);const r=i;r.lookSpeed=.4,r.movementSpeed=20,r.noFly=!0,r.lookVertical=!0,r.constrainVertical=!0,r.verticalMin=1,r.verticalMax=2,r.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=i,this._renderer=new tGt({antialias:!0}),this._renderer.setPixelRatio(window.devicePixelRatio),this._renderer.setSize(this._canvasSize.width,this._canvasSize.height),this._renderer.setClearColor(16777215,1)}_clearScene(){for(;this._scene.children.length>0;)this._scene.remove(this._scene.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){return{far:this._camera.far,position:this._camera.position.clone(),target:this._cameraControls.target.clone()}}setCanvasSize(t){this._canvasSize=t}draw(){this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex),this._camera.aspect=this._canvasSize.width/this._canvasSize.height,this._camera.updateProjectionMatrix(),this._renderer.setSize(this._canvasSize.width,this._canvasSize.height);const t=function(){var e=this._clock.getDelta();this._cameraControls.update(e),this._animationFrameIndex=requestAnimationFrame(t),this._renderer.render(this._scene,this._camera)}.bind(this);t()}updateScene(t,e){let n={};"config"in t&&t.config&&(n=JSON.parse(t.config)),this.dispatchEvent({type:"beforeUpdateScene"}),n=this._applyDefaults(n,{camera:{cls:"PerspectiveCamera",fov:75,near:.1,far:1e3},lights:[{cls:"AmbientLight",color:"#ffffff",intensity:.75},{cls:"DirectionalLight",color:"#ffffff",intensity:.75,position:[0,-1,2]}]}),this._createWorld(n,e),this._clearScene(),this._createLights(this._scene,n),this._createGeometry(t,n),this._createLayers(),this.draw()}resetView(t){if(!this.isReady())return;let e;this._cameraControls.reset(),!t&&this._lastMesh&&(e=this._lastMesh),e&&(this._fitObjectToViewport(e),this._lastMesh=e),this._cameraControls.update()}_createGeometry(t,e){const n=t.mesh;n.vertices&&n.faces&&n.faces.length?this._createMesh(n,e):this._createPointCloud(n,e)}_createPointCloud(t,e){const n=t.vertices,i=t.colors;let r={material:{cls:"PointsMaterial",size:.005}};i&&i.length==n.length?r.material.vertexColors=!0:r.material.color=this._runColor;const o=this._applyDefaults(e,r),a=new pVt,s=new Float32Array(n.flat());if(a.setAttribute("position",new qFt(s,3)),i&&i.length==n.length){const t=new Float32Array(i.flat());for(let e=0;e<t.length;e++)t[e]=t[e]/255;a.setAttribute("color",new qFt(t,3))}var l=new rWt(a,new R$t[o.material.cls](o.material));this._scene.add(l),this._lastMesh=l}setCameraViewpoint(t,e,n){this._silent=!0,this._camera.far=e,this._camera.position.set(t.x,t.y,t.z),this._camera.lookAt(n.clone()),this._camera.updateProjectionMatrix(),this._cameraControls.target=n.clone(),this._cameraControls.update(),this._silent=!1}_onCameraPositionChange(t){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:t})}_fitObjectToViewport(t){const e=new xHt,n=new yHt,i=new yHt;e.setFromObject(t),e.getCenter(n),e.getSize(i);const r=Math.max(i.x,i.y,i.z),o=this._camera.fov*(Math.PI/180);let a=1.25*Math.abs(r/(2*Math.tan(o/2)));const s=e.min.z;this.setCameraViewpoint({x:n.x,y:n.y,z:a},3*(s<0?-s+a:a-s),n)}_createMesh(t,e){const n=t.vertices,i=t.faces,r=t.colors,o=this._applyDefaults(e,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}}),a=new pVt,s=new Float32Array(n.flat());a.setAttribute("position",new qFt(s,3));const l=new Uint16Array(i.flat());if(r&&r.length){const t=r.flat();for(let e=0;e<t.length;e++)t[e]=t[e]/255;a.setAttribute("color",new qFt(new Float32Array(t),3)),o.material=o.material||{},o.material.vertexColors=!0}a.center(),a.computeBoundingSphere(),a.setIndex(new qFt(l,1)),a.computeVertexNormals();let c=new PVt(a,new R$t[o.material.cls](o.material));c.castShadow=!0,c.receiveShadow=!0,this._scene.add(c),this._lastMesh=c}_createLights(t,e){for(let n=0;n<e.lights.length;n++){const i=e.lights[n];let r=new R$t[i.cls](i.color,i.intensity);i.position&&r.position.set(i.position[0],i.position[1],i.position[2]),t.add(r)}}}let mKt=class extends(tr(ye)){constructor(){super(...arguments),this.selectedView="all",this.active=!1,this._colorScaleFunction=xO,this._steps=[],this._meshViewerAttached=!1,this._cameraPositionInitialized=!1,this._isMeshLoading=!1}get _runColor(){return this._colorScaleFunction(this.run)}connectedCallback(){super.connectedCallback(),this._dataProvider=new JDt(this.requestManager);const t=new fKt(this._runColor);t.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this)),t.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this)),this._meshViewer=t}reload(){this.active&&this._dataProvider&&(this._isMeshLoading=!0,this._dataProvider.reload(this.run,this.tag,this.sample).then((t=>{t&&(this._steps=t,this._stepIndex=t.length-1)})).catch((t=>{if(!t||!t.code||t.code!=$Dt.CANCELLED)throw t=t||"Response processing failed.",new Error(t)})))}_updateScene(){const t=this._currentStep;t&&t.mesh&&(this._meshViewer.updateScene(t,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||(this.shadowRoot.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))}_debouncedFetchMesh(){this.debounce("fetchMesh",(()=>this._maybeFetchMesh()),100)}_maybeFetchMesh(){return n(this,void 0,void 0,(function*(){const t=this._currentStep;if(t&&!t.mesh&&!t.meshFetching){t.meshFetching=!0,this._isMeshLoading=!0;try{const e=yield this._dataProvider.fetchData(t,this.run,this.tag,this.sample);t.mesh=e[0],this.notifyPath("_currentStep.mesh")}catch(t){if(!t||!t.code||t.code!=$Dt.CANCELLED)throw t=t||"Response processing failed.",new Error(t)}finally{this._isMeshLoading=!1,t.meshFetching=!1}}}))}_onCameraPositionChange(){if(!this._meshViewer.isReady())return;const t=new CustomEvent("camera-position-change",{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(t)}setCameraViewpoint(t,e,n){this._meshViewer.setCameraViewpoint(t,e,n)}_updateCanvasSize(){const t=this.offsetWidth,e=t,n=this.$$(".tf-mesh-loader-header").offsetHeight;this._meshViewer.setCanvasSize({width:t,height:e-n})}redraw(){this._updateCanvasSize(),this.isConnected&&this._meshViewer.draw()}_hasAtLeastOneStep(t){return!!t&&t.length>0}_hasMultipleSteps(t){return!!t&&t.length>1}get _currentStep(){return this._steps[this._stepIndex]||null}get _stepValue(){const t=this._currentStep;return t?t.step:0}get _currentWallTime(){const t=this._currentStep;return t?AO(t.wall_time):""}_getMaxStepIndex(t){return t.length-1}_getSampleText(t){return String(t+1)}_hasMultipleSamples(t){return t>1}_updateView(){this._meshViewer&&"all"==this.selectedView&&this._meshViewer.resetView()}toLocaleString_(t){return t.toLocaleString()}};mKt.template=_e`
    <tf-card-heading color="[[_runColor]]" class="tf-mesh-loader-header">
      <template is="dom-if" if="[[_hasMultipleSamples(ofSamples)]]">
        <div>sample: [[_getSampleText(sample)]] of [[ofSamples]]</div>
      </template>
      <template is="dom-if" if="[[_hasAtLeastOneStep(_steps)]]">
        <div class="heading-row">
          <div class="heading-label">
            step
            <span style="font-weight: bold"
              >[[toLocaleString_(_stepValue)]]</span
            >
          </div>
          <div class="heading-label heading-right">
            <template is="dom-if" if="[[_currentWallTime]]">
              [[_currentWallTime]]
            </template>
          </div>
          <div class="label right">
            <paper-spinner-lite active hidden$="[[!_isMeshLoading]]">
            </paper-spinner-lite>
          </div>
        </div>
      </template>
      <template is="dom-if" if="[[_hasMultipleSteps(_steps)]]">
        <div>
          <paper-slider
            id="steps"
            immediate-value="{{_stepIndex}}"
            max="[[_getMaxStepIndex(_steps)]]"
            max-markers="[[_getMaxStepIndex(_steps)]]"
            snaps
            step="1"
            value="{{_stepIndex}}"
          ></paper-slider>
        </div>
      </template>
    </tf-card-heading>
    <style>
      paper-slider {
        width: 100%;
        margin-left: 1px;
        margin-right: 1px;
      }
      .tf-mesh-loader-header {
        display: block;
        height: 105px;
      }
      [hidden] {
        display: none;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],mKt.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],mKt.prototype,"tag",void 0),t([o({type:Number}),e("design:type",Number)],mKt.prototype,"sample",void 0),t([o({type:Number}),e("design:type",Number)],mKt.prototype,"ofSamples",void 0),t([o({type:String}),e("design:type",String)],mKt.prototype,"selectedView",void 0),t([o({type:Boolean}),e("design:type",Boolean)],mKt.prototype,"active",void 0),t([o({type:Object}),e("design:type",hr)],mKt.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",fKt)],mKt.prototype,"_meshViewer",void 0),t([o({type:Object}),e("design:type",JDt)],mKt.prototype,"_dataProvider",void 0),t([o({type:Object}),e("design:type",Object)],mKt.prototype,"_colorScaleFunction",void 0),t([o({type:Array,notify:!0}),e("design:type",Array)],mKt.prototype,"_steps",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],mKt.prototype,"_stepIndex",void 0),t([o({type:Boolean}),e("design:type",Boolean)],mKt.prototype,"_meshViewerAttached",void 0),t([o({type:Boolean}),e("design:type",Boolean)],mKt.prototype,"_cameraPositionInitialized",void 0),t([o({type:Boolean}),e("design:type",Boolean)],mKt.prototype,"_isMeshLoading",void 0),t([s("run"),e("design:type",String),e("design:paramtypes",[])],mKt.prototype,"_runColor",null),t([a("run","tag","active","_dataProvider","_meshViewer"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mKt.prototype,"reload",null),t([a("_currentStep.*","_meshViewer"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mKt.prototype,"_updateScene",null),t([a("_currentStep"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mKt.prototype,"_debouncedFetchMesh",null),t([s("_steps","_stepIndex"),e("design:type",Object),e("design:paramtypes",[])],mKt.prototype,"_currentStep",null),t([s("_currentStep"),e("design:type",Number),e("design:paramtypes",[])],mKt.prototype,"_stepValue",null),t([s("_currentStep"),e("design:type",String),e("design:paramtypes",[])],mKt.prototype,"_currentWallTime",null),t([a("selectedView"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],mKt.prototype,"_updateView",null),mKt=t([i("tf-mesh-loader")],mKt);let gKt=class extends ye{constructor(){super(),this.reloadOnReady=!0,this._tagFilter=".*",this._selectedView="all",this._requestManager=new hr,window.addEventListener("resize",(()=>{this._handleWindowResize()}),!1),this.reloadOnReady&&this.reload()}_getAllChildren(){return Array.from(this.shadowRoot.querySelectorAll("tf-mesh-loader"))}_onCameraPositionChanged(t){"share"==this._selectedView&&this._getAllChildren().forEach((e=>{t.target!=e&&e.setCameraViewpoint(t.detail.position,t.detail.far,t.detail.target)}))}_shouldOpen(t){return t<=2}reload(){this._fetchTags().then(this._reloadMeshes.bind(this))}_handleWindowResize(){this._getAllChildren().forEach((t=>{t.redraw()}))}_fetchTags(){const t=gr().pluginRoute("mesh","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=or(we.mapValues(t,(t=>Object.keys(t))));this._dataNotFound=0===e.length,this._runToTagInfo=t}))}_reloadMeshes(){this._getAllChildren().forEach((t=>{t.reload()}))}get _categories(){var t=this._runToTagInfo,e=this._selectedRuns,n=this._tagFilter;function i(e){const n=t[e.run][e.tag].samples;return we.range(n).map((t=>Object.assign({},e,{sample:t,ofSamples:n})))}return Sr(we.mapValues(t,(t=>Object.keys(t))),e,n).map((t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(i))})))}};gKt.template=_e`
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <div class="settings">
          <div class="sidebar-section view-control">
            <h3 class="title">Point of view</h3>
            <div>
              <paper-radio-group
                id="view-radio-group"
                selected="{{_selectedView}}"
              >
                <paper-radio-button id="all-radio-button" name="all">
                  Display all points
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="all-radio-button"
                  position="right"
                  offset="0"
                >
                  Zoom and center camera to display all points at once. Note,
                  that some points could be too far (i.e. too small) to be
                  visible.
                </paper-tooltip>
                <paper-radio-button id="user-radio-button" name="user">
                  Current view
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="user-radio-button"
                  position="right"
                  offset="0"
                >
                  Keep current camera position and zoom level.
                </paper-tooltip>
                <paper-radio-button id="share-radio-button" name="share">
                  Share viewpoint
                </paper-radio-button>
                <paper-tooltip
                  animation-delay="0"
                  for="share-radio-button"
                  position="right"
                  offset="0"
                >
                  Share viewpoint among all cameras.
                </paper-tooltip>
              </paper-radio-group>
            </div>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No point cloud data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any point cloud data to your event files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-mesh-loader
                  active="[[active]]"
                  selected-view="[[_selectedView]]"
                  run="[[item.run]]"
                  tag="[[item.tag]]"
                  sample="[[item.sample]]"
                  of-samples="[[item.ofSamples]]"
                  request-manager="[[_requestManager]]"
                  class="tf-mesh-loader-container"
                  on-camera-position-change="_onCameraPositionChanged"
                >
                </tf-mesh-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      paper-radio-button {
        display: block;
        padding: 5px;
      }
      .sidebar-section h3.title {
        color: var(--paper-grey-800);
        margin: 0;
        font-weight: normal;
        font-size: 14px;
        margin-bottom: 5px;
      }

      .runs-selector {
        flex-grow: 1;
      }

      tf-runs-selector {
        display: flex;
      }

      .view-control {
        display: block !important;
      }

      .view-control h3.title {
        padding-top: 16px;
        padding-bottom: 16px;
      }

      .allcontrols .view-control paper-radio-group {
        margin-top: 5px;
      }
      /* Layout must be horizontal, i.e. items arranged in a row. If items cannot fit in a row,
       * they should be moved to next line. All items must be square at all times. Minimum size of
       * the item is 480px. This means that maximum size of the item must be 480px + 479px = 959px.
       * */
      .horizontal {
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
      }
      tf-mesh-loader {
        width: 480px;
        flex-basis: 480px;
        flex-grow: 1;
        display: block;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],gKt.prototype,"reloadOnReady",void 0),t([o({type:Array}),e("design:type",Array)],gKt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],gKt.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],gKt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],gKt.prototype,"_tagFilter",void 0),t([o({type:String,notify:!0}),e("design:type",String)],gKt.prototype,"_selectedView",void 0),t([o({type:Object}),e("design:type",Object)],gKt.prototype,"_requestManager",void 0),t([s("_runToTagInfo","_selectedRuns","_tagFilter"),e("design:type",Array),e("design:paramtypes",[])],gKt.prototype,"_categories",null),gKt=t([i("mesh-dashboard"),e("design:paramtypes",[])],gKt);let _Kt=class extends ye{constructor(){super(...arguments),this._expanded=!1,this._runToPrCurveEntry={},this._previousRunToPrCurveEntry={},this._colorScaleFunction={scale:xO},this._canceller=new EO,this._xComponentsCreationMethod=()=>{const t=new Ugt.Scales.Linear;return{scale:t,axis:new Ugt.Axes.Numeric(t,"bottom"),accessor:t=>t.recall}},this._yValueAccessor=t=>t.precision,this._tooltipColumns=(()=>{const t=qgt(4),e=e=>isNaN(e)?"NaN":t(e);return[{title:"Run",evaluate:t=>t.dataset.metadata().name},{title:"Threshold",evaluate:t=>e(t.datum.thresholds)},{title:"Precision",evaluate:t=>e(t.datum.precision)},{title:"Recall",evaluate:t=>e(t.datum.recall)},{title:"TP",evaluate:t=>t.datum.true_positives},{title:"FP",evaluate:t=>t.datum.false_positives},{title:"TN",evaluate:t=>t.datum.true_negatives},{title:"FN",evaluate:t=>t.datum.false_negatives}]})(),this._seriesDataFields=["thresholds","precision","recall","true_positives","false_positives","true_negatives","false_negatives"],this._defaultXRange=[-.05,1.05],this._defaultYRange=[-.05,1.05],this._requestData=(t,e,n)=>{const i=gr().pluginRoute("pr_curves","/pr_curves");Promise.all(t.map((t=>{const n=OO(i,{tag:this.tag,run:t});return this.requestManager.request(n).then((n=>{e({item:t,data:n})}))}))).finally((()=>{n()}))},this._smoothingEnabled=!1}_createProcessDataFunction(){return(t,e,n)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,n))}}_computeRunColor(t){return xO(t)}connectedCallback(){super.connectedCallback(),this._attached=!0,this.reload()}_getChartDataLoader(){return this.shadowRoot.querySelector("tf-line-chart-data-loader")}reload(){this._attached&&(0!==this.runs.length?this._getChartDataLoader().reload():this.set("_runToDataOverTime",{}))}_setChartData(){var t=this._runToPrCurveEntry,e=this._previousRunToPrCurveEntry,n=this._setOfRelevantRuns;we.forOwn(t,((i,r)=>{const o=e[r];o&&t[r].step===o.step||(n[r]?this._updateSeriesDataForRun(r,i):this._clearSeriesData(r))}))}_updateSeriesDataForRun(t,e){const n=we.reduce(this._seriesDataFields,((t,n)=>(t[n]=e[n].slice().reverse(),t)),{}),i=new Array(n[this._seriesDataFields[0]].length);for(let t=0;t<i.length;t++)i[t]=we.mapValues(n,(e=>e[t]));const r=this._getChartDataLoader();r.setSeriesData(t,i),r.commitChanges()}_clearSeriesData(t){const e=this._getChartDataLoader();e.setSeriesData(t,[]),e.commitChanges()}_updateRunToPrCurveEntry(){var t=this.runToStepCap;const e={};we.forOwn(this._runToDataOverTime,((n,i)=>{n&&n.length&&(e[i]=this._computeEntryClosestOrEqualToStepCap(t[i],n))})),this.set("_previousRunToPrCurveEntry",this._runToPrCurveEntry),this.set("_runToPrCurveEntry",e)}_notifyDataChange(){this.onDataChange&&this.onDataChange(this._runToDataOverTime)}_computeEntryClosestOrEqualToStepCap(t,e){const n=Math.min(we.sortedIndex(e.map((t=>t.step)),t),e.length-1);return e[n]}get _runsWithStepAvailable(){var t=this._runToPrCurveEntry;return we.filter(this.runs,(e=>t[e])).sort()}get _setOfRelevantRuns(){const t={};return we.forEach(this._runsWithStepAvailable,(e=>{t[e]=!0})),t}_computeCurrentStepForRun(t,e){const n=t[e];return n?n.step:null}_computeCurrentWallTimeForRun(t,e){const n=t[e];return n?new Date(1e3*n.wall_time).toString():null}_toggleExpanded(t){this.set("_expanded",!this._expanded),this.redraw()}_resetDomain(){this._getChartDataLoader().resetDomain()}redraw(){this._getChartDataLoader().redraw()}};_Kt.template=_e`
    <tf-card-heading
      tag="[[tag]]"
      display-name="[[tagMetadata.displayName]]"
      description="[[tagMetadata.description]]"
    ></tf-card-heading>

    <tf-line-chart-data-loader
      x-components-creation-method="[[_xComponentsCreationMethod]]"
      y-value-accessor="[[_yValueAccessor]]"
      tooltip-columns="[[_tooltipColumns]]"
      color-scale="[[_colorScaleFunction]]"
      default-x-range="[[_defaultXRange]]"
      default-y-range="[[_defaultYRange]]"
      smoothing-enabled="[[_smoothingEnabled]]"
      request-manager="[[requestManager]]"
      data-to-load="[[runs]]"
      data-series="[[runs]]"
      load-key="[[tag]]"
      request-data="[[_requestData]]"
      load-data-callback="[[_createProcessDataFunction()]]"
      active="[[active]]"
    ></tf-line-chart-data-loader>

    <div id="buttons-row">
      <paper-icon-button
        selected$="[[_expanded]]"
        icon="fullscreen"
        on-tap="_toggleExpanded"
      ></paper-icon-button>
      <paper-icon-button
        icon="settings-overscan"
        on-tap="_resetDomain"
        title="Reset axes to [0, 1]."
      ></paper-icon-button>
    </div>

    <div id="step-legend">
      <template is="dom-repeat" items="[[_runsWithStepAvailable]]" as="run">
        <div class="legend-row">
          <div
            class="color-box"
            style="background: [[_computeRunColor(run)]];"
          ></div>
          [[run]] is at
          <span class="step-label-text">
            step [[_computeCurrentStepForRun(_runToPrCurveEntry, run)]] </span
          ><br />
          <span class="wall-time-label-text">
            ([[_computeCurrentWallTimeForRun(_runToPrCurveEntry, run)]])
          </span>
        </div>
      </template>
    </div>

    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 500px;
        margin-right: 10px;
        margin-bottom: 25px;
      }
      :host([_expanded]) {
        width: 100%;
      }
      tf-line-chart-data-loader {
        height: 300px;
        position: relative;
      }
      :host([_expanded]) tf-line-chart-data-loader {
        height: 600px;
      }
      #buttons-row {
        display: flex;
        flex-direction: row;
      }
      #buttons-row paper-icon-button {
        color: #2196f3;
        border-radius: 100%;
        width: 32px;
        height: 32px;
        padding: 4px;
      }
      #buttons-row paper-icon-button[selected] {
        background: var(--tb-ui-light-accent);
      }
      #step-legend {
        box-sizing: border-box;
        font-size: 0.8em;
        max-height: 200px;
        overflow-y: auto;
        padding: 0 0 0 10px;
        width: 100%;
      }
      .legend-row {
        margin: 5px 0 5px 0;
        width: 100%;
      }
      .color-box {
        display: inline-block;
        border-radius: 1px;
        width: 10px;
        height: 10px;
      }
      .step-label-text {
        font-weight: bold;
      }
      .wall-time-label-text {
        color: #888;
        font-size: 0.8em;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],_Kt.prototype,"runs",void 0),t([o({type:String}),e("design:type",String)],_Kt.prototype,"tag",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"tagMetadata",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"runToStepCap",void 0),t([o({type:Object}),e("design:type",hr)],_Kt.prototype,"requestManager",void 0),t([o({type:Boolean}),e("design:type",Boolean)],_Kt.prototype,"active",void 0),t([o({type:Boolean,reflectToAttribute:!0}),e("design:type",Boolean)],_Kt.prototype,"_expanded",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_runToPrCurveEntry",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_previousRunToPrCurveEntry",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_runToDataOverTime",void 0),t([o({type:Object}),e("design:type",Function)],_Kt.prototype,"onDataChange",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_colorScaleFunction",void 0),t([o({type:Object}),e("design:type",EO)],_Kt.prototype,"_canceller",void 0),t([o({type:Boolean}),e("design:type",Boolean)],_Kt.prototype,"_attached",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_xComponentsCreationMethod",void 0),t([o({type:Object}),e("design:type",Object)],_Kt.prototype,"_yValueAccessor",void 0),t([o({type:Array}),e("design:type",Array)],_Kt.prototype,"_tooltipColumns",void 0),t([o({type:Array}),e("design:type",Array)],_Kt.prototype,"_seriesDataFields",void 0),t([o({type:Array}),e("design:type",Array)],_Kt.prototype,"_defaultXRange",void 0),t([o({type:Array}),e("design:type",Array)],_Kt.prototype,"_defaultYRange",void 0),t([o({type:Object}),e("design:type",Function)],_Kt.prototype,"_requestData",void 0),t([o({type:Boolean}),e("design:type",Boolean)],_Kt.prototype,"_smoothingEnabled",void 0),t([a("runs","tag"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],_Kt.prototype,"reload",null),t([a("_runToPrCurveEntry","_previousRunToPrCurveEntry","_setOfRelevantRuns"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],_Kt.prototype,"_setChartData",null),t([a("_runToDataOverTime","runToStepCap"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],_Kt.prototype,"_updateRunToPrCurveEntry",null),t([a("_runToDataOverTime"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],_Kt.prototype,"_notifyDataChange",null),t([s("runs","_runToPrCurveEntry"),e("design:type",Array),e("design:paramtypes",[])],_Kt.prototype,"_runsWithStepAvailable",null),t([s("_runsWithStepAvailable"),e("design:type",Object),e("design:paramtypes",[])],_Kt.prototype,"_setOfRelevantRuns",null),_Kt=t([i("tf-pr-curve-card")],_Kt);let yKt=class extends ye{constructor(){super(...arguments),this._runToStepIndex={}}_computeColorForRun(t){return xO(t)}_computeTimeTextForRun(t,e,n,i){const r=e[n];if(!we.isNumber(r))return"";const o=t[n];if(!o)return"";const a=o[r][i];if("step"===i)return`step ${a}`;if("relative"===i)return a<1?`${(1e3*a).toFixed(2)} ms`:`${a.toFixed(2)} s`;if("wall_time"===i)return new Date(1e3*a).toString();throw new Error(`The display type of ${i} is not recognized.`)}_sliderValueChanged(t){const e=t.target.dataset.run,n=t.target.immediateValue,i=Object.assign({},this._runToStepIndex);isNaN(n)?delete i[e]:i[e]=t.target.immediateValue,this._runToStepIndex=i}_computeMaxStepIndexForRun(t,e){const n=t[e];return n&&n.length?n.length-1:0}_updateStepsForNewRuns(){var t=this.runToAvailableTimeEntries;const e=Object.assign({},this._runToStepIndex);we.forOwn(t,((t,n)=>{we.isNumber(e[n])||(e[n]=t.length-1)})),this._runToStepIndex=e}_getStep(t,e){return this._runToStepIndex?this._runToStepIndex[e]:0}_computeRunToStep(t,e){const n={};return we.forOwn(e,((e,i)=>{const r=t[i];r&&(n[i]=r[e].step)})),n}get _runsWithSliders(){var t=this.runToAvailableTimeEntries;return this.runs.filter((e=>t[e]))}};yKt.template=_e`
    <template is="dom-repeat" items="[[_runsWithSliders]]" as="run">
      <div class="run-widget">
        <div class="run-display-container">
          <div
            class="run-color-box"
            style="background:[[_computeColorForRun(run)]];"
          ></div>
          <div class="run-text">[[run]]</div>
        </div>
        <div class="step-display-container">
          [[_computeTimeTextForRun(runToAvailableTimeEntries, _runToStepIndex,
          run, timeDisplayType)]]
        </div>
        <paper-slider
          data-run$="[[run]]"
          step="1"
          type="number"
          min="0"
          max="[[_computeMaxStepIndexForRun(runToAvailableTimeEntries, run)]]"
          value="[[_getStep(_runToStepIndex, run)]]"
          on-immediate-value-changed="_sliderValueChanged"
        ></paper-slider>
      </div>
    </template>
    <style>
      .run-widget {
        margin: 10px 0 0 0;
      }
      paper-slider {
        margin: -8px 0 0 -15px;
        width: 100%;
      }
      .step-display-container {
        font-size: 0.9em;
        margin: 0 15px 0 0;
      }
      .run-text {
        display: inline-block;
      }
      .run-color-box {
        width: 12px;
        height: 12px;
        border-radius: 3px;
        display: inline-block;
      }
    </style>
  `,t([o({type:Array}),e("design:type",Array)],yKt.prototype,"runs",void 0),t([o({type:Object}),e("design:type",Object)],yKt.prototype,"runToAvailableTimeEntries",void 0),t([o({type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"}),e("design:type",Object)],yKt.prototype,"runToStep",void 0),t([o({type:String}),e("design:type",String)],yKt.prototype,"timeDisplayType",void 0),t([o({type:Object}),e("design:type",Object)],yKt.prototype,"_runToStepIndex",void 0),t([a("runToAvailableTimeEntries"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],yKt.prototype,"_updateStepsForNewRuns",null),t([s("runs","runToAvailableTimeEntries"),e("design:type",Array),e("design:paramtypes",[])],yKt.prototype,"_runsWithSliders",null),yKt=t([i("tf-pr-curve-steps-selector")],yKt);let vKt=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._timeDisplayType="step",this._selectedRuns=[],this._runToTagInfo={},this._tagToRunToData={},this._getCategoryItemKey=t=>t.tag,this._requestManager=new hr,this._step=0}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){Promise.all([this._fetchTags()]).then((()=>{this._reloadCards()}))}_shouldOpen(t){return t<=2}_fetchTags(){const t=gr().pluginRoute("pr_curves","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=or(we.mapValues(t,(t=>we.keys(t))));this.set("_dataNotFound",0===e.length),this.set("_runToTagInfo",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadCards(){we.forEach(this.root.querySelectorAll("tf-pr-curve-card"),(t=>{t.reload()}))}get _categories(){var t=this._selectedRuns,e=this._tagFilter;return xr(we.mapValues(this._runToTagInfo,(t=>Object.keys(t))),t,e)}get _relevantSelectedRuns(){var t=this._runToTagInfo;return this._selectedRuns.filter((e=>t[e]))}_tagMetadata(t,e,n){const i={};e.forEach((e=>{i[e]=t[e][n]}));const r=n.replace(/\/pr_curves$/,"");return IO(i,r)}_createDataChangeCallback(t){return e=>{this.set("_tagToRunToData",Object.assign(Object.assign({},this._tagToRunToData),{[t]:e}))}}get _runToAvailableTimeEntries(){var t=this._tagToRunToData;const e={};for(const[n,i]of Object.entries(t))for(const[t]of Object.entries(i))(null==e[t]||n<e[t])&&(e[t]=n);const n={};for(const[i,r]of Object.entries(e)){const e=t[r][i];n[i]=e.map((t=>({step:t.step,wall_time:t.wall_time,relative:t.wall_time-e[0].wall_time})))}return n}};vKt.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <tf-option-selector
              id="time-type-selector"
              name="Time Display Type"
              selected-id="{{_timeDisplayType}}"
            >
              <paper-button id="step">step</paper-button>
              <!--
            -->
              <paper-button id="relative">relative</paper-button>
              <!--
            -->
              <paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
          <template is="dom-if" if="[[_runToAvailableTimeEntries]]">
            <div class="sidebar-section" id="steps-selector-container">
              <tf-pr-curve-steps-selector
                runs="[[_relevantSelectedRuns]]"
                run-to-step="{{_runToStep}}"
                run-to-available-time-entries="[[_runToAvailableTimeEntries]]"
                time-display-type="[[_timeDisplayType]]"
              >
              </tf-pr-curve-steps-selector>
            </div>
          </template>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No precision–recall curve data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>
                You haven’t written any precision–recall data to your event
                files.
              </li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>
            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-pr-curve-card
                  active="[[active]]"
                  runs="[[item.runs]]"
                  tag="[[item.tag]]"
                  tag-metadata="[[_tagMetadata(_runToTagInfo, item.runs, item.tag)]]"
                  request-manager="[[_requestManager]]"
                  run-to-step-cap="[[_runToStep]]"
                  on-data-change="[[_createDataChangeCallback(item.tag)]]"
                ></tf-pr-curve-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      /** Do not let the steps selector occlude the run selector. */
      #steps-selector-container {
        max-height: 60%;
        overflow-y: auto;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],vKt.prototype,"reloadOnReady",void 0),t([o({type:String}),e("design:type",String)],vKt.prototype,"_timeDisplayType",void 0),t([o({type:Array}),e("design:type",Array)],vKt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],vKt.prototype,"_runToTagInfo",void 0),t([o({type:Object}),e("design:type",Object)],vKt.prototype,"_tagToRunToData",void 0),t([o({type:Object,notify:!0}),e("design:type",Object)],vKt.prototype,"_runToStep",void 0),t([o({type:Boolean}),e("design:type",Boolean)],vKt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],vKt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],vKt.prototype,"_categoriesDomReady",void 0),t([o({type:Object}),e("design:type",Object)],vKt.prototype,"_getCategoryItemKey",void 0),t([o({type:Object}),e("design:type",hr)],vKt.prototype,"_requestManager",void 0),t([o({type:Number,notify:!0}),e("design:type",Number)],vKt.prototype,"_step",void 0),t([s("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Array),e("design:paramtypes",[])],vKt.prototype,"_categories",null),t([s("_selectedRuns","_runToTagInfo"),e("design:type",Array),e("design:paramtypes",[])],vKt.prototype,"_relevantSelectedRuns",null),t([s("_tagToRunToData"),e("design:type",Object),e("design:paramtypes",[])],vKt.prototype,"_runToAvailableTimeEntries",null),vKt=t([i("tf-pr-curve-dashboard")],vKt);let bKt=class extends(tr(ye)){constructor(){super(...arguments),this._installCommand="pip install -U tensorboard-plugin-profile"}_copyInstallCommand(){return n(this,void 0,void 0,(function*(){const t=()=>n(this,void 0,void 0,(function*(){this.$.commandTextarea.select();try{yield navigator.clipboard.writeText(this._installCommand)}catch(t){if(!document.execCommand("copy"))return Promise.reject()}})),e=this.$.copiedMessage;try{yield t(),e.innerText="Copied."}catch(t){e.innerText="Failed to copy to clipboard."}}))}_removeCopiedMessage(){this.$.copiedMessage.innerText=""}};bKt.template=_e`
    <div class="message">
      <h3>The profile plugin has moved.</h3>
      <p>
        Please install the new version of the profile plugin from PyPI by
        running the following command from the machine running TensorBoard:
      </p>
      <textarea
        id="commandTextarea"
        readonly=""
        rows="1"
        on-blur="_removeCopiedMessage"
      >
[[_installCommand]]</textarea
      >
      <div id="copyContainer">
        <span id="copiedMessage"></span>
        <paper-button raised="" on-tap="_copyInstallCommand"
          >Copy to clipboard</paper-button
        >
      </div>
    </div>

    <style>
      .message {
        margin: 80px auto 0 auto;
        max-width: 540px;
      }
      #commandTextarea {
        margin-top: 1ex;
        padding: 1ex 1em;
        resize: vertical;
        width: 100%;
      }
      #copyContainer {
        display: flex;
      }
      #copiedMessage {
        align-self: center;
        flex-grow: 1;
        font-style: italic;
        padding-right: 1em;
        text-align: right;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],bKt.prototype,"_installCommand",void 0),bKt=t([i("tf-profile-redirect-dashboard")],bKt);let xKt=class extends(tr(hl)){constructor(){super(...arguments),this.reloadOnReady=!0,this._showDownloadLinks=zs("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}).call(this),this._smoothingWeight=Vs("_smoothingWeight",{defaultValue:.6}).call(this),this._ignoreYOutliers=zs("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}).call(this),this._xType=Wgt.STEP,this._selectedRuns=[],this._tagFilter="",this._categories=[],this._getCategoryItemKey=t=>t.tag,this._requestManager=new hr(50),this._showDownloadLinksObserver=Ds("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),this._smoothingWeightObserver=js("_smoothingWeight",{defaultValue:.6}),this._ignoreYOutliersObserver=Ds("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0})}get _smoothingEnabled(){return this._smoothingWeight>0}_getCategoryKey(t){return t.metadata.type==vr.SEARCH_RESULTS?"":t.name}_shouldOpen(t){return t<=2}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadCharts()}))}_fetchTags(){const t=gr().pluginRoute("scalars","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTagInfo))return;const e=or(we.mapValues(t,(t=>Object.keys(t))));this.set("_dataNotFound",0===e.length),this.set("_runToTagInfo",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadCharts(){this.root.querySelectorAll("tf-scalar-card").forEach((t=>{t.reload()}))}_updateCategories(){var t=this._selectedRuns;let e,n=this._tagFilter;e=xr(we.mapValues(this._runToTagInfo,(t=>Object.keys(t))),t,n),e.forEach((t=>{t.items=t.items.map((t=>({tag:t.tag,series:t.runs.map((e=>({run:e,tag:t.tag})))})))})),this.updateArrayProp("_categories",e,this._getCategoryKey)}_tagMetadata(t,e,n){const i=t.name,r=n.tag,o={};n.series.forEach((({run:t})=>{o[t]=e[t][r]}));const a=r.replace(/\/scalar_summary$/,"");let{description:s,displayName:l}=IO(o,a);return t.metadata.type==vr.PREFIX_GROUP&&l.startsWith(i+"/")&&(l=l.slice(i.length+1)),{description:s,displayName:l}}};xKt.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="settings">
          <div class="sidebar-section">
            <div class="line-item">
              <paper-checkbox
                id="show-download-links"
                checked="{{_showDownloadLinks}}"
                >Show data download links</paper-checkbox
              >
            </div>
            <div class="line-item">
              <paper-checkbox
                id="ignore-y-outlier"
                checked="{{_ignoreYOutliers}}"
                >Ignore outliers in chart scaling</paper-checkbox
              >
            </div>
            <div id="tooltip-sorting">
              <div>Tooltip sorting method:</div>
              <paper-dropdown-menu
                no-label-float
                selected-item-label="{{_tooltipSortingMethod}}"
              >
                <paper-listbox
                  class="dropdown-content"
                  selected="0"
                  slot="dropdown-content"
                >
                  <paper-item>default</paper-item>
                  <paper-item>descending</paper-item>
                  <paper-item>ascending</paper-item>
                  <paper-item>nearest</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
          <div class="sidebar-section">
            <tf-smoothing-input
              weight="{{_smoothingWeight}}"
              step="0.001"
              min="0"
              max="0.999"
            ></tf-smoothing-input>
          </div>
          <div class="sidebar-section">
            <tf-option-selector
              id="x-type-selector"
              name="Horizontal Axis"
              selected-id="{{_xType}}"
            >
              <paper-button id="step">step</paper-button
              ><!--
            --><paper-button id="relative">relative</paper-button
              ><!--
            --><paper-button id="wall_time">wall</paper-button>
            </tf-option-selector>
          </div>
        </div>
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No scalar data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any scalar data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
              get-category-item-key="[[_getCategoryItemKey]]"
            >
              <template>
                <tf-scalar-card
                  active="[[active]]"
                  data-to-load="[[item.series]]"
                  ignore-y-outliers="[[_ignoreYOutliers]]"
                  multi-experiments="[[_getMultiExperiments(dataSelection)]]"
                  request-manager="[[_requestManager]]"
                  show-download-links="[[_showDownloadLinks]]"
                  smoothing-enabled="[[_smoothingEnabled]]"
                  smoothing-weight="[[_smoothingWeight]]"
                  tag-metadata="[[_tagMetadata(category, _runToTagInfo, item)]]"
                  tag="[[item.tag]]"
                  tooltip-sorting-method="[[_tooltipSortingMethod]]"
                  x-type="[[_xType]]"
                  batch-size="[[featureFlags.scalarsBatchSize]]"
                  in-colab="[[featureFlags.inColab]]"
                ></tf-scalar-card>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      #tooltip-sorting {
        align-items: center;
        display: flex;
        font-size: 14px;
        margin-top: 15px;
      }

      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .center {
        overflow-x: hidden;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],xKt.prototype,"reloadOnReady",void 0),t([o({type:Object}),e("design:type",Object)],xKt.prototype,"featureFlags",void 0),t([o({type:Boolean,notify:!0,observer:"_showDownloadLinksObserver"}),e("design:type",Boolean)],xKt.prototype,"_showDownloadLinks",void 0),t([o({type:Number,notify:!0,observer:"_smoothingWeightObserver"}),e("design:type",Number)],xKt.prototype,"_smoothingWeight",void 0),t([o({type:Boolean,observer:"_ignoreYOutliersObserver"}),e("design:type",Boolean)],xKt.prototype,"_ignoreYOutliers",void 0),t([o({type:String}),e("design:type",String)],xKt.prototype,"_xType",void 0),t([o({type:Array}),e("design:type",Array)],xKt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],xKt.prototype,"_runToTagInfo",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xKt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],xKt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],xKt.prototype,"_categoriesDomReady",void 0),t([o({type:Array}),e("design:type",Array)],xKt.prototype,"_categories",void 0),t([o({type:Object}),e("design:type",Object)],xKt.prototype,"_getCategoryItemKey",void 0),t([o({type:Object}),e("design:type",hr)],xKt.prototype,"_requestManager",void 0),t([s("_smoothingWeight"),e("design:type",Boolean),e("design:paramtypes",[])],xKt.prototype,"_smoothingEnabled",null),t([a("_runToTagInfo","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],xKt.prototype,"_updateCategories",null),xKt=t([i("tf-scalar-dashboard")],xKt);let wKt=class extends(tr(ye)){constructor(){super(...arguments),this._texts=[],this._canceller=new EO}get _runColor(){return xO(this.run)}_changeRunColor(){this.updateStyles({"--tb-text-loader-outline":this._runColor})}attached(){this.reload()}reload(){if(!this.isAttached)return;this._canceller.cancelAll();const t=OO(gr().pluginRoute("text","/text"),{tag:this.tag,run:this.run}),e=this._canceller.cancellable((t=>{if(t.cancelled)return;const e=t.value.map((t=>({wall_time:new Date(1e3*t.wall_time),step:t.step,text:t.text})));this.set("_texts",e.slice().reverse())}));this.requestManager.request(t).then(e)}_formatStep(t){return py(",")(t)}};wKt.template=_e`
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material
      elevation="1"
      id="steps-container"
      class="container scrollbar"
    >
      <template is="dom-repeat" items="[[_texts]]">
        <paper-material elevation="1" class="step-container">
          step <span class="step-value">[[_formatStep(item.step)]]</span>
        </paper-material>
        <paper-material elevation="1" class="text">
          <tf-markdown-view html="[[item.text]]"></tf-markdown-view>
        </paper-material>
      </template>
    </paper-material>
    <style include="scrollbar-style"></style>
    <style>
      :host {
        display: flex;
        flex-direction: column;
        width: 100%;
        height: auto;
        margin-right: 10px;
        margin-bottom: 15px;
      }
      .scrollbar {
        will-change: transform;
      }
      #steps-container {
        border-radius: 3px;
        border: 2px solid /* color computed and set as inline style */;
        display: block;
        max-height: 500px;
        overflow: auto;
        padding: 10px;
        border-color: var(--tb-text-loader-outline);
      }
      .text {
        background-color: white;
        border-radius: 0 3px 3px 3px;
        padding: 5px;
        word-break: break-word;
      }
      .step-container {
        background-color: var(--tb-ui-light-accent);
        border-bottom: none;
        border-radius: 3px 3px 0 0;
        border: 1px solid #ccc;
        display: inline-block;
        font-size: 12px;
        font-style: italic;
        margin-left: -1px; /* to correct for border */
        padding: 3px;
      }
      .step-container:not(:first-child) {
        margin-top: 15px;
      }

      tf-card-heading {
        margin-bottom: 10px;
      }
    </style>
  `,t([o({type:String}),e("design:type",String)],wKt.prototype,"run",void 0),t([o({type:String}),e("design:type",String)],wKt.prototype,"tag",void 0),t([o({type:Array}),e("design:type",Array)],wKt.prototype,"_texts",void 0),t([o({type:Object}),e("design:type",hr)],wKt.prototype,"requestManager",void 0),t([o({type:Object}),e("design:type",EO)],wKt.prototype,"_canceller",void 0),t([s("run"),e("design:type",String),e("design:paramtypes",[])],wKt.prototype,"_runColor",null),t([a("_runColor"),e("design:type",Function),e("design:paramtypes",[]),e("design:returntype",void 0)],wKt.prototype,"_changeRunColor",null),wKt=t([i("tf-text-loader")],wKt);let SKt=class extends(tr(ye)){constructor(){super(...arguments),this.reloadOnReady=!0,this._requestManager=new hr}ready(){super.ready(),this.reloadOnReady&&this.reload()}reload(){this._fetchTags().then((()=>{this._reloadTexts()}))}_shouldOpen(t){return t<=2}_fetchTags(){const t=gr().pluginRoute("text","/tags");return this._requestManager.request(t).then((t=>{if(we.isEqual(t,this._runToTag))return;const e=or(t);this.set("_dataNotFound",0===e.length),this.set("_runToTag",t),this.async((()=>{this.set("_categoriesDomReady",!0)}))}))}_reloadTexts(){this.root.querySelectorAll("tf-text-loader").forEach((t=>{t.reload()}))}get _categories(){return Sr(this._runToTag,this._selectedRuns,this._tagFilter)}};SKt.template=_e`
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section runs-selector">
          <tf-runs-selector selected-runs="{{_selectedRuns}}">
          </tf-runs-selector>
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[_dataNotFound]]">
          <div class="no-data-warning">
            <h3>No text data was found.</h3>
            <p>Probable causes:</p>
            <ul>
              <li>You haven’t written any text data to your event files.</li>
              <li>TensorBoard can’t find your event files.</li>
            </ul>

            <p>
              If you’re new to using TensorBoard, and want to find out how to
              add data and set up your event files, check out the
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md"
                >README</a
              >
              and perhaps the
              <a
                href="https://www.tensorflow.org/get_started/summaries_and_tensorboard"
                >TensorBoard tutorial</a
              >.
            </p>

            <p>
              If you think TensorBoard is configured properly, please see
              <a
                href="https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"
                >the section of the README devoted to missing data problems</a
              >
              and consider filing an issue on GitHub.
            </p>
          </div>
        </template>
        <template is="dom-if" if="[[!_dataNotFound]]">
          <tf-tag-filterer tag-filter="{{_tagFilter}}"></tf-tag-filterer>
          <template is="dom-repeat" items="[[_categories]]" as="category">
            <tf-category-paginated-view
              category="[[category]]"
              initial-opened="[[_shouldOpen(index)]]"
            >
              <template>
                <tf-text-loader
                  active="[[active]]"
                  tag="[[item.tag]]"
                  run="[[item.run]]"
                  request-manager="[[_requestManager]]"
                ></tf-text-loader>
              </template>
            </tf-category-paginated-view>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
    </style>
  `,t([o({type:Boolean}),e("design:type",Boolean)],SKt.prototype,"reloadOnReady",void 0),t([o({type:Array}),e("design:type",Array)],SKt.prototype,"_selectedRuns",void 0),t([o({type:Object}),e("design:type",Object)],SKt.prototype,"_runToTag",void 0),t([o({type:Boolean}),e("design:type",Boolean)],SKt.prototype,"_dataNotFound",void 0),t([o({type:String}),e("design:type",String)],SKt.prototype,"_tagFilter",void 0),t([o({type:Boolean}),e("design:type",Boolean)],SKt.prototype,"_categoriesDomReady",void 0),t([o({type:Object}),e("design:type",Object)],SKt.prototype,"_requestManager",void 0),t([s("_runToTag","_selectedRuns","_tagFilter","_categoriesDomReady"),e("design:type",Array),e("design:paramtypes",[])],SKt.prototype,"_categories",null),SKt=t([i("tf-text-dashboard")],SKt);class MKt{constructor(t){this.port=t,this.id=0,this.responseWaits=new Map,this.listeners=new Map,this.port.addEventListener("message",(t=>this.onMessage(t)))}listen(t,e){this.listeners.set(t,e)}unlisten(t){this.listeners.delete(t)}onMessage(t){return n(this,void 0,void 0,(function*(){const e=JSON.parse(t.data),n=e.type,i=e.id,r=e.payload,o=e.error;if(e.isReply){if(!this.responseWaits.has(i))return;const{resolve:t,reject:e}=this.responseWaits.get(i);return this.responseWaits.delete(i),void(o?e(new Error(o)):t(r))}let a=null,s=null;if(this.listeners.has(n)){const t=this.listeners.get(n);try{a=yield t(r)}catch(t){s=t}}this.postMessage({type:n,id:i,payload:a,error:s,isReply:!0})}))}postMessage(t){this.port.postMessage(JSON.stringify(t))}sendMessage(t,e){const n=this.id++;return this.postMessage({type:t,id:n,payload:e,error:null,isReply:!1}),new Promise(((t,e)=>{this.responseWaits.set(n,{resolve:t,reject:e})}))}}function EKt(t,e){TKt.set(t,{pluginName:e})}const TKt=new WeakMap,AKt=new Set,CKt=new Map,kKt=new Map;function LKt(t,e){return n=>{const i=kKt.get(e),r=TKt.get(i)||null;return t(r,n)}}function PKt(t,e){CKt.set(t,e);for(const n of AKt){const i=LKt(e,n);n.listen(t,i)}}window.addEventListener("message",(t=>{if("experimental.bootstrap"!==t.data)return;const e=t.ports[0];if(!e)return;const n=t.source?t.source.frameElement:null;n&&(function i(t,e){const n=new MKt(t);AKt.add(n),kKt.set(n,e),t.start();for(const[t,e]of CKt){const i=LKt(e,n);n.listen(t,i)}})(e,n)})),PKt("experimental.GetURLPluginData",(t=>{if(!t)return;const e=`p.${t.pluginName}.`,n={},i=Cs();for(let t in i)t.startsWith(e)&&(n[t.substring(e.length)]=i[t]);return n})),PKt("experimental.GetRuns",(()=>vl.getRuns())),vl.addListener((()=>(function t(e,n){for(const t of AKt)kKt.get(t).isConnected||(AKt.delete(t),kKt.delete(t));const i=[...AKt].map((t=>t.sendMessage(e,n)));return Promise.all(i)})("experimental.RunsChanged",vl.getRuns())));let IKt=class extends ye{constructor(){super(...arguments),this._template=null,this.registerPluginIframe=EKt}};IKt=t([i("tf-experimental-plugin-host-lib")],IKt);let NKt=class extends ye{constructor(){super(...arguments),this._template=null,this.tf_backend=Y_t}};NKt=t([i("tf-backend")],NKt);let OKt=class extends ye{constructor(){super(...arguments),this._template=null,this.tf_globals=Ms}};OKt=t([i("tf-globals")],OKt);let RKt=class extends ye{constructor(){super(...arguments),this._template=null,this.tf_storage=iyt}};RKt=t([i("tf-storage")],RKt);var zKt=Object.freeze({__proto__:null,addLimitListener:ll,removeLimitListener:cl,getLimit:ul,setLimit:function DKt(t){if(t!==Math.floor(t))throw new Error(`limit must be an integer, but got: ${t}`);if(t<=0)throw new Error(`limit must be positive, but got: ${t}`);t!==al&&(al=t,Fs(ol,al,{useLocalStorage:!0}),sl.forEach((t=>{t()})))},TfDomRepeat:dl});let BKt=class extends ye{constructor(){super(...arguments),this._template=null,this.tf_paginated_view=zKt}};BKt=t([i("tf-paginated-view-store")],BKt);let HKt=class extends ye{constructor(){super(...arguments),this._template=null,this.runsColorScale=xO}};HKt=t([i("tf-color-scale")],HKt)})();

!(function(){function t(t){return"function"==typeof t}let n=!1;const e={Promise:void 0,set useDeprecatedSynchronousErrorHandling(t){if(t){const t=new Error;console.warn("DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n"+t.stack)}else n&&console.log("RxJS: Back to a better error behavior. Thank you. <3");n=t},get useDeprecatedSynchronousErrorHandling(){return n}};function a(t){setTimeout((()=>{throw t}),0)}const o={closed:!0,next(t){},error(t){if(e.useDeprecatedSynchronousErrorHandling)throw t;a(t)},complete(){}},r=Array.isArray||(t=>t&&"number"==typeof t.length);function i(t){return null!==t&&"object"==typeof t}const c=(()=>{function t(t){return Error.call(this),this.message=t?`${t.length} errors occurred during unsubscription:\n${t.map(((t,n)=>`${n+1}) ${t.toString()}`)).join("\n  ")}`:"",this.name="UnsubscriptionError",this.errors=t,this}return t.prototype=Object.create(Error.prototype),t})();class s{constructor(t){this.closed=!1,this._parentOrParents=null,this._subscriptions=null,t&&(this._unsubscribe=t)}unsubscribe(){let n;if(this.closed)return;let{_parentOrParents:e,_unsubscribe:a,_subscriptions:o}=this;if(this.closed=!0,this._parentOrParents=null,this._subscriptions=null,e instanceof s)e.remove(this);else if(null!==e)for(let t=0;t<e.length;++t)e[t].remove(this);if(t(a))try{a.call(this)}catch(t){n=t instanceof c?l(t.errors):[t]}if(r(o)){let t=-1,e=o.length;for(;++t<e;){const e=o[t];if(i(e))try{e.unsubscribe()}catch(t){n=n||[],t instanceof c?n=n.concat(l(t.errors)):n.push(t)}}}if(n)throw new c(n)}add(t){let n=t;if(!t)return s.EMPTY;switch(typeof t){case"function":n=new s(t);case"object":if(n===this||n.closed||"function"!=typeof n.unsubscribe)return n;if(this.closed)return n.unsubscribe(),n;if(!(n instanceof s)){const t=n;n=new s,n._subscriptions=[t]}break;default:throw new Error("unrecognized teardown "+t+" added to Subscription.")}let{_parentOrParents:e}=n;if(null===e)n._parentOrParents=this;else if(e instanceof s){if(e===this)return n;n._parentOrParents=[e,this]}else{if(-1!==e.indexOf(this))return n;e.push(this)}const a=this._subscriptions;return null===a?this._subscriptions=[n]:a.push(n),n}remove(t){const n=this._subscriptions;if(n){const e=n.indexOf(t);-1!==e&&n.splice(e,1)}}}function l(t){return t.reduce(((t,n)=>t.concat(n instanceof c?n.errors:n)),[])}s.EMPTY=(function(t){return t.closed=!0,t})(new s);const m="function"==typeof Symbol?Symbol("rxSubscriber"):"@@rxSubscriber_"+Math.random();class d extends s{constructor(t,n,e){switch(super(),this.syncErrorValue=null,this.syncErrorThrown=!1,this.syncErrorThrowable=!1,this.isStopped=!1,arguments.length){case 0:this.destination=o;break;case 1:if(!t){this.destination=o;break}if("object"==typeof t){t instanceof d?(this.syncErrorThrowable=t.syncErrorThrowable,this.destination=t,t.add(this)):(this.syncErrorThrowable=!0,this.destination=new g(this,t));break}default:this.syncErrorThrowable=!0,this.destination=new g(this,t,n,e)}}[m](){return this}static create(t,n,e){const a=new d(t,n,e);return a.syncErrorThrowable=!1,a}next(t){this.isStopped||this._next(t)}error(t){this.isStopped||(this.isStopped=!0,this._error(t))}complete(){this.isStopped||(this.isStopped=!0,this._complete())}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe())}_next(t){this.destination.next(t)}_error(t){this.destination.error(t),this.unsubscribe()}_complete(){this.destination.complete(),this.unsubscribe()}_unsubscribeAndRecycle(){const{_parentOrParents:t}=this;return this._parentOrParents=null,this.unsubscribe(),this.closed=!1,this.isStopped=!1,this._parentOrParents=t,this}}class g extends d{constructor(n,e,a,r){let i;super(),this._parentSubscriber=n;let c=this;t(e)?i=e:e&&(i=e.next,a=e.error,r=e.complete,e!==o&&(c=Object.create(e),t(c.unsubscribe)&&this.add(c.unsubscribe.bind(c)),c.unsubscribe=this.unsubscribe.bind(this))),this._context=c,this._next=i,this._error=a,this._complete=r}next(t){if(!this.isStopped&&this._next){const{_parentSubscriber:n}=this;e.useDeprecatedSynchronousErrorHandling&&n.syncErrorThrowable?this.__tryOrSetError(n,this._next,t)&&this.unsubscribe():this.__tryOrUnsub(this._next,t)}}error(t){if(!this.isStopped){const{_parentSubscriber:n}=this,{useDeprecatedSynchronousErrorHandling:o}=e;if(this._error)o&&n.syncErrorThrowable?(this.__tryOrSetError(n,this._error,t),this.unsubscribe()):(this.__tryOrUnsub(this._error,t),this.unsubscribe());else if(n.syncErrorThrowable)o?(n.syncErrorValue=t,n.syncErrorThrown=!0):a(t),this.unsubscribe();else{if(this.unsubscribe(),o)throw t;a(t)}}}complete(){if(!this.isStopped){const{_parentSubscriber:t}=this;if(this._complete){const n=()=>this._complete.call(this._context);e.useDeprecatedSynchronousErrorHandling&&t.syncErrorThrowable?(this.__tryOrSetError(t,n),this.unsubscribe()):(this.__tryOrUnsub(n),this.unsubscribe())}else this.unsubscribe()}}__tryOrUnsub(t,n){try{t.call(this._context,n)}catch(t){if(this.unsubscribe(),e.useDeprecatedSynchronousErrorHandling)throw t;a(t)}}__tryOrSetError(t,n,o){if(!e.useDeprecatedSynchronousErrorHandling)throw new Error("bad call");try{n.call(this._context,o)}catch(n){return e.useDeprecatedSynchronousErrorHandling?(t.syncErrorValue=n,t.syncErrorThrown=!0,!0):(a(n),!0)}return!1}_unsubscribe(){const{_parentSubscriber:t}=this;this._context=null,this._parentSubscriber=null,t.unsubscribe()}}const p="function"==typeof Symbol&&Symbol.observable||"@@observable";function b(t){return t}function u(t){return this instanceof u?(this.v=t,this):new u(t)}function f(t,n,e){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var a,o=e.apply(t,n||[]),r=[];return a={},i("next"),i("throw"),i("return"),a[Symbol.asyncIterator]=function(){return this},a;function i(t){o[t]&&(a[t]=function(n){return new Promise((function(e,a){r.push([t,n,e,a])>1||c(t,n)}))})}function c(t,n){try{!(function e(t){t.value instanceof u?Promise.resolve(t.value.v).then(s,l):m(r[0][2],t)})(o[t](n))}catch(t){m(r[0][3],t)}}function s(t){c("next",t)}function l(t){c("throw",t)}function m(t,n){t(n),r.shift(),r.length&&c(r[0][0],r[0][1])}}class h{constructor(){this.resolve=null,this.reject=null,this.promise=new Promise(((t,n)=>{this.resolve=t,this.reject=n}))}}class _{constructor(t){this._isScalar=!1,t&&(this._subscribe=t)}lift(t){const n=new _;return n.source=this,n.operator=t,n}subscribe(t,n,a){const{operator:r}=this,i=(function c(t,n,e){if(t){if(t instanceof d)return t;if(t[m])return t[m]()}return t||n||e?new d(t,n,e):new d(o)})(t,n,a);if(i.add(r?r.call(i,this.source):this.source||e.useDeprecatedSynchronousErrorHandling&&!i.syncErrorThrowable?this._subscribe(i):this._trySubscribe(i)),e.useDeprecatedSynchronousErrorHandling&&i.syncErrorThrowable&&(i.syncErrorThrowable=!1,i.syncErrorThrown))throw i.syncErrorValue;return i}_trySubscribe(t){try{return this._subscribe(t)}catch(n){e.useDeprecatedSynchronousErrorHandling&&(t.syncErrorThrown=!0,t.syncErrorValue=n),(function n(t){for(;t;){const{closed:n,destination:e,isStopped:a}=t;if(n||a)return!1;t=e&&e instanceof d?e:null}return!0})(t)?t.error(n):console.warn(n)}}forEach(t,n){return new(n=C(n))(((n,e)=>{let a;a=this.subscribe((n=>{try{t(n)}catch(t){e(t),a&&a.unsubscribe()}}),e,n)}))}_subscribe(t){const{source:n}=this;return n&&n.subscribe(t)}[p](){return this}pipe(...t){return 0===t.length?this:(function n(t){return 0===t.length?b:1===t.length?t[0]:function n(e){return t.reduce(((t,n)=>n(t)),e)}}
/*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */)(t)(this)}toPromise(t){return new(t=C(t))(((t,n)=>{let e;this.subscribe((t=>e=t),(t=>n(t)),(()=>t(e)))}))}}function C(t){if(t||(t=Promise),!t)throw new Error("no Promise impl found");return t}_.create=t=>new _(t),Symbol&&Symbol.asyncIterator&&(_.prototype[Symbol.asyncIterator]=function(){return(function t(n){return(function e(t){return f(this,arguments,(function*n(){const e=[],a=[];let o=!1,r=null,i=!1;const c=t.subscribe({next:t=>{e.length>0?e.shift().resolve({value:t,done:!1}):a.push(t)},error:t=>{for(o=!0,r=t;e.length>0;)e.shift().reject(t)},complete:()=>{for(i=!0;e.length>0;)e.shift().resolve({value:void 0,done:!0})}});try{for(;;)if(a.length>0)yield yield u(a.shift());else{if(i)return yield u(void 0);if(o)throw r;{const t=new h;e.push(t);const n=yield u(t.promise);if(n.done)return yield u(void 0);yield yield u(n.value)}}}catch(t){throw t}finally{c.unsubscribe()}}))})(n)})(this)});const M=(()=>{function t(){return Error.call(this),this.message="object unsubscribed",this.name="ObjectUnsubscribedError",this}return t.prototype=Object.create(Error.prototype),t})();class O extends s{constructor(t,n){super(),this.subject=t,this.subscriber=n,this.closed=!1}unsubscribe(){if(this.closed)return;this.closed=!0;const t=this.subject,n=t.observers;if(this.subject=null,!n||0===n.length||t.isStopped||t.closed)return;const e=n.indexOf(this.subscriber);-1!==e&&n.splice(e,1)}}class P extends d{constructor(t){super(t),this.destination=t}}class x extends _{constructor(){super(),this.observers=[],this.closed=!1,this.isStopped=!1,this.hasError=!1,this.thrownError=null}[m](){return new P(this)}lift(t){const n=new y(this,this);return n.operator=t,n}next(t){if(this.closed)throw new M;if(!this.isStopped){const{observers:n}=this,e=n.length,a=n.slice();for(let n=0;n<e;n++)a[n].next(t)}}error(t){if(this.closed)throw new M;this.hasError=!0,this.thrownError=t,this.isStopped=!0;const{observers:n}=this,e=n.length,a=n.slice();for(let n=0;n<e;n++)a[n].error(t);this.observers.length=0}complete(){if(this.closed)throw new M;this.isStopped=!0;const{observers:t}=this,n=t.length,e=t.slice();for(let t=0;t<n;t++)e[t].complete();this.observers.length=0}unsubscribe(){this.isStopped=!0,this.closed=!0,this.observers=null}_trySubscribe(t){if(this.closed)throw new M;return super._trySubscribe(t)}_subscribe(t){if(this.closed)throw new M;return this.hasError?(t.error(this.thrownError),s.EMPTY):this.isStopped?(t.complete(),s.EMPTY):(this.observers.push(t),new O(this,t))}asObservable(){const t=new _;return t.source=this,t}}x.create=(t,n)=>new y(t,n);class y extends x{constructor(t,n){super(),this.destination=t,this.source=n}next(t){const{destination:n}=this;n&&n.next&&n.next(t)}error(t){const{destination:n}=this;n&&n.error&&this.destination.error(t)}complete(){const{destination:t}=this;t&&t.complete&&this.destination.complete()}_subscribe(t){const{source:n}=this;return n?this.source.subscribe(t):s.EMPTY}}function k(){return function t(n){return n.lift(new v(n))}}class v{constructor(t){this.connectable=t}call(t,n){const{connectable:e}=this;e._refCount++;const a=new w(t,e),o=n.subscribe(a);return a.closed||(a.connection=e.connect()),o}}class w extends d{constructor(t,n){super(t),this.connectable=n,this.connection=null}_unsubscribe(){const{connectable:t}=this;if(!t)return void(this.connection=null);this.connectable=null;const n=t._refCount;if(n<=0)return void(this.connection=null);if(t._refCount=n-1,n>1)return void(this.connection=null);const{connection:e}=this,a=t._connection;this.connection=null,!a||e&&a!==e||a.unsubscribe()}}class S extends _{constructor(t,n){super(),this.source=t,this.subjectFactory=n,this._refCount=0,this._isComplete=!1}_subscribe(t){return this.getSubject().subscribe(t)}getSubject(){const t=this._subject;return t&&!t.isStopped||(this._subject=this.subjectFactory()),this._subject}connect(){let t=this._connection;return t||(this._isComplete=!1,t=this._connection=new s,t.add(this.source.subscribe(new A(this.getSubject(),this))),t.closed&&(this._connection=null,t=s.EMPTY)),t}refCount(){return k()(this)}}const E=(()=>{const t=S.prototype;return{operator:{value:null},_refCount:{value:0,writable:!0},_subject:{value:null,writable:!0},_connection:{value:null,writable:!0},_subscribe:{value:t._subscribe},_isComplete:{value:t._isComplete,writable:!0},getSubject:{value:t.getSubject},connect:{value:t.connect},refCount:{value:t.refCount}}})();class A extends P{constructor(t,n){super(t),this.connectable=n}_error(t){this._unsubscribe(),super._error(t)}_complete(){this.connectable._isComplete=!0,this._unsubscribe(),super._complete()}_unsubscribe(){const t=this.connectable;if(t){this.connectable=null;const n=t._connection;t._refCount=0,t._subject=null,t._connection=null,n&&n.unsubscribe()}}}function z(t,n,e,a){return o=>o.lift(new R(t,n,e,a))}class R{constructor(t,n,e,a){this.keySelector=t,this.elementSelector=n,this.durationSelector=e,this.subjectSelector=a}call(t,n){return n.subscribe(new T(t,this.keySelector,this.elementSelector,this.durationSelector,this.subjectSelector))}}class T extends d{constructor(t,n,e,a,o){super(t),this.keySelector=n,this.elementSelector=e,this.durationSelector=a,this.subjectSelector=o,this.groups=null,this.attemptedToUnsubscribe=!1,this.count=0}_next(t){let n;try{n=this.keySelector(t)}catch(t){return void this.error(t)}this._group(t,n)}_group(t,n){let e=this.groups;e||(e=this.groups=new Map);let a,o=e.get(n);if(this.elementSelector)try{a=this.elementSelector(t)}catch(t){this.error(t)}else a=t;if(!o){o=this.subjectSelector?this.subjectSelector():new x,e.set(n,o);const t=new I(n,o,this);if(this.destination.next(t),this.durationSelector){let t;try{t=this.durationSelector(new I(n,o))}catch(t){return void this.error(t)}this.add(t.subscribe(new D(n,o,this)))}}o.closed||o.next(a)}_error(t){const n=this.groups;n&&(n.forEach(((n,e)=>{n.error(t)})),n.clear()),this.destination.error(t)}_complete(){const t=this.groups;t&&(t.forEach(((t,n)=>{t.complete()})),t.clear()),this.destination.complete()}removeGroup(t){this.groups.delete(t)}unsubscribe(){this.closed||(this.attemptedToUnsubscribe=!0,0===this.count&&super.unsubscribe())}}class D extends d{constructor(t,n,e){super(n),this.key=t,this.group=n,this.parent=e}_next(t){this.complete()}_unsubscribe(){const{parent:t,key:n}=this;this.key=this.parent=null,t&&t.removeGroup(n)}}class I extends _{constructor(t,n,e){super(),this.key=t,this.groupSubject=n,this.refCountSubscription=e}_subscribe(t){const n=new s,{refCountSubscription:e,groupSubject:a}=this;return e&&!e.closed&&n.add(new N(e)),n.add(a.subscribe(t)),n}}class N extends s{constructor(t){super(),this.parent=t,t.count++}unsubscribe(){const t=this.parent;t.closed||this.closed||(super.unsubscribe(),t.count-=1,0===t.count&&t.attemptedToUnsubscribe&&t.unsubscribe())}}class F extends x{constructor(t){super(),this._value=t}get value(){return this.getValue()}_subscribe(t){const n=super._subscribe(t);return n&&!n.closed&&t.next(this._value),n}getValue(){if(this.hasError)throw this.thrownError;if(this.closed)throw new M;return this._value}next(t){super.next(this._value=t)}}class L extends s{constructor(t,n){super()}schedule(t,n=0){return this}}class H extends L{constructor(t,n){super(t,n),this.scheduler=t,this.work=n,this.pending=!1}schedule(t,n=0){if(this.closed)return this;this.state=t;const e=this.id,a=this.scheduler;return null!=e&&(this.id=this.recycleAsyncId(a,e,n)),this.pending=!0,this.delay=n,this.id=this.id||this.requestAsyncId(a,this.id,n),this}requestAsyncId(t,n,e=0){return setInterval(t.flush.bind(t,this),e)}recycleAsyncId(t,n,e=0){if(null!==e&&this.delay===e&&!1===this.pending)return n;clearInterval(n)}execute(t,n){if(this.closed)return new Error("executing a cancelled action");this.pending=!1;const e=this._execute(t,n);if(e)return e;!1===this.pending&&null!=this.id&&(this.id=this.recycleAsyncId(this.scheduler,this.id,null))}_execute(t,n){let e,a=!1;try{this.work(t)}catch(t){a=!0,e=!!t&&t||new Error(t)}if(a)return this.unsubscribe(),e}_unsubscribe(){const t=this.id,n=this.scheduler,e=n.actions,a=e.indexOf(this);this.work=null,this.state=null,this.pending=!1,this.scheduler=null,-1!==a&&e.splice(a,1),null!=t&&(this.id=this.recycleAsyncId(n,t,null)),this.delay=null}}class B{constructor(t,n=B.now){this.SchedulerAction=t,this.now=n}schedule(t,n=0,e){return new this.SchedulerAction(this,t).schedule(e,n)}}B.now=()=>Date.now();class V extends B{constructor(t,n=B.now){super(t,(()=>V.delegate&&V.delegate!==this?V.delegate.now():n())),this.actions=[],this.active=!1,this.scheduled=void 0}schedule(t,n=0,e){return V.delegate&&V.delegate!==this?V.delegate.schedule(t,n,e):super.schedule(t,n,e)}flush(t){const{actions:n}=this;if(this.active)return void n.push(t);let e;this.active=!0;do{if(e=t.execute(t.state,t.delay))break}while(t=n.shift());if(this.active=!1,e){for(;t=n.shift();)t.unsubscribe();throw e}}}const j=new class extends V{}(class extends H{constructor(t,n){super(t,n),this.scheduler=t,this.work=n}schedule(t,n=0){return n>0?super.schedule(t,n):(this.delay=n,this.state=t,this.scheduler.flush(this),this)}execute(t,n){return n>0||this.closed?super.execute(t,n):this._execute(t,n)}requestAsyncId(t,n,e=0){return null!==e&&e>0||null===e&&this.delay>0?super.requestAsyncId(t,n,e):t.flush(this)}}),U=new _((t=>t.complete()));function W(t){return t&&"function"==typeof t.schedule}const G=t=>n=>{for(let e=0,a=t.length;e<a&&!n.closed;e++)n.next(t[e]);n.complete()};function Y(t,n){return new _((e=>{const a=new s;let o=0;return a.add(n.schedule((function(){o!==t.length?(e.next(t[o++]),e.closed||a.add(this.schedule())):e.complete()}))),a}))}function q(t,n){return n?Y(t,n):new _(G(t))}function Z(...t){let n=t[t.length-1];return W(n)?(t.pop(),Y(t,n)):q(t)}function X(t,n){return new _(n?e=>n.schedule(J,0,{error:t,subscriber:e}):n=>n.error(t))}function J({error:t,subscriber:n}){n.error(t)}var Q;!(function(t){t.NEXT="N",t.ERROR="E",t.COMPLETE="C"})(Q||(Q={}));class K{constructor(t,n,e){this.kind=t,this.value=n,this.error=e,this.hasValue="N"===t}observe(t){switch(this.kind){case"N":return t.next&&t.next(this.value);case"E":return t.error&&t.error(this.error);case"C":return t.complete&&t.complete()}}do(t,n,e){switch(this.kind){case"N":return t&&t(this.value);case"E":return n&&n(this.error);case"C":return e&&e()}}accept(t,n,e){return t&&"function"==typeof t.next?this.observe(t):this.do(t,n,e)}toObservable(){switch(this.kind){case"N":return Z(this.value);case"E":return X(this.error);case"C":return U}throw new Error("unexpected notification kind value")}static createNext(t){return void 0!==t?new K("N",t):K.undefinedValueNotification}static createError(t){return new K("E",void 0,t)}static createComplete(){return K.completeNotification}}K.completeNotification=new K("C"),K.undefinedValueNotification=new K("N",void 0);class ${constructor(t,n=0){this.scheduler=t,this.delay=n}call(t,n){return n.subscribe(new tt(t,this.scheduler,this.delay))}}class tt extends d{constructor(t,n,e=0){super(t),this.scheduler=n,this.delay=e}static dispatch(t){const{notification:n,destination:e}=t;n.observe(e),this.unsubscribe()}scheduleMessage(t){this.destination.add(this.scheduler.schedule(tt.dispatch,this.delay,new nt(t,this.destination)))}_next(t){this.scheduleMessage(K.createNext(t))}_error(t){this.scheduleMessage(K.createError(t)),this.unsubscribe()}_complete(){this.scheduleMessage(K.createComplete()),this.unsubscribe()}}class nt{constructor(t,n){this.notification=t,this.destination=n}}class et extends x{constructor(t=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY,e){super(),this.scheduler=e,this._events=[],this._infiniteTimeWindow=!1,this._bufferSize=t<1?1:t,this._windowTime=n<1?1:n,n===Number.POSITIVE_INFINITY?(this._infiniteTimeWindow=!0,this.next=this.nextInfiniteTimeWindow):this.next=this.nextTimeWindow}nextInfiniteTimeWindow(t){const n=this._events;n.push(t),n.length>this._bufferSize&&n.shift(),super.next(t)}nextTimeWindow(t){this._events.push(new at(this._getNow(),t)),this._trimBufferThenGetEvents(),super.next(t)}_subscribe(t){const n=this._infiniteTimeWindow,e=n?this._events:this._trimBufferThenGetEvents(),a=this.scheduler,o=e.length;let r;if(this.closed)throw new M;if(this.isStopped||this.hasError?r=s.EMPTY:(this.observers.push(t),r=new O(this,t)),a&&t.add(t=new tt(t,a)),n)for(let n=0;n<o&&!t.closed;n++)t.next(e[n]);else for(let n=0;n<o&&!t.closed;n++)t.next(e[n].value);return this.hasError?t.error(this.thrownError):this.isStopped&&t.complete(),r}_getNow(){return(this.scheduler||j).now()}_trimBufferThenGetEvents(){const t=this._getNow(),n=this._bufferSize,e=this._windowTime,a=this._events,o=a.length;let r=0;for(;r<o&&!(t-a[r].time<e);)r++;return o>n&&(r=Math.max(r,o-n)),r>0&&a.splice(0,r),a}}class at{constructor(t,n){this.time=t,this.value=n}}let ot,rt=1;const it={};function ct(t){return t in it&&(delete it[t],!0)}const st={setImmediate(t){const n=rt++;return it[n]=!0,ot||(ot=Promise.resolve()),ot.then((()=>ct(n)&&t())),n},clearImmediate(t){ct(t)}},lt=new class extends V{flush(t){this.active=!0,this.scheduled=void 0;const{actions:n}=this;let e,a=-1,o=n.length;t=t||n.shift();do{if(e=t.execute(t.state,t.delay))break}while(++a<o&&(t=n.shift()));if(this.active=!1,e){for(;++a<o&&(t=n.shift());)t.unsubscribe();throw e}}}(class extends H{constructor(t,n){super(t,n),this.scheduler=t,this.work=n}requestAsyncId(t,n,e=0){return null!==e&&e>0?super.requestAsyncId(t,n,e):(t.actions.push(this),t.scheduled||(t.scheduled=st.setImmediate(t.flush.bind(t,void 0))))}recycleAsyncId(t,n,e=0){if(null!==e&&e>0||null===e&&this.delay>0)return super.recycleAsyncId(t,n,e);0===t.actions.length&&(st.clearImmediate(n),t.scheduled=void 0)}}),mt=new V(H),dt=new class extends V{flush(t){this.active=!0,this.scheduled=void 0;const{actions:n}=this;let e,a=-1,o=n.length;t=t||n.shift();do{if(e=t.execute(t.state,t.delay))break}while(++a<o&&(t=n.shift()));if(this.active=!1,e){for(;++a<o&&(t=n.shift());)t.unsubscribe();throw e}}}(class extends H{constructor(t,n){super(t,n),this.scheduler=t,this.work=n}requestAsyncId(t,n,e=0){return null!==e&&e>0?super.requestAsyncId(t,n,e):(t.actions.push(this),t.scheduled||(t.scheduled=requestAnimationFrame((()=>t.flush(void 0)))))}recycleAsyncId(t,n,e=0){if(null!==e&&e>0||null===e&&this.delay>0)return super.recycleAsyncId(t,n,e);0===t.actions.length&&(cancelAnimationFrame(n),t.scheduled=void 0)}});function gt(){}function pt(t){return!!t&&(t instanceof _||"function"==typeof t.lift&&"function"==typeof t.subscribe)}const bt=(()=>{function t(){return Error.call(this),this.message="no elements in sequence",this.name="EmptyError",this}return t.prototype=Object.create(Error.prototype),t})(),ut=(()=>{function t(){return Error.call(this),this.message="argument out of range",this.name="ArgumentOutOfRangeError",this}return t.prototype=Object.create(Error.prototype),t})();function ft(t,n){return function e(a){if("function"!=typeof t)throw new TypeError("argument is not a function. Are you looking for `mapTo()`?");return a.lift(new ht(t,n))}}class ht{constructor(t,n){this.project=t,this.thisArg=n}call(t,n){return n.subscribe(new _t(t,this.project,this.thisArg))}}class _t extends d{constructor(t,n,e){super(t),this.project=n,this.count=0,this.thisArg=e||this}_next(t){let n;try{n=this.project.call(this.thisArg,t,this.count++)}catch(t){return void this.destination.error(t)}this.destination.next(n)}}class Ct extends d{notifyNext(t,n,e,a,o){this.destination.next(n)}notifyError(t,n){this.destination.error(t)}notifyComplete(t){this.destination.complete()}}class Mt extends d{constructor(t,n,e){super(),this.parent=t,this.outerValue=n,this.outerIndex=e,this.index=0}_next(t){this.parent.notifyNext(this.outerValue,t,this.outerIndex,this.index++,this)}_error(t){this.parent.notifyError(t,this),this.unsubscribe()}_complete(){this.parent.notifyComplete(this),this.unsubscribe()}}const Ot=(function Pt(){return"function"==typeof Symbol&&Symbol.iterator?Symbol.iterator:"@@iterator"})(),xt=t=>t&&"number"==typeof t.length&&"function"!=typeof t;function yt(t){return!!t&&"function"!=typeof t.subscribe&&"function"==typeof t.then}function kt(t){return n=>{(function e(t,n){var e,a,o,r;return(function i(t,n,e,a){return new(e||(e=Promise))((function(o,r){function i(t){try{s(a.next(t))}catch(t){r(t)}}function c(t){try{s(a.throw(t))}catch(t){r(t)}}function s(t){t.done?o(t.value):(function n(t){return t instanceof e?t:new e((function(n){n(t)}))})(t.value).then(i,c)}s((a=a.apply(t,n||[])).next())}))})(this,void 0,void 0,(function*(){try{for(e=(function i(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var n,e=t[Symbol.asyncIterator];return e?e.call(t):(t=(function a(t){var n="function"==typeof Symbol&&Symbol.iterator,e=n&&t[n],a=0;if(e)return e.call(t);if(t&&"number"==typeof t.length)return{next:function(){return t&&a>=t.length&&(t=void 0),{value:t&&t[a++],done:!t}}};throw new TypeError(n?"Object is not iterable.":"Symbol.iterator is not defined.")})(t),n={},o("next"),o("throw"),o("return"),n[Symbol.asyncIterator]=function(){return this},n);function o(e){n[e]=t[e]&&function(n){return new Promise((function(a,o){!(function r(t,n,e,a){Promise.resolve(a).then((function(n){t({value:n,done:e})}),n)})(a,o,(n=t[e](n)).done,n.value)}))}}})(t);!(a=yield e.next()).done;)n.next(a.value)}catch(t){o={error:t}}finally{try{a&&!a.done&&(r=e.return)&&(yield r.call(e))}finally{if(o)throw o.error}}n.complete()}))})(t,n).catch((t=>n.error(t)))}}const vt=t=>{if(t&&"function"==typeof t[p])return e=t,t=>{const n=e[p]();if("function"!=typeof n.subscribe)throw new TypeError("Provided object does not correctly implement Symbol.observable");return n.subscribe(t)};if(xt(t))return G(t);if(yt(t))return(t=>n=>(t.then((t=>{n.closed||(n.next(t),n.complete())}),(t=>n.error(t))).then(null,a),n))(t);if(t&&"function"==typeof t[Ot])return n=t,t=>{const e=n[Ot]();for(;;){const n=e.next();if(n.done){t.complete();break}if(t.next(n.value),t.closed)break}return"function"==typeof e.return&&t.add((()=>{e.return&&e.return()})),t};if(Symbol&&Symbol.asyncIterator&&t&&"function"==typeof t[Symbol.asyncIterator])return kt(t);{const n=i(t)?"an invalid object":`'${t}'`;throw new TypeError(`You provided ${n} where a stream was expected. You can provide an Observable, Promise, Array, or Iterable.`)}var n,e};function wt(t,n,e,a,o=new Mt(t,e,a)){if(!o.closed)return n instanceof _?n.subscribe(o):vt(n)(o)}const St={};function Et(...t){let n,e;return W(t[t.length-1])&&(e=t.pop()),"function"==typeof t[t.length-1]&&(n=t.pop()),1===t.length&&r(t[0])&&(t=t[0]),q(t,e).lift(new At(n))}class At{constructor(t){this.resultSelector=t}call(t,n){return n.subscribe(new zt(t,this.resultSelector))}}class zt extends Ct{constructor(t,n){super(t),this.resultSelector=n,this.active=0,this.values=[],this.observables=[]}_next(t){this.values.push(St),this.observables.push(t)}_complete(){const t=this.observables,n=t.length;if(0===n)this.destination.complete();else{this.active=n,this.toRespond=n;for(let e=0;e<n;e++){const n=t[e];this.add(wt(this,n,n,e))}}}notifyComplete(t){0==(this.active-=1)&&this.destination.complete()}notifyNext(t,n,e,a,o){const r=this.values,i=this.toRespond?r[e]===St?--this.toRespond:this.toRespond:0;r[e]=n,0===i&&(this.resultSelector?this._tryResultSelector(r):this.destination.next(r.slice()))}_tryResultSelector(t){let n;try{n=this.resultSelector.apply(this,t)}catch(t){return void this.destination.error(t)}this.destination.next(n)}}function Rt(t,n){return n?(function e(t,n){if(null!=t){if((function e(t){return t&&"function"==typeof t[p]})(t))return(function a(t,n){return new _((e=>{const a=new s;return a.add(n.schedule((()=>{const o=t[p]();a.add(o.subscribe({next(t){a.add(n.schedule((()=>e.next(t))))},error(t){a.add(n.schedule((()=>e.error(t))))},complete(){a.add(n.schedule((()=>e.complete())))}}))}))),a}))})(t,n);if(yt(t))return(function o(t,n){return new _((e=>{const a=new s;return a.add(n.schedule((()=>t.then((t=>{a.add(n.schedule((()=>{e.next(t),a.add(n.schedule((()=>e.complete())))})))}),(t=>{a.add(n.schedule((()=>e.error(t))))}))))),a}))})(t,n);if(xt(t))return Y(t,n);if((function r(t){return t&&"function"==typeof t[Ot]})(t)||"string"==typeof t)return(function i(t,n){if(!t)throw new Error("Iterable cannot be null");return new _((e=>{const a=new s;let o;return a.add((()=>{o&&"function"==typeof o.return&&o.return()})),a.add(n.schedule((()=>{o=t[Ot](),a.add(n.schedule((function(){if(e.closed)return;let t,n;try{const e=o.next();t=e.value,n=e.done}catch(t){return void e.error(t)}n?e.complete():(e.next(t),this.schedule())})))}))),a}))})(t,n);if(Symbol&&Symbol.asyncIterator&&"function"==typeof t[Symbol.asyncIterator])return(function c(t,n){if(!t)throw new Error("Iterable cannot be null");return new _((e=>{const a=new s;return a.add(n.schedule((()=>{const o=t[Symbol.asyncIterator]();a.add(n.schedule((function(){o.next().then((t=>{t.done?e.complete():(e.next(t.value),this.schedule())}))})))}))),a}))})(t,n)}throw new TypeError((null!==t&&typeof t||t)+" is not observable")})(t,n):t instanceof _?t:new _(vt(t))}function Tt(t,n,e=Number.POSITIVE_INFINITY){return"function"==typeof n?a=>a.pipe(Tt(((e,a)=>Rt(t(e,a)).pipe(ft(((t,o)=>n(e,t,a,o))))),e)):("number"==typeof n&&(e=n),n=>n.lift(new Dt(t,e)))}class Dt{constructor(t,n=Number.POSITIVE_INFINITY){this.project=t,this.concurrent=n}call(t,n){return n.subscribe(new It(t,this.project,this.concurrent))}}class It extends Ct{constructor(t,n,e=Number.POSITIVE_INFINITY){super(t),this.project=n,this.concurrent=e,this.hasCompleted=!1,this.buffer=[],this.active=0,this.index=0}_next(t){this.active<this.concurrent?this._tryNext(t):this.buffer.push(t)}_tryNext(t){let n;const e=this.index++;try{n=this.project(t,e)}catch(t){return void this.destination.error(t)}this.active++,this._innerSub(n,t,e)}_innerSub(t,n,e){const a=new Mt(this,n,e),o=this.destination;o.add(a);const r=wt(this,t,void 0,void 0,a);r!==a&&o.add(r)}_complete(){this.hasCompleted=!0,0===this.active&&0===this.buffer.length&&this.destination.complete(),this.unsubscribe()}notifyNext(t,n,e,a,o){this.destination.next(n)}notifyComplete(t){const n=this.buffer;this.remove(t),this.active--,n.length>0?this._next(n.shift()):0===this.active&&this.hasCompleted&&this.destination.complete()}}function Nt(t=Number.POSITIVE_INFINITY){return Tt(b,t)}function Ft(...t){return(function n(){return Nt(1)})()(Z(...t))}function Lt(t){return new _((n=>{let e;try{e=t()}catch(t){return void n.error(t)}return(e?Rt(e):U).subscribe(n)}))}function Ht(...t){if(1===t.length){const n=t[0];if(r(n))return Bt(n,null);if(i(n)&&Object.getPrototypeOf(n)===Object.prototype){const t=Object.keys(n);return Bt(t.map((t=>n[t])),t)}}if("function"==typeof t[t.length-1]){const n=t.pop();return Bt(t=1===t.length&&r(t[0])?t[0]:t,null).pipe(ft((t=>n(...t))))}return Bt(t,null)}function Bt(t,n){return new _((e=>{const a=t.length;if(0===a)return void e.complete();const o=new Array(a);let r=0,i=0;for(let c=0;c<a;c++){const s=Rt(t[c]);let l=!1;e.add(s.subscribe({next:t=>{l||(l=!0,i++),o[c]=t},error:t=>e.error(t),complete:()=>{r++,r!==a&&l||(i===a&&e.next(n?n.reduce(((t,n,e)=>(t[n]=o[e],t)),{}):o),e.complete())}}))}}))}function Vt(n,e,a,o){return t(a)&&(o=a,a=void 0),o?Vt(n,e,a).pipe(ft((t=>r(t)?o(...t):o(t)))):new _((t=>{jt(n,e,(function o(n){t.next(arguments.length>1?Array.prototype.slice.call(arguments):n)}),t,a)}))}function jt(t,n,e,a,o){let r;if((function i(t){return t&&"function"==typeof t.addEventListener&&"function"==typeof t.removeEventListener})(t)){const a=t;t.addEventListener(n,e,o),r=()=>a.removeEventListener(n,e,o)}else if((function c(t){return t&&"function"==typeof t.on&&"function"==typeof t.off})(t)){const a=t;t.on(n,e),r=()=>a.off(n,e)}else if((function s(t){return t&&"function"==typeof t.addListener&&"function"==typeof t.removeListener})(t)){const a=t;t.addListener(n,e),r=()=>a.removeListener(n,e)}else{if(!t||!t.length)throw new TypeError("Invalid event target");for(let r=0,i=t.length;r<i;r++)jt(t[r],n,e,a,o)}a.add(r)}function Ut(t){return!r(t)&&t-parseFloat(t)+1>=0}function Wt(...t){let n,e=Number.POSITIVE_INFINITY,a=t[t.length-1];return W(a)?(n=t.pop(),t.length>1&&"number"==typeof t[t.length-1]&&(e=t.pop())):"number"==typeof a&&(e=t.pop()),!n&&1===t.length&&t[0]instanceof _?t[0]:Nt(e)(q(t,n))}function Gt(t,n){return function e(a){return a.lift(new Yt(t,n))}}class Yt{constructor(t,n){this.predicate=t,this.thisArg=n}call(t,n){return n.subscribe(new qt(t,this.predicate,this.thisArg))}}class qt extends d{constructor(t,n,e){super(t),this.predicate=n,this.thisArg=e,this.count=0}_next(t){let n;try{n=this.predicate.call(this.thisArg,t,this.count++)}catch(t){return void this.destination.error(t)}n&&this.destination.next(t)}}function Zt(t=0,n,e){let a=-1;return Ut(n)?a=Number(n)<1?1:Number(n):W(n)&&(e=n),W(e)||(e=mt),new _((n=>{const o=Ut(t)?t:+t-e.now();return e.schedule(Xt,o,{index:0,period:a,subscriber:n})}))}function Xt(t){const{index:n,period:e,subscriber:a}=t;if(a.next(n),!a.closed){if(-1===e)return a.complete();t.index=n+1,this.schedule(t,e)}}class Jt{constructor(t){this.resultSelector=t}call(t,n){return n.subscribe(new Qt(t,this.resultSelector))}}class Qt extends d{constructor(t,n,e=Object.create(null)){super(t),this.iterators=[],this.active=0,this.resultSelector=n,this.values=e}_next(t){const n=this.iterators;r(t)?n.push(new $t(t)):n.push("function"==typeof t[Ot]?new Kt(t[Ot]()):new tn(this.destination,this,t))}_complete(){const t=this.iterators,n=t.length;if(this.unsubscribe(),0!==n){this.active=n;for(let e=0;e<n;e++){let n=t[e];n.stillUnsubscribed?this.destination.add(n.subscribe(n,e)):this.active--}}else this.destination.complete()}notifyInactive(){this.active--,0===this.active&&this.destination.complete()}checkIterators(){const t=this.iterators,n=t.length,e=this.destination;for(let e=0;e<n;e++){let n=t[e];if("function"==typeof n.hasValue&&!n.hasValue())return}let a=!1;const o=[];for(let r=0;r<n;r++){let n=t[r],i=n.next();if(n.hasCompleted()&&(a=!0),i.done)return void e.complete();o.push(i.value)}this.resultSelector?this._tryresultSelector(o):e.next(o),a&&e.complete()}_tryresultSelector(t){let n;try{n=this.resultSelector.apply(this,t)}catch(t){return void this.destination.error(t)}this.destination.next(n)}}class Kt{constructor(t){this.iterator=t,this.nextResult=t.next()}hasValue(){return!0}next(){const t=this.nextResult;return this.nextResult=this.iterator.next(),t}hasCompleted(){const t=this.nextResult;return t&&!!t.done}}class $t{constructor(t){this.array=t,this.index=0,this.length=0,this.length=t.length}[Ot](){return this}next(t){const n=this.index++;return n<this.length?{value:this.array[n],done:!1}:{value:null,done:!0}}hasValue(){return this.array.length>this.index}hasCompleted(){return this.array.length===this.index}}class tn extends Ct{constructor(t,n,e){super(t),this.parent=n,this.observable=e,this.stillUnsubscribed=!0,this.buffer=[],this.isComplete=!1}[Ot](){return this}next(){const t=this.buffer;return 0===t.length&&this.isComplete?{value:null,done:!0}:{value:t.shift(),done:!1}}hasValue(){return this.buffer.length>0}hasCompleted(){return 0===this.buffer.length&&this.isComplete}notifyComplete(){this.buffer.length>0?(this.isComplete=!0,this.parent.notifyInactive()):this.destination.complete()}notifyNext(t,n,e,a,o){this.buffer.push(n),this.parent.checkIterators()}subscribe(t,n){return wt(this,this.observable,this,n)}}class nn{constructor(t){this.durationSelector=t}call(t,n){return n.subscribe(new en(t,this.durationSelector))}}class en extends Ct{constructor(t,n){super(t),this.durationSelector=n,this.value=null,this.hasValue=!1,this.throttled=null}_next(t){if(this.value=t,this.hasValue=!0,!this.throttled){let n;try{const{durationSelector:e}=this;n=e(t)}catch(t){return this.destination.error(t)}const e=wt(this,n);!e||e.closed?this.clearThrottle():this.add(this.throttled=e)}}clearThrottle(){const{value:t,hasValue:n,throttled:e}=this;e&&(this.remove(e),this.throttled=null,e.unsubscribe()),n&&(this.value=null,this.hasValue=!1,this.destination.next(t))}notifyNext(t,n,e,a){this.clearThrottle()}notifyComplete(){this.clearThrottle()}}function an(t,n=mt){return(function e(t){return function n(e){return e.lift(new nn(t))}})((()=>Zt(t,n)))}function on(t){return function n(e){const a=new rn(t),o=e.lift(a);return a.caught=o}}class rn{constructor(t){this.selector=t}call(t,n){return n.subscribe(new cn(t,this.selector,this.caught))}}class cn extends Ct{constructor(t,n,e){super(t),this.selector=n,this.caught=e}error(t){if(!this.isStopped){let n;try{n=this.selector(t,this.caught)}catch(t){return void super.error(t)}this._unsubscribeAndRecycle();const e=new Mt(this,void 0,void 0);this.add(e);const a=wt(this,n,void 0,void 0,e);a!==e&&this.add(a)}}}function sn(...t){return(function n(...t){let n;return"function"==typeof t[t.length-1]&&(n=t.pop()),1===t.length&&r(t[0])&&(t=t[0].slice()),e=>e.lift.call(Rt([e,...t]),new At(n))})(...t)}function ln(t,n=mt){return e=>e.lift(new mn(t,n))}class mn{constructor(t,n){this.dueTime=t,this.scheduler=n}call(t,n){return n.subscribe(new dn(t,this.dueTime,this.scheduler))}}class dn extends d{constructor(t,n,e){super(t),this.dueTime=n,this.scheduler=e,this.debouncedSubscription=null,this.lastValue=null,this.hasValue=!1}_next(t){this.clearDebounce(),this.lastValue=t,this.hasValue=!0,this.add(this.debouncedSubscription=this.scheduler.schedule(gn,this.dueTime,this))}_complete(){this.debouncedNext(),this.destination.complete()}debouncedNext(){if(this.clearDebounce(),this.hasValue){const{lastValue:t}=this;this.lastValue=null,this.hasValue=!1,this.destination.next(t)}}clearDebounce(){const t=this.debouncedSubscription;null!==t&&(this.remove(t),t.unsubscribe(),this.debouncedSubscription=null)}}function gn(t){t.debouncedNext()}function pn(t=null){return n=>n.lift(new bn(t))}class bn{constructor(t){this.defaultValue=t}call(t,n){return n.subscribe(new un(t,this.defaultValue))}}class un extends d{constructor(t,n){super(t),this.defaultValue=n,this.isEmpty=!0}_next(t){this.isEmpty=!1,this.destination.next(t)}_complete(){this.isEmpty&&this.destination.next(this.defaultValue),this.destination.complete()}}function fn(t,n=mt){const e=(function a(t){return t instanceof Date&&!isNaN(+t)})(t)?+t-n.now():Math.abs(t);return t=>t.lift(new hn(e,n))}class hn{constructor(t,n){this.delay=t,this.scheduler=n}call(t,n){return n.subscribe(new _n(t,this.delay,this.scheduler))}}class _n extends d{constructor(t,n,e){super(t),this.delay=n,this.scheduler=e,this.queue=[],this.active=!1,this.errored=!1}static dispatch(t){const n=t.source,e=n.queue,a=t.scheduler,o=t.destination;for(;e.length>0&&e[0].time-a.now()<=0;)e.shift().notification.observe(o);if(e.length>0){const n=Math.max(0,e[0].time-a.now());this.schedule(t,n)}else n.isStopped?(n.destination.complete(),n.active=!1):(this.unsubscribe(),n.active=!1)}_schedule(t){this.active=!0,this.destination.add(t.schedule(_n.dispatch,this.delay,{source:this,destination:this.destination,scheduler:t}))}scheduleNotification(t){if(!0===this.errored)return;const n=this.scheduler,e=new Cn(n.now()+this.delay,t);this.queue.push(e),!1===this.active&&this._schedule(n)}_next(t){this.scheduleNotification(K.createNext(t))}_error(t){this.errored=!0,this.queue=[],this.destination.error(t),this.unsubscribe()}_complete(){0===this.queue.length&&this.destination.complete(),this.unsubscribe()}}class Cn{constructor(t,n){this.time=t,this.notification=n}}class Mn{constructor(t){this.delayDurationSelector=t}call(t,n){return n.subscribe(new On(t,this.delayDurationSelector))}}class On extends Ct{constructor(t,n){super(t),this.delayDurationSelector=n,this.completed=!1,this.delayNotifierSubscriptions=[],this.index=0}notifyNext(t,n,e,a,o){this.destination.next(t),this.removeSubscription(o),this.tryComplete()}notifyError(t,n){this._error(t)}notifyComplete(t){const n=this.removeSubscription(t);n&&this.destination.next(n),this.tryComplete()}_next(t){const n=this.index++;try{const e=this.delayDurationSelector(t,n);e&&this.tryDelay(e,t)}catch(t){this.destination.error(t)}}_complete(){this.completed=!0,this.tryComplete(),this.unsubscribe()}removeSubscription(t){t.unsubscribe();const n=this.delayNotifierSubscriptions.indexOf(t);return-1!==n&&this.delayNotifierSubscriptions.splice(n,1),t.outerValue}tryDelay(t,n){const e=wt(this,t,n);e&&!e.closed&&(this.destination.add(e),this.delayNotifierSubscriptions.push(e))}tryComplete(){this.completed&&0===this.delayNotifierSubscriptions.length&&this.destination.complete()}}class Pn extends _{constructor(t,n){super(),this.source=t,this.subscriptionDelay=n}_subscribe(t){this.subscriptionDelay.subscribe(new xn(t,this.source))}}class xn extends d{constructor(t,n){super(),this.parent=t,this.source=n,this.sourceSubscribed=!1}_next(t){this.subscribeToSource()}_error(t){this.unsubscribe(),this.parent.error(t)}_complete(){this.unsubscribe(),this.subscribeToSource()}subscribeToSource(){this.sourceSubscribed||(this.sourceSubscribed=!0,this.unsubscribe(),this.source.subscribe(this.parent))}}class yn{call(t,n){return n.subscribe(new kn(t))}}class kn extends d{constructor(t){super(t)}_next(t){t.observe(this.destination)}}function vn(t,n){return e=>e.lift(new wn(t,n))}class wn{constructor(t,n){this.compare=t,this.keySelector=n}call(t,n){return n.subscribe(new Sn(t,this.compare,this.keySelector))}}class Sn extends d{constructor(t,n,e){super(t),this.keySelector=e,this.hasKey=!1,"function"==typeof n&&(this.compare=n)}compare(t,n){return t===n}_next(t){let n;try{const{keySelector:e}=this;n=e?e(t):t}catch(t){return this.destination.error(t)}let e=!1;if(this.hasKey)try{const{compare:t}=this;e=t(this.key,n)}catch(t){return this.destination.error(t)}else this.hasKey=!0;e||(this.key=n,this.destination.next(t))}}function En(t=Rn){return n=>n.lift(new An(t))}class An{constructor(t){this.errorFactory=t}call(t,n){return n.subscribe(new zn(t,this.errorFactory))}}class zn extends d{constructor(t,n){super(t),this.errorFactory=n,this.hasValue=!1}_next(t){this.hasValue=!0,this.destination.next(t)}_complete(){if(this.hasValue)return this.destination.complete();{let t;try{t=this.errorFactory()}catch(n){t=n}this.destination.error(t)}}}function Rn(){return new bt}function Tn(t){return n=>0===t?U:n.lift(new Dn(t))}class Dn{constructor(t){if(this.total=t,this.total<0)throw new ut}call(t,n){return n.subscribe(new In(t,this.total))}}class In extends d{constructor(t,n){super(t),this.total=n,this.count=0}_next(t){const n=this.total,e=++this.count;e<=n&&(this.destination.next(t),e===n&&(this.destination.complete(),this.unsubscribe()))}}function Nn(t,n){return n?e=>e.pipe(Nn(((e,a)=>Rt(t(e,a)).pipe(ft(((t,o)=>n(e,t,a,o))))))):n=>n.lift(new Fn(t))}class Fn{constructor(t){this.project=t}call(t,n){return n.subscribe(new Ln(t,this.project))}}class Ln extends Ct{constructor(t,n){super(t),this.project=n,this.hasSubscription=!1,this.hasCompleted=!1,this.index=0}_next(t){this.hasSubscription||this.tryNext(t)}tryNext(t){let n;const e=this.index++;try{n=this.project(t,e)}catch(t){return void this.destination.error(t)}this.hasSubscription=!0,this._innerSub(n,t,e)}_innerSub(t,n,e){const a=new Mt(this,n,e),o=this.destination;o.add(a);const r=wt(this,t,void 0,void 0,a);r!==a&&o.add(r)}_complete(){this.hasCompleted=!0,this.hasSubscription||this.destination.complete(),this.unsubscribe()}notifyNext(t,n,e,a,o){this.destination.next(n)}notifyError(t){this.destination.error(t)}notifyComplete(t){this.destination.remove(t),this.hasSubscription=!1,this.hasCompleted&&this.destination.complete()}}class Hn{constructor(t){this.callback=t}call(t,n){return n.subscribe(new Bn(t,this.callback))}}class Bn extends d{constructor(t,n){super(t),this.add(new s(n))}}class Vn{call(t,n){return n.subscribe(new jn(t))}}class jn extends d{_next(t){}}function Un(t){return function n(e){return 0===t?U:e.lift(new Wn(t))}}class Wn{constructor(t){if(this.total=t,this.total<0)throw new ut}call(t,n){return n.subscribe(new Gn(t,this.total))}}class Gn extends d{constructor(t,n){super(t),this.total=n,this.ring=new Array,this.count=0}_next(t){const n=this.ring,e=this.total,a=this.count++;n.length<e?n.push(t):n[a%e]=t}_complete(){const t=this.destination;let n=this.count;if(n>0){const e=this.count>=this.total?this.total:this.count,a=this.ring;for(let o=0;o<e;o++){const o=n++%e;t.next(a[o])}}t.complete()}}class Yn{call(t,n){return n.subscribe(new qn(t))}}class qn extends d{constructor(t){super(t)}_next(t){this.destination.next(K.createNext(t))}_error(t){const n=this.destination;n.next(K.createError(t)),n.complete()}_complete(){const t=this.destination;t.next(K.createComplete()),t.complete()}}class Zn{constructor(t,n,e=!1){this.accumulator=t,this.seed=n,this.hasSeed=e}call(t,n){return n.subscribe(new Xn(t,this.accumulator,this.seed,this.hasSeed))}}class Xn extends d{constructor(t,n,e,a){super(t),this.accumulator=n,this._state=e,this._hasState=a,this.index=0}_next(t){const{destination:n}=this;if(this._hasState){const e=this.index++;let a;try{a=this.accumulator(this._state,t,e)}catch(t){return void n.error(t)}this._state=a,n.next(a)}else this._state=t,this._hasState=!0,n.next(t)}}class Jn{constructor(t,n){this.subjectFactory=t,this.selector=n}call(t,n){const{selector:e}=this,a=this.subjectFactory(),o=e(a).subscribe(t);return o.add(n.subscribe(a)),o}}class Qn{call(t,n){return n.subscribe(new Kn(t))}}class Kn extends d{constructor(t){super(t),this.hasPrev=!1}_next(t){let n;this.hasPrev?n=[this.prev,t]:this.hasPrev=!0,this.prev=t,n&&this.destination.next(n)}}class $n{constructor(t){this.notifier=t}call(t,n){return n.subscribe(new te(t,this.notifier,n))}}class te extends Ct{constructor(t,n,e){super(t),this.notifier=n,this.source=e,this.notifications=null,this.retries=null,this.retriesSubscription=null,this.sourceIsBeingSubscribedTo=!0}notifyNext(t,n,e,a,o){this.sourceIsBeingSubscribedTo=!0,this.source.subscribe(this)}notifyComplete(t){if(!1===this.sourceIsBeingSubscribedTo)return super.complete()}complete(){if(this.sourceIsBeingSubscribedTo=!1,!this.isStopped){if(this.retries||this.subscribeToRetries(),!this.retriesSubscription||this.retriesSubscription.closed)return super.complete();this._unsubscribeAndRecycle(),this.notifications.next()}}_unsubscribe(){const{notifications:t,retriesSubscription:n}=this;t&&(t.unsubscribe(),this.notifications=null),n&&(n.unsubscribe(),this.retriesSubscription=null),this.retries=null}_unsubscribeAndRecycle(){const{_unsubscribe:t}=this;return this._unsubscribe=null,super._unsubscribeAndRecycle(),this._unsubscribe=t,this}subscribeToRetries(){let t;this.notifications=new x;try{const{notifier:n}=this;t=n(this.notifications)}catch(t){return super.complete()}this.retries=t,this.retriesSubscription=wt(this,t)}}function ne(){return new x}function ee(){return t=>k()((function n(t,e){return function n(a){let o;if(o="function"==typeof t?t:function n(){return t},"function"==typeof e)return a.lift(new Jn(o,e));const r=Object.create(a,E);return r.source=a,r.subjectFactory=o,r}})(ne)(t))}function ae(t,n,e){let a;return a=t&&"object"==typeof t?t:{bufferSize:t,windowTime:n,refCount:!1,scheduler:e},t=>t.lift((function n({bufferSize:t=Number.POSITIVE_INFINITY,windowTime:e=Number.POSITIVE_INFINITY,refCount:a,scheduler:o}){let r,i,c=0,s=!1,l=!1;return function n(m){c++,r&&!s||(s=!1,r=new et(t,e,o),i=m.subscribe({next(t){r.next(t)},error(t){s=!0,r.error(t)},complete(){l=!0,i=void 0,r.complete()}}));const d=r.subscribe(this);this.add((()=>{c--,d.unsubscribe(),i&&!l&&a&&0===c&&(i.unsubscribe(),i=void 0,r=void 0)}))}})(a))}function oe(t){return n=>n.lift(new re(t))}class re{constructor(t){this.total=t}call(t,n){return n.subscribe(new ie(t,this.total))}}class ie extends d{constructor(t,n){super(t),this.total=n,this.count=0}_next(t){++this.count>this.total&&this.destination.next(t)}}function ce(...t){const n=t[t.length-1];return W(n)?(t.pop(),e=>Ft(t,e,n)):n=>Ft(t,n)}function se(t,n){return"function"==typeof n?e=>e.pipe(se(((e,a)=>Rt(t(e,a)).pipe(ft(((t,o)=>n(e,t,a,o))))))):n=>n.lift(new le(t))}class le{constructor(t){this.project=t}call(t,n){return n.subscribe(new me(t,this.project))}}class me extends Ct{constructor(t,n){super(t),this.project=n,this.index=0}_next(t){let n;const e=this.index++;try{n=this.project(t,e)}catch(t){return void this.destination.error(t)}this._innerSub(n,t,e)}_innerSub(t,n,e){const a=this.innerSubscription;a&&a.unsubscribe();const o=new Mt(this,n,e),r=this.destination;r.add(o),this.innerSubscription=wt(this,t,void 0,void 0,o),this.innerSubscription!==o&&r.add(this.innerSubscription)}_complete(){const{innerSubscription:t}=this;t&&!t.closed||super._complete(),this.unsubscribe()}_unsubscribe(){this.innerSubscription=null}notifyComplete(t){this.destination.remove(t),this.innerSubscription=null,this.isStopped&&super._complete()}notifyNext(t,n,e,a,o){this.destination.next(n)}}function de(t){return n=>n.lift(new ge(t))}class ge{constructor(t){this.notifier=t}call(t,n){const e=new pe(t),a=wt(e,this.notifier);return a&&!e.seenValue?(e.add(a),n.subscribe(e)):e}}class pe extends Ct{constructor(t){super(t),this.seenValue=!1}notifyNext(t,n,e,a,o){this.seenValue=!0,this.complete()}notifyComplete(){}}function be(t,n=!1){return e=>e.lift(new ue(t,n))}class ue{constructor(t,n){this.predicate=t,this.inclusive=n}call(t,n){return n.subscribe(new fe(t,this.predicate,this.inclusive))}}class fe extends d{constructor(t,n,e){super(t),this.predicate=n,this.inclusive=e,this.index=0}_next(t){const n=this.destination;let e;try{e=this.predicate(t,this.index++)}catch(t){return void n.error(t)}this.nextOrComplete(t,e)}nextOrComplete(t,n){const e=this.destination;Boolean(n)?e.next(t):(this.inclusive&&e.next(t),e.complete())}}function he(t,n,e){return function a(o){return o.lift(new _e(t,n,e))}}class _e{constructor(t,n,e){this.nextOrObserver=t,this.error=n,this.complete=e}call(t,n){return n.subscribe(new Ce(t,this.nextOrObserver,this.error,this.complete))}}class Ce extends d{constructor(n,e,a,o){super(n),this._tapNext=gt,this._tapError=gt,this._tapComplete=gt,this._tapError=a||gt,this._tapComplete=o||gt,t(e)?(this._context=this,this._tapNext=e):e&&(this._context=e,this._tapNext=e.next||gt,this._tapError=e.error||gt,this._tapComplete=e.complete||gt)}_next(t){try{this._tapNext.call(this._context,t)}catch(t){return void this.destination.error(t)}this.destination.next(t)}_error(t){try{this._tapError.call(this._context,t)}catch(t){return void this.destination.error(t)}this.destination.error(t)}_complete(){try{this._tapComplete.call(this._context)}catch(t){return void this.destination.error(t)}return this.destination.complete()}}const Me={leading:!0,trailing:!1};class Oe{constructor(t,n,e,a){this.duration=t,this.scheduler=n,this.leading=e,this.trailing=a}call(t,n){return n.subscribe(new Pe(t,this.duration,this.scheduler,this.leading,this.trailing))}}class Pe extends d{constructor(t,n,e,a,o){super(t),this.duration=n,this.scheduler=e,this.leading=a,this.trailing=o,this.throttled=null,this._hasTrailingValue=!1,this._trailingValue=null}_next(t){this.throttled?this.trailing&&(this._trailingValue=t,this._hasTrailingValue=!0):(this.add(this.throttled=this.scheduler.schedule(xe,this.duration,{subscriber:this})),this.leading?this.destination.next(t):this.trailing&&(this._trailingValue=t,this._hasTrailingValue=!0))}_complete(){this._hasTrailingValue?(this.destination.next(this._trailingValue),this.destination.complete()):this.destination.complete()}clearThrottle(){const t=this.throttled;t&&(this.trailing&&this._hasTrailingValue&&(this.destination.next(this._trailingValue),this._trailingValue=null,this._hasTrailingValue=!1),t.unsubscribe(),this.remove(t),this.throttled=null)}}function xe(t){const{subscriber:n}=t;n.clearThrottle()}function ye(...t){return n=>{let e;return"function"==typeof t[t.length-1]&&(e=t.pop()),n.lift(new ke(t,e))}}class ke{constructor(t,n){this.observables=t,this.project=n}call(t,n){return n.subscribe(new ve(t,this.observables,this.project))}}class ve extends Ct{constructor(t,n,e){super(t),this.observables=n,this.project=e,this.toRespond=[];const a=n.length;this.values=new Array(a);for(let t=0;t<a;t++)this.toRespond.push(t);for(let t=0;t<a;t++){let e=n[t];this.add(wt(this,e,e,t))}}notifyNext(t,n,e,a,o){this.values[e]=n;const r=this.toRespond;if(r.length>0){const t=r.indexOf(e);-1!==t&&r.splice(t,1)}}notifyComplete(){}_next(t){if(0===this.toRespond.length){const n=[t,...this.values];this.project?this._tryProject(n):this.destination.next(n)}}_tryProject(t){let n;try{n=this.project.apply(this,t)}catch(t){return void this.destination.error(t)}this.destination.next(n)}}
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function we(t){return{toString:t}.toString()}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Se="__annotations__",Ee="__parameters__",Ae="__prop__metadata__";function ze(t,n,e,a,o){return we((()=>{const r=Re(n);function i(...t){if(this instanceof i)return r.call(this,...t),this;const n=new i(...t);return function e(r){return o&&o(r,...t),(r.hasOwnProperty(Se)?r[Se]:Object.defineProperty(r,Se,{value:[]})[Se]).push(n),a&&a(r),r}}return e&&(i.prototype=Object.create(e.prototype)),i.prototype.ngMetadataName=t,i.annotationCls=i,i}))}function Re(t){return function n(...e){if(t){const n=t(...e);for(const t in n)this[t]=n[t]}}}function Te(t,n,e){return we((()=>{const a=Re(n);function o(...t){if(this instanceof o)return a.apply(this,t),this;const n=new o(...t);return e.annotation=n,e;function e(t,e,a){const o=t.hasOwnProperty(Ee)?t[Ee]:Object.defineProperty(t,Ee,{value:[]})[Ee];for(;o.length<=a;)o.push(null);return(o[a]=o[a]||[]).push(n),t}}return e&&(o.prototype=Object.create(e.prototype)),o.prototype.ngMetadataName=t,o.annotationCls=o,o}))}function De(t,n,e,a){return we((()=>{const o=Re(n);function r(...t){if(this instanceof r)return o.apply(this,t),this;const n=new r(...t);return function e(o,r){const i=o.constructor,c=i.hasOwnProperty(Ae)?i[Ae]:Object.defineProperty(i,Ae,{value:{}})[Ae];c[r]=c.hasOwnProperty(r)&&c[r]||[],c[r].unshift(n),a&&a(o,r,...t)}}return e&&(r.prototype=Object.create(e.prototype)),r.prototype.ngMetadataName=t,r.annotationCls=r,r}))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Ie=Te("Inject",(t=>({token:t}))),Ne=Te("Optional"),Fe=Te("Self"),Le=Te("SkipSelf"),He=Te("Host"),Be=Te("Attribute",(t=>({attributeName:t})));
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
var Ve;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function je(t){for(let n in t)if(t[n]===je)return n;throw Error("Could not find renamed property on target object.")}function Ue(t,n){for(const e in n)n.hasOwnProperty(e)&&!t.hasOwnProperty(e)&&(t[e]=n[e])}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function We(t){return{token:t.token,providedIn:t.providedIn||null,factory:t.factory,value:void 0}}function Ge(t){return{factory:t.factory,providers:t.providers||[],imports:t.imports||[]}}function Ye(t){return qe(t,t[Xe])||qe(t,t[Ke])}function qe(t,n){return n&&n.token===t?n:null}function Ze(t){return t&&(t.hasOwnProperty(Je)||t.hasOwnProperty($e))?t[Je]:null}!(function(t){t[t.Default=0]="Default",t[t.Host=1]="Host",t[t.Self=2]="Self",t[t.SkipSelf=4]="SkipSelf",t[t.Optional=8]="Optional"})(Ve||(Ve={}));const Xe=je({"ɵprov":je}),Je=je({"ɵinj":je}),Qe=je({"ɵprovFallback":je}),Ke=je({ngInjectableDef:je}),$e=je({ngInjectorDef:je});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function ta(t){if("string"==typeof t)return t;if(Array.isArray(t))return"["+t.map(ta).join(", ")+"]";if(null==t)return""+t;if(t.overriddenName)return`${t.overriddenName}`;if(t.name)return`${t.name}`;const n=t.toString();if(null==n)return""+n;const e=n.indexOf("\n");return-1===e?n:n.substring(0,e)}function na(t,n){return null==t||""===t?null===n?"":n:null==n||""===n?t:t+" "+n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const ea=je({__forward_ref__:je});function aa(t){return t.__forward_ref__=aa,t.toString=function(){return ta(this())},t}function oa(t){return ra(t)?t():t}function ra(t){return"function"==typeof t&&t.hasOwnProperty(ea)&&t.__forward_ref__===aa}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const ia="undefined"!=typeof globalThis&&globalThis,ca="undefined"!=typeof window&&window,sa="undefined"!=typeof self&&"undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope&&self,la="undefined"!=typeof global&&global,ma=ia||la||ca||sa;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
var da,ga,pa;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function ba(){const t=ma.ng;if(!t||!t.ɵcompilerFacade)throw new Error("Angular JIT compilation failed: '@angular/compiler' not loaded!\n  - JIT compilation is discouraged for production use-cases! Consider AOT mode instead.\n  - Did you bootstrap using '@angular/platform-browser-dynamic' or '@angular/platform-server'?\n  - Alternatively provide the compiler with 'import \"@angular/compiler\";' before bootstrapping.");return t.ɵcompilerFacade}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */!(function(t){t[t.Token=0]="Token",t[t.Attribute=1]="Attribute",t[t.ChangeDetectorRef=2]="ChangeDetectorRef",t[t.Invalid=3]="Invalid"})(da||(da={})),(function(t){t[t.Directive=0]="Directive",t[t.Component=1]="Component",t[t.Injectable=2]="Injectable",t[t.Pipe=3]="Pipe",t[t.NgModule=4]="NgModule"})(ga||(ga={})),(function(t){t[t.Emulated=0]="Emulated",t[t.Native=1]="Native",t[t.None=2]="None",t[t.ShadowDom=3]="ShadowDom"})(pa||(pa={}));const ua=je({"ɵcmp":je}),fa=je({"ɵdir":je}),ha=je({"ɵpipe":je}),_a=je({"ɵmod":je}),Ca=je({"ɵloc":je}),Ma=je({"ɵfac":je}),Oa=je({__NG_ELEMENT_ID__:je});function Pa(){return!("undefined"!=typeof ngDevMode&&!ngDevMode||("object"!=typeof ngDevMode&&(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function t(){const t="undefined"!=typeof location?location.toString():"",n={namedConstructors:-1!=t.indexOf("ngDevMode=namedConstructors"),firstCreatePass:0,tNode:0,tView:0,rendererCreateTextNode:0,rendererSetText:0,rendererCreateElement:0,rendererAddEventListener:0,rendererSetAttribute:0,rendererRemoveAttribute:0,rendererSetProperty:0,rendererSetClassName:0,rendererAddClass:0,rendererRemoveClass:0,rendererSetStyle:0,rendererRemoveStyle:0,rendererDestroy:0,rendererDestroyNode:0,rendererMoveNode:0,rendererRemoveNode:0,rendererAppendChild:0,rendererInsertBefore:0,rendererCreateComment:0},e=-1===t.indexOf("ngDevMode=false");ma.ngDevMode=e&&n})(),"undefined"==typeof ngDevMode||!ngDevMode))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function xa(t,n){"number"!=typeof t&&Da(n,typeof t,"number","===")}function ya(t,n,e){xa(t,"Expected a number"),za(t,e,"Expected number to be less than or equal to"),(function a(t,n,e){t>=n||Da(e,t,n,">=")})(t,n,"Expected number to be greater than or equal to")}function ka(t,n){"string"!=typeof t&&Da(n,null===t?"null":typeof t,"string","===")}function va(t,n,e){t!=n&&Da(e,t,n,"==")}function wa(t,n,e){t==n&&Da(e,t,n,"!=")}function Sa(t,n,e){t!==n&&Da(e,t,n,"===")}function Ea(t,n,e){t===n&&Da(e,t,n,"!==")}function Aa(t,n,e){t<n||Da(e,t,n,"<")}function za(t,n,e){t<=n||Da(e,t,n,"<=")}function Ra(t,n,e){t>n||Da(e,t,n,">")}function Ta(t,n){null==t&&Da(n,t,null,"!=")}function Da(t,n,e,a){throw new Error(`ASSERTION ERROR: ${t}`+(null==a?"":` [Expected=> ${e} ${a} ${n} <=Actual]`))}function Ia(t){va("undefined"!=typeof Node&&t instanceof Node||"object"==typeof t&&null!=t&&"WebWorkerRenderNode"===t.constructor.name,!0,`The provided value must be an instance of a DOM Node but got ${ta(t)}`)}function Na(t,n){const e=t?t.length:0;Aa(n,e,`Index expected to be less than ${e} but got ${n}`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Fa{constructor(t,n){this._desc=t,this.ngMetadataName="InjectionToken",this.ɵprov=void 0,"number"==typeof n?this.__NG_ELEMENT_ID__=n:void 0!==n&&(this.ɵprov=We({token:this,providedIn:n.providedIn||"root",factory:n.factory}))}toString(){return`InjectionToken ${this._desc}`}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const La=new Fa("INJECTOR",-1),Ha={},Ba=/\n/gm,Va="__source",ja=je({provide:String,useValue:je});let Ua,Wa;function Ga(t){const n=Ua;return Ua=t,n}function Ya(t){const n=Wa;return Wa=t,n}function qa(t,n=Ve.Default){if(void 0===Ua)throw new Error("inject() must be called from an injection context");return null===Ua?Qa(t,void 0,n):Ua.get(t,n&Ve.Optional?null:void 0,n)}function Za(t,n=Ve.Default){return(Wa||qa)(oa(t),n)}function Xa(t){const n=ngDevMode?`This constructor is not compatible with Angular Dependency Injection because its dependency at index ${t} of the parameter list is invalid.\nThis can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.\n\nPlease check that 1) the type for the parameter at index ${t} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`:"invalid";throw new Error(n)}const Ja=Za;function Qa(t,n,e){const a=Ye(t);if(a&&"root"==a.providedIn)return void 0===a.value?a.value=a.factory():a.value;if(e&Ve.Optional)return null;if(void 0!==n)return n;throw new Error(`Injector: NOT_FOUND [${ta(t)}]`)}function Ka(t){const n=[];for(let e=0;e<t.length;e++){const a=oa(t[e]);if(Array.isArray(a)){if(0===a.length)throw new Error("Arguments array must have arguments.");let t,e=Ve.Default;for(let n=0;n<a.length;n++){const o=a[n];o instanceof Ne||"Optional"===o.ngMetadataName||o===Ne?e|=Ve.Optional:o instanceof Le||"SkipSelf"===o.ngMetadataName||o===Le?e|=Ve.SkipSelf:o instanceof Fe||"Self"===o.ngMetadataName||o===Fe?e|=Ve.Self:t=o instanceof Ie||o===Ie?o.token:o}n.push(Za(t,e))}else n.push(Za(a))}return n}class $a{get(t,n=Ha){if(n===Ha){const n=new Error(`NullInjectorError: No provider for ${ta(t)}!`);throw n.name="NullInjectorError",n}return n}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const to={"ɵɵdefineInjectable":We,"ɵɵdefineInjector":Ge,"ɵɵinject":Za,"ɵɵgetFactoryOf":function t(n){const e=n;if(ra(n))return()=>{const n=t(oa(e));return n?n():null};const a=Ye(e)||Ze(e);return a&&void 0!==a.factory?a.factory:null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */,"ɵɵinvalidFactoryDep":Xa};class no{}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function eo(t,n){for(let e=0;e<t.length;e++)n.push(t[e])}function ao(t,n){void 0===n&&(n=t);for(let e=0;e<t.length;e++){let a=t[e];Array.isArray(a)?(n===t&&(n=t.slice(0,e)),ao(a,n)):n!==t&&n.push(a)}return n}function oo(t,n){t.forEach((t=>Array.isArray(t)?oo(t,n):n(t)))}function ro(t,n,e){n>=t.length?t.push(e):t.splice(n,0,e)}function io(t,n){return n>=t.length-1?t.pop():t.splice(n,1)[0]}function co(t,n){const e=[];for(let a=0;a<t;a++)e.push(n);return e}function so(t,n,e){let a=mo(t,n);return a>=0?t[1|a]=e:(a=~a,(function o(t,n,e,a){ngDevMode&&za(n,t.length,"Can't insert past array end.");let o=t.length;if(o==n)t.push(e,a);else if(1===o)t.push(a,t[0]),t[0]=e;else{for(o--,t.push(t[o-1],t[o]);o>n;)t[o]=t[o-2],o--;t[n]=e,t[n+1]=a}})(t,a,n,e)),a}function lo(t,n){const e=mo(t,n);if(e>=0)return t[1|e]}function mo(t,n){return(function e(t,n,a){ngDevMode&&va(Array.isArray(t),!0,"Expecting an array");let o=0,r=t.length>>a;for(;r!==o;){const e=o+(r-o>>1),i=t[e<<a];if(n===i)return e<<a;i>n?r=e:o=e+1}return~(r<<a)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t,n,1)}var go,po,bo;!(function(t){t[t.OnPush=0]="OnPush",t[t.Default=1]="Default"})(go||(go={})),(function(t){t[t.CheckOnce=0]="CheckOnce",t[t.Checked=1]="Checked",t[t.CheckAlways=2]="CheckAlways",t[t.Detached=3]="Detached",t[t.Errored=4]="Errored",t[t.Destroyed=5]="Destroyed"})(po||(po={})),(function(t){t[t.Emulated=0]="Emulated",t[t.Native=1]="Native",t[t.None=2]="None",t[t.ShadowDom=3]="ShadowDom"})(bo||(bo={}));
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const uo={},fo=[];("undefined"==typeof ngDevMode||ngDevMode)&&Pa()&&(Object.freeze(uo),Object.freeze(fo))
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;let ho=0;function _o(t){return we((()=>{("undefined"==typeof ngDevMode||ngDevMode)&&Pa();const n={},e={type:t.type,providersResolver:null,decls:t.decls,vars:t.vars,factory:null,template:t.template||null,consts:t.consts||null,ngContentSelectors:t.ngContentSelectors,hostBindings:t.hostBindings||null,hostVars:t.hostVars||0,hostAttrs:t.hostAttrs||null,contentQueries:t.contentQueries||null,declaredInputs:n,inputs:null,outputs:null,exportAs:t.exportAs||null,onPush:t.changeDetection===go.OnPush,directiveDefs:null,pipeDefs:null,selectors:t.selectors||fo,viewQuery:t.viewQuery||null,features:t.features||null,data:t.data||{},encapsulation:t.encapsulation||bo.Emulated,id:"c",styles:t.styles||fo,_:null,setInput:null,schemas:t.schemas||null,tView:null},a=t.directives,o=t.features,r=t.pipes;return e.id+=ho++,e.inputs=ko(t.inputs,n),e.outputs=ko(t.outputs),o&&o.forEach((t=>t(e))),e.directiveDefs=a?()=>("function"==typeof a?a():a).map(Mo):null,e.pipeDefs=r?()=>("function"==typeof r?r():r).map(Oo):null,e}))}function Co(t,n,e){const a=t.ɵcmp;a.directiveDefs=()=>n.map(Mo),a.pipeDefs=()=>e.map(Oo)}function Mo(t){const n=So(t)||Eo(t);if(ngDevMode&&!n)throw new Error(`'${t.name}' is neither 'ComponentType' or 'DirectiveType'.`);return n}function Oo(t){const n=Ao(t);if(ngDevMode&&!n)throw new Error(`'${t.name}' is not a 'PipeType'.`);return n}const Po={};function xo(t){const n={type:t.type,bootstrap:t.bootstrap||fo,declarations:t.declarations||fo,imports:t.imports||fo,exports:t.exports||fo,transitiveCompileScopes:null,schemas:t.schemas||null,id:t.id||null};return null!=t.id&&we((()=>{Po[t.id]=t.type})),n}function yo(t,n){return we((()=>{const e=Ro(t,!0);e.declarations=n.declarations||fo,e.imports=n.imports||fo,e.exports=n.exports||fo}))}function ko(t,n){if(null==t)return uo;const e={};for(const a in t)if(t.hasOwnProperty(a)){let o=t[a],r=o;Array.isArray(o)&&(r=o[1],o=o[0]),e[o]=a,n&&(n[o]=r)}return e}const vo=_o;function wo(t){return{type:t.type,name:t.name,factory:null,pure:!1!==t.pure,onDestroy:t.type.prototype.ngOnDestroy||null}}function So(t){return t[ua]||null}function Eo(t){return t[fa]||null}function Ao(t){return t[ha]||null}function zo(t,n){const e=t.hasOwnProperty(Ma);if(!e&&!0===n&&ngDevMode)throw new Error(`Type ${ta(t)} does not have 'ɵfac' property.`);return e?t[Ma]:null}function Ro(t,n){const e=t[_a]||null;if(!e&&!0===n)throw new Error(`Type ${ta(t)} does not have 'ɵmod' property.`);return e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const To=20,Do=["Root","Component","Embedded"],Io=10;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function No(t){return Array.isArray(t)&&"object"==typeof t[1]}function Fo(t){return Array.isArray(t)&&!0===t[1]}function Lo(t){return 0!=(8&t.flags)}function Ho(t){return 2==(2&t.flags)}function Bo(t){return 1==(1&t.flags)}function Vo(t){return null!==t.template}function jo(t){return 0!=(512&t[2])}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Uo(t,n){Wo(t,n[1])}function Wo(t,n){Ta(t,"TNode must be defined"),t.hasOwnProperty("tView_")&&va(t.tView_,n,"This TNode does not belong to this TView.")}function Go(t){Ta(t,"currentTNode should exist!"),Ta(t.parent,"currentTNode should have a parent")}function Yo(t){Ta(t,"LContainer must be defined"),va(Fo(t),!0,"Expecting LContainer")}function qo(t){t&&va(No(t),!0,"Expecting LView or undefined or null")}function Zo(t){Ta(t,"LView must be defined"),va(No(t),!0,"Expecting LView")}function Xo(t,n){va(t.firstCreatePass,!0,n||"Should only be called in first create pass.")}function Jo(t,n){va(t.firstUpdatePass,!0,n||"Should only be called in first update pass.")}function Qo(t,n){!(function e(t,n,a){t<=a&&a<n||Da(`Index out of range (expecting ${t} <= ${a} < ${n})`)})(t[1].expandoStartIndex,t.length,n)}function Ko(t,n){Qo(t,n),Qo(t,n+8),xa(t[n+0],"injectorIndex should point to a bloom filter"),xa(t[n+1],"injectorIndex should point to a bloom filter"),xa(t[n+2],"injectorIndex should point to a bloom filter"),xa(t[n+3],"injectorIndex should point to a bloom filter"),xa(t[n+4],"injectorIndex should point to a bloom filter"),xa(t[n+5],"injectorIndex should point to a bloom filter"),xa(t[n+6],"injectorIndex should point to a bloom filter"),xa(t[n+7],"injectorIndex should point to a bloom filter"),xa(t[n+8],"injectorIndex should point to parent injector")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function $o(t){return"string"==typeof t?t:null==t?"":""+t}function tr(t){return"function"==typeof t?t.name||t.toString():"object"==typeof t&&null!=t&&"function"==typeof t.type?t.type.name||t.type.toString():$o(t)}const nr=("undefined"!=typeof requestAnimationFrame&&requestAnimationFrame||setTimeout).bind(ma);function er(t){return{name:"window",target:t.ownerDocument.defaultView}}function ar(t){return{name:"document",target:t.ownerDocument}}function or(t){return{name:"body",target:t.ownerDocument.body}}const rr="�";function ir(t){return t instanceof Function?t():t}function cr(t,n){const e=n?`. Dependency path: ${n.join(" > ")} > ${t}`:"";throw new Error(`Circular dependency in DI detected for ${t}${e}`)}function sr(t){throw new Error(`Multiple components match node with tagname ${t.tagName}`)}function lr(){throw new Error("Cannot mix multi providers and regular providers")}function mr(t,n,e,a,o){const[r,i,...c]=a.split(rr);let s=i,l=i;for(let a=0;a<c.length;a++){const r=n+a;s+=`${t[r]}${c[a]}`,l+=`${r===e?o:t[r]}${c[a]}`}return{propName:r,oldValue:s,newValue:l}}function dr(t,n){const e=n?` in ${n}`:"";throw new Error(`No provider for ${tr(t)} found${e}`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class gr{constructor(t,n,e){this.previousValue=t,this.currentValue=n,this.firstChange=e}isFirstChange(){return this.firstChange}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function pr(){return br}function br(t){return t.type.prototype.ngOnChanges&&(t.setInput=fr),ur}function ur(){const t=hr(this),n=null==t?void 0:t.current;if(n){const e=t.previous;if(e===uo)t.previous=n;else for(let t in n)e[t]=n[t];t.current=null,this.ngOnChanges(n)}}function fr(t,n,e,a){const o=hr(t)||(function r(t,n){return t.__ngSimpleChanges__=n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t,{previous:uo,current:null}),i=o.current||(o.current={}),c=o.previous,s=this.declaredInputs[e],l=c[s];i[s]=new gr(l&&l.currentValue,n,c===uo),t[a]=n}function hr(t){return t.__ngSimpleChanges__||null}pr.ngInherit=!0;const _r="http://www.w3.org/2000/svg",Cr="http://www.w3.org/1998/MathML/";
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let Mr;function Or(){return void 0!==Mr?Mr:"undefined"!=typeof document?document:void 0}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */var Pr;function xr(t){return!!t.listen}!(function(t){t[t.Important=1]="Important",t[t.DashCase=2]="DashCase"})(Pr||(Pr={}));const yr={createRenderer:(t,n)=>Or()};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function kr(t){for(;Array.isArray(t);)t=t[0];return t}function vr(t,n){return kr(n[t+To])}function wr(t,n){ngDevMode&&Uo(t,n),ngDevMode&&Na(n,t.index);const e=kr(n[t.index]);return ngDevMode&&!xr(n[11])&&Ia(e),e}function Sr(t,n){return ngDevMode&&Ra(n,-1,"wrong index for TNode"),ngDevMode&&Aa(n,t.data.length,"wrong index for TNode"),t.data[n+To]}function Er(t,n){return ngDevMode&&Na(t,n+To),t[n+To]}function Ar(t,n){ngDevMode&&Na(n,t);const e=n[t];return No(e)?e:e[0]}function zr(t){return ngDevMode&&Ta(t,"Target expected"),t.__ngContext__||null}function Rr(t){const n=zr(t);return n?Array.isArray(n)?n:n.lView:null}function Tr(t){return 4==(4&t[2])}function Dr(t){return 128==(128&t[2])}function Ir(t,n){return null===t||null==n?null:t[n]}function Nr(t){t[18]=0}function Fr(t,n){t[5]+=n;let e=t,a=t[3];for(;null!==a&&(1===n&&1===e[5]||-1===n&&0===e[5]);)a[5]+=n,e=a,a=a[3]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Lr={lFrame:si(null),bindingsEnabled:!0,isInCheckNoChangesMode:!1};function Hr(){return Lr.bindingsEnabled}function Br(){return Lr.lFrame.lView}function Vr(){return Lr.lFrame.tView}function jr(t){Lr.lFrame.contextLView=t}function Ur(){return Lr.lFrame.currentTNode}function Wr(t,n){ngDevMode&&Wo(t,Lr.lFrame.tView),Lr.lFrame.currentTNode=t,Lr.lFrame.isParent=n}function Gr(){return Lr.lFrame.isParent}function Yr(){Lr.lFrame.isParent=!1}function qr(){return Lr.isInCheckNoChangesMode}function Zr(t){Lr.isInCheckNoChangesMode=t}function Xr(){const t=Lr.lFrame;let n=t.bindingRootIndex;return-1===n&&(n=t.bindingRootIndex=t.tView.bindingStartIndex),n}function Jr(){return Lr.lFrame.bindingIndex}function Qr(t){return Lr.lFrame.bindingIndex=t}function Kr(){return Lr.lFrame.bindingIndex++}function $r(t){const n=Lr.lFrame,e=n.bindingIndex;return n.bindingIndex=n.bindingIndex+t,e}function ti(t,n){const e=Lr.lFrame;e.bindingIndex=e.bindingRootIndex=t,ni(n)}function ni(t){Lr.lFrame.currentDirectiveIndex=t}function ei(t){const n=Lr.lFrame.currentDirectiveIndex;return-1===n?null:t[n]}function ai(){return Lr.lFrame.currentQueryIndex}function oi(t){Lr.lFrame.currentQueryIndex=t}function ri(t,n){ngDevMode&&qo(t);const e=ci();Lr.lFrame=e,e.currentTNode=n,e.lView=t}function ii(t){ngDevMode&&qo(t);const n=ci();ngDevMode&&(va(n.isParent,!0,"Expected clean LFrame"),va(n.lView,null,"Expected clean LFrame"),va(n.tView,null,"Expected clean LFrame"),va(n.selectedIndex,0,"Expected clean LFrame"),va(n.elementDepthCount,0,"Expected clean LFrame"),va(n.currentDirectiveIndex,-1,"Expected clean LFrame"),va(n.currentNamespace,null,"Expected clean LFrame"),va(n.bindingRootIndex,-1,"Expected clean LFrame"),va(n.currentQueryIndex,0,"Expected clean LFrame"));const e=t[1];Lr.lFrame=n,ngDevMode&&e.firstChild&&Wo(e.firstChild,e),n.currentTNode=e.firstChild,n.lView=t,n.tView=e,n.contextLView=t,n.bindingIndex=e.bindingStartIndex}function ci(){const t=Lr.lFrame,n=null===t?null:t.child;return null===n?si(t):n}function si(t){const n={currentTNode:null,isParent:!0,lView:null,tView:null,selectedIndex:0,contextLView:null,elementDepthCount:0,currentNamespace:null,currentDirectiveIndex:-1,bindingRootIndex:-1,bindingIndex:-1,currentQueryIndex:0,parent:t,child:null};return null!==t&&(t.child=n),n}function li(){const t=Lr.lFrame;return Lr.lFrame=t.parent,t.currentTNode=null,t.lView=null,t}const mi=li;function di(){const t=li();t.isParent=!0,t.tView=null,t.selectedIndex=0,t.contextLView=null,t.elementDepthCount=0,t.currentDirectiveIndex=-1,t.currentNamespace=null,t.bindingRootIndex=-1,t.bindingIndex=-1,t.currentQueryIndex=0}function gi(){return Lr.lFrame.selectedIndex}function pi(t){Lr.lFrame.selectedIndex=t}function bi(){const t=Lr.lFrame;return Sr(t.tView,t.selectedIndex)}function ui(){Lr.lFrame.currentNamespace=_r}function fi(){!(function t(){Lr.lFrame.currentNamespace=null})()}function hi(t,n){ngDevMode&&Xo(t);for(let e=n.directiveStart,a=n.directiveEnd;e<a;e++){const n=t.data[e].type.prototype,{ngAfterContentInit:a,ngAfterContentChecked:o,ngAfterViewInit:r,ngAfterViewChecked:i,ngOnDestroy:c}=n;a&&(t.contentHooks||(t.contentHooks=[])).push(-e,a),o&&((t.contentHooks||(t.contentHooks=[])).push(e,o),(t.contentCheckHooks||(t.contentCheckHooks=[])).push(e,o)),r&&(t.viewHooks||(t.viewHooks=[])).push(-e,r),i&&((t.viewHooks||(t.viewHooks=[])).push(e,i),(t.viewCheckHooks||(t.viewCheckHooks=[])).push(e,i)),null!=c&&(t.destroyHooks||(t.destroyHooks=[])).push(e,c)}}function _i(t,n,e){Oi(t,n,3,e)}function Ci(t,n,e,a){ngDevMode&&wa(e,3,"Init pre-order hooks should not be called more than once"),(3&t[2])===e&&Oi(t,n,e,a)}function Mi(t,n){ngDevMode&&wa(n,3,"Init hooks phase should not be incremented after all init hooks have been run.");let e=t[2];(3&e)===n&&(e&=2047,e+=1,t[2]=e)}function Oi(t,n,e,a){ngDevMode&&va(qr(),!1,"Hooks should never be run when in check no changes mode.");const o=null!=a?a:-1;let r=0;for(let i=void 0!==a?65535&t[18]:0;i<n.length;i++)if("number"==typeof n[i+1]){if(r=n[i],null!=a&&r>=a)break}else n[i]<0&&(t[18]+=65536),(r<o||-1==o)&&(Pi(t,e,n,i),t[18]=(4294901760&t[18])+i+2),i++}function Pi(t,n,e,a){const o=e[a]<0,r=e[a+1],i=t[o?-e[a]:e[a]];o?t[2]>>11<t[18]>>16&&(3&t[2])===n&&(t[2]+=2048,r.call(i)):r.call(i)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const xi=-1;class yi{constructor(t,n,e){this.factory=t,this.resolving=!1,ngDevMode&&Ta(t,"Factory not specified"),ngDevMode&&va(typeof t,"function","Expected factory function."),this.canSeeViewProviders=n,this.injectImpl=e}}const ki=["Container","Projection","Element","ElementContainer","IcuContainer"];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function vi(t,n){Ta(t,"should be called with a TNode"),va(t.type,n,`should be a ${Si(n)}`)}function wi(t,n,e){Ta(t,"should be called with a TNode"),va(n.some((n=>t.type===n)),!0,null!=e?e:`Should be one of ${n.map(Si).join(", ")} but got ${Si(t.type)}`)}function Si(t){return ki[t]||"<unknown>"}function Ei(t,n,e){const a=xr(t);let o=0;for(;o<e.length;){const r=e[o];if("number"==typeof r){if(0!==r)break;o++;const i=e[o++],c=e[o++],s=e[o++];ngDevMode&&ngDevMode.rendererSetAttribute++,a?t.setAttribute(n,c,s,i):n.setAttributeNS(i,c,s)}else{const i=r,c=e[++o];ngDevMode&&ngDevMode.rendererSetAttribute++,zi(i)?a&&t.setProperty(n,i,c):a?t.setAttribute(n,i,c):n.setAttribute(i,c),o++}}return o}function Ai(t){return 3===t||4===t||6===t}function zi(t){return 64===t.charCodeAt(0)}function Ri(t,n){if(null===n||0===n.length);else if(null===t||0===t.length)t=n.slice();else{let e=-1;for(let a=0;a<n.length;a++){const o=n[a];"number"==typeof o?e=o:0===e||Ti(t,e,o,null,-1===e||2===e?n[++a]:null)}}return t}function Ti(t,n,e,a,o){let r=0,i=t.length;if(-1===n)i=-1;else for(;r<t.length;){const e=t[r++];if("number"==typeof e){if(e===n){i=-1;break}if(e>n){i=r-1;break}}}for(;r<t.length;){const n=t[r];if("number"==typeof n)break;if(n===e){if(null===a)return void(null!==o&&(t[r+1]=o));if(a===t[r+1])return void(t[r+2]=o)}r++,null!==a&&r++,null!==o&&r++}-1!==i&&(t.splice(i,0,n),r=i+1),t.splice(r++,0,e),null!==a&&t.splice(r++,0,a),null!==o&&t.splice(r++,0,o)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Di(t){return t!==xi}function Ii(t){return ngDevMode&&xa(t,"Number expected"),ngDevMode&&wa(t,-1,"Not a valid state."),ngDevMode&&Ra(32767&t,To,"Parent injector must be pointing past HEADER_OFFSET."),32767&t}function Ni(t,n){let e=(function a(t){return t>>16})(t),o=n;for(;e>0;)o=o[15],e--;return o}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let Fi=!0;function Li(t){const n=Fi;return Fi=t,n}let Hi=0;function Bi(t,n){const e=ji(t,n);if(-1!==e)return e;const a=n[1];a.firstCreatePass&&(t.injectorIndex=n.length,Vi(a.data,t),Vi(n,null),Vi(a.blueprint,null));const o=Ui(t,n),r=t.injectorIndex;if(Di(o)){const t=Ii(o),e=Ni(o,n),a=e[1].data;for(let o=0;o<8;o++)n[r+o]=e[t+o]|a[t+o]}return n[r+8]=o,r}function Vi(t,n){t.push(0,0,0,0,0,0,0,0,n)}function ji(t,n){return-1===t.injectorIndex||t.parent&&t.parent.injectorIndex===t.injectorIndex||null===n[t.injectorIndex+8]?-1:(ngDevMode&&Na(n,t.injectorIndex),t.injectorIndex)}function Ui(t,n){if(t.parent&&-1!==t.parent.injectorIndex)return t.parent.injectorIndex;let e=0,a=null,o=n;for(;null!==o;){const t=o[1],n=t.type;if(2===n?(ngDevMode&&Ta(t.declTNode,"Embedded TNodes should have declaration parents."),a=t.declTNode):1===n?a=o[6]:(ngDevMode&&va(t.type,0,"Root type expected"),a=null),null===a)return xi;if(ngDevMode&&a&&Uo(a,o[15]),e++,o=o[15],-1!==a.injectorIndex)return a.injectorIndex|e<<16}return xi}function Wi(t,n,e){!(function a(t,n,e){let a;ngDevMode&&va(n.firstCreatePass,!0,"expected firstCreatePass to be true"),"string"==typeof e?a=e.charCodeAt(0)||0:e.hasOwnProperty(Oa)&&(a=e[Oa]),null==a&&(a=e[Oa]=Hi++);const o=255&a,r=1<<o,i=64&o,c=32&o,s=n.data;128&o?i?c?s[t+7]|=r:s[t+6]|=r:c?s[t+5]|=r:s[t+4]|=r:i?c?s[t+3]|=r:s[t+2]|=r:c?s[t+1]|=r:s[t]|=r})(t,n,e)}function Gi(t,n,e,a=Ve.Default,o){if(null!==t){const o=(function r(t){if(ngDevMode&&Ta(t,"token must be defined"),"string"==typeof t)return t.charCodeAt(0)||0;const n=t.hasOwnProperty(Oa)?t[Oa]:void 0;return"number"==typeof n&&n>0?255&n:n})(e);if("function"==typeof o){ri(n,t);try{const t=o();if(null!=t||a&Ve.Optional)return t;dr(e)}finally{mi()}}else if("number"==typeof o){if(-1===o)return new Ki(t,n);let r=null,i=ji(t,n),c=xi,s=a&Ve.Host?n[16][6]:null;for((-1===i||a&Ve.SkipSelf)&&(c=-1===i?Ui(t,n):n[i+8],c!==xi&&Qi(a,!1)?(r=n[1],i=Ii(c),n=Ni(c,n)):i=-1);-1!==i;){ngDevMode&&Ko(n,i);const t=n[1];if(ngDevMode&&Uo(t.data[i+8],n),Ji(o,i,t.data)){const t=qi(i,n,e,r,a,s);if(t!==Yi)return t}c=n[i+8],c!==xi&&Qi(a,n[1].data[i+8]===s)&&Ji(o,i,n)?(r=t,i=Ii(c),n=Ni(c,n)):i=-1}}}if(a&Ve.Optional&&void 0===o&&(o=null),0==(a&(Ve.Self|Ve.Host))){const t=n[9],r=Ya(void 0);try{return t?t.get(e,o,a&Ve.Optional):Qa(e,o,a&Ve.Optional)}finally{Ya(r)}}if(a&Ve.Optional)return o;dr(e,"NodeInjector")}const Yi={};function qi(t,n,e,a,o,r){const i=n[1],c=i.data[t+8],s=Zi(c,i,e,null==a?Ho(c)&&Fi:a!=i&&2===c.type,o&Ve.Host&&r===c);return null!==s?Xi(n,i,s,c):Yi}function Zi(t,n,e,a,o){const r=t.providerIndexes,i=n.data,c=1048575&r,s=t.directiveStart,l=r>>20,m=o?c+l:t.directiveEnd;for(let t=a?c:c+l;t<m;t++){const n=i[t];if(t<s&&e===n||t>=s&&n.type===e)return t}if(o){const t=i[s];if(t&&Vo(t)&&t.type===e)return s}return null}function Xi(t,n,e,a){let o=t[e];const r=n.data;if((function i(t){return t instanceof yi})(o)){const i=o;i.resolving&&cr(tr(r[e]));const c=Li(i.canSeeViewProviders);i.resolving=!0;const s=i.injectImpl?Ya(i.injectImpl):null;ri(t,a);try{o=t[e]=i.factory(void 0,r,t,a),n.firstCreatePass&&e>=a.directiveStart&&(ngDevMode&&(function c(t){void 0!==t.type&&null!=t.selectors&&void 0!==t.inputs||Da("Expected a DirectiveDef/ComponentDef and this object does not seem to have the expected shape.")})(r[e]),(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function s(t,n,e){ngDevMode&&Xo(e);const{ngOnChanges:a,ngOnInit:o,ngDoCheck:r}=n.type.prototype;if(a){const a=br(n);(e.preOrderHooks||(e.preOrderHooks=[])).push(t,a),(e.preOrderCheckHooks||(e.preOrderCheckHooks=[])).push(t,a)}o&&(e.preOrderHooks||(e.preOrderHooks=[])).push(0-t,o),r&&((e.preOrderHooks||(e.preOrderHooks=[])).push(t,r),(e.preOrderCheckHooks||(e.preOrderCheckHooks=[])).push(t,r))})(e,r[e],n))}finally{null!==s&&Ya(s),Li(c),i.resolving=!1,mi()}}return o}function Ji(t,n,e){const a=64&t,o=32&t;let r;return r=128&t?a?o?e[n+7]:e[n+6]:o?e[n+5]:e[n+4]:a?o?e[n+3]:e[n+2]:o?e[n+1]:e[n],!!(r&1<<t)}function Qi(t,n){return!(t&Ve.Self||t&Ve.Host&&n)}class Ki{constructor(t,n){this._tNode=t,this._lView=n}get(t,n){return Gi(this._tNode,this._lView,t,void 0,n)}}function $i(t){const n=t;if(ra(t))return()=>{const t=$i(oa(n));return t?t():null};let e=zo(n);if(null===e){const t=Ze(n);e=t&&t.factory}return e||null}function tc(t){return we((()=>{const n=t.prototype.constructor,e=n[Ma]||$i(n),a=Object.prototype;let o=Object.getPrototypeOf(t.prototype).constructor;for(;o&&o!==a;){const t=o[Ma]||$i(o);if(t&&t!==e)return t;o=Object.getPrototypeOf(o)}return t=>new t}))}function nc(t){return t.ngDebugContext}function ec(t){return t.ngOriginalError}function ac(t,...n){t.error(...n)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class oc{constructor(){this._console=console}handleError(t){const n=this._findOriginalError(t),e=this._findContext(t),a=(function o(t){return t.ngErrorLogger||ac})(t);a(this._console,"ERROR",t),n&&a(this._console,"ORIGINAL ERROR",n),e&&a(this._console,"ERROR CONTEXT",e)}_findContext(t){return t?nc(t)?nc(t):this._findContext(ec(t)):null}_findOriginalError(t){let n=ec(t);for(;n&&ec(n);)n=ec(n);return n}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const rc={name:"custom-elements"},ic={name:"no-errors-schema"};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class cc{constructor(t){this.changingThisBreaksApplicationSecurity=t}toString(){return`SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see http://g.co/ng/security#xss)`}}class sc extends cc{getTypeName(){return"HTML"}}class lc extends cc{getTypeName(){return"Style"}}class mc extends cc{getTypeName(){return"Script"}}class dc extends cc{getTypeName(){return"URL"}}class gc extends cc{getTypeName(){return"ResourceURL"}}function pc(t){return t instanceof cc?t.changingThisBreaksApplicationSecurity:t}function bc(t,n){const e=uc(t);if(null!=e&&e!==n){if("ResourceURL"===e&&"URL"===n)return!0;throw new Error(`Required a safe ${n}, got a ${e} (see http://g.co/ng/security#xss)`)}return e===n}function uc(t){return t instanceof cc&&t.getTypeName()||null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let fc=!0,hc=!1;function _c(){return hc=!0,fc}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function Cc(t){return(function n(){try{return!!(new window.DOMParser).parseFromString("","text/html")}catch(t){return!1}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)()?new Mc:new Oc(t)}class Mc{getInertBodyElement(t){t="<body><remove></remove>"+t;try{const n=(new window.DOMParser).parseFromString(t,"text/html").body;return n.removeChild(n.firstChild),n}catch(t){return null}}}class Oc{constructor(t){if(this.defaultDoc=t,this.inertDocument=this.defaultDoc.implementation.createHTMLDocument("sanitization-inert"),null==this.inertDocument.body){const t=this.inertDocument.createElement("html");this.inertDocument.appendChild(t);const n=this.inertDocument.createElement("body");t.appendChild(n)}}getInertBodyElement(t){const n=this.inertDocument.createElement("template");if("content"in n)return n.innerHTML=t,n;const e=this.inertDocument.createElement("body");return e.innerHTML=t,this.defaultDoc.documentMode&&this.stripCustomNsAttrs(e),e}stripCustomNsAttrs(t){const n=t.attributes;for(let e=n.length-1;0<e;e--){const a=n.item(e).name;"xmlns:ns1"!==a&&0!==a.indexOf("ns1:")||t.removeAttribute(a)}let e=t.firstChild;for(;e;)e.nodeType===Node.ELEMENT_NODE&&this.stripCustomNsAttrs(e),e=e.nextSibling}}const Pc=/^(?:(?:https?|mailto|ftp|tel|file|sms):|[^&:/?#]*(?:[/?#]|$))/gi,xc=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\/]+=*$/i;function yc(t){return(t=String(t)).match(Pc)||t.match(xc)?t:(_c()&&console.warn(`WARNING: sanitizing unsafe URL value ${t} (see http://g.co/ng/security#xss)`),"unsafe:"+t)}function kc(t){return(t=String(t)).split(",").map((t=>yc(t.trim()))).join(", ")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function vc(t){const n={};for(const e of t.split(","))n[e]=!0;return n}function wc(...t){const n={};for(const e of t)for(const t in e)e.hasOwnProperty(t)&&(n[t]=!0);return n}const Sc=vc("area,br,col,hr,img,wbr"),Ec=vc("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),Ac=vc("rp,rt"),zc=wc(Ac,Ec),Rc=wc(Ec,vc("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul")),Tc=wc(Ac,vc("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video")),Dc=wc(Sc,Rc,Tc,zc),Ic=vc("background,cite,href,itemtype,longdesc,poster,src,xlink:href"),Nc=vc("srcset"),Fc=vc("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width"),Lc=vc("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext"),Hc=wc(Ic,Nc,Fc,Lc),Bc=vc("script,style,template");class Vc{constructor(){this.sanitizedSomething=!1,this.buf=[]}sanitizeChildren(t){let n=t.firstChild,e=!0;for(;n;)if(n.nodeType===Node.ELEMENT_NODE?e=this.startElement(n):n.nodeType===Node.TEXT_NODE?this.chars(n.nodeValue):this.sanitizedSomething=!0,e&&n.firstChild)n=n.firstChild;else for(;n;){n.nodeType===Node.ELEMENT_NODE&&this.endElement(n);let t=this.checkClobberedElement(n,n.nextSibling);if(t){n=t;break}n=this.checkClobberedElement(n,n.parentNode)}return this.buf.join("")}startElement(t){const n=t.nodeName.toLowerCase();if(!Dc.hasOwnProperty(n))return this.sanitizedSomething=!0,!Bc.hasOwnProperty(n);this.buf.push("<"),this.buf.push(n);const e=t.attributes;for(let t=0;t<e.length;t++){const n=e.item(t),a=n.name,o=a.toLowerCase();if(!Hc.hasOwnProperty(o)){this.sanitizedSomething=!0;continue}let r=n.value;Ic[o]&&(r=yc(r)),Nc[o]&&(r=kc(r)),this.buf.push(" ",a,'="',Wc(r),'"')}return this.buf.push(">"),!0}endElement(t){const n=t.nodeName.toLowerCase();Dc.hasOwnProperty(n)&&!Sc.hasOwnProperty(n)&&(this.buf.push("</"),this.buf.push(n),this.buf.push(">"))}chars(t){this.buf.push(Wc(t))}checkClobberedElement(t,n){if(n&&(t.compareDocumentPosition(n)&Node.DOCUMENT_POSITION_CONTAINED_BY)===Node.DOCUMENT_POSITION_CONTAINED_BY)throw new Error(`Failed to sanitize html because the element is clobbered: ${t.outerHTML}`);return n}}const jc=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,Uc=/([^\#-~ |!])/g;function Wc(t){return t.replace(/&/g,"&amp;").replace(jc,(function(t){return"&#"+(1024*(t.charCodeAt(0)-55296)+(t.charCodeAt(1)-56320)+65536)+";"})).replace(Uc,(function(t){return"&#"+t.charCodeAt(0)+";"})).replace(/</g,"&lt;").replace(/>/g,"&gt;")}let Gc;function Yc(t,n){let e=null;try{Gc=Gc||Cc(t);let a=n?String(n):"";e=Gc.getInertBodyElement(a);let o=5,r=a;do{if(0===o)throw new Error("Failed to sanitize html because the input is unstable");o--,a=r,r=e.innerHTML,e=Gc.getInertBodyElement(a)}while(a!==r);const i=new Vc,c=i.sanitizeChildren(qc(e)||e);return _c()&&i.sanitizedSomething&&console.warn("WARNING: sanitizing HTML stripped some content, see http://g.co/ng/security#xss"),c}finally{if(e){const t=qc(e)||e;for(;t.firstChild;)t.removeChild(t.firstChild)}}}function qc(t){return"content"in t&&(function n(t){return t.nodeType===Node.ELEMENT_NODE&&"TEMPLATE"===t.nodeName}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t)?t.content:null}var Zc;function Xc(t){const n=Qc();return n?n.sanitize(Zc.URL,t)||"":bc(t,"URL")?pc(t):yc($o(t))}function Jc(t){const n=Qc();if(n)return n.sanitize(Zc.RESOURCE_URL,t)||"";if(bc(t,"ResourceURL"))return pc(t);throw new Error("unsafe value used in a resource URL context (see http://g.co/ng/security#xss)")}function Qc(){const t=Br();return t&&t[12]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */!(function(t){t[t.NONE=0]="NONE",t[t.HTML=1]="HTML",t[t.STYLE=2]="STYLE",t[t.SCRIPT=3]="SCRIPT",t[t.URL=4]="URL",t[t.RESOURCE_URL=5]="RESOURCE_URL"})(Zc||(Zc={}));const Kc=/-->/g;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function $c(t){if(!ngDevMode)throw new Error("Looks like we are in 'prod mode', but we are creating a named Array type, which is wrong! Check your code");try{return new(0,$c.constructor)("Array",`return class ${t} extends Array{}`)(Array)}catch(t){return Array}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const ts=/([A-Z])/g;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function ns(t){let n=zr(t);if(n){if(Array.isArray(n)){const e=n;let a,o,r;if((function e(t){return t&&t.constructor&&t.constructor.ɵcmp})(t)){if(a=cs(e,t),-1==a)throw new Error("The provided component was not found in the application");o=t}else if((function a(t){return t&&t.constructor&&t.constructor.ɵdir})(t)){if(a=(function o(t,n){let e=t[1].firstChild;for(;e;){const a=e.directiveEnd;for(let o=e.directiveStart;o<a;o++)if(t[o]===n)return e.index;e=is(e)}return-1})(e,t),-1==a)throw new Error("The provided directive was not found in the application");r=ss(a,e,!1)}else if(a=rs(e,t),-1==a)return null;const i=kr(e[a]),c=zr(i),s=c&&!Array.isArray(c)?c:es(e,a,i);if(o&&void 0===s.component&&(s.component=o,os(s.component,s)),r&&void 0===s.directives){s.directives=r;for(let t=0;t<r.length;t++)os(r[t],s)}os(s.native,s),n=s}}else{const e=t;ngDevMode&&Ia(e);let a=e;for(;a=a.parentNode;){const t=zr(a);if(t){let a;if(a=Array.isArray(t)?t:t.lView,!a)return null;const o=rs(a,e);if(o>=0){const t=kr(a[o]),e=es(a,o,t);os(t,e),n=e;break}}}}return n||null}function es(t,n,e){return{lView:t,nodeIndex:n,native:e,component:void 0,directives:void 0,localRefs:void 0}}function as(t){let n,e=zr(t);if(Array.isArray(e)){const a=cs(e,t);n=Ar(a,e);const o=es(e,a,n[0]);o.component=t,os(t,o),os(o.native,o)}else n=Ar(e.nodeIndex,e.lView);return n}function os(t,n){t.__ngContext__=n}function rs(t,n){const e=t[1];for(let a=To;a<e.bindingStartIndex;a++)if(kr(t[a])===n)return a;return-1}function is(t){if(t.child&&t.child.parent===t)return t.child;if(t.next)return t.next;for(;t.parent&&!t.parent.next;)t=t.parent;return t.parent&&t.parent.next}function cs(t,n){const e=t[1].components;if(e)for(let a=0;a<e.length;a++){const o=e[a];if(Ar(o,t)[8]===n)return o}else if(Ar(To,t)[8]===n)return To;return-1}function ss(t,n,e){const a=n[1].data[t];let o=a.directiveStart;return 0==o?fo:(!e&&2&a.flags&&o++,n.slice(o,a.directiveEnd))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function ls(t,n,e){ngDevMode&&wa(n,"",'can not look for "" string.');let a=t.length;for(;;){const o=t.indexOf(n,e);if(-1===o)return o;if(0===o||t.charCodeAt(o-1)<=32){const e=n.length;if(o+e===a||t.charCodeAt(o+e)<=32)return o}e=o+1}}const ms="ng-template";function ds(t,n,e){ngDevMode&&va(n,n.toLowerCase(),"Class name expected to be lowercase.");let a=0;for(;a<t.length;){let o=t[a++];if(e&&"class"===o){if(o=t[a],-1!==ls(o.toLowerCase(),n,0))return!0}else if(1===o){for(;a<t.length&&"string"==typeof(o=t[a++]);)if(o.toLowerCase()===n)return!0;return!1}}return!1}function gs(t){return 0===t.type&&t.tagName!==ms}function ps(t,n,e){return n===(0!==t.type||e?t.tagName:ms)}function bs(t,n,e){ngDevMode&&Ta(n[0],"Selector should have a tag name");let a=4;const o=t.attrs||[],r=(function i(t){for(let n=0;n<t.length;n++)if(Ai(t[n]))return n;return t.length})(o);let c=!1;for(let i=0;i<n.length;i++){const s=n[i];if("number"!=typeof s){if(!c)if(4&a){if(a=2|1&a,""!==s&&!ps(t,s,e)||""===s&&1===n.length){if(us(a))return!1;c=!0}}else{const l=8&a?s:n[++i];if(8&a&&null!==t.attrs){if(!ds(t.attrs,l,e)){if(us(a))return!1;c=!0}continue}const m=fs(8&a?"class":s,o,gs(t),e);if(-1===m){if(us(a))return!1;c=!0;continue}if(""!==l){let t;m>r?t="":(ngDevMode&&wa(o[m],0,"We do not match directives on namespaced attributes"),t=o[m+1].toLowerCase());const n=8&a?t:null;if(n&&-1!==ls(n,l,0)||2&a&&l!==t){if(us(a))return!1;c=!0}}}}else{if(!c&&!us(a)&&!us(s))return!1;if(c&&us(s))continue;c=!1,a=s|1&a}}return us(a)||c}function us(t){return 0==(1&t)}function fs(t,n,e,a){if(null===n)return-1;let o=0;if(a||!e){let e=!1;for(;o<n.length;){const a=n[o];if(a===t)return o;if(3===a||6===a)e=!0;else{if(1===a||2===a){let t=n[++o];for(;"string"==typeof t;)t=n[++o];continue}if(4===a)break;if(0===a){o+=4;continue}}o+=e?1:2}return-1}return(function r(t,n){let e=t.indexOf(4);if(e>-1)for(e++;e<t.length;){const a=t[e];if("number"==typeof a)return-1;if(a===n)return e;e++}return-1})(n,t)}function hs(t,n,e=!1){for(let a=0;a<n.length;a++)if(bs(t,n[a],e))return!0;return!1}function _s(t,n){t:for(let e=0;e<n.length;e++){const a=n[e];if(t.length===a.length){for(let n=0;n<t.length;n++)if(t[n]!==a[n])continue t;return!0}}return!1}function Cs(t,n){return t?":not("+n.trim()+")":n}function Ms(t){let n=t[0],e=1,a=2,o="",r=!1;for(;e<t.length;){let i=t[e];if("string"==typeof i)if(2&a){const n=t[++e];o+="["+i+(n.length>0?'="'+n+'"':"")+"]"}else 8&a?o+="."+i:4&a&&(o+=" "+i);else""===o||us(i)||(n+=Cs(r,o),o=""),a=i,r=r||!us(a);e++}return""!==o&&(n+=Cs(r,o)),n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Os="undefined"==typeof ngDevMode||ngDevMode?{__brand__:"NO_CHANGE"}:{};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Ps(t){ngDevMode&&Zo(t);const n=t[3];return Fo(n)?n[3]:n}function xs(t){const n=(function e(t){ngDevMode&&Ta(t,"component");let n=No(t)?t:Rr(t);for(;n&&!(512&n[2]);)n=Ps(n);return ngDevMode&&Zo(n),n})(t);return ngDevMode&&Ta(n[8],"RootView has no context. Perhaps it is disconnected?"),n[8]}function ys(t){return vs(t[13])}function ks(t){return vs(t[4])}function vs(t){for(;null!==t&&!Fo(t);)t=t[4];return t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function ws(t){ngDevMode&&Ra(t,0,"Can only advance forward"),Ss(Vr(),Br(),gi()+t,qr())}function Ss(t,n,e,a){if(ngDevMode&&Ra(e,-1,"Invalid index"),ngDevMode&&Na(n,e+To),!a)if(3==(3&n[2])){const a=t.preOrderCheckHooks;null!==a&&_i(n,a,e)}else{const a=t.preOrderHooks;null!==a&&Ci(n,a,0,e)}pi(e)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Es(t,n){return ngDevMode&&ya(t,0,32767),ngDevMode&&ya(n,0,32767),t<<17|n<<2}function As(t){return ngDevMode&&xa(t,"expected number"),t>>17&32767}function zs(t){return ngDevMode&&xa(t,"expected number"),2==(2&t)}function Rs(t){return ngDevMode&&xa(t,"expected number"),2|t}function Ts(t){return ngDevMode&&xa(t,"expected number"),(131068&t)>>2}function Ds(t,n){return ngDevMode&&xa(t,"expected number"),ngDevMode&&ya(n,0,32767),-131069&t|n<<2}function Is(t){return ngDevMode&&xa(t,"expected number"),1==(1&t)}function Ns(t){return ngDevMode&&xa(t,"expected number"),1|t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Fs(t,n){if(!ngDevMode)throw new Error("This method should be guarded with `ngDevMode` so that it can be tree shaken in production!");Object.defineProperty(t,"debug",{value:n,enumerable:!1})}function Ls(t,n){if(!ngDevMode)throw new Error("This method should be guarded with `ngDevMode` so that it can be tree shaken in production!");Object.defineProperty(t,"debug",{get:n,enumerable:!1})}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Hs=("undefined"==typeof ngDevMode||!!ngDevMode)&&Pa();let Bs,Vs,js;function Us(t){if(null==t)return"";const n=t.lastIndexOf("_Template");return"_"+(-1===n?t:t.substr(0,n))}function Ws(t,n){const e=t.tView_.data,a=[],o=n?t.classBindings:t.styleBindings,r=As(o),i=Ts(o);let c=0!==i,s=c?i:r;for(;0!==s;){const t=e[s+1];a.unshift({key:e[s],index:s,isTemplate:c,prevDuplicate:zs(t),nextDuplicate:Is(t),nextIndex:Ts(t),prevIndex:As(t)}),s===r&&(c=!1),s=As(t)}return a.push((n?t.residualClasses:t.residualStyles)||null),a}function Gs(t,n){for(;t;)n.push(t.template_),t=t.next}const Ys=Hs&&$c("TViewData")||null;let qs;const Zs=Hs&&$c("LViewBlueprint")||null,Xs=Hs&&$c("MatchesArray")||null,Js=Hs&&$c("TViewComponents")||null,Qs=Hs&&$c("TNodeLocalNames")||null,Ks=Hs&&$c("TNodeInitialInputs")||null;Hs&&$c("TNodeInitialData");const $s=Hs&&$c("LCleanup")||null,tl=Hs&&$c("TCleanup")||null;function nl(t){if(t){const n=t.debug;return Ta(n,"Object does not have a debug representation."),n}return t}function el(t,n=!1){const e=kr(t);if(e)switch(e.nodeType){case Node.TEXT_NODE:return e.textContent;case Node.COMMENT_NODE:return`\x3c!--${e.textContent}--\x3e`;case Node.ELEMENT_NODE:const t=e.outerHTML;return n?t:t.split(">"+e.innerHTML+"<")[0]+">"}return null}class al{constructor(t){this._raw_lView=t}get flags(){const t=this._raw_lView[2];return{__raw__flags__:t,initPhaseState:3&t,creationMode:!!(4&t),firstViewPass:!!(8&t),checkAlways:!!(16&t),dirty:!!(64&t),attached:!!(128&t),destroyed:!!(256&t),isRoot:!!(512&t),indexWithinInitPhase:t>>11}}get parent(){return nl(this._raw_lView[3])}get hostHTML(){return el(this._raw_lView[0],!0)}get html(){return(this.nodes||[]).map((t=>el(t.native,!0))).join("")}get context(){return this._raw_lView[8]}get nodes(){const t=this._raw_lView;return rl(t[1].firstChild,t)}get tView(){return this._raw_lView[1]}get cleanup(){return this._raw_lView[7]}get injector(){return this._raw_lView[9]}get rendererFactory(){return this._raw_lView[10]}get renderer(){return this._raw_lView[11]}get sanitizer(){return this._raw_lView[12]}get childHead(){return nl(this._raw_lView[13])}get next(){return nl(this._raw_lView[4])}get childTail(){return nl(this._raw_lView[14])}get declarationView(){return nl(this._raw_lView[15])}get queries(){return this._raw_lView[19]}get tHost(){return this._raw_lView[6]}get decls(){return ol(this.tView,this._raw_lView,To,this.tView.bindingStartIndex)}get vars(){const t=this.tView;return ol(t,this._raw_lView,t.bindingStartIndex,t.i18nStartIndex)}get i18n(){const t=this.tView;return ol(t,this._raw_lView,t.i18nStartIndex,t.expandoStartIndex)}get expando(){return ol(this.tView,this._raw_lView,this.tView.expandoStartIndex,this._raw_lView.length)}get childViews(){const t=[];let n=this.childHead;for(;n;)t.push(n),n=n.next;return t}}function ol(t,n,e,a){let o=[];for(let r=e;r<a;r++)o.push({index:r,t:t.data[r],l:n[r]});return{start:e,end:a,length:a-e,content:o}}function rl(t,n){if(t){const e=[];let a=t;for(;a;)e.push(il(a,n)),a=a.next;return e}return[]}function il(t,n){const e=kr(n[t.index]),a=[],o=[],r=n[1];for(let e=t.directiveStart;e<t.directiveEnd;e++)a.push(r.data[e].type),o.push(n[e]);return{html:el(e),type:ki[t.type],native:e,children:rl(t.child,n),factories:a,instances:o,injector:cl(t,r,n)}}function cl(t,n,e){const a=[];for(let e=t.providerIndexStart_;e<t.providerIndexEnd_;e++)a.push(n.data[e]);const o=[];for(let e=t.providerIndexEnd_;e<t.directiveEnd;e++)o.push(n.data[e]);return{bloom:ll(e,t.injectorIndex),cumulativeBloom:ll(n.data,t.injectorIndex),providers:o,viewProviders:a,parentInjectorIndex:e[t.providerIndexStart_-1]}}function sl(t,n){const e=t[n];if("number"!=typeof e)return"????????";const a="00000000"+e.toString(2);return a.substring(a.length-8)}function ll(t,n){return`${sl(t,n+7)}_${sl(t,n+6)}_${sl(t,n+5)}_${sl(t,n+4)}_${sl(t,n+3)}_${sl(t,n+2)}_${sl(t,n+1)}_${sl(t,n+0)}`}class ml{constructor(t){this._raw_lContainer=t}get hasTransplantedViews(){return this._raw_lContainer[2]}get views(){return this._raw_lContainer.slice(Io).map(nl)}get parent(){return nl(this._raw_lContainer[3])}get movedViews(){return this._raw_lContainer[9]}get host(){return this._raw_lContainer[0]}get native(){return this._raw_lContainer[7]}get next(){return nl(this._raw_lContainer[4])}}const dl=Promise.resolve(null);function gl(t,n){const e=t.contentQueries;if(null!==e)for(let a=0;a<e.length;a+=2){const o=e[a],r=e[a+1];if(-1!==r){const e=t.data[r];ngDevMode&&Ta(e.contentQueries,"contentQueries function should be defined"),oi(o),e.contentQueries(2,n[r],r)}}}function pl(t,n,e){return xr(n)?n.createElement(t,e):null===e?n.createElement(t):n.createElementNS(e,t)}function bl(t,n,e,a,o,r,i,c,s,l){const m=ngDevMode?(function d(t){return(function n(t,e){switch(t){case 0:return void 0===js&&(js=new($c("LRootView"))),js;case 1:void 0===Bs&&(Bs=new Map);let t=Bs.get(e);return void 0===t&&(t=new($c("LComponentView"+Us(e))),Bs.set(e,t)),t;case 2:void 0===Vs&&(Vs=new Map);let n=Vs.get(e);return void 0===n&&(n=new($c("LEmbeddedView"+Us(e))),Vs.set(e,n)),n}throw new Error("unreachable code")})(t.type,t.template&&t.template.name).concat(t.blueprint)})(n):n.blueprint.slice();return m[0]=o,m[2]=140|a,Nr(m),ngDevMode&&n.declTNode&&t&&Uo(n.declTNode,t),m[3]=m[15]=t,m[8]=e,m[10]=i||t&&t[10],ngDevMode&&Ta(m[10],"RendererFactory is required"),m[11]=c||t&&t[11],ngDevMode&&Ta(m[11],"Renderer is required"),m[12]=s||t&&t[12]||null,m[9]=l||t&&t[9]||null,m[6]=r,ngDevMode&&va(2!=n.type||null!==t,!0,"Embedded views must have parentLView"),m[16]=2==n.type?t[16]:m,ngDevMode&&(function g(t){Fs(t,new al(t))})(m),m}function ul(t,n,e,a,o){const r=n+To,i=t.data[r]||(function c(t,n,e,a,o){const r=Ur(),i=Gr(),c=t.data[n]=(function s(t,n,e,a,o,r){ngDevMode&&ngDevMode.tNode++;let i=n?n.injectorIndex:-1;const c=ngDevMode?new class{constructor(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C,M,O,P,x,y,k,v,w,S,E,A){this.tView_=t,this.type=n,this.index=e,this.injectorIndex=a,this.directiveStart=o,this.directiveEnd=r,this.directiveStylingLast=i,this.propertyBindings=c,this.flags=s,this.providerIndexes=l,this.tagName=m,this.attrs=d,this.mergedAttrs=g,this.localNames=p,this.initialInputs=b,this.inputs=u,this.outputs=f,this.tViews=h,this.next=_,this.projectionNext=C,this.child=M,this.parent=O,this.projection=P,this.styles=x,this.stylesWithoutHost=y,this.residualStyles=k,this.classes=v,this.classesWithoutHost=w,this.residualClasses=S,this.classBindings=E,this.styleBindings=A}debugNodeInjectorPath(t){const n=[];let e=ji(this,t);for(ngDevMode&&Ko(t,e);-1!==e;){n.push(il(t[1].data[e+8],t));const a=t[e+8];a===xi?e=-1:(e=Ii(a),t=Ni(a,t))}return n}get type_(){return ki[this.type]||`TNodeType.?${this.type}?`}get flags_(){const t=[];return 16&this.flags&&t.push("TNodeFlags.hasClassInput"),8&this.flags&&t.push("TNodeFlags.hasContentQuery"),32&this.flags&&t.push("TNodeFlags.hasStyleInput"),128&this.flags&&t.push("TNodeFlags.hasHostBindings"),2&this.flags&&t.push("TNodeFlags.isComponentHost"),1&this.flags&&t.push("TNodeFlags.isDirectiveHost"),64&this.flags&&t.push("TNodeFlags.isDetached"),4&this.flags&&t.push("TNodeFlags.isProjected"),t.join("|")}get template_(){const t=[];if(t.push("<",this.tagName||this.type_),this.attrs)for(let n=0;n<this.attrs.length;){const e=this.attrs[n++];if("number"==typeof e)break;const a=this.attrs[n++];t.push(" ",e,'="',a,'"')}return t.push(">"),Gs(this.child,t),t.push("</",this.tagName||this.type_,">"),t.join("")}get styleBindings_(){return Ws(this,!1)}get classBindings_(){return Ws(this,!0)}get providerIndexStart_(){return 1048575&this.providerIndexes}get providerIndexEnd_(){return this.providerIndexStart_+(this.providerIndexes>>>20)}}(t,e,a,i,-1,-1,-1,null,0,0,o,r,null,null,void 0,null,null,null,null,null,null,n,null,null,null,void 0,null,null,void 0,0,0):{type:e,index:a,injectorIndex:i,directiveStart:-1,directiveEnd:-1,directiveStylingLast:-1,propertyBindings:null,flags:0,providerIndexes:0,tagName:o,attrs:r,mergedAttrs:null,localNames:null,initialInputs:void 0,inputs:null,outputs:null,tViews:null,next:null,projectionNext:null,child:null,parent:n,projection:null,styles:null,stylesWithoutHost:null,residualStyles:void 0,classes:null,classesWithoutHost:null,residualClasses:void 0,classBindings:0,styleBindings:0};return ngDevMode&&Object.seal(c),c})(t,i?r:r&&r.parent,e,n,a,o);return null===t.firstChild&&(t.firstChild=c),null!==r&&(i&&null==r.child&&null!==c.parent?r.child=c:i||(r.next=c)),c})(t,r,e,a,o);return Wr(i,!0),i}function fl(t,n,e){ngDevMode&&va(Tr(n),!0,"Should be run in creation mode"),ii(n);try{const a=t.viewQuery;null!==a&&nm(1,a,e);const o=t.template;null!==o&&Cl(t,n,o,1,e),t.firstCreatePass&&(t.firstCreatePass=!1),t.staticContentQueries&&gl(t,n),t.staticViewQueries&&nm(2,t.viewQuery,e);const r=t.components;null!==r&&(function a(t,n){for(let e=0;e<n.length;e++)Xl(t,n[e])})(n,r)}catch(n){throw t.firstCreatePass&&(t.incompleteFirstPass=!0),n}finally{n[2]&=-5,di()}}function hl(t,n,e,a){ngDevMode&&va(Tr(n),!1,"Should be run in update mode");const o=n[2];if(256==(256&o))return;ii(n);const r=qr();try{Nr(n),Qr(t.bindingStartIndex),null!==e&&Cl(t,n,e,2,a);const i=3==(3&o);if(!r)if(i){const e=t.preOrderCheckHooks;null!==e&&_i(n,e,null)}else{const e=t.preOrderHooks;null!==e&&Ci(n,e,0,null),Mi(n,0)}if((function i(t){for(let n=ys(t);null!==n;n=ks(n)){if(!n[2])continue;const t=n[9];ngDevMode&&Ta(t,"Transplanted View flags set but missing MOVED_VIEWS");for(let n=0;n<t.length;n++){const e=t[n],a=e[3];ngDevMode&&Yo(a),0==(1024&e[2])&&Fr(a,1),e[2]|=1024}}})(n),(function c(t){for(let n=ys(t);null!==n;n=ks(n))for(let t=Io;t<n.length;t++){const e=n[t],a=e[1];ngDevMode&&Ta(a,"TView must be allocated"),Dr(e)&&hl(a,e,a.template,e[8])}})(n),null!==t.contentQueries&&gl(t,n),!r)if(i){const e=t.contentCheckHooks;null!==e&&_i(n,e)}else{const e=t.contentHooks;null!==e&&Ci(n,e,1),Mi(n,1)}!(function s(t,n){ngDevMode&&Sa(t,n[1],"`LView` is not associated with the `TView`!");try{const e=t.expandoInstructions;if(null!==e){let a=t.expandoStartIndex,o=-1,r=-1;for(let t=0;t<e.length;t++){const i=e[t];"number"==typeof i?i<=0?(r=0-i,pi(r),a+=9+e[++t],o=a):a+=i:(null!==i&&(ngDevMode&&Aa(o,1048576,"Reached the max number of host bindings"),ti(a,o),i(2,n[o])),o++)}}}finally{pi(-1)}})(t,n);const c=t.components;null!==c&&(function l(t,n){for(let e=0;e<n.length;e++)ql(t,n[e])})(n,c);const s=t.viewQuery;if(null!==s&&nm(2,s,a),!r)if(i){const e=t.viewCheckHooks;null!==e&&_i(n,e)}else{const e=t.viewHooks;null!==e&&Ci(n,e,2),Mi(n,2)}!0===t.firstUpdatePass&&(t.firstUpdatePass=!1),r||(n[2]&=-73),1024&n[2]&&(n[2]&=-1025,Fr(n[3],-1))}finally{di()}}function _l(t,n,e,a){const o=n[10],r=!qr(),i=Tr(n);try{r&&!i&&o.begin&&o.begin(),i&&fl(t,n,a),hl(t,n,e,a)}finally{r&&!i&&o.end&&o.end()}}function Cl(t,n,e,a,o){const r=gi();try{pi(-1),2&a&&n.length>To&&Ss(t,n,0,qr()),e(a,o)}finally{pi(r)}}function Ml(t,n,e){if(Lo(n)){const a=n.directiveEnd;for(let o=n.directiveStart;o<a;o++){const n=t.data[o];n.contentQueries&&n.contentQueries(1,e[o],o)}}}function Ol(t,n,e){Hr()&&((function a(t,n,e,o){const r=e.directiveStart,i=e.directiveEnd;t.firstCreatePass||Bi(e,n),os(o,n);const c=e.initialInputs;for(let a=r;a<i;a++){const o=t.data[a],i=Vo(o);i&&(ngDevMode&&wi(e,[2]),Vl(n,e,o));const s=Xi(n,t,a,e);os(s,n),null!==c&&Ul(n,a-r,s,o,e,c),i&&(Ar(e.index,n)[8]=s)}})(t,n,e,wr(e,n)),128==(128&e.flags)&&(function o(t,n,e){const a=e.directiveStart,o=e.directiveEnd,r=t.expandoInstructions,i=t.firstCreatePass,c=e.index-To,s=(function l(){return Lr.lFrame.currentDirectiveIndex})();try{pi(c);for(let e=a;e<o;e++){const a=t.data[e],o=n[e];ni(e),null!==a.hostBindings||0!==a.hostVars||null!==a.hostAttrs?Il(a,o):i&&r.push(null)}}finally{pi(-1),ni(s)}})(t,n,e))}function Pl(t,n,e=wr){const a=n.localNames;if(null!==a){let o=n.index+1;for(let r=0;r<a.length;r+=2){const i=a[r+1],c=-1===i?e(n,t):t[i];t[o++]=c}}}function xl(t){const n=t.tView;return null===n||n.incompleteFirstPass?t.tView=yl(1,null,t.template,t.decls,t.vars,t.directiveDefs,t.pipeDefs,t.viewQuery,t.schemas,t.consts):n}function yl(t,n,e,a,o,r,i,c,s,l){ngDevMode&&ngDevMode.tView++;const m=To+a,d=m+o,g=(function p(t,n){const e=ngDevMode?new Zs:[];for(let a=0;a<n;a++)e.push(a<t?null:Os);return e})(m,d),b="function"==typeof l?l():l,u=g[1]=ngDevMode?new class{constructor(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C,M,O,P,x,y,k,v,w,S,E,A,z){this.type=t,this.blueprint=n,this.template=e,this.queries=a,this.viewQuery=o,this.declTNode=r,this.data=i,this.bindingStartIndex=c,this.expandoStartIndex=s,this.expandoInstructions=l,this.firstCreatePass=m,this.firstUpdatePass=d,this.staticViewQueries=g,this.staticContentQueries=p,this.preOrderHooks=b,this.preOrderCheckHooks=u,this.contentHooks=f,this.contentCheckHooks=h,this.viewHooks=_,this.viewCheckHooks=C,this.destroyHooks=M,this.cleanup=O,this.contentQueries=P,this.components=x,this.directiveRegistry=y,this.pipeRegistry=k,this.firstChild=v,this.schemas=w,this.consts=S,this.incompleteFirstPass=E,this._decls=A,this._vars=z}get template_(){const t=[];return Gs(this.firstChild,t),t.join("")}get type_(){return Do[this.type]||`TViewType.?${this.type}?`}get i18nStartIndex(){return To+this._decls+this._vars}}(t,g,e,null,c,n,(function f(t){return void 0===qs&&(qs=new Ys),qs.concat(t)})(g).fill(null,m),m,d,null,!0,!0,!1,!1,null,null,null,null,null,null,null,null,null,null,"function"==typeof r?r():r,"function"==typeof i?i():i,null,s,b,!1,a,o):{type:t,blueprint:g,template:e,queries:null,viewQuery:c,declTNode:n,data:g.slice().fill(null,m),bindingStartIndex:m,expandoStartIndex:d,expandoInstructions:null,firstCreatePass:!0,firstUpdatePass:!0,staticViewQueries:!1,staticContentQueries:!1,preOrderHooks:null,preOrderCheckHooks:null,contentHooks:null,contentCheckHooks:null,viewHooks:null,viewCheckHooks:null,destroyHooks:null,cleanup:null,contentQueries:null,components:null,directiveRegistry:"function"==typeof r?r():r,pipeRegistry:"function"==typeof i?i():i,firstChild:null,schemas:s,consts:b,incompleteFirstPass:!1};return ngDevMode&&Object.seal(u),u}function kl(t,n,e,a){const o=om(n);o.push(e),t.firstCreatePass&&(function r(t){return t.cleanup||(t.cleanup=ngDevMode?new tl:[])})(t).push(a,o.length-1)}function vl(t,n,e){for(let a in t)if(t.hasOwnProperty(a)){const o=t[a];(e=null===e?{}:e).hasOwnProperty(a)?e[a].push(n,o):e[a]=[n,o]}return e}function wl(t,n,e,a,o,r,i,c){ngDevMode&&Ea(o,Os,"Incoming value should never be NO_CHANGE.");const s=wr(n,e);let l,m=n.inputs;if(!c&&null!=m&&(l=m[a]))cm(t,e,l,a,o),Ho(n)&&(function d(t,n){ngDevMode&&Zo(t);const e=Ar(n,t);16&e[2]||(e[2]|=64)})(e,n.index),ngDevMode&&El(e,s,n.type,l,o);else if(2===n.type){if(a=(function g(t){return"class"===t?"className":"for"===t?"htmlFor":"formaction"===t?"formAction":"innerHtml"===t?"innerHTML":"readonly"===t?"readOnly":"tabindex"===t?"tabIndex":t})(a),ngDevMode){if((function p(t){if(t.toLowerCase().startsWith("on")){const n=`Binding to event property '${t}' is disallowed for security reasons, please use (${t.slice(2)})=...\nIf '${t}' is a directive input, make sure the directive is imported by the current module.`;throw new Error(n)}})(a),!(function b(t,n,e,a){return!(null!==t.schemas&&!(Al(t,a.tagName)||e in n||zi(e))&&"undefined"!=typeof Node&&null!==Node&&n instanceof Node)})(t,s,a,n))return void zl(a,n);ngDevMode.rendererSetProperty++}o=null!=i?i(o,n.tagName||"",a):o,xr(r)?r.setProperty(s,a,o):zi(a)||(s.setProperty?s.setProperty(a,o):s[a]=o)}else 0!==n.type&&3!==n.type||ngDevMode&&!Al(t,n.tagName)&&zl(a,n)}function Sl(t,n,e,a,o){const r=t[11];a=(function i(t){return`ng-reflect-${t=(function n(t){return t.replace(ts,((...t)=>"-"+t[1].toLowerCase()))})(t.replace(/[$@]/g,"_"))}`})(a);const c=(function s(t){try{return null!=t?t.toString().slice(0,30):t}catch(t){return"[ERROR] Exception while trying to serialize the value"}})(o);if(2===e)null==o?xr(r)?r.removeAttribute(n,a):n.removeAttribute(a):xr(r)?r.setAttribute(n,a,c):n.setAttribute(a,c);else{const t=(function l(t){return t.replace(Kc,"-​-​>")})(`bindings=${JSON.stringify({[a]:c},null,2)}`);xr(r)?r.setValue(n,t):n.textContent=t}}function El(t,n,e,a,o){if(2===e||0===e)for(let r=0;r<a.length;r+=2)Sl(t,n,e,a[r+1],o)}function Al(t,n){const e=t.schemas;if(null!==e)for(let t=0;t<e.length;t++){const a=e[t];if(a===ic||a===rc&&n&&n.indexOf("-")>-1)return!0}return!1}function zl(t,n){console.error(`Can't bind to '${t}' since it isn't a known property of '${n.tagName}'.`)}function Rl(t,n,e,a){ngDevMode&&Xo(t);let o=!1;if(Hr()){const r=(function r(t,n,e){ngDevMode&&Xo(t),ngDevMode&&wi(e,[2,3,0]);const a=t.directiveRegistry;let o=null;if(a)for(let r=0;r<a.length;r++){const i=a[r];hs(e,i.selectors,!1)&&(o||(o=ngDevMode?new Xs:[]),Wi(Bi(e,n),t,i.type),Vo(i)?(ngDevMode&&(wi(e,[2],`"${e.tagName}" tags cannot be used as component hosts. Please use a different tag to activate the ${ta(i.type)} component.`),2&e.flags&&sr(e)),Fl(t,e),o.unshift(i)):o.push(i))}return o})(t,n,e),i=null===a?null:{"":-1};if(null!==r){let a=0;o=!0,Hl(e,t.data.length,r.length);for(let t=0;t<r.length;t++){const n=r[t];n.providersResolver&&n.providersResolver(n)}Nl(t,e,r.length);let c=!1,s=!1;for(let o=0;o<r.length;o++){const l=r[o];e.mergedAttrs=Ri(e.mergedAttrs,l.hostAttrs),Bl(t,n,l),Ll(t.data.length-1,l,i),null!==l.contentQueries&&(e.flags|=8),null===l.hostBindings&&null===l.hostAttrs&&0===l.hostVars||(e.flags|=128);const m=l.type.prototype;!c&&(m.ngOnChanges||m.ngOnInit||m.ngDoCheck)&&((t.preOrderHooks||(t.preOrderHooks=[])).push(e.index-To),c=!0),s||!m.ngOnChanges&&!m.ngDoCheck||((t.preOrderCheckHooks||(t.preOrderCheckHooks=[])).push(e.index-To),s=!0),Tl(t,l),a+=l.hostVars}!(function i(t,n){ngDevMode&&Xo(t);const e=n.directiveStart,a=n.directiveEnd,o=t.data,r=n.attrs,i=ngDevMode?new Ks:[];let c=null,s=null;for(let t=e;t<a;t++){const e=o[t],a=e.inputs,l=null===r||gs(n)?null:Wl(a,r);i.push(l),c=vl(a,t,c),s=vl(e.outputs,t,s)}null!==c&&(c.hasOwnProperty("class")&&(n.flags|=16),c.hasOwnProperty("style")&&(n.flags|=32)),n.initialInputs=i,n.inputs=c,n.outputs=s})(t,e),Dl(t,n,a)}i&&(function c(t,n,e){if(n){const a=t.localNames=ngDevMode?new Qs:[];for(let t=0;t<n.length;t+=2){const o=e[n[t+1]];if(null==o)throw new Error(`Export of name '${n[t+1]}' not found!`);a.push(n[t],o)}}})(e,a,i)}return e.mergedAttrs=Ri(e.mergedAttrs,e.attrs),o}function Tl(t,n){ngDevMode&&Xo(t);const e=t.expandoInstructions;e.push(n.hostBindings),0!==n.hostVars&&e.push(n.hostVars)}function Dl(t,n,e){ngDevMode&&Xo(t),ngDevMode&&Sa(t,n[1],"`LView` must be associated with `TView`!");for(let a=0;a<e;a++)n.push(Os),t.blueprint.push(Os),t.data.push(null)}function Il(t,n){null!==t.hostBindings&&t.hostBindings(1,n)}function Nl(t,n,e){ngDevMode&&va(t.firstCreatePass,!0,"Expando block should only be generated on first create pass.");const a=To-n.index,o=t.data.length-(1048575&n.providerIndexes);(t.expandoInstructions||(t.expandoInstructions=[])).push(a,o,e)}function Fl(t,n){ngDevMode&&Xo(t),n.flags|=2,(t.components||(t.components=ngDevMode?new Js:[])).push(n.index)}function Ll(t,n,e){if(e){if(n.exportAs)for(let a=0;a<n.exportAs.length;a++)e[n.exportAs[a]]=t;Vo(n)&&(e[""]=t)}}function Hl(t,n,e){ngDevMode&&wa(e,t.directiveEnd-t.directiveStart,"Reached the max number of directives"),t.flags|=1,t.directiveStart=n,t.directiveEnd=n+e,t.providerIndexes=n}function Bl(t,n,e){t.data.push(e);const a=e.factory||(e.factory=zo(e.type,!0)),o=new yi(a,Vo(e),null);t.blueprint.push(o),n.push(o)}function Vl(t,n,e){const a=wr(n,t),o=xl(e),r=t[10],i=Jl(t,bl(t,o,null,e.onPush?64:16,a,n,r,r.createRenderer(a,e),null,null));t[n.index]=i}function jl(t,n,e,a,o,r){ngDevMode&&(Ea(a,Os,"Incoming value should never be NO_CHANGE."),(function i(t){if(t.toLowerCase().startsWith("on")){const n=`Binding to event attribute '${t}' is disallowed for security reasons, please use (${t.slice(2)})=...`;throw new Error(n)}})(e),(function c(t,n,e){Ta(t,"should be called with a TNode"),va(n.some((n=>t.type===n)),!1,null!=e?e:`Should not be one of ${n.map(Si).join(", ")} but got ${Si(t.type)}`)})(t,[0,3],`Attempted to set attribute \`${e}\` on a container node. Host bindings are not valid on ng-container or ng-template.`));const s=wr(t,n),l=n[11];if(null==a)ngDevMode&&ngDevMode.rendererRemoveAttribute++,xr(l)?l.removeAttribute(s,e,r):s.removeAttribute(e);else{ngDevMode&&ngDevMode.rendererSetAttribute++;const n=null==o?$o(a):o(a,t.tagName||"",e);xr(l)?l.setAttribute(s,e,n,r):r?s.setAttributeNS(r,e,n):s.setAttribute(e,n)}}function Ul(t,n,e,a,o,r){const i=r[n];if(null!==i){const n=a.setInput;for(let r=0;r<i.length;){const c=i[r++],s=i[r++],l=i[r++];null!==n?a.setInput(e,l,c,s):e[s]=l,ngDevMode&&Sl(t,wr(o,t),o.type,s,l)}}}function Wl(t,n){let e=null,a=0;for(;a<n.length;){const o=n[a];if(0!==o)if(5!==o){if("number"==typeof o)break;t.hasOwnProperty(o)&&(null===e&&(e=[]),e.push(o,t[o],n[a+1])),a+=2}else a+=2;else a+=4}return e}const Gl=("undefined"==typeof ngDevMode||ngDevMode)&&Pa()&&$c("LContainer");function Yl(t,n,e,a){ngDevMode&&Zo(n),ngDevMode&&!xr(n[11])&&Ia(e);const o=new(ngDevMode?Gl:Array)(t,!0,!1,n,null,0,a,e,null,null);return ngDevMode&&va(o.length,Io,"Should allocate correct number of slots for LContainer header."),ngDevMode&&(function r(t){Fs(t,new ml(t))})(o),o}function ql(t,n){ngDevMode&&va(Tr(t),!1,"Should be run in update mode");const e=Ar(n,t);if(Dr(e)){const t=e[1];80&e[2]?hl(t,e,t.template,e[8]):e[5]>0&&Zl(e)}}function Zl(t){for(let n=ys(t);null!==n;n=ks(n))for(let t=Io;t<n.length;t++){const e=n[t];if(1024&e[2]){const t=e[1];ngDevMode&&Ta(t,"TView must be allocated"),hl(t,e,t.template,e[8])}else e[5]>0&&Zl(e)}const n=t[1].components;if(null!==n)for(let e=0;e<n.length;e++){const a=Ar(n[e],t);Dr(a)&&a[5]>0&&Zl(a)}}function Xl(t,n){ngDevMode&&va(Tr(t),!0,"Should be run in creation mode");const e=Ar(n,t),a=e[1];!(function o(t,n){for(let e=n.length;e<t.blueprint.length;e++)n.push(t.blueprint[e])})(a,e),fl(a,e,e[8])}function Jl(t,n){return t[13]?t[14][4]=n:t[13]=n,t[14]=n,n}function Ql(t){for(;t;){t[2]|=64;const n=Ps(t);if(jo(t)&&!n)return t;t=n}return null}function Kl(t){for(let n=0;n<t.components.length;n++){const e=t.components[n],a=Rr(e),o=a[1];_l(o,a,o.template,e)}}function $l(t,n,e){const a=n[10];a.begin&&a.begin();try{hl(t,n,t.template,e)}catch(t){throw im(n,t),t}finally{a.end&&a.end()}}function tm(t){Kl(t[8])}function nm(t,n,e){ngDevMode&&Ta(n,"View queries function to execute must be defined."),oi(0),n(t,e)}function em(t,n,e,a,...o){if(null===t[a]&&(null==n.inputs||!n.inputs[e])){(n.propertyBindings||(n.propertyBindings=[])).push(a);let r=e;o.length>0&&(r+=rr+o.join(rr)),t[a]=r}}const am=dl;function om(t){return t[7]||(t[7]=ngDevMode?new $s:[])}function rm(t,n,e){return(null===t||Vo(t))&&(e=(function a(t){for(;Array.isArray(t);){if("object"==typeof t[1])return t;t=t[0]}return null})(e[n.index])),e[11]}function im(t,n){const e=t[9],a=e?e.get(oc,null):null;a&&a.handleError(n)}function cm(t,n,e,a,o){for(let r=0;r<e.length;){const i=e[r++],c=e[r++],s=n[i];ngDevMode&&Na(n,i);const l=t.data[i];null!==l.setInput?l.setInput(s,o,a,c):s[c]=o}}function sm(t,n,e){ngDevMode&&Ea(e,Os,"value should not be NO_CHANGE"),ngDevMode&&Na(t,n+To);const a=vr(n,t);ngDevMode&&Ta(a,"native element should exist"),ngDevMode&&ngDevMode.rendererSetText++;const o=t[11];xr(o)?o.setValue(a,e):a.textContent=e}function lm(t,n,e,a,o){if(null!=a){let r,i=!1;Fo(a)?r=a:No(a)&&(i=!0,ngDevMode&&Ta(a[0],"HOST must be defined for a component LView"),a=a[0]);const c=kr(a);ngDevMode&&!xr(n)&&Ia(c),0===t&&null!==e?null==o?hm(n,e,c):fm(n,e,c,o||null):1===t&&null!==e?fm(n,e,c,o||null):2===t?ym(n,c,i):3===t&&(ngDevMode&&ngDevMode.rendererDestroyNode++,n.destroyNode(c)),null!=r&&(function r(t,n,e,a,o){ngDevMode&&Yo(e);const r=e[7];r!==kr(e)&&lm(n,t,a,r,o);for(let o=Io;o<e.length;o++){const i=e[o];vm(i[1],i,t,n,a,r)}})(n,t,r,e,o)}}function mm(t,n){return ngDevMode&&ngDevMode.rendererCreateTextNode++,ngDevMode&&ngDevMode.rendererSetText++,xr(n)?n.createText(t):n.createTextNode(t)}function dm(t,n){ngDevMode&&Yo(t),ngDevMode&&Ta(t[9],"A projected view should belong to a non-empty projected views collection");const e=t[9],a=e.indexOf(n),o=n[3];ngDevMode&&Yo(o),1024&n[2]&&(n[2]&=-1025,Fr(o,-1)),e.splice(a,1)}function gm(t,n){if(t.length<=Io)return;const e=Io+n,a=t[e];if(a){const o=a[17];null!==o&&o!==t&&dm(o,a),n>0&&(t[e-1][4]=a[4]);const r=io(t,Io+n);!(function o(t,n){vm(t,n,n[11],2,null,null),n[0]=null,n[6]=null})(a[1],a);const i=r[19];null!==i&&i.detachView(r[1]),a[3]=null,a[4]=null,a[2]&=-129}return a}function pm(t,n){if(!(256&n[2])){const e=n[11];xr(e)&&e.destroyNode&&vm(t,n,e,3,null,null),(function e(t){let n=t[13];if(!n)return bm(t[1],t);for(;n;){let e=null;if(No(n))e=n[13];else{ngDevMode&&Yo(n);const t=n[10];t&&(e=t)}if(!e){for(;n&&!n[4]&&n!==t;)No(n)&&bm(n[1],n),n=n[3];null===n&&(n=t),No(n)&&bm(n[1],n),e=n&&n[4]}n=e}})(n)}}function bm(t,n){if(!(256&n[2])){n[2]&=-129,n[2]|=256,(function e(t,n){let e;if(null!=t&&null!=(e=t.destroyHooks))for(let t=0;t<e.length;t+=2){const a=n[e[t]];if(!(a instanceof yi)){const n=e[t+1];if(Array.isArray(n))for(let t=0;t<n.length;t+=2)n[t+1].call(a[n[t]]);else n.call(a)}}})(t,n),(function a(t,n){const e=t.cleanup;if(null!==e){const t=n[7];for(let a=0;a<e.length-1;a+=2)if("string"==typeof e[a]){const o=e[a+1],r="function"==typeof o?o(n):kr(n[o]),i=t[e[a+2]],c=e[a+3];"boolean"==typeof c?r.removeEventListener(e[a],i,c):c>=0?t[c]():t[-c].unsubscribe(),a+=2}else e[a].call(t[e[a+1]]);n[7]=null}})(t,n),1===n[1].type&&xr(n[11])&&(ngDevMode&&ngDevMode.rendererDestroy++,n[11].destroy());const e=n[17];if(null!==e&&Fo(n[3])){e!==n[3]&&dm(e,n);const a=n[19];null!==a&&a.detachView(t)}}}function um(t,n,e){let a=n.parent;for(;null!=a&&(3===a.type||4===a.type);)a=(n=a).parent;if(null===a)return e[0];if(n&&4===n.type&&4&n.flags)return wr(n,e).parentNode;if(ngDevMode&&vi(a,2),2&a.flags){const n=t.data,e=n[n[a.index].directiveStart].encapsulation;if(e!==bo.ShadowDom&&e!==bo.Native)return null}return wr(a,e)}function fm(t,n,e,a){ngDevMode&&ngDevMode.rendererInsertBefore++,xr(t)?t.insertBefore(n,e,a):n.insertBefore(e,a,!0)}function hm(t,n,e){ngDevMode&&ngDevMode.rendererAppendChild++,ngDevMode&&Ta(n,"parent node must be defined"),xr(t)?t.appendChild(n,e):n.appendChild(e)}function _m(t,n,e,a){null!==a?fm(t,n,e,a):hm(t,n,e)}function Cm(t,n){return xr(t)?t.parentNode(n):n.parentNode}function Mm(t,n){return 3===t.type||4===t.type?wr(t,n):null}function Om(t,n,e,a){const o=um(t,a,n);if(null!=o){const t=n[11],r=Mm(a.parent||n[6],n);if(Array.isArray(e))for(let n=0;n<e.length;n++)_m(t,o,e[n],r);else _m(t,o,e,r)}}function Pm(t,n){if(null!==n){ngDevMode&&wi(n,[2,0,3,4,1]);const e=n.type;if(2===e)return wr(n,t);if(0===e)return xm(-1,t[n.index]);if(3===e||4===e){const e=n.child;if(null!==e)return Pm(t,e);{const e=t[n.index];return Fo(e)?xm(-1,e):kr(e)}}{const e=t[16],a=e[6],o=Ps(e),r=a.projection[n.projection];return null!=r?Pm(o,r):Pm(t,n.next)}}return null}function xm(t,n){const e=Io+t+1;if(e<n.length){const t=n[e],a=t[1].firstChild;if(null!==a)return Pm(t,a)}return n[7]}function ym(t,n,e){const a=Cm(t,n);a&&(function o(t,n,e,a){xr(t)?t.removeChild(n,e,a):n.removeChild(e)})(t,a,n,e)}function km(t,n,e,a,o,r,i){for(;null!=e;){ngDevMode&&Uo(e,a),ngDevMode&&wi(e,[0,2,3,1,4]);const c=a[e.index],s=e.type;i&&0===n&&(c&&os(kr(c),a),e.flags|=4),64!=(64&e.flags)&&(3===s||4===s?(km(t,n,e.child,a,o,r,!1),lm(n,t,o,c,r)):1===s?Sm(t,n,a,e,o,r):(ngDevMode&&wi(e,[2,0]),lm(n,t,o,c,r))),e=i?e.projectionNext:e.next}}function vm(t,n,e,a,o,r){km(e,a,t.firstChild,n,o,r,!1)}function wm(t,n,e){Sm(n[11],0,n,e,um(t,e,n),Mm(e.parent||n[6],n))}function Sm(t,n,e,a,o,r){const i=e[16],c=i[6];ngDevMode&&va(typeof a.projection,"number","expecting projection index");const s=c.projection[a.projection];if(Array.isArray(s))for(let e=0;e<s.length;e++)lm(n,t,o,s[e],r);else km(t,n,s,i[3],o,r,!0)}function Em(t,n,e){ngDevMode&&ka(e,"'newValue' should be a string"),xr(t)?t.setAttribute(n,"style",e):n.style.cssText=e,ngDevMode&&ngDevMode.rendererSetStyle++}function Am(t,n,e){ngDevMode&&ka(e,"'newValue' should be a string"),xr(t)?""===e?t.removeAttribute(n,"class"):t.setAttribute(n,"class",e):n.className=e,ngDevMode&&ngDevMode.rendererSetClassName++}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class zm{constructor(t,n){this._lView=t,this._cdRefInjectingView=n,this._appRef=null,this._viewContainerRef=null}get rootNodes(){const t=this._lView,n=t[1];return Tm(n,t,n.firstChild,[])}get context(){return this._lView[8]}get destroyed(){return 256==(256&this._lView[2])}destroy(){if(this._appRef)this._appRef.detachView(this);else if(this._viewContainerRef){const t=this._viewContainerRef.indexOf(this);t>-1&&this._viewContainerRef.detach(t),this._viewContainerRef=null}pm(this._lView[1],this._lView)}onDestroy(t){kl(this._lView[1],this._lView,null,t)}markForCheck(){Ql(this._cdRefInjectingView||this._lView)}detach(){this._lView[2]&=-129}reattach(){this._lView[2]|=128}detectChanges(){$l(this._lView[1],this._lView,this.context)}checkNoChanges(){!(function t(n,e,a){Zr(!0);try{$l(n,e,a)}finally{Zr(!1)}})(this._lView[1],this._lView,this.context)}attachToViewContainerRef(t){if(this._appRef)throw new Error("This view is already attached directly to the ApplicationRef!");this._viewContainerRef=t}detachFromAppRef(){this._appRef=null,(function t(n,e){vm(n,e,e[11],2,null,null)})(this._lView[1],this._lView)}attachToAppRef(t){if(this._viewContainerRef)throw new Error("This view is already attached to a ViewContainer!");this._appRef=t}}class Rm extends zm{constructor(t){super(t),this._view=t}detectChanges(){tm(this._view)}checkNoChanges(){!(function t(n){Zr(!0);try{tm(n)}finally{Zr(!1)}})(this._view)}get context(){return null}}function Tm(t,n,e,a,o=!1){for(;null!==e;){ngDevMode&&wi(e,[2,0,1,3,4]);const r=n[e.index];if(null!==r&&a.push(kr(r)),Fo(r))for(let t=Io;t<r.length;t++){const n=r[t],e=n[1].firstChild;null!==e&&Tm(n[1],n,e,a)}const i=e.type;if(3===i||4===i)Tm(t,n,e.child,a);else if(1===i){const t=n[16],o=t[6],r=e.projection;ngDevMode&&Ta(o.projection,"Components with projection nodes (<ng-content>) must have projection slots defined.");const i=o.projection[r];if(Array.isArray(i))a.push(...i);else{const n=Ps(t);ngDevMode&&Ta(n,"Component views should always have a parent view (component's host view)"),Tm(n[1],n,i,a,!0)}}e=o?e.projectionNext:e.next}return a}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let Dm,Im,Nm;function Fm(t,n,e){return Dm||(Dm=class extends t{}),new Dm(wr(n,e))}function Lm(t,n,e,a){return Im||(Im=class extends t{constructor(t,n,e){super(),this._declarationView=t,this._declarationTContainer=n,this.elementRef=e}createEmbeddedView(t){const n=this._declarationTContainer.tViews,e=bl(this._declarationView,n,t,16,null,n.declTNode,null,null,null,null),a=this._declarationView[this._declarationTContainer.index];ngDevMode&&Yo(a),e[17]=a;const o=this._declarationView[19];return null!==o&&(e[19]=o.createEmbeddedView(n)),fl(n,e,t),new zm(e)}}),0===e.type?(ngDevMode&&Ta(e.tViews,"TView must be allocated"),new Im(a,e,Fm(n,e,a))):null}function Hm(t,n,e,a){let o;Nm||(Nm=class extends t{constructor(t,n,e){super(),this._lContainer=t,this._hostTNode=n,this._hostView=e}get element(){return Fm(n,this._hostTNode,this._hostView)}get injector(){return new Ki(this._hostTNode,this._hostView)}get parentInjector(){const t=Ui(this._hostTNode,this._hostView);if(Di(t)){const n=Ni(t,this._hostView),e=Ii(t);return ngDevMode&&Ko(n,e),new Ki(n[1].data[e+8],n)}return new Ki(null,this._hostView)}clear(){for(;this.length>0;)this.remove(this.length-1)}get(t){return null!==this._lContainer[8]&&this._lContainer[8][t]||null}get length(){return this._lContainer.length-Io}createEmbeddedView(t,n,e){const a=t.createEmbeddedView(n||{});return this.insert(a,e),a}createComponent(t,n,e,a,o){const r=e||this.parentInjector;if(!o&&null==t.ngModule&&r){const t=r.get(no,null);t&&(o=t)}const i=t.create(r,a,void 0,o);return this.insert(i.hostView,n),i}insert(t,n){const e=t._lView,a=e[1];if(t.destroyed)throw new Error("Cannot insert a destroyed View in a ViewContainer!");if(this.allocateContainerIfNeeded(),(function o(t){return Fo(t[3])})(e)){const n=this.indexOf(t);if(-1!==n)this.detach(n);else{const n=e[3];ngDevMode&&va(Fo(n),!0,"An attached view should have its PARENT point to a container.");const a=new Nm(n,n[6],n[3]);a.detach(a.indexOf(t))}}const r=this._adjustIndex(n),i=this._lContainer;!(function c(t,n,e,a){ngDevMode&&Zo(n),ngDevMode&&Yo(e);const o=Io+a,r=e.length;a>0&&(e[o-1][4]=n),a<r-Io?(n[4]=e[o],ro(e,Io+a,n)):(e.push(n),n[4]=null),n[3]=e;const i=n[17];null!==i&&e!==i&&(function c(t,n){ngDevMode&&Ta(n,"LView required"),ngDevMode&&Yo(t);const e=t[9],a=n[3];ngDevMode&&Yo(a);const o=a[3][16];ngDevMode&&Ta(o,"Missing insertedComponentLView");const r=n[16];ngDevMode&&Ta(r,"Missing declaredComponentLView"),r!==o&&(t[2]=!0),null===e?t[9]=[n]:e.push(n)})(i,n);const s=n[19];null!==s&&s.insertView(t),n[2]|=128})(a,e,i,r);const s=xm(r,i),l=e[11],m=Cm(l,i[7]);return null!==m&&(function d(t,n,e,a,o,r){a[0]=o,a[6]=n,vm(t,a,e,1,o,r)})(a,i[6],l,e,m,s),t.attachToViewContainerRef(this),ro(i[8],r,t),t}move(t,n){if(t.destroyed)throw new Error("Cannot move a destroyed View in a ViewContainer!");return this.insert(t,n)}indexOf(t){const n=this._lContainer[8];return null!==n?n.indexOf(t):-1}remove(t){this.allocateContainerIfNeeded();const n=this._adjustIndex(t,-1),e=gm(this._lContainer,n);e&&(io(this._lContainer[8],n),pm(e[1],e))}detach(t){this.allocateContainerIfNeeded();const n=this._adjustIndex(t,-1),e=gm(this._lContainer,n);return e&&null!=io(this._lContainer[8],n)?new zm(e):null}_adjustIndex(t,n=0){return null==t?this.length+n:(ngDevMode&&(Ra(t,-1,`ViewRef index must be positive, got ${t}`),Aa(t,this.length+1+n,"index")),t)}allocateContainerIfNeeded(){null===this._lContainer[8]&&(this._lContainer[8]=[])}}),ngDevMode&&wi(e,[0,2,3]);const r=a[e.index];if(Fo(r))o=r;else{let t;if(3===e.type)t=kr(r);else if(ngDevMode&&ngDevMode.rendererCreateComment++,t=a[11].createComment(ngDevMode?"container":""),jo(a)){const n=a[11],o=wr(e,a);fm(n,Cm(n,o),t,(function i(t,n){return xr(t)?t.nextSibling(n):n.nextSibling})(n,o))}else Om(a[1],a,t,e);a[e.index]=o=Yl(r,a,t,e),Jl(a,o)}return new Nm(o,e,a)}function Bm(t=!1){return(function n(t,e,a){if(!a&&Ho(t)){const n=Ar(t.index,e);return new zm(n,n)}return 2===t.type||0===t.type||3===t.type||4===t.type?new zm(e[16],e):null})(Ur(),Br(),t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Vm{}Vm.__NG_ELEMENT_ID__=()=>jm();const jm=Bm,Um=Function;function Wm(t){return"function"==typeof t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Gm=/^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|[^()]+\(arguments\))\)/,Ym=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/,qm=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/,Zm=/^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{\s*super\(\.\.\.arguments\)/;class Xm{constructor(t){this._reflect=t||ma.Reflect}isReflectionEnabled(){return!0}factory(t){return(...n)=>new t(...n)}_zipTypesAndAnnotations(t,n){let e;e=co(void 0===t?n.length:t.length);for(let a=0;a<e.length;a++)e[a]=void 0===t?[]:t[a]&&t[a]!=Object?[t[a]]:[],n&&null!=n[a]&&(e[a]=e[a].concat(n[a]));return e}_ownParameters(t,n){if((function e(t){return Gm.test(t)||Zm.test(t)||Ym.test(t)&&!qm.test(t)})(t.toString()))return null;if(t.parameters&&t.parameters!==n.parameters)return t.parameters;const a=t.ctorParameters;if(a&&a!==n.ctorParameters){const t="function"==typeof a?a():a,n=t.map((t=>t&&t.type)),e=t.map((t=>t&&Jm(t.decorators)));return this._zipTypesAndAnnotations(n,e)}const o=t.hasOwnProperty(Ee)&&t[Ee],r=this._reflect&&this._reflect.getOwnMetadata&&this._reflect.getOwnMetadata("design:paramtypes",t);return r||o?this._zipTypesAndAnnotations(r,o):co(t.length)}parameters(t){if(!Wm(t))return[];const n=Qm(t);let e=this._ownParameters(t,n);return e||n===Object||(e=this.parameters(n)),e||[]}_ownAnnotations(t,n){if(t.annotations&&t.annotations!==n.annotations){let n=t.annotations;return"function"==typeof n&&n.annotations&&(n=n.annotations),n}return t.decorators&&t.decorators!==n.decorators?Jm(t.decorators):t.hasOwnProperty(Se)?t[Se]:null}annotations(t){if(!Wm(t))return[];const n=Qm(t),e=this._ownAnnotations(t,n)||[];return(n!==Object?this.annotations(n):[]).concat(e)}_ownPropMetadata(t,n){if(t.propMetadata&&t.propMetadata!==n.propMetadata){let n=t.propMetadata;return"function"==typeof n&&n.propMetadata&&(n=n.propMetadata),n}if(t.propDecorators&&t.propDecorators!==n.propDecorators){const n=t.propDecorators,e={};return Object.keys(n).forEach((t=>{e[t]=Jm(n[t])})),e}return t.hasOwnProperty(Ae)?t[Ae]:null}propMetadata(t){if(!Wm(t))return{};const n=Qm(t),e={};if(n!==Object){const t=this.propMetadata(n);Object.keys(t).forEach((n=>{e[n]=t[n]}))}const a=this._ownPropMetadata(t,n);return a&&Object.keys(a).forEach((t=>{const n=[];e.hasOwnProperty(t)&&n.push(...e[t]),n.push(...a[t]),e[t]=n})),e}ownPropMetadata(t){return Wm(t)&&this._ownPropMetadata(t,Qm(t))||{}}hasLifecycleHook(t,n){return t instanceof Um&&n in t.prototype}guards(t){return{}}getter(t){return new Function("o","return o."+t+";")}setter(t){return new Function("o","v","return o."+t+" = v;")}method(t){return new Function("o","args",`if (!o.${t}) throw new Error('"${t}" is undefined');\n        return o.${t}.apply(o, args);`)}importUri(t){return"object"==typeof t&&t.filePath?t.filePath:`./${ta(t)}`}resourceUri(t){return`./${ta(t)}`}resolveIdentifier(t,n,e,a){return a}resolveEnum(t,n){return t[n]}}function Jm(t){return t?t.map((t=>new(0,t.type.annotationCls)(...t.args?t.args:[]))):[]}function Qm(t){const n=t.prototype?Object.getPrototypeOf(t.prototype):null;return(n?n.constructor:null)||Object}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let Km=null;function $m(){return Km=Km||new Xm}function td(t){return nd($m().parameters(t))}function nd(t){const n=ba();return t.map((t=>(function e(t,n){const e={token:null,host:!1,optional:!1,resolved:t.R3ResolvedDependencyType.Token,self:!1,skipSelf:!1};function a(n){e.resolved=t.R3ResolvedDependencyType.Token,e.token=n}if(Array.isArray(n)&&n.length>0)for(let o=0;o<n.length;o++){const r=n[o];if(void 0===r)continue;const i=Object.getPrototypeOf(r);if(r instanceof Ne||"Optional"===i.ngMetadataName)e.optional=!0;else if(r instanceof Le||"SkipSelf"===i.ngMetadataName)e.skipSelf=!0;else if(r instanceof Fe||"Self"===i.ngMetadataName)e.self=!0;else if(r instanceof He||"Host"===i.ngMetadataName)e.host=!0;else if(r instanceof Ie)e.token=r.token;else if(r instanceof Be){if(void 0===r.attributeName)throw new Error("Attribute name must be defined.");e.token=r.attributeName,e.resolved=t.R3ResolvedDependencyType.Attribute}else r===Vm?(e.token=r,e.resolved=t.R3ResolvedDependencyType.ChangeDetectorRef):a(r)}else void 0===n||Array.isArray(n)&&0===n.length?(e.token=void 0,e.resolved=da.Invalid):a(n);return e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(n,t)))}const ed=je({provide:String,useValue:je});function ad(t){return void 0!==t.useClass}function od(t){return void 0!==t.useFactory}function rd(t,n){const e=n||{providedIn:null},a={name:t.name,type:t,typeArgumentCount:0,providedIn:e.providedIn,userDeps:void 0};return(ad(e)||od(e))&&void 0!==e.deps&&(a.userDeps=nd(e.deps)),ad(e)?a.useClass=oa(e.useClass):(function o(t){return ed in t})(e)?a.useValue=oa(e.useValue):od(e)?a.useFactory=e.useFactory:(function r(t){return void 0!==t.useExisting})(e)&&(a.useExisting=oa(e.useExisting)),a}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */je({provide:String,useValue:je});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const id=ze("Injectable",void 0,void 0,void 0,((t,n)=>cd(t,n))),cd=function sd(t,n){let e=null,a=null;t.hasOwnProperty(Xe)||(Object.defineProperty(t,Xe,{get:()=>(null===e&&(e=ba().compileInjectable(to,`ng:///${t.name}/ɵprov.js`,rd(t,n))),e)}),t.hasOwnProperty(Qe)||(t[Qe]=()=>t[Xe])),t.hasOwnProperty(Ma)||Object.defineProperty(t,Ma,{get:()=>{if(null===a){const e=rd(t,n),o=ba();a=o.compileFactory(to,`ng:///${t.name}/ɵfac.js`,{name:e.name,type:e.type,typeArgumentCount:e.typeArgumentCount,deps:td(t),injectFn:"inject",target:o.R3FactoryTarget.Injectable})}return a},configurable:!0})},ld=new Fa("Set Injector scope."),md={},dd={},gd=[];let pd;function bd(){return void 0===pd&&(pd=new $a),pd}function ud(t,n=null,e=null,a){return new fd(t,e,n||bd(),a)}class fd{constructor(t,n,e,a=null){this.parent=e,this.records=new Map,this.injectorDefTypes=new Set,this.onDestroy=new Set,this._destroyed=!1;const o=[];n&&oo(n,(e=>this.processProvider(e,t,n))),oo([t],(t=>this.processInjectorType(t,[],o))),this.records.set(La,Cd(void 0,this));const r=this.records.get(ld);this.scope=null!=r?r.value:null,this.source=a||("object"==typeof t?null:ta(t))}get destroyed(){return this._destroyed}destroy(){this.assertNotDestroyed(),this._destroyed=!0;try{this.onDestroy.forEach((t=>t.ngOnDestroy()))}finally{this.records.clear(),this.onDestroy.clear(),this.injectorDefTypes.clear()}}get(t,n=Ha,e=Ve.Default){this.assertNotDestroyed();const a=Ga(this);try{if(!(e&Ve.SkipSelf)){let n=this.records.get(t);if(void 0===n){const e=(function o(t){return"function"==typeof t||"object"==typeof t&&t instanceof Fa})(t)&&Ye(t);n=e&&this.injectableDefInScope(e)?Cd(hd(t),md):null,this.records.set(t,n)}if(null!=n)return this.hydrate(t,n)}return(e&Ve.Self?bd():this.parent).get(t,n=e&Ve.Optional&&n===Ha?null:n)}catch(n){if("NullInjectorError"===n.name){if((n.ngTempTokenPath=n.ngTempTokenPath||[]).unshift(ta(t)),a)throw n;return(function r(t,n,e,a){const o=t.ngTempTokenPath;throw n[Va]&&o.unshift(n[Va]),t.message=(function r(t,n,e,a=null){t=t&&"\n"===t.charAt(0)&&"ɵ"==t.charAt(1)?t.substr(2):t;let o=ta(n);if(Array.isArray(n))o=n.map(ta).join(" -> ");else if("object"==typeof n){let t=[];for(let e in n)if(n.hasOwnProperty(e)){let a=n[e];t.push(e+":"+("string"==typeof a?JSON.stringify(a):ta(a)))}o=`{${t.join(", ")}}`}return`${e}${a?"("+a+")":""}[${o}]: ${t.replace(Ba,"\n  ")}`})("\n"+t.message,o,e,a),t.ngTokenPath=o,t.ngTempTokenPath=null,t})(n,t,"R3InjectorError",this.source)}throw n}finally{Ga(a)}}_resolveInjectorDefTypes(){this.injectorDefTypes.forEach((t=>this.get(t)))}toString(){const t=[];return this.records.forEach(((n,e)=>t.push(ta(e)))),`R3Injector[${t.join(", ")}]`}assertNotDestroyed(){if(this._destroyed)throw new Error("Injector has already been destroyed.")}processInjectorType(t,n,e){if(!(t=oa(t)))return!1;let a=Ze(t);const o=null==a&&t.ngModule||void 0,r=void 0===o?t:o;ngDevMode&&-1!==n.indexOf(r)&&cr(ta(r),n.map(ta));const i=-1!==e.indexOf(r);if(void 0!==o&&(a=Ze(o)),null==a)return!1;if(null!=a.imports&&!i){let t;ngDevMode&&n.push(r),e.push(r);try{oo(a.imports,(a=>{this.processInjectorType(a,n,e)&&(void 0===t&&(t=[]),t.push(a))}))}finally{ngDevMode&&n.pop()}if(void 0!==t)for(let n=0;n<t.length;n++){const{ngModule:e,providers:a}=t[n];oo(a,(t=>this.processProvider(t,e,a||gd)))}}this.injectorDefTypes.add(r),this.records.set(r,Cd(a.factory,md));const c=a.providers;if(null!=c&&!i){const n=t;oo(c,(t=>this.processProvider(t,n,c)))}return void 0!==o&&void 0!==t.providers}processProvider(t,n,e){let a=Od(t=oa(t))?t:oa(t&&t.provide);const o=(function r(t,n,e){return Md(t)?Cd(void 0,t.useValue):Cd(_d(t,n,e),md)})(t,n,e);if(Od(t)||!0!==t.multi){const t=this.records.get(a);ngDevMode&&t&&void 0!==t.multi&&lr()}else{let n=this.records.get(a);n?ngDevMode&&void 0===n.multi&&lr():(n=Cd(void 0,md,!0),n.factory=()=>Ka(n.multi),this.records.set(a,n)),a=t,n.multi.push(t)}this.records.set(a,o)}hydrate(t,n){return ngDevMode&&n.value===dd?cr(ta(t)):n.value===md&&(n.value=dd,n.value=n.factory()),"object"==typeof n.value&&n.value&&(function e(t){return null!==t&&"object"==typeof t&&"function"==typeof t.ngOnDestroy})(n.value)&&this.onDestroy.add(n.value),n.value}injectableDefInScope(t){return!!t.providedIn&&("string"==typeof t.providedIn?"any"===t.providedIn||t.providedIn===this.scope:this.injectorDefTypes.has(t.providedIn))}}function hd(t){const n=Ye(t),e=null!==n?n.factory:zo(t);if(null!==e)return e;const a=Ze(t);if(null!==a)return a.factory;if(t instanceof Fa)throw new Error(`Token ${ta(t)} is missing a ɵprov definition.`);if(t instanceof Function)return(function o(t){const n=t.length;if(n>0){const e=co(n,"?");throw new Error(`Can't resolve all parameters for ${ta(t)}: (${e.join(", ")}).`)}const e=(function a(t){const n=t&&(t[Xe]||t[Ke]||t[Qe]&&t[Qe]());if(n){const e=(function e(t){if(t.hasOwnProperty("name"))return t.name;const n=(""+t).match(/^function\s*([^\s(]+)/);return null===n?"":n[1]})(t);return console.warn(`DEPRECATED: DI is instantiating a token "${e}" that inherits its @Injectable decorator but does not provide one itself.\nThis will become an error in a future version of Angular. Please add @Injectable() to the "${e}" class.`),n}return null})(t);return null!==e?()=>e.factory(t):()=>new t})(t);throw new Error("unreachable")}function _d(t,n,e){let a;if(Od(t)){const n=oa(t);return zo(n)||hd(n)}if(Md(t))a=()=>oa(t.useValue);else if((function o(t){return!(!t||!t.useFactory)})(t))a=()=>t.useFactory(...Ka(t.deps||[]));else if((function r(t){return!(!t||!t.useExisting)})(t))a=()=>Za(oa(t.useExisting));else{const o=oa(t&&(t.useClass||t.provide));if(ngDevMode&&!o&&(function i(t,n,e){let a="";throw t&&n&&(a=` - only instances of Provider and Type are allowed, got: [${n.map((t=>t==e?"?"+e+"?":"...")).join(", ")}]`),new Error(`Invalid provider for the NgModule '${ta(t)}'`+a)})(n,e,t),!(function c(t){return!!t.deps})(t))return zo(o)||hd(o);a=()=>new o(...Ka(t.deps))}return a}function Cd(t,n,e=!1){return{factory:t,value:n,multi:e?[]:void 0}}function Md(t){return null!==t&&"object"==typeof t&&ja in t}function Od(t){return"function"==typeof t}const Pd=function xd(t,n,e){return(function a(t,n=null,e=null,o){const r=ud(t,n,e,o);return r._resolveInjectorDefTypes(),r})({name:e},n,t,e)};class yd{static create(t,n){return Array.isArray(t)?Pd(t,n,""):Pd(t.providers,t.parent,t.name||"")}}function kd(t){return t.length>1?" ("+(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function n(t){const n=[];for(let e=0;e<t.length;++e){if(n.indexOf(t[e])>-1)return n.push(t[e]),n;n.push(t[e])}return n})(t.slice().reverse()).map((t=>ta(t.token))).join(" -> ")+")":""}function vd(t,n,e,a){const o=[n],r=e(o),i=a?(function c(t,n){const e=`${t} caused by: ${n instanceof Error?n.message:n}`,a=Error(e);return a.ngOriginalError=n,a})(r,a):Error(r);return i.addKey=wd,i.keys=o,i.injectors=[t],i.constructResolvingMessage=e,i.ngOriginalError=a,i}function wd(t,n){this.injectors.push(t),this.keys.push(n),this.message=this.constructResolvingMessage(this.keys)}function Sd(t,n){const e=[];for(let t=0,a=n.length;t<a;t++){const a=n[t];e.push(a&&0!=a.length?a.map(ta).join(" "):"?")}return Error("Cannot resolve all parameters for '"+ta(t)+"'("+e.join(", ")+"). Make sure that all the parameters are decorated with Inject or have valid type annotations and that '"+ta(t)+"' is decorated with Injectable.")}yd.THROW_IF_NOT_FOUND=Ha,yd.NULL=new $a,yd.ɵprov=We({token:yd,providedIn:"any",factory:()=>Za(La)}),yd.__NG_ELEMENT_ID__=-1;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Ed{constructor(t,n){if(this.token=t,this.id=n,!t)throw new Error("Token must be defined!");this.displayName=ta(this.token)}static get(t){return Ad.get(oa(t))}static get numberOfKeys(){return Ad.numberOfKeys}}const Ad=new class{constructor(){this._allKeys=new Map}get(t){if(t instanceof Ed)return t;if(this._allKeys.has(t))return this._allKeys.get(t);const n=new Ed(t,Ed.numberOfKeys);return this._allKeys.set(t,n),n}get numberOfKeys(){return this._allKeys.size}},zd=new
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{constructor(t){this.reflectionCapabilities=t}updateCapabilities(t){this.reflectionCapabilities=t}factory(t){return this.reflectionCapabilities.factory(t)}parameters(t){return this.reflectionCapabilities.parameters(t)}annotations(t){return this.reflectionCapabilities.annotations(t)}propMetadata(t){return this.reflectionCapabilities.propMetadata(t)}hasLifecycleHook(t,n){return this.reflectionCapabilities.hasLifecycleHook(t,n)}getter(t){return this.reflectionCapabilities.getter(t)}setter(t){return this.reflectionCapabilities.setter(t)}method(t){return this.reflectionCapabilities.method(t)}importUri(t){return this.reflectionCapabilities.importUri(t)}resourceUri(t){return this.reflectionCapabilities.resourceUri(t)}resolveIdentifier(t,n,e,a){return this.reflectionCapabilities.resolveIdentifier(t,n,e,a)}resolveEnum(t,n){return this.reflectionCapabilities.resolveEnum(t,n)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */(new Xm);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Rd{constructor(t,n,e){this.key=t,this.optional=n,this.visibility=e}static fromKey(t){return new Rd(t,!1,null)}}const Td=[];class Dd{constructor(t,n,e){this.key=t,this.resolvedFactories=n,this.multiProvider=e,this.resolvedFactory=this.resolvedFactories[0]}}class Id{constructor(t,n){this.factory=t,this.dependencies=n}}function Nd(t){let n,e;if(t.useClass){const a=oa(t.useClass);n=zd.factory(a),e=Bd(a)}else t.useExisting?(n=t=>t,e=[Rd.fromKey(Ed.get(t.useExisting))]):t.useFactory?(n=t.useFactory,e=(function a(t,n){if(n){const e=n.map((t=>[t]));return n.map((n=>Vd(t,n,e)))}return Bd(t)})(t.useFactory,t.deps)):(n=()=>t.useValue,e=Td);return new Id(n,e)}function Fd(t){return new Dd(Ed.get(t.provide),[Nd(t)],t.multi||!1)}function Ld(t){const n=(function e(t,n){for(let e=0;e<t.length;e++){const a=t[e],o=n.get(a.key.id);if(o){if(a.multiProvider!==o.multiProvider)throw Error(`Cannot mix multi providers and regular providers, got: ${o} ${a}`);if(a.multiProvider)for(let t=0;t<a.resolvedFactories.length;t++)o.resolvedFactories.push(a.resolvedFactories[t]);else n.set(a.key.id,a)}else{let t;t=a.multiProvider?new Dd(a.key,a.resolvedFactories.slice(),a.multiProvider):a,n.set(a.key.id,t)}}return n})(Hd(t,[]).map(Fd),new Map);return Array.from(n.values())}function Hd(t,n){return t.forEach((t=>{if(t instanceof Um)n.push({provide:t,useClass:t});else if(t&&"object"==typeof t&&void 0!==t.provide)n.push(t);else{if(!Array.isArray(t))throw(function e(t){return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${t}`)})(t);Hd(t,n)}})),n}function Bd(t){const n=zd.parameters(t);if(!n)return[];if(n.some((t=>null==t)))throw Sd(t,n);return n.map((e=>Vd(t,e,n)))}function Vd(t,n,e){let a=null,o=!1;if(!Array.isArray(n))return jd(n instanceof Ie?n.token:n,o,null);let r=null;for(let t=0;t<n.length;++t){const e=n[t];e instanceof Um?a=e:e instanceof Ie?a=e.token:e instanceof Ne?o=!0:e instanceof Fe||e instanceof Le?r=e:e instanceof Fa&&(a=e)}if(a=oa(a),null!=a)return jd(a,o,r);throw Sd(t,e)}function jd(t,n,e){return new Rd(Ed.get(t),n,e)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Ud={};class Wd{static resolve(t){return Ld(t)}static resolveAndCreate(t,n){const e=Wd.resolve(t);return Wd.fromResolvedProviders(e,n)}static fromResolvedProviders(t,n){return new Gd(t,n)}}class Gd{constructor(t,n){this._constructionCounter=0,this._providers=t,this.parent=n||null;const e=t.length;this.keyIds=[],this.objs=[];for(let n=0;n<e;n++)this.keyIds[n]=t[n].key.id,this.objs[n]=Ud}get(t,n=Ha){return this._getByKey(Ed.get(t),null,n)}resolveAndCreateChild(t){const n=Wd.resolve(t);return this.createChildFromResolved(n)}createChildFromResolved(t){const n=new Gd(t);return n.parent=this,n}resolveAndInstantiate(t){return this.instantiateResolved(Wd.resolve([t])[0])}instantiateResolved(t){return this._instantiateProvider(t)}getProviderAtIndex(t){if(t<0||t>=this._providers.length)throw(function n(t){return Error(`Index ${t} is out-of-bounds.`)})(t);return this._providers[t]}_new(t){if(this._constructionCounter++>this._getMaxNumberOfObjects())throw(function n(t,e){return vd(t,e,(function(t){return`Cannot instantiate cyclic dependency!${kd(t)}`}))})(this,t.key);return this._instantiateProvider(t)}_getMaxNumberOfObjects(){return this.objs.length}_instantiateProvider(t){if(t.multiProvider){const n=[];for(let e=0;e<t.resolvedFactories.length;++e)n[e]=this._instantiate(t,t.resolvedFactories[e]);return n}return this._instantiate(t,t.resolvedFactories[0])}_instantiate(t,n){const e=n.factory;let a,o;try{a=n.dependencies.map((t=>this._getByReflectiveDependency(t)))}catch(n){throw n.addKey&&n.addKey(this,t.key),n}try{o=e(...a)}catch(n){throw(function r(t,n,e,a){return vd(t,a,(function(t){const e=ta(t[0].token);return`${n.message}: Error during instantiation of ${e}!${kd(t)}.`}),n)})(this,n,0,t.key)}return o}_getByReflectiveDependency(t){return this._getByKey(t.key,t.visibility,t.optional?null:Ha)}_getByKey(t,n,e){return t===Gd.INJECTOR_KEY?this:n instanceof Fe?this._getByKeySelf(t,e):this._getByKeyDefault(t,e,n)}_getObjByKeyId(t){for(let n=0;n<this.keyIds.length;n++)if(this.keyIds[n]===t)return this.objs[n]===Ud&&(this.objs[n]=this._new(this._providers[n])),this.objs[n];return Ud}_throwOrNull(t,n){if(n!==Ha)return n;throw(function e(t,n){return vd(t,n,(function(t){return`No provider for ${ta(t[0].token)}!${kd(t)}`}))})(this,t)}_getByKeySelf(t,n){const e=this._getObjByKeyId(t.id);return e!==Ud?e:this._throwOrNull(t,n)}_getByKeyDefault(t,n,e){let a;for(a=e instanceof Le?this.parent:this;a instanceof Gd;){const n=a,e=n._getObjByKeyId(t.id);if(e!==Ud)return e;a=n.parent}return null!==a?a.get(t.token,n):this._throwOrNull(t,n)}get displayName(){return`ReflectiveInjector(providers: [${(function t(n,e){const a=[];for(let t=0;t<n._providers.length;++t)a[t]=e(n.getProviderAtIndex(t));return a}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(this,(t=>' "'+t.key.displayName+'" ')).join(", ")}])`}toString(){return this.displayName}}Gd.INJECTOR_KEY=Ed.get(yd),new Fa("AnalyzeForEntryComponents");class Yd{}const qd=De("ContentChildren",((t,n={})=>Object.assign({selector:t,first:!1,isViewQuery:!1,descendants:!1},n)),Yd),Zd=De("ContentChild",((t,n={})=>Object.assign({selector:t,first:!0,isViewQuery:!1,descendants:!0},n)),Yd);De("ViewChildren",((t,n={})=>Object.assign({selector:t,first:!1,isViewQuery:!0,descendants:!0},n)),Yd);const Xd=De("ViewChild",((t,n)=>Object.assign({selector:t,first:!0,isViewQuery:!0,descendants:!0},n)),Yd);let Jd=new Map;const Qd=new Set;function Kd(t){return!!(t.templateUrl&&!t.hasOwnProperty("template")||t.styleUrls&&t.styleUrls.length)}function $d(t){return"string"==typeof t?t:t.text()}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function tg(t,n,e){ngDevMode&&Xo(Vr(),"Expecting to be called in first template pass only");let a=e?t.styles:null,o=e?t.classes:null,r=0;if(null!==n)for(let t=0;t<n.length;t++){const e=n[t];"number"==typeof e?r=e:1==r?o=na(o,e):2==r&&(a=na(a,e+": "+n[++t]+";"))}e?t.styles=a:t.stylesWithoutHost=a,e?t.classes=o:t.classesWithoutHost=o}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function ng(t){dg(t);const n=cg(t,!1);return null===n?null:(void 0===n.component&&(n.component=(function e(t,n){const e=n[1].data[t];return 2&e.flags?n[e.directiveStart]:null})(n.nodeIndex,n.lView)),n.component)}function eg(t){dg(t);const n=cg(t,!1);return null===n?null:n.lView[8]}function ag(t){const n=cg(t,!1);if(null===n)return null;let e,a=n.lView;for(ngDevMode&&Zo(a);2===a[1].type&&(e=Ps(a));)a=e;return 512&a[2]?null:a[8]}function og(t){return[...xs(t).components]}function rg(t){const n=cg(t,!1);return null===n?yd.NULL:new Ki(n.lView[1].data[n.nodeIndex],n.lView)}function ig(t){const n=cg(t);return void 0===n.directives&&(n.directives=ss(n.nodeIndex,n.lView,!1)),null===n.directives?[]:[...n.directives]}function cg(t,n=!0){const e=ns(t);if(!e&&n)throw new Error(ngDevMode?`Unable to find context associated with ${tr(t)}`:"Invalid ng target");return e}function sg(t){return ns(t).native}function lg(t){dg(t);const n=cg(t,!1);if(null===n)return[];const e=n.lView,a=e[7],o=e[1].cleanup,r=[];if(o&&a)for(let n=0;n<o.length;){const i=o[n++],c=o[n++];if("string"==typeof i){const s=i,l=kr(e[c]),m=a[o[n++]],d=o[n++],g="boolean"==typeof d||d>=0?"dom":"output",p="boolean"==typeof d&&d;t==l&&r.push({element:t,name:s,callback:m,useCapture:p,type:g})}}return r.sort(mg),r}function mg(t,n){return t.name==n.name?0:t.name<n.name?-1:1}function dg(t){if("undefined"!=typeof Element&&!(t instanceof Element))throw new Error("Expecting instance of DOM Element")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function gg(t){(function n(t){ngDevMode&&Ta(t,"component");const n=Ql(as(t));ngDevMode&&Ta(n[8],"rootContext should be defined"),(function e(t,n){if(0===t.flags&&t.clean==dl){let e;t.flags|=n,t.clean=new Promise((t=>e=t)),t.scheduler((()=>{if(1&t.flags&&(t.flags&=-2,Kl(t)),2&t.flags){t.flags&=-3;const n=t.playerHandler;n&&n.flushPlayers()}t.clean=dl,e(null)}))}})(n[8],1)})(t),og(t).forEach((t=>(function n(t){const n=as(t);$l(n[1],n,t)})(t)))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let pg=!1;function bg(t,n){if("undefined"==typeof COMPILED||!COMPILED){const e=ma;if(ngDevMode&&Ta(n,"function not defined"),e){let a=e.ng;a||(a=e.ng={}),a[t]=n}}}function ug(t,n){const e=Rr(t)[1],a=e.data.length-1;hi(e,{directiveStart:a,directiveEnd:a+1})}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function fg(t){return Object.getPrototypeOf(t.prototype).constructor}function hg(t){let n=fg(t.type),e=!0;const a=[t];for(;n;){let o;if(Vo(t))o=n.ɵcmp||n.ɵdir;else{if(n.ɵcmp)throw new Error("Directives cannot inherit Components");o=n.ɵdir}if(o){if(e){a.push(o);const n=t;n.inputs=_g(t.inputs),n.declaredInputs=_g(t.declaredInputs),n.outputs=_g(t.outputs);const e=o.hostBindings;e&&Og(t,e);const r=o.viewQuery,i=o.contentQueries;if(r&&Cg(t,r),i&&Mg(t,i),Ue(t.inputs,o.inputs),Ue(t.declaredInputs,o.declaredInputs),Ue(t.outputs,o.outputs),Vo(o)&&o.data.animation){const n=t.data;n.animation=(n.animation||[]).concat(o.data.animation)}}const n=o.features;if(n)for(let a=0;a<n.length;a++){const o=n[a];o&&o.ngInherit&&o(t),o===hg&&(e=!1)}}n=Object.getPrototypeOf(n)}!(function o(t){let n=0,e=null;for(let a=t.length-1;a>=0;a--){const o=t[a];o.hostVars=n+=o.hostVars,o.hostAttrs=Ri(o.hostAttrs,e=Ri(e,o.hostAttrs))}})(a)}function _g(t){return t===uo?{}:t===fo?[]:t}function Cg(t,n){const e=t.viewQuery;t.viewQuery=e?(t,a)=>{n(t,a),e(t,a)}:n}function Mg(t,n){const e=t.contentQueries;t.contentQueries=e?(t,a,o)=>{n(t,a,o),e(t,a,o)}:n}function Og(t,n){const e=t.hostBindings;t.hostBindings=e?(t,a)=>{n(t,a),e(t,a)}:n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Pg=["providersResolver"],xg=["template","decls","consts","vars","onPush","ngContentSelectors","styles","encapsulation","schemas"];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let yg=null;function kg(){if(!yg){const t=ma.Symbol;if(t&&t.iterator)yg=t.iterator;else{const t=Object.getOwnPropertyNames(Map.prototype);for(let n=0;n<t.length;++n){const e=t[n];"entries"!==e&&"size"!==e&&Map.prototype[e]===Map.prototype.entries&&(yg=e)}}}return yg}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function vg(t,n){const e=Sg(t),a=Sg(n);if(e&&a)return(function o(t,n,e){const a=t[kg()](),o=n[kg()]();for(;;){const t=a.next(),n=o.next();if(t.done&&n.done)return!0;if(t.done||n.done)return!1;if(!e(t.value,n.value))return!1}})(t,n,vg);{const o=t&&("object"==typeof t||"function"==typeof t),r=n&&("object"==typeof n||"function"==typeof n);return!(e||!o||a||!r)||Object.is(t,n)}}class wg{constructor(t){this.wrapped=t}static wrap(t){return new wg(t)}static unwrap(t){return wg.isWrapped(t)?t.wrapped:t}static isWrapped(t){return t instanceof wg}}function Sg(t){return!!Eg(t)&&(Array.isArray(t)||!(t instanceof Map)&&kg()in t)}function Eg(t){return null!==t&&("function"==typeof t||"object"==typeof t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Ag(t,n,e){return t[n]=e}function zg(t,n){return ngDevMode&&Na(t,n),ngDevMode&&Ea(t[n],Os,"Stored value should never be NO_CHANGE."),t[n]}function Rg(t,n,e){ngDevMode&&Ea(e,Os,"Incoming value should never be NO_CHANGE."),ngDevMode&&Aa(n,t.length,"Slot should have been initialized to NO_CHANGE");const a=t[n];if(Object.is(a,e))return!1;if(ngDevMode&&qr()){const o=a!==Os?a:void 0;if(!vg(o,e)){const r=(function o(t,n,e,a){const o=t[1].data,r=o[n];if("string"==typeof r)return r.indexOf(rr)>-1?mr(t,n,n,r,a):{propName:r,oldValue:e,newValue:a};if(null===r){let e=n-1;for(;"string"!=typeof o[e]&&null===o[e+1];)e--;const r=o[e];if("string"==typeof r){const o=r.match(new RegExp(rr,"g"));if(o&&o.length-1>n-e)return mr(t,e,n,r,a)}}return{propName:void 0,oldValue:e,newValue:a}})(t,n,o,e);!(function r(t,n,e,a){let o=`ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value${a?` for '${a}'`:""}: '${n}'. Current value: '${e}'.`;throw t&&(o+=" It seems like the view has been created after its parent and its children have been dirty checked. Has it been created in a change detection hook?"),new Error(o)})(a===Os,r.oldValue,r.newValue,r.propName)}return!1}return t[n]=e,!0}function Tg(t,n,e,a){const o=Rg(t,n,e);return Rg(t,n+1,a)||o}function Dg(t,n,e,a,o){const r=Tg(t,n,e,a);return Rg(t,n+2,o)||r}function Ig(t,n,e,a,o,r){const i=Tg(t,n,e,a);return Tg(t,n+2,o,r)||i}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Ng(t,n,e,a){const o=Br(),r=Kr();if(Rg(o,r,n)){const i=Vr(),c=bi();jl(c,o,t,n,e,a),ngDevMode&&em(i.data,c,"attr."+t,r)}return Ng}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Fg(t,n){ngDevMode&&Aa(2,n.length,"should have at least 3 values"),ngDevMode&&va(n.length%2,1,"should have an odd number of values");let e=!1,a=Jr();for(let o=1;o<n.length;o+=2)e=Rg(t,a++,n[o])||e;if(Qr(a),!e)return Os;let o=n[0];for(let t=1;t<n.length;t+=2)o+=$o(n[t])+n[t+1];return o}function Lg(t,n,e,a){return Rg(t,Kr(),e)?n+$o(e)+a:Os}function Hg(t,n,e,a,o,r){const i=Tg(t,Jr(),e,o);return $r(2),i?n+$o(e)+a+$o(o)+r:Os}function Bg(t,n,e,a,o,r,i,c){const s=Dg(t,Jr(),e,o,i);return $r(3),s?n+$o(e)+a+$o(o)+r+$o(i)+c:Os}function Vg(t,n,e,a,o,r,i,c,s,l){const m=Ig(t,Jr(),e,o,i,s);return $r(4),m?n+$o(e)+a+$o(o)+r+$o(i)+c+$o(s)+l:Os}function jg(t,n,e,a,o,r,i,c,s,l,m,d){const g=Jr();let p=Ig(t,g,e,o,i,s);return p=Rg(t,g+4,m)||p,$r(5),p?n+$o(e)+a+$o(o)+r+$o(i)+c+$o(s)+l+$o(m)+d:Os}function Ug(t,n,e,a,o,r,i,c,s,l,m,d,g,p){const b=Jr();let u=Ig(t,b,e,o,i,s);return u=Tg(t,b+4,m,g)||u,$r(6),u?n+$o(e)+a+$o(o)+r+$o(i)+c+$o(s)+l+$o(m)+d+$o(g)+p:Os}function Wg(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u){const f=Jr();let h=Ig(t,f,e,o,i,s);return h=Dg(t,f+4,m,g,b)||h,$r(7),h?n+$o(e)+a+$o(o)+r+$o(i)+c+$o(s)+l+$o(m)+d+$o(g)+p+$o(b)+u:Os}function Gg(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h){const _=Jr();let C=Ig(t,_,e,o,i,s);return C=Ig(t,_+4,m,g,b,f)||C,$r(8),C?n+$o(e)+a+$o(o)+r+$o(i)+c+$o(s)+l+$o(m)+d+$o(g)+p+$o(b)+u+$o(f)+h:Os}function Yg(t,n,e,a,o,r,i,c){const s=Br(),l=Vr(),m=t+To,d=l.firstCreatePass?(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function g(t,n,e,a,o,r,i,c,s){ngDevMode&&Xo(n),ngDevMode&&ngDevMode.firstCreatePass++;const l=n.consts,m=ul(n,t,0,i||null,Ir(l,c));Rl(n,e,m,Ir(l,s)),hi(n,m);const d=m.tViews=yl(2,m,a,o,r,n.directiveRegistry,n.pipeRegistry,null,n.schemas,l);return null!==n.queries&&(n.queries.template(n,m),d.queries=n.queries.embeddedTView(m)),m})(t,l,s,n,e,a,o,r,i):l.data[m];Wr(d,!1);const p=s[11].createComment(ngDevMode?"container":"");Om(l,s,p,d),os(p,s),Jl(s,s[m]=Yl(p,s,p,d)),Bo(d)&&Ol(l,s,d),null!=i&&Pl(s,d,c)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function qg(t){return Er((function n(){return Lr.lFrame.contextLView})(),t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Zg(t,n=Ve.Default){const e=Br();return null===e?(ngDevMode&&(function a(t){ngDevMode&&wa(Wa,t,"Calling ɵɵinject would cause infinite recursion")})(Zg),Za(t,n)):Gi(Ur(),e,oa(t),n)}function Xg(t){return(function n(t,e){if(ngDevMode&&wi(t,[0,2,3]),ngDevMode&&Ta(t,"expecting tNode"),"class"===e)return t.classes;if("style"===e)return t.styles;const a=t.attrs;if(a){const t=a.length;let n=0;for(;n<t;){const o=a[n];if(Ai(o))break;if(0===o)n+=2;else if("number"==typeof o)for(n++;n<t&&"string"==typeof a[n];)n++;else{if(o===e)return a[n+1];n+=2}}}return null})(Ur(),t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function Jg(t,n,e){const a=Br(),o=Kr();if(Rg(a,o,n)){const r=Vr(),i=bi();wl(r,i,a,t,n,a[11],e,!1),ngDevMode&&em(r.data,i,t,o)}return Jg}function Qg(t,n,e,a,o){const r=o?"class":"style";cm(t,e,n.inputs[r],r,a)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Kg(t,n,e,a){const o=Br(),r=Vr(),i=To+t;ngDevMode&&va(Jr(),r.bindingStartIndex,"elements should be created before any bindings"),ngDevMode&&ngDevMode.rendererCreateElement++,ngDevMode&&Na(o,i);const c=o[11],s=o[i]=pl(n,c,(function l(){return Lr.lFrame.currentNamespace})()),m=r.firstCreatePass?(function d(t,n,e,a,o,r,i){ngDevMode&&Xo(n),ngDevMode&&ngDevMode.firstCreatePass++;const c=n.consts,s=ul(n,t,2,o,Ir(c,r)),l=Rl(n,e,s,Ir(c,i));return ngDevMode&&(function m(t,n,e,a){if(null===t.schemas)return;const o=e.tagName;if(!a&&null!==o&&("undefined"!=typeof HTMLUnknownElement&&HTMLUnknownElement&&n instanceof HTMLUnknownElement||"undefined"!=typeof customElements&&o.indexOf("-")>-1&&!customElements.get(o))&&!Al(t,o)){let t=`'${o}' is not a known element:\n`;t+=`1. If '${o}' is an Angular component, then verify that it is part of this module.\n`,o&&o.indexOf("-")>-1?t+=`2. If '${o}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.`:t+="2. To allow any element add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.",console.error(t)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(n,a,s,l),null!==s.attrs&&tg(s,s.attrs,!1),null!==s.mergedAttrs&&tg(s,s.mergedAttrs,!0),null!==n.queries&&n.queries.elementStart(n,s),s})(t,r,o,s,n,e,a):r.data[i];Wr(m,!0);const g=m.mergedAttrs;null!==g&&Ei(c,s,g);const p=m.classes;null!==p&&Am(c,s,p);const b=m.styles;null!==b&&Em(c,s,b),Om(r,o,s,m),0===(function u(){return Lr.lFrame.elementDepthCount})()&&os(s,o),(function f(){Lr.lFrame.elementDepthCount++})(),Bo(m)&&(Ol(r,o,m),Ml(r,m,o)),null!==a&&Pl(o,m)}function $g(){let t=Ur();ngDevMode&&Ta(t,"No parent node to close."),Gr()?Yr():(ngDevMode&&Go(Ur()),t=t.parent,Wr(t,!1));const n=t;ngDevMode&&vi(n,2),(function e(){Lr.lFrame.elementDepthCount--})();const a=Vr();a.firstCreatePass&&(hi(a,t),Lo(t)&&a.queries.elementEnd(t)),null!=n.classesWithoutHost&&(function o(t){return 0!=(16&t.flags)})(n)&&Qg(a,n,Br(),n.classesWithoutHost,!0),null!=n.stylesWithoutHost&&(function r(t){return 0!=(32&t.flags)})(n)&&Qg(a,n,Br(),n.stylesWithoutHost,!1)}function tp(t,n,e,a){Kg(t,n,e,a),$g()}function np(t,n,e){const a=Br(),o=Vr(),r=t+To;ngDevMode&&Na(a,r),ngDevMode&&va(Jr(),o.bindingStartIndex,"element containers should be created before any bindings");const i=o.firstCreatePass?(function c(t,n,e,a,o){ngDevMode&&ngDevMode.firstCreatePass++;const r=n.consts,i=Ir(r,a),c=ul(n,t,3,"ng-container",i);return null!==i&&tg(c,i,!0),Rl(n,e,c,Ir(r,o)),null!==n.queries&&n.queries.elementStart(n,c),c})(t,o,a,n,e):o.data[r];Wr(i,!0),ngDevMode&&ngDevMode.rendererCreateComment++;const s=a[r]=a[11].createComment(ngDevMode?"ng-container":"");Om(o,a,s,i),os(s,a),Bo(i)&&(Ol(o,a,i),Ml(o,i,a)),null!=e&&Pl(a,i)}function ep(){let t=Ur();const n=Vr();Gr()?Yr():(ngDevMode&&Go(t),t=t.parent,Wr(t,!1)),ngDevMode&&vi(t,3),n.firstCreatePass&&(hi(n,t),Lo(t)&&n.queries.elementEnd(t))}function ap(t,n,e){np(t,n,e),ep()}function op(){return Br()}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function rp(t){return!!t&&"function"==typeof t.then}function ip(t){return!!t&&"function"==typeof t.subscribe}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function cp(t,n,e=!1,a){const o=Br(),r=Vr(),i=Ur();return lp(r,o,o[11],i,t,n,e,a),cp}function sp(t,n,e=!1,a){const o=Ur(),r=Br(),i=Vr();return lp(i,r,rm(ei(i.data),o,r),o,t,n,e,a),sp}function lp(t,n,e,a,o,r,i=!1,c){const s=Bo(a),l=t.firstCreatePass&&(t.cleanup||(t.cleanup=[])),m=om(n);ngDevMode&&wi(a,[2,0,3]);let d=!0;if(2===a.type){const g=wr(a,n),p=c?c(g):uo,b=p.target||g,u=m.length,f=c?t=>c(kr(t[a.index])).target:a.index;if(xr(e)){let i=null;if(!c&&s&&(i=(function g(t,n,e,a){const o=t.cleanup;if(null!=o)for(let t=0;t<o.length-1;t+=2){const r=o[t];if(r===e&&o[t+1]===a){const e=n[7],a=o[t+2];return e.length>a?e[a]:null}"string"==typeof r&&(t+=2)}return null})(t,n,o,a.index)),null!==i)(i.__ngLastListenerFn__||i).__ngNextListenerFn__=r,i.__ngLastListenerFn__=r,d=!1;else{r=dp(a,n,r,!1);const t=e.listen(p.name||b,o,r);ngDevMode&&ngDevMode.rendererAddEventListener++,m.push(r,t),l&&l.push(o,f,u,u+1)}}else r=dp(a,n,r,!0),b.addEventListener(o,r,i),ngDevMode&&ngDevMode.rendererAddEventListener++,m.push(r),l&&l.push(o,f,u,i)}const p=a.outputs;let b;if(d&&null!==p&&(b=p[o])){const t=b.length;if(t)for(let e=0;e<t;e+=2){const t=b[e];ngDevMode&&Na(n,t);const i=b[e+1],c=n[t],s=c[i];if(ngDevMode&&!ip(s))throw new Error(`@Output ${i} not initialized in '${c.constructor.name}'.`);const d=s.subscribe(r),g=m.length;m.push(r,d),l&&l.push(o,a.index,g,-(g+1))}}}function mp(t,n,e){try{return!1!==n(e)}catch(n){return im(t,n),!1}}function dp(t,n,e,a){return function o(r){if(r===Function)return e;const i=2&t.flags?Ar(t.index,n):n;0==(32&n[2])&&Ql(i);let c=mp(n,e,r),s=o.__ngNextListenerFn__;for(;s;)c=mp(n,s,r)&&c,s=s.__ngNextListenerFn__;return a&&!1===c&&(r.preventDefault(),r.returnValue=!1),c}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function gp(t=1){return(function n(t){return(Lr.lFrame.contextLView=(function n(t,e){for(;t>0;)ngDevMode&&Ta(e[15],"Declaration view should be defined if nesting level is greater than 0."),e=e[15],t--;return e})(t,Lr.lFrame.contextLView))[8]})(t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function pp(t,n){let e=null;const a=(function o(t){const n=t.attrs;if(null!=n){const t=n.indexOf(5);if(0==(1&t))return n[t+1]}return null})(t);for(let o=0;o<n.length;o++){const r=n[o];if("*"!==r){if(null===a?hs(t,r,!0):_s(a,r))return o}else e=o}return e}function bp(t){const n=Br()[16][6];if(!n.projection){const e=n.projection=co(t?t.length:1,null),a=e.slice();let o=n.child;for(;null!==o;){const n=t?pp(o,t):0;null!==n&&(a[n]?a[n].projectionNext=o:e[n]=o,a[n]=o),o=o.next}}}let up=!1;function fp(t){up=t}function hp(t,n=0,e){const a=Br(),o=Vr(),r=ul(o,t,1,null,e||null);null===r.projection&&(r.projection=n),Yr(),up||wm(o,a,r)}function _p(t,n,e){return Cp(t,"",n,"",e),_p}function Cp(t,n,e,a,o){const r=Br(),i=Lg(r,n,e,a);if(i!==Os){const e=Vr(),c=bi();wl(e,c,r,t,i,r[11],o,!1),ngDevMode&&em(e.data,c,t,Jr()-1,n,a)}return Cp}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Mp=[];function Op(t,n,e,a,o){const r=t[e+1],i=null===n;let c=a?As(r):Ts(r),s=!1;for(;0!==c&&(!1===s||i);){ngDevMode&&Na(t,c);const e=t[c+1];Pp(t[c],n)&&(s=!0,t[c+1]=a?Ns(e):Rs(e)),c=a?As(e):Ts(e)}s&&(t[e+1]=a?Rs(r):Ns(r))}function Pp(t,n){return ngDevMode&&wa(Array.isArray(n),!0,"Expected that 'tStylingKey' has been unwrapped"),null===t||null==n||(Array.isArray(t)?t[1]:t)===n||!(!Array.isArray(t)||"string"!=typeof n)&&mo(t,n)>=0}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */("undefined"==typeof ngDevMode||ngDevMode)&&Pa()&&(Object.freeze({}),Object.freeze(Mp));const xp={textEnd:0,key:0,keyEnd:0,value:0,valueEnd:0};function yp(t){return t.substring(xp.key,xp.keyEnd)}function kp(t){return t.substring(xp.value,xp.valueEnd)}function vp(t,n){const e=xp.textEnd;return e===n?-1:(n=xp.keyEnd=(function a(t,n,e){for(;n<e&&t.charCodeAt(n)>32;)n++;return n})(t,xp.key=n,e),Ep(t,n,e))}function wp(t,n){const e=xp.textEnd;let a=xp.key=Ep(t,n,e);return e===a?-1:(a=xp.keyEnd=(function o(t,n,e){let a;for(;n<e&&(45===(a=t.charCodeAt(n))||95===a||(-33&a)>=65&&(-33&a)<=90||a>=48&&a<=57);)n++;return n})(t,a,e),a=Ap(t,a,e,58),a=xp.value=Ep(t,a,e),a=xp.valueEnd=(function r(t,n,e){let a=-1,o=-1,r=-1,i=n,c=i;for(;i<e;){const s=t.charCodeAt(i++);if(59===s)return c;34===s||39===s?c=i=zp(t,s,i,e):n===i-4&&85===r&&82===o&&76===a&&40===s?c=i=zp(t,41,i,e):s>32&&(c=i),r=o,o=a,a=-33&s}return c})(t,a,e),Ap(t,a,e,59))}function Sp(t){xp.key=0,xp.keyEnd=0,xp.value=0,xp.valueEnd=0,xp.textEnd=t.length}function Ep(t,n,e){for(;n<e&&t.charCodeAt(n)<=32;)n++;return n}function Ap(t,n,e,a){return(n=Ep(t,n,e))<e&&(ngDevMode&&t.charCodeAt(n)!==a&&Rp(t,String.fromCharCode(a),n),n++),n}function zp(t,n,e,a){let o=-1,r=e;for(;r<a;){const e=t.charCodeAt(r++);if(e==n&&92!==o)return r;o=92==e&&92===o?0:e}throw ngDevMode?Rp(t,String.fromCharCode(n),a):new Error}function Rp(t,n,e){throw ngDevMode&&va("string"==typeof t,!0,"String expected here"),Da(`Malformed style at location ${e} in string '`+t.substring(0,e)+"[>>"+t.substring(e,e+1)+"<<]"+t.substr(e+1)+`'. Expecting '${n}'.`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Tp(t,n,e){return Hp(t,n,e,!1),Tp}function Dp(t,n){return Hp(t,n,null,!0),Dp}function Ip(t){Bp(Gp,Np,t,!1)}function Np(t,n){for(let e=(function e(t){return Sp(t),wp(t,Ep(t,0,xp.textEnd))})(n);e>=0;e=wp(n,e))Gp(t,yp(n),kp(n))}function Fp(t){Bp(so,Lp,t,!0)}function Lp(t,n){for(let e=(function e(t){return Sp(t),vp(t,Ep(t,0,xp.textEnd))})(n);e>=0;e=vp(n,e))so(t,yp(n),!0)}function Hp(t,n,e,a){const o=Br(),r=Vr(),i=$r(2);r.firstUpdatePass&&jp(r,t,i,a),n!==Os&&Rg(o,i,n)&&Yp(r,r.data[gi()+To],o,o[11],t,o[i+1]=(function c(t,n){return null==t||("string"==typeof n?t+=n:"object"==typeof t&&(t=ta(pc(t)))),t})(n,e),a,i)}function Bp(t,n,e,a){const o=Vr(),r=$r(2);o.firstUpdatePass&&jp(o,null,r,a);const i=Br();if(e!==Os&&Rg(i,r,e)){const c=o.data[gi()+To];if(Xp(c,a)&&!Vp(o,r)){if(ngDevMode){const t=o.data[r];va(Array.isArray(t)?t[1]:t,!1,"Styling linked list shadow input should be marked as 'false'")}let t=a?c.classesWithoutHost:c.stylesWithoutHost;ngDevMode&&!1===a&&null!==t&&va(t.endsWith(";"),!0,"Expecting static portion to end with ';'"),null!==t&&(e=na(t,e||"")),Qg(o,c,i,e,a)}else!(function s(t,n,e,a,o,r,i,c){o===Os&&(o=Mp);let s=0,l=0,m=0<o.length?o[0]:null,d=0<r.length?r[0]:null;for(;null!==m||null!==d;){ngDevMode&&Aa(s,999,"Are we stuck in infinite loop?"),ngDevMode&&Aa(l,999,"Are we stuck in infinite loop?");const g=s<o.length?o[s+1]:void 0,p=l<r.length?r[l+1]:void 0;let b,u=null;m===d?(s+=2,l+=2,g!==p&&(u=d,b=p)):null===d||null!==m&&m<d?(s+=2,u=m):(ngDevMode&&Ta(d,"Expecting to have a valid key"),l+=2,u=d,b=p),null!==u&&Yp(t,n,e,a,u,b,i,c),m=s<o.length?o[s]:null,d=l<r.length?r[l]:null}})(o,c,i,i[11],i[r+1],i[r+1]=(function c(t,n,e){if(null==e||""===e)return Mp;const a=[],o=pc(e);if(Array.isArray(o))for(let n=0;n<o.length;n++)t(a,o[n],!0);else if("object"==typeof o)for(const n in o)o.hasOwnProperty(n)&&t(a,n,o[n]);else"string"==typeof o?n(a,o):ngDevMode&&Da("Unsupported styling type "+typeof o+": "+o);return a})(t,n,e),a,r)}}function Vp(t,n){return n>=t.expandoStartIndex}function jp(t,n,e,a){ngDevMode&&Jo(t);const o=t.data;if(null===o[e+1]){const r=o[gi()+To],i=Vp(t,e);Xp(r,a)&&null===n&&!i&&(n=!1),n=(function r(t,n,e,a){const o=ei(t);let r=a?n.residualClasses:n.residualStyles;if(null===o)0===(a?n.classBindings:n.styleBindings)&&(e=Wp(e=Up(null,t,n,e,a),n.attrs,a),r=null);else{const i=n.directiveStylingLast;if(-1===i||t[i]!==o)if(e=Up(o,t,n,e,a),null===r){let e=(function i(t,n,e){const a=e?n.classBindings:n.styleBindings;if(0!==Ts(a))return t[As(a)]})(t,n,a);void 0!==e&&Array.isArray(e)&&(e=Up(null,t,n,e[1],a),e=Wp(e,n.attrs,a),(function c(t,n,e,a){const o=e?n.classBindings:n.styleBindings;ngDevMode&&wa(Ts(o),0,"Expecting to have at least one template styling binding."),t[As(o)]=a})(t,n,a,e))}else r=(function s(t,n,e){let a;const o=n.directiveEnd;ngDevMode&&wa(n.directiveStylingLast,-1,"By the time this function gets called at least one hostBindings-node styling instruction must have executed.");for(let r=1+n.directiveStylingLast;r<o;r++)a=Wp(a,t[r].hostAttrs,e);return Wp(a,n.attrs,e)})(t,n,a)}return void 0!==r&&(a?n.residualClasses=r:n.residualStyles=r),e})(o,r,n,a),(function i(t,n,e,a,o,r){ngDevMode&&Jo(Vr());let i=r?n.classBindings:n.styleBindings,c=As(i),s=Ts(i);t[a]=e;let l,m=!1;if(Array.isArray(e)){const t=e;l=t[1],(null===l||mo(t,l)>0)&&(m=!0)}else l=e;if(o)if(0!==s){const n=As(t[c+1]);t[a+1]=Es(n,c),0!==n&&(t[n+1]=Ds(t[n+1],a)),t[c+1]=(function d(t,n){return ngDevMode&&xa(t,"expected number"),ngDevMode&&ya(n,0,32767),131071&t|n<<17})(t[c+1],a)}else t[a+1]=Es(c,0),0!==c&&(t[c+1]=Ds(t[c+1],a)),c=a;else t[a+1]=Es(s,0),ngDevMode&&va(0!==c&&0===s,!1,"Adding template bindings after hostBindings is not allowed."),0===c?c=a:t[s+1]=Ds(t[s+1],a),s=a;m&&(t[a+1]=Rs(t[a+1])),Op(t,l,a,!0),Op(t,l,a,!1),(function g(t,n,e,a,o){const r=o?t.residualClasses:t.residualStyles;null!=r&&"string"==typeof n&&mo(r,n)>=0&&(e[a+1]=Ns(e[a+1]))})(n,l,t,a,r),i=Es(c,s),r?n.classBindings=i:n.styleBindings=i})(o,r,n,e,i,a)}}function Up(t,n,e,a,o){let r=null;const i=e.directiveEnd;let c=e.directiveStylingLast;for(-1===c?c=e.directiveStart:c++;c<i&&(r=n[c],ngDevMode&&Ta(r,"expected to be defined"),a=Wp(a,r.hostAttrs,o),r!==t);)c++;return null!==t&&(e.directiveStylingLast=c),a}function Wp(t,n,e){const a=e?1:2;let o=-1;if(null!==n)for(let r=0;r<n.length;r++){const i=n[r];"number"==typeof i?o=i:o===a&&(Array.isArray(t)||(t=void 0===t?[]:["",t]),so(t,i,!!e||n[++r]))}return void 0===t?null:t}function Gp(t,n,e){so(t,n,pc(e))}function Yp(t,n,e,a,o,r,i,c){if(2!==n.type)return;const s=t.data,l=s[c+1];Zp(Is(l)?qp(s,n,e,o,Ts(l),i):void 0)||(Zp(r)||zs(l)&&(r=qp(s,null,e,o,c,i)),(function m(t,n,e,a,o){const r=xr(t);if(n)o?(ngDevMode&&ngDevMode.rendererAddClass++,r?t.addClass(e,a):(ngDevMode&&Ta(e.classList,"HTMLElement expected"),e.classList.add(a))):(ngDevMode&&ngDevMode.rendererRemoveClass++,r?t.removeClass(e,a):e.classList.remove(a));else{const n=-1==a.indexOf("-")?void 0:2;null==o?(ngDevMode&&ngDevMode.rendererRemoveStyle++,r?t.removeStyle(e,a,n):e.style.removeProperty(a)):(ngDevMode&&ngDevMode.rendererSetStyle++,r?t.setStyle(e,a,o,n):(ngDevMode&&Ta(e.style,"HTMLElement expected"),e.style.setProperty(a,o)))}})(a,i,vr(gi(),e),o,r))}function qp(t,n,e,a,o,r){const i=null===n;let c;for(;o>0;){const n=t[o],r=Array.isArray(n),s=r?n[1]:n,l=null===s;let m=e[o+1];m===Os&&(m=l?Mp:void 0);let d=l?lo(m,a):s===a?m:void 0;if(r&&!Zp(d)&&(d=lo(n,a)),Zp(d)&&(c=d,i))return c;const g=t[o+1];o=i?As(g):Ts(g)}if(null!==n){let t=r?n.residualClasses:n.residualStyles;null!=t&&(c=lo(t,a))}return c}function Zp(t){return void 0!==t}function Xp(t,n){return 0!=(t.flags&(n?16:32))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Jp(t,n=""){const e=Br(),a=Vr(),o=t+To;ngDevMode&&va(Jr(),a.bindingStartIndex,"text nodes should be created before any bindings"),ngDevMode&&Na(e,o);const r=a.firstCreatePass?ul(a,t,2,null,null):a.data[o],i=e[o]=mm(n,e[11]);Om(a,e,i,r),Wr(r,!1)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Qp(t){return Kp("",t,""),Qp}function Kp(t,n,e){const a=Br(),o=Lg(a,t,n,e);return o!==Os&&sm(a,gi(),o),Kp}function $p(t,n,e,a,o){const r=Br(),i=Hg(r,t,n,e,a,o);return i!==Os&&sm(r,gi(),i),$p}function tb(t,n,e,a,o,r,i){const c=Br(),s=Bg(c,t,n,e,a,o,r,i);return s!==Os&&sm(c,gi(),s),tb}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function nb(t,n,e){Bp(so,Lp,Lg(Br(),t,n,e),!0)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function eb(t,n,e){const a=Br(),o=Kr();if(Rg(a,o,n)){const r=Vr(),i=bi();wl(r,i,a,t,n,a[11],e,!0),ngDevMode&&em(r.data,i,t,o)}return eb}function ab(t,n,e){const a=Br(),o=Kr();if(Rg(a,o,n)){const r=Vr(),i=bi();wl(r,i,a,t,n,rm(ei(r.data),i,a),e,!0),ngDevMode&&em(r.data,i,t,o)}return ab}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */"undefined"==typeof ngI18nClosureMode&&(ma.ngI18nClosureMode="undefined"!=typeof goog&&"function"==typeof goog.getMsg);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const ob=void 0;var rb=["en",[["a","p"],["AM","PM"],ob],[["AM","PM"],ob,ob],[["S","M","T","W","T","F","S"],["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],["Su","Mo","Tu","We","Th","Fr","Sa"]],ob,[["J","F","M","A","M","J","J","A","S","O","N","D"],["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],["January","February","March","April","May","June","July","August","September","October","November","December"]],ob,[["B","A"],["BC","AD"],["Before Christ","Anno Domini"]],0,[6,0],["M/d/yy","MMM d, y","MMMM d, y","EEEE, MMMM d, y"],["h:mm a","h:mm:ss a","h:mm:ss a z","h:mm:ss a zzzz"],["{1}, {0}",ob,"{1} 'at' {0}",ob],[".",",",";","%","+","-","E","×","‰","∞","NaN",":"],["#,##0.###","#,##0%","¤#,##0.00","#E0"],"USD","$","US Dollar",{},"ltr",function ib(t){let n=Math.floor(Math.abs(t)),e=t.toString().replace(/^[^.]*\.?/,"").length;return 1===n&&0===e?1:5}];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let cb={};function sb(t){const n=(function e(t){return t.toLowerCase().replace(/_/g,"-")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t);let a=mb(n);if(a)return a;const o=n.split("-")[0];if(a=mb(o),a)return a;if("en"===o)return rb;throw new Error(`Missing locale data for the locale "${t}".`)}function lb(t){return sb(t)[db.PluralCase]}function mb(t){return t in cb||(cb[t]=ma.ng&&ma.ng.common&&ma.ng.common.locales&&ma.ng.common.locales[t]),cb[t]}var db;!(function(t){t[t.LocaleId=0]="LocaleId",t[t.DayPeriodsFormat=1]="DayPeriodsFormat",t[t.DayPeriodsStandalone=2]="DayPeriodsStandalone",t[t.DaysFormat=3]="DaysFormat",t[t.DaysStandalone=4]="DaysStandalone",t[t.MonthsFormat=5]="MonthsFormat",t[t.MonthsStandalone=6]="MonthsStandalone",t[t.Eras=7]="Eras",t[t.FirstDayOfWeek=8]="FirstDayOfWeek",t[t.WeekendRange=9]="WeekendRange",t[t.DateFormat=10]="DateFormat",t[t.TimeFormat=11]="TimeFormat",t[t.DateTimeFormat=12]="DateTimeFormat",t[t.NumberSymbols=13]="NumberSymbols",t[t.NumberFormats=14]="NumberFormats",t[t.CurrencyCode=15]="CurrencyCode",t[t.CurrencySymbol=16]="CurrencySymbol",t[t.CurrencyName=17]="CurrencyName",t[t.Currencies=18]="Currencies",t[t.Directionality=19]="Directionality",t[t.PluralCase=20]="PluralCase",t[t.ExtraData=21]="ExtraData"})(db||(db={}));const gb=["zero","one","two","few","many"],pb="en-US",bb={marker:"element"},ub={marker:"comment"};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let fb=pb;function hb(t){Ta(t,"Expected localeId to be defined"),"string"==typeof t&&(fb=t.toLowerCase().replace(/_/g,"-"))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const _b=[];let Cb=-1,Mb=0,Ob=0;function Pb(t,n,e,a){const o=a[11];let r=null,i=null;const c=[];for(let s=0;s<e.length;s++){const l=e[s];if("string"==typeof l){const n=mm(l,o),m=e[++s];ngDevMode&&ngDevMode.rendererCreateTextNode++,i=r,r=Eb(t,a,m,2,n,null),c.push(m),Yr()}else if("number"==typeof l)switch(7&l){case 1:const o=l>>>17;let m;m=o===n?a[6]:Sr(t,o),ngDevMode&&Ta(r,"You need to create or select a node before you can insert it into the DOM"),i=wb(t,r,m,i,a);break;case 0:const d=l>=0,g=(d?l:~l)>>>3;c.push(g),i=r,r=Sr(t,g),r&&Wr(r,d);break;case 5:i=r=Sr(t,l>>>3),Wr(r,!1);break;case 4:const p=e[++s],b=e[++s];jl(Sr(t,l>>>3),a,p,b,null,null);break;default:throw new Error(`Unable to determine the type of mutate operation for "${l}"`)}else switch(l){case ub:const n=e[++s],m=e[++s];ngDevMode&&va(typeof n,"string",`Expected "${n}" to be a comment node value`);const d=o.createComment(n);ngDevMode&&ngDevMode.rendererCreateComment++,i=r,r=Eb(t,a,m,4,d,null),c.push(m),os(d,a),Yr();break;case bb:const g=e[++s],p=e[++s];ngDevMode&&va(typeof g,"string",`Expected "${g}" to be an element node tag name`);const b=o.createElement(g);ngDevMode&&ngDevMode.rendererCreateElement++,i=r,r=Eb(t,a,p,2,b,g),c.push(p);break;default:throw new Error(`Unable to determine the type of mutate operation for "${l}"`)}}return Yr(),c}function xb(t,n,e,a,o,r){let i=!1;for(let c=0;c<a.length;c++){const s=a[c],l=a[++c];if(s&r){let r="";for(let s=c+1;s<=c+l;s++){const c=a[s];if("string"==typeof c)r+=c;else if("number"==typeof c)if(c<0)r+=$o(e[o-c]);else{const l=c>>>2;switch(3&c){case 1:const c=a[++s],m=a[++s];wl(t,Sr(t,l),e,c,r,e[11],m,!1);break;case 0:sm(e,l,r);break;case 2:i=kb(t,n,a[++s],e,r);break;case 3:yb(t,n,a[++s],o,e,i)}}}}c+=l}}function yb(t,n,e,a,o,r){ngDevMode&&Na(n,e);const i=n[e];ngDevMode&&Na(o,i.currentCaseLViewIndex);const c=o[i.currentCaseLViewIndex];null!==c&&xb(t,n,o,i.update[c],a,r?-1:Mb)}function kb(t,n,e,a,o){vb(t,n,e,a);let r=!1;const i=n[e],c=(function s(t,n){let e=t.cases.indexOf(n);if(-1===e)switch(t.type){case 1:{const a=(function o(t,n){const e=lb(n)(parseInt(t,10)),a=gb[e];return void 0!==a?a:"other"})(n,(function a(){return fb})());e=t.cases.indexOf(a),-1===e&&"other"!==a&&(e=t.cases.indexOf("other"));break}case 0:e=t.cases.indexOf("other")}return e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(i,o);return a[i.currentCaseLViewIndex]=-1!==c?c:null,c>-1&&(Pb(t,-1,i.create[c],a),r=!0),r}function vb(t,n,e,a){ngDevMode&&Na(n,e);const o=n[e],r=a[o.currentCaseLViewIndex];if(null!==r){const e=o.remove[r];for(let o=0;o<e.length;o++){const r=e[o],i=r>>>3;switch(7&r){case 3:Sb(t,a,i,!1);break;case 6:vb(t,n,i,a)}}}}function wb(t,n,e,a,o){ngDevMode&&ngDevMode.rendererMoveNode++;const r=n.next;a||(a=e),a===e&&n!==e.child?(n.next=e.child,null===n.parent?t.firstChild=n:e.child=n):a!==e&&n!==a.next?(n.next=a.next,a.next=n):n.next=null,e!==o[6]&&(n.parent=e);let i=n.next;for(;i;)i.next===n&&(i.next=r),i=i.next;if(1===n.type)return wm(t,o,n),n;Om(t,o,wr(n,o),n);const c=o[n.index];return 0!==n.type&&Fo(c)&&Om(t,o,c[7],n),n}function Sb(t,n,e,a){const o=Sr(t,e),r=vr(e,n);r&&ym(n[11],r);const i=Er(n,e);if(Fo(i)){const t=i;0!==o.type&&ym(n[11],t[7])}a&&o&&(o.flags|=64),ngDevMode&&ngDevMode.rendererRemoveNode++}function Eb(t,n,e,a,o,r){const i=Ur();ngDevMode&&Na(n,e+To),n[e+To]=o;const c=ul(t,e,a,r,null);return i&&i.next===c&&(i.next=null),c}function Ab(t){const n=new Rb(t||(Array.isArray(this)?this:[]));let e=[];function a(t){const e=t>>>2;switch(3&t){case 0:return`(lView[${e}] as Text).textContent = $$$`;case 1:const t=n.consumeString(),a=n.consumeFunction();return`(lView[${e}] as Element).setAttribute('${t}', ${a?`(${a})($$$)`:"$$$"})`;case 2:return`icuSwitchCase(lView[${e}] as Comment, ${n.consumeNumber()}, $$$)`;case 3:return`icuUpdateCase(lView[${e}] as Comment, ${n.consumeNumber()})`}throw new Error("unexpected OpCode")}for(;n.hasMore();){let t=n.consumeNumber(),o=n.consumeNumber();const r=n.i+o,i=[];let c="";for(;n.i<r;){let t=n.consumeNumberOrString();if("string"==typeof t)c+=t;else if(t<0)c+="${lView["+(0-t)+"]}";else{const n=a(t);i.push(n.replace("$$$","`"+c+"`")+";"),c=""}}e.push(`if (mask & 0b${t.toString(2)}) { ${i.join(" ")} }`)}return e}function zb(t){const n=new Rb(t||(Array.isArray(this)?this:[]));let e=[];function a(t){const e=(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function a(t){return t>>>17})(t),r=(function i(t){return(131064&t)>>>3})(t);switch((function c(t){return 7&t})(t)){case 0:return o=r,"";case 1:return`(lView[${e}] as Element).appendChild(lView[${o}])`;case 3:return`(lView[${e}] as Element).remove(lView[${r}])`;case 4:return`(lView[${r}] as Element).setAttribute("${n.consumeString()}", "${n.consumeString()}")`;case 5:return`setCurrentTNode(tView.data[${r}] as TNode)`;case 6:return`removeNestedICU(${r})`}throw new Error("Unexpected OpCode")}let o=-1;for(;n.hasMore();){let t=n.consumeNumberStringOrMarker();if(t===ub){const t=n.consumeString();o=n.consumeNumber(),e.push(`lView[${o}] = document.createComment("${t}")`)}else if(t===bb){const t=n.consumeString();o=n.consumeNumber(),e.push(`lView[${o}] = document.createElement("${t}")`)}else if("string"==typeof t)o=n.consumeNumber(),e.push(`lView[${o}] = document.createTextNode("${t}")`);else{if("number"!=typeof t)throw new Error("Unexpected value");{const n=a(t);n&&e.push(n)}}}return e}class Rb{constructor(t){this.i=0,this.codes=t}hasMore(){return this.i<this.codes.length}consumeNumber(){let t=this.codes[this.i++];return xa(t,"expecting number in OpCode"),t}consumeString(){let t=this.codes[this.i++];return ka(t,"expecting string in OpCode"),t}consumeFunction(){let t=this.codes[this.i++];if(null===t||"function"==typeof t)return t;throw new Error("expecting function in OpCode")}consumeNumberOrString(){let t=this.codes[this.i++];return"string"==typeof t||xa(t,"expecting number or string in OpCode"),t}consumeNumberStringOrMarker(){let t=this.codes[this.i++];return"string"==typeof t||"number"==typeof t||t==ub||t==bb||xa(t,"expecting number, string, COMMENT_MARKER or ELEMENT_MARKER in OpCode"),t}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Tb=/�(\d+):?\d*�/gi,Db=/({\s*�\d+:?\d*�\s*,\s*\S{6}\s*,[\s\S]*})/gi,Ib=/�(\d+)�/,Nb=/^\s*(�\d+:?\d*�)\s*,\s*(select|plural)\s*,/;let Fb;const Lb=[],Hb=/�\/?\*(\d+:\d+)�/gi,Bb=/�(\/?[#*!]\d+):?\d*�/gi,Vb=/\uE500/g;function jb(t,n,e,a=null){const o=[null,null];ngDevMode&&Ls(o,Ab);const r=t.split(Tb);let i=0;for(let t=0;t<r.length;t++){const n=r[t];if(1&t){const t=parseInt(n,10);o.push(-1-t),i|=Gb(t)}else""!==n&&o.push(n)}return o.push(n<<2|(e?1:0)),e&&o.push(e,a),o[0]=i,o[1]=o.length-2,o}function Ub(t,n=0){let e;n|=Gb(t.mainBinding);for(let a=0;a<t.values.length;a++){const o=t.values[a];for(let t=0;t<o.length;t++){const a=o[t];if("string"==typeof a)for(;e=Tb.exec(a);)n|=Gb(parseInt(e[1],10));else n=Ub(a,n)}}return n}function Wb(t){return t+Fb++}function Gb(t){return 1<<Math.min(t,31)}function Yb(t){return void 0===t}function qb(t){let n,e,a="",o=0,r=!1;for(;null!==(n=Hb.exec(t));)r?n[0]===`�/*${e}�`&&(o=n.index,r=!1):(a+=t.substring(o,n.index+n[0].length),e=n[1],r=!0);return ngDevMode&&va(r,!1,`Tag mismatch: unable to find the end of the sub-template in the translation "${t}"`),a+=t.substr(o),a}function Zb(t,n,e,a){const o=[],r=[],i=[],c=[],s=[],l=n.values;for(let n=0;n<l.length;n++){const m=l[n],d=[];for(let t=0;t<m.length;t++){const n=m[t];if("string"!=typeof n){const e=d.push(n)-1;m[t]=`\x3c!--�${e}�--\x3e`}}const g=Jb(m.join(""),e,d,t,a);o.push(g.create),r.push(g.remove),i.push(g.update),c.push(g.vars),s.push(g.childIcus)}t.push({type:n.type,vars:c,currentCaseLViewIndex:To+a+1,childIcus:s,cases:n.cases,create:o,remove:r,update:i}),Fb+=Math.max(...c)}function Xb(t){const n=[],e=[];let a=1,o=0;const r=Qb(t=t.replace(Nb,(function(t,n,e){return a="select"===e?0:1,o=parseInt(n.substr(1),10),""})));for(let t=0;t<r.length;){let o=r[t++].trim();1===a&&(o=o.replace(/\s*(?:=)?(\w+)\s*/,"$1")),o.length&&n.push(o);const i=Qb(r[t++]);n.length>e.length&&e.push(i)}return{type:a,mainBinding:o,cases:n,values:e}}function Jb(t,n,e,a,o){const r=Cc(Or()).getInertBodyElement(t);if(!r)throw new Error("Unable to generate inert body element");const i=qc(r)||r,c={vars:1,childIcus:[],create:[],remove:[],update:[]};return ngDevMode&&(Ls(c.create,zb),Ls(c.remove,zb),Ls(c.update,Ab)),Kb(i.firstChild,c,n,e,a,o),c}function Qb(t){if(!t)return[];let n=0;const e=[],a=[],o=/[{}]/g;let r;for(o.lastIndex=0;r=o.exec(t);){const o=r.index;if("}"==r[0]){if(e.pop(),0==e.length){const e=t.substring(n,o);Nb.test(e)?a.push(Xb(e)):a.push(e),n=o+1}}else{if(0==e.length){const e=t.substring(n,o);a.push(e),n=o+1}e.push("{")}}const i=t.substring(n);return a.push(i),a}function Kb(t,n,e,a,o,r){if(t){const i=[];for(;t;){const c=t.nextSibling,s=r+ ++n.vars;switch(t.nodeType){case Node.ELEMENT_NODE:const c=t,l=c.tagName.toLowerCase();if(Dc.hasOwnProperty(l)){n.create.push(bb,l,s,e<<17|1);const i=c.attributes;for(let t=0;t<i.length;t++){const e=i.item(t),a=e.name.toLowerCase();e.value.match(Tb)?Hc.hasOwnProperty(a)?eo(Ic[a]?jb(e.value,s,e.name,yc):Nc[a]?jb(e.value,s,e.name,kc):jb(e.value,s,e.name),n.update):ngDevMode&&console.warn(`WARNING: ignoring unsafe attribute value ${a} on element ${l} (see http://g.co/ng/security#xss)`):n.create.push(s<<3|4,e.name,e.value)}Kb(t.firstChild,n,s,a,o,r),n.remove.push(s<<3|3)}else n.vars--;break;case Node.TEXT_NODE:const m=t.textContent||"",d=m.match(Tb);n.create.push(d?"":m,s,e<<17|1),n.remove.push(s<<3|3),d&&eo(jb(m,s),n.update);break;case Node.COMMENT_NODE:const g=Ib.exec(t.textContent||"");if(g){const t=parseInt(g[1],10),o=ngDevMode?`nested ICU ${t}`:"";n.create.push(ub,o,s,e<<17|1),i.push([a[t],s])}else n.vars--;break;default:n.vars--}t=c}for(let t=0;t<i.length;t++){const e=i[t][0],a=i[t][1];Zb(o,e,a,r+n.vars);const c=o.length-1;n.vars+=Math.max(...o[c].vars),n.childIcus.push(c);const s=Ub(e);n.update.push(Gb(e.mainBinding),3,-1-e.mainBinding,a<<2|2,c,s,2,a<<2|3,c),n.remove.push(c<<3|6,a<<3|3)}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const $b=/\[(�.+?�?)\]/,tu=/\[(�.+?�?)\]|(�\/?\*\d+:\d+�)/g,nu=/({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g,eu=/{([A-Z0-9_]+)}/g,au=/�I18N_EXP_(ICU(_\d+)?)�/g,ou=/\/\*/,ru=/\d+\:(\d+)/;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function iu(t,n,e){const a=Vr();ngDevMode&&Ta(a,"tView should be defined");const o=Ir(a.consts,n);!(function r(t){_b[++Cb]=t})(t),fp(!0),a.firstCreatePass&&null===a.data[t+To]&&(function i(t,n,e,a,o){const r=n.blueprint.length-To;Fb=0;const i=Ur(),c=Gr()?i:i&&i.parent;let s=c&&c!==t[6]?c.index-To:e,l=0;Lb[l]=s;const m=[];if(ngDevMode&&Ls(m,zb),e>0&&i!==c){let t=i.index-To;Gr()||(t=~t),m.push(t<<3|0)}const d=[];ngDevMode&&Ls(d,Ab);const g=[];if(""===a&&Yb(o))m.push(a,Wb(r),s<<17|1);else{const t=(function p(t,n){if(Yb(n))return qb(t);{const e=t.indexOf(`:${n}�`)+2+n.toString().length,a=t.search(new RegExp(`�\\/\\*\\d+:${n}�`));return qb(t.substring(e,a))}})(a,o),n=(function b(t){return t.replace(Vb," ")})(t).split(Bb);for(let e=0;e<n.length;e++){let a=n[e];if(1&e)if("/"===a.charAt(0)){if("#"===a.charAt(1)){const t=parseInt(a.substr(2),10);s=Lb[--l],m.push(t<<3|5)}}else{const t=parseInt(a.substr(1),10),n="#"===a.charAt(0);m.push((n?t:~t)<<3|0,s<<17|1),n&&(Lb[++l]=s=t)}else{const n=Qb(a);for(let e=0;e<n.length;e++)if(1&e){const a=n[e];if("object"!=typeof a)throw new Error(`Unable to parse ICU expression in "${t}" message.`);const o=Wb(r);m.push(ub,ngDevMode?`ICU ${o}`:"",o,s<<17|1);const i=Ub(a);Zb(g,a,o,o);const c=g.length-1;d.push(Gb(a.mainBinding),3,-1-a.mainBinding,o<<2|2,c,i,2,o<<2|3,c)}else if(""!==n[e]){const t=n[e],a=t.match(Tb),o=Wb(r);m.push(a?"":t,o,s<<17|1),a&&eo(jb(t,o),d)}}}}Fb>0&&(function u(t,n,e){if(ngDevMode&&Ra(e,0,"The number of slots to alloc should be greater than 0"),e>0&&t.firstCreatePass){for(let a=0;a<e;a++)t.blueprint.push(null),t.data.push(null),n.push(null);t.expandoInstructions?t.expandoInstructions.push(e):t.expandoStartIndex+=e}})(n,t,Fb),n.data[e+To]={vars:Fb,create:m,update:d,icus:g.length?g:null}})(Br(),a,t,o,e)}function cu(){const t=Br(),n=Vr();ngDevMode&&Ta(n,"tView should be defined"),(function e(t,n){ngDevMode&&va(Jr(),t.bindingStartIndex,"i18nEnd should be called before any binding");const e=(function a(){return _b[Cb--]})(),o=t.data[e+To];ngDevMode&&Ta(o,"You should call i18nStart before i18nEnd");const r=Ur(),i=Pb(t,e,o.create,n);let c=e+1;for(;null!==r&&c<=r.index-To;){-1===i.indexOf(c)&&Sb(t,n,c,!0);const e=Sr(t,c);!e||0!==e.type&&2!==e.type&&3!==e.type||null===e.localNames||(c+=e.localNames.length>>1),c++}})(n,t),fp(!1)}function su(t,n,e){iu(t,n,e),cu()}function lu(t,n){const e=Br(),a=Vr();ngDevMode&&Ta(a,"tView should be defined"),(function o(t,n,e,a){const o=Ur().index-To,r=[];ngDevMode&&Ls(r,Ab);for(let i=0;i<a.length;i+=2){const c=a[i],s=a[i+1].split(Db);for(let a=0;a<s.length;a++){const i=s[a];if(1&a)throw new Error("ICU expressions are not yet supported in attributes");if(""!==i)if(i.match(Tb))n.firstCreatePass&&null===n.data[e+To]&&eo(jb(i,o,c),r);else{const e=Sr(n,o);2===e.type&&jl(e,t,c,i,null,null);const a=null!==e.inputs&&e.inputs[c];a&&(cm(n,t,a,c,i),ngDevMode)&&El(t,vr(o,t),e.type,a,i)}}}n.firstCreatePass&&null===n.data[e+To]&&(n.data[e+To]=r)})(e,a,t,Ir(a.consts,n))}function mu(t){return(function n(t){t&&(Mb|=1<<Ob),Ob++})(Rg(Br(),Kr(),t)),mu}function du(t){!(function n(t,e,a){if(Ob>0){ngDevMode&&Ta(t,"tView should be defined");const n=t.data[a+To];let o,r=null;Array.isArray(n)?o=n:(o=n.update,r=n.icus),xb(t,r,e,o,Jr()-Ob-1,Mb),Mb=0,Ob=0}})(Vr(),Br(),t)}function gu(t,n={}){return(function e(t,n={}){let e=t;if($b.test(t)){const t={},n=[0];e=e.replace(tu,((e,a,o)=>{const r=a||o,i=t[r]||[];if(i.length||(r.split("|").forEach((t=>{const n=t.match(ru),e=n?parseInt(n[1],10):0,a=ou.test(t);i.push([e,a,t])})),t[r]=i),!i.length)throw new Error(`i18n postprocess: unmatched placeholder - ${r}`);const c=n[n.length-1];let s=0;for(let t=0;t<i.length;t++)if(i[t][0]===c){s=t;break}const[l,m,d]=i[s];return m?n.pop():c!==l&&n.push(l),i.splice(s,1),d}))}return Object.keys(n).length?(e=e.replace(nu,((t,e,a,o,r,i)=>n.hasOwnProperty(a)?`${e}${n[a]}${i}`:t)),e=e.replace(eu,((t,e)=>n.hasOwnProperty(e)?n[e]:t)),e=e.replace(au,((t,e)=>{if(n.hasOwnProperty(e)){const a=n[e];if(!a.length)throw new Error(`i18n postprocess: unmatched ICU - ${t} with key: ${e}`);return a.shift()}return t})),e):e})(t,n)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function pu(t,n,e,a,o){if(t=oa(t),Array.isArray(t))for(let r=0;r<t.length;r++)pu(t[r],n,e,a,o);else{const r=Vr(),i=Br();let c=Od(t)?t:oa(t.provide),s=_d(t);const l=Ur(),m=1048575&l.providerIndexes,d=l.directiveStart,g=l.providerIndexes>>20;if(Od(t)||!t.multi){const a=new yi(s,o,Zg),p=fu(c,n,o?m:m+g,d);-1===p?(Wi(Bi(l,i),r,c),bu(r,t,n.length),n.push(c),l.directiveStart++,l.directiveEnd++,o&&(l.providerIndexes+=1048576),e.push(a),i.push(a)):(e[p]=a,i[p]=a)}else{const p=fu(c,n,m+g,d),b=fu(c,n,m,m+g),u=p>=0&&e[p],f=b>=0&&e[b];if(o&&!f||!o&&!u){Wi(Bi(l,i),r,c);const m=(function r(t,n,e,a,o){const r=new yi(t,e,Zg);return r.multi=[],r.index=n,r.componentProviders=0,uu(r,o,a&&!e),r})(o?_u:hu,e.length,o,a,s);!o&&f&&(e[b].providerFactory=m),bu(r,t,n.length,0),n.push(c),l.directiveStart++,l.directiveEnd++,o&&(l.providerIndexes+=1048576),e.push(m),i.push(m)}else bu(r,t,p>-1?p:b,uu(e[o?b:p],s,!o&&a));!o&&a&&f&&e[b].componentProviders++}}}function bu(t,n,e,a){const o=Od(n);if(o||(function r(t){return!!t.useClass})(n)){const r=(n.useClass||n).prototype.ngOnDestroy;if(r){const i=t.destroyHooks||(t.destroyHooks=[]);if(!o&&n.multi){ngDevMode&&Ta(a,"indexInFactory when registering multi factory destroy hook");const t=i.indexOf(e);-1===t?i.push(e,[a,r]):i[t+1].push(a,r)}else i.push(e,r)}}}function uu(t,n,e){return e&&t.componentProviders++,t.multi.push(n)-1}function fu(t,n,e,a){for(let o=e;o<a;o++)if(n[o]===t)return o;return-1}function hu(t,n,e,a){return Cu(this.multi,[])}function _u(t,n,e,a){const o=this.multi;let r;if(this.providerFactory){const t=this.providerFactory.componentProviders,n=Xi(e,e[1],this.providerFactory.index,a);r=n.slice(0,t),Cu(o,r);for(let e=t;e<n.length;e++)r.push(n[e])}else r=[],Cu(o,r);return r}function Cu(t,n){for(let e=0;e<t.length;e++)n.push((0,t[e])());return n}function Mu(t,n=[]){return e=>{e.providersResolver=(e,a)=>(function o(t,n,e){const a=Vr();if(a.firstCreatePass){const o=Vo(t);pu(e,a.data,a.blueprint,o,!0),pu(n,a.data,a.blueprint,o,!1)}})(e,a?a(t):t,n)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Ou{}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Pu{}Pu.NULL=new class{resolveComponentFactory(t){throw(function n(t){const n=Error(`No component factory found for ${ta(t)}. Did you add it to @NgModule.entryComponents?`);return n.ngComponent=t,n})(t)}};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class xu{constructor(t){this.nativeElement=t}}xu.__NG_ELEMENT_ID__=()=>yu(xu);const yu=function ku(t){return Fm(t,Ur(),Br())};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
new Fa("Renderer2Interceptor");class vu{}var wu;!(function(t){t[t.Important=1]="Important",t[t.DashCase=2]="DashCase"})(wu||(wu={}));class Su{}Su.__NG_ELEMENT_ID__=()=>Eu();const Eu=function Au(){const t=Br(),n=Ar(Ur().index,t);return(function e(t){const n=t[11];if(xr(n))return n;throw new Error("Cannot inject Renderer2 when the application uses Renderer3!")})(No(n)?n:t)};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class zu{}zu.ɵprov=We({token:zu,providedIn:"root",factory:()=>null});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Ru{constructor(t){this.full=t,this.major=t.split(".")[0],this.minor=t.split(".")[1],this.patch=t.split(".").slice(2).join(".")}}const Tu=new Ru("10.2.4");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Du{constructor(){}supports(t){return Sg(t)}create(t){return new Nu(t)}}const Iu=(t,n)=>n;class Nu{constructor(t){this.length=0,this._linkedRecords=null,this._unlinkedRecords=null,this._previousItHead=null,this._itHead=null,this._itTail=null,this._additionsHead=null,this._additionsTail=null,this._movesHead=null,this._movesTail=null,this._removalsHead=null,this._removalsTail=null,this._identityChangesHead=null,this._identityChangesTail=null,this._trackByFn=t||Iu}forEachItem(t){let n;for(n=this._itHead;null!==n;n=n._next)t(n)}forEachOperation(t){let n=this._itHead,e=this._removalsHead,a=0,o=null;for(;n||e;){const r=!e||n&&n.currentIndex<Bu(e,a,o)?n:e,i=Bu(r,a,o),c=r.currentIndex;if(r===e)a--,e=e._nextRemoved;else if(n=n._next,null==r.previousIndex)a++;else{o||(o=[]);const t=i-a,n=c-a;if(t!=n){for(let e=0;e<t;e++){const a=e<o.length?o[e]:o[e]=0,r=a+e;n<=r&&r<t&&(o[e]=a+1)}o[r.previousIndex]=n-t}}i!==c&&t(r,i,c)}}forEachPreviousItem(t){let n;for(n=this._previousItHead;null!==n;n=n._nextPrevious)t(n)}forEachAddedItem(t){let n;for(n=this._additionsHead;null!==n;n=n._nextAdded)t(n)}forEachMovedItem(t){let n;for(n=this._movesHead;null!==n;n=n._nextMoved)t(n)}forEachRemovedItem(t){let n;for(n=this._removalsHead;null!==n;n=n._nextRemoved)t(n)}forEachIdentityChange(t){let n;for(n=this._identityChangesHead;null!==n;n=n._nextIdentityChange)t(n)}diff(t){if(null==t&&(t=[]),!Sg(t))throw new Error(`Error trying to diff '${ta(t)}'. Only arrays and iterables are allowed`);return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let n,e,a,o=this._itHead,r=!1;if(Array.isArray(t)){this.length=t.length;for(let n=0;n<this.length;n++)e=t[n],a=this._trackByFn(n,e),null!==o&&Object.is(o.trackById,a)?(r&&(o=this._verifyReinsertion(o,e,a,n)),Object.is(o.item,e)||this._addIdentityChange(o,e)):(o=this._mismatch(o,e,a,n),r=!0),o=o._next}else n=0,(function i(t,n){if(Array.isArray(t))for(let e=0;e<t.length;e++)n(t[e]);else{const e=t[kg()]();let a;for(;!(a=e.next()).done;)n(a.value)}})(t,(t=>{a=this._trackByFn(n,t),null!==o&&Object.is(o.trackById,a)?(r&&(o=this._verifyReinsertion(o,t,a,n)),Object.is(o.item,t)||this._addIdentityChange(o,t)):(o=this._mismatch(o,t,a,n),r=!0),o=o._next,n++})),this.length=n;return this._truncate(o),this.collection=t,this.isDirty}get isDirty(){return null!==this._additionsHead||null!==this._movesHead||null!==this._removalsHead||null!==this._identityChangesHead}_reset(){if(this.isDirty){let t;for(t=this._previousItHead=this._itHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._additionsHead;null!==t;t=t._nextAdded)t.previousIndex=t.currentIndex;for(this._additionsHead=this._additionsTail=null,t=this._movesHead;null!==t;t=t._nextMoved)t.previousIndex=t.currentIndex;this._movesHead=this._movesTail=null,this._removalsHead=this._removalsTail=null,this._identityChangesHead=this._identityChangesTail=null}}_mismatch(t,n,e,a){let o;return null===t?o=this._itTail:(o=t._prev,this._remove(t)),null!==(t=null===this._linkedRecords?null:this._linkedRecords.get(e,a))?(Object.is(t.item,n)||this._addIdentityChange(t,n),this._moveAfter(t,o,a)):null!==(t=null===this._unlinkedRecords?null:this._unlinkedRecords.get(e,null))?(Object.is(t.item,n)||this._addIdentityChange(t,n),this._reinsertAfter(t,o,a)):t=this._addAfter(new Fu(n,e),o,a),t}_verifyReinsertion(t,n,e,a){let o=null===this._unlinkedRecords?null:this._unlinkedRecords.get(e,null);return null!==o?t=this._reinsertAfter(o,t._prev,a):t.currentIndex!=a&&(t.currentIndex=a,this._addToMoves(t,a)),t}_truncate(t){for(;null!==t;){const n=t._next;this._addToRemovals(this._unlink(t)),t=n}null!==this._unlinkedRecords&&this._unlinkedRecords.clear(),null!==this._additionsTail&&(this._additionsTail._nextAdded=null),null!==this._movesTail&&(this._movesTail._nextMoved=null),null!==this._itTail&&(this._itTail._next=null),null!==this._removalsTail&&(this._removalsTail._nextRemoved=null),null!==this._identityChangesTail&&(this._identityChangesTail._nextIdentityChange=null)}_reinsertAfter(t,n,e){null!==this._unlinkedRecords&&this._unlinkedRecords.remove(t);const a=t._prevRemoved,o=t._nextRemoved;return null===a?this._removalsHead=o:a._nextRemoved=o,null===o?this._removalsTail=a:o._prevRemoved=a,this._insertAfter(t,n,e),this._addToMoves(t,e),t}_moveAfter(t,n,e){return this._unlink(t),this._insertAfter(t,n,e),this._addToMoves(t,e),t}_addAfter(t,n,e){return this._insertAfter(t,n,e),this._additionsTail=null===this._additionsTail?this._additionsHead=t:this._additionsTail._nextAdded=t,t}_insertAfter(t,n,e){const a=null===n?this._itHead:n._next;return t._next=a,t._prev=n,null===a?this._itTail=t:a._prev=t,null===n?this._itHead=t:n._next=t,null===this._linkedRecords&&(this._linkedRecords=new Hu),this._linkedRecords.put(t),t.currentIndex=e,t}_remove(t){return this._addToRemovals(this._unlink(t))}_unlink(t){null!==this._linkedRecords&&this._linkedRecords.remove(t);const n=t._prev,e=t._next;return null===n?this._itHead=e:n._next=e,null===e?this._itTail=n:e._prev=n,t}_addToMoves(t,n){return t.previousIndex===n||(this._movesTail=null===this._movesTail?this._movesHead=t:this._movesTail._nextMoved=t),t}_addToRemovals(t){return null===this._unlinkedRecords&&(this._unlinkedRecords=new Hu),this._unlinkedRecords.put(t),t.currentIndex=null,t._nextRemoved=null,null===this._removalsTail?(this._removalsTail=this._removalsHead=t,t._prevRemoved=null):(t._prevRemoved=this._removalsTail,this._removalsTail=this._removalsTail._nextRemoved=t),t}_addIdentityChange(t,n){return t.item=n,this._identityChangesTail=null===this._identityChangesTail?this._identityChangesHead=t:this._identityChangesTail._nextIdentityChange=t,t}}class Fu{constructor(t,n){this.item=t,this.trackById=n,this.currentIndex=null,this.previousIndex=null,this._nextPrevious=null,this._prev=null,this._next=null,this._prevDup=null,this._nextDup=null,this._prevRemoved=null,this._nextRemoved=null,this._nextAdded=null,this._nextMoved=null,this._nextIdentityChange=null}}class Lu{constructor(){this._head=null,this._tail=null}add(t){null===this._head?(this._head=this._tail=t,t._nextDup=null,t._prevDup=null):(this._tail._nextDup=t,t._prevDup=this._tail,t._nextDup=null,this._tail=t)}get(t,n){let e;for(e=this._head;null!==e;e=e._nextDup)if((null===n||n<=e.currentIndex)&&Object.is(e.trackById,t))return e;return null}remove(t){const n=t._prevDup,e=t._nextDup;return null===n?this._head=e:n._nextDup=e,null===e?this._tail=n:e._prevDup=n,null===this._head}}class Hu{constructor(){this.map=new Map}put(t){const n=t.trackById;let e=this.map.get(n);e||(e=new Lu,this.map.set(n,e)),e.add(t)}get(t,n){const e=this.map.get(t);return e?e.get(t,n):null}remove(t){const n=t.trackById;return this.map.get(n).remove(t)&&this.map.delete(n),t}get isEmpty(){return 0===this.map.size}clear(){this.map.clear()}}function Bu(t,n,e){const a=t.previousIndex;if(null===a)return a;let o=0;return e&&a<e.length&&(o=e[a]),a+n+o}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Vu{constructor(){}supports(t){return t instanceof Map||Eg(t)}create(){return new ju}}class ju{constructor(){this._records=new Map,this._mapHead=null,this._appendAfter=null,this._previousMapHead=null,this._changesHead=null,this._changesTail=null,this._additionsHead=null,this._additionsTail=null,this._removalsHead=null,this._removalsTail=null}get isDirty(){return null!==this._additionsHead||null!==this._changesHead||null!==this._removalsHead}forEachItem(t){let n;for(n=this._mapHead;null!==n;n=n._next)t(n)}forEachPreviousItem(t){let n;for(n=this._previousMapHead;null!==n;n=n._nextPrevious)t(n)}forEachChangedItem(t){let n;for(n=this._changesHead;null!==n;n=n._nextChanged)t(n)}forEachAddedItem(t){let n;for(n=this._additionsHead;null!==n;n=n._nextAdded)t(n)}forEachRemovedItem(t){let n;for(n=this._removalsHead;null!==n;n=n._nextRemoved)t(n)}diff(t){if(t){if(!(t instanceof Map||Eg(t)))throw new Error(`Error trying to diff '${ta(t)}'. Only maps and objects are allowed`)}else t=new Map;return this.check(t)?this:null}onDestroy(){}check(t){this._reset();let n=this._mapHead;if(this._appendAfter=null,this._forEach(t,((t,e)=>{if(n&&n.key===e)this._maybeAddToChanges(n,t),this._appendAfter=n,n=n._next;else{const a=this._getOrCreateRecordForKey(e,t);n=this._insertBeforeOrAppend(n,a)}})),n){n._prev&&(n._prev._next=null),this._removalsHead=n;for(let t=n;null!==t;t=t._nextRemoved)t===this._mapHead&&(this._mapHead=null),this._records.delete(t.key),t._nextRemoved=t._next,t.previousValue=t.currentValue,t.currentValue=null,t._prev=null,t._next=null}return this._changesTail&&(this._changesTail._nextChanged=null),this._additionsTail&&(this._additionsTail._nextAdded=null),this.isDirty}_insertBeforeOrAppend(t,n){if(t){const e=t._prev;return n._next=t,n._prev=e,t._prev=n,e&&(e._next=n),t===this._mapHead&&(this._mapHead=n),this._appendAfter=t,t}return this._appendAfter?(this._appendAfter._next=n,n._prev=this._appendAfter):this._mapHead=n,this._appendAfter=n,null}_getOrCreateRecordForKey(t,n){if(this._records.has(t)){const e=this._records.get(t);this._maybeAddToChanges(e,n);const a=e._prev,o=e._next;return a&&(a._next=o),o&&(o._prev=a),e._next=null,e._prev=null,e}const e=new Uu(t);return this._records.set(t,e),e.currentValue=n,this._addToAdditions(e),e}_reset(){if(this.isDirty){let t;for(this._previousMapHead=this._mapHead,t=this._previousMapHead;null!==t;t=t._next)t._nextPrevious=t._next;for(t=this._changesHead;null!==t;t=t._nextChanged)t.previousValue=t.currentValue;for(t=this._additionsHead;null!=t;t=t._nextAdded)t.previousValue=t.currentValue;this._changesHead=this._changesTail=null,this._additionsHead=this._additionsTail=null,this._removalsHead=null}}_maybeAddToChanges(t,n){Object.is(n,t.currentValue)||(t.previousValue=t.currentValue,t.currentValue=n,this._addToChanges(t))}_addToAdditions(t){null===this._additionsHead?this._additionsHead=this._additionsTail=t:(this._additionsTail._nextAdded=t,this._additionsTail=t)}_addToChanges(t){null===this._changesHead?this._changesHead=this._changesTail=t:(this._changesTail._nextChanged=t,this._changesTail=t)}_forEach(t,n){t instanceof Map?t.forEach(n):Object.keys(t).forEach((e=>n(t[e],e)))}}class Uu{constructor(t){this.key=t,this.previousValue=null,this.currentValue=null,this._nextPrevious=null,this._next=null,this._prev=null,this._nextAdded=null,this._nextRemoved=null,this._nextChanged=null}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Wu{constructor(t){this.factories=t}static create(t,n){if(null!=n){const e=n.factories.slice();t=t.concat(e)}return new Wu(t)}static extend(t){return{provide:Wu,useFactory:n=>{if(!n)throw new Error("Cannot extend IterableDiffers without a parent injector");return Wu.create(t,n)},deps:[[Wu,new Le,new Ne]]}}find(t){const n=this.factories.find((n=>n.supports(t)));if(null!=n)return n;throw new Error(`Cannot find a differ supporting object '${t}' of type '${(function e(t){return t.name||typeof t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t)}'`)}}Wu.ɵprov=We({token:Wu,providedIn:"root",factory:()=>new Wu([new Du])});class Gu{constructor(t){this.factories=t}static create(t,n){if(n){const e=n.factories.slice();t=t.concat(e)}return new Gu(t)}static extend(t){return{provide:Gu,useFactory:n=>{if(!n)throw new Error("Cannot extend KeyValueDiffers without a parent injector");return Gu.create(t,n)},deps:[[Gu,new Le,new Ne]]}}find(t){const n=this.factories.find((n=>n.supports(t)));if(n)return n;throw new Error(`Cannot find a differ supporting object '${t}'`)}}Gu.ɵprov=We({token:Gu,providedIn:"root",factory:()=>new Gu([new Vu])});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Yu=[new Vu],qu=[new Du],Zu=new Wu(qu),Xu=new Gu(Yu);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Ju{}Ju.__NG_ELEMENT_ID__=()=>Qu(Ju,xu);const Qu=function Ku(t,n){return Lm(t,n,Ur(),Br())};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class $u{}$u.__NG_ELEMENT_ID__=()=>tf($u,xu);const tf=function nf(t,n){return Hm(t,n,Ur(),Br())},ef=new Map;function af(t){let n=ef.get(t);return n||(n=ta(t)+"_"+ef.size,ef.set(t,n)),n}af(yd),af(La),af(no),
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
af(Su),af(xu),af($u),af(Ju),af(Vm),af(yd),af(La);const of={};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class rf extends Pu{constructor(t){super(),this.ngModule=t}resolveComponentFactory(t){ngDevMode&&(function n(t,e="Type passed in is not ComponentType, it does not have 'ɵcmp' property."){So(t)||Da(e)})(t);const e=So(t);return new lf(e,this.ngModule)}}function cf(t){const n=[];for(let e in t)t.hasOwnProperty(e)&&n.push({propName:t[e],templateName:e});return n}const sf=new Fa("SCHEDULER_TOKEN",{providedIn:"root",factory:()=>nr});class lf extends Ou{constructor(t,n){super(),this.componentDef=t,this.ngModule=n,this.componentType=t.type,this.selector=(function e(t){return t.map(Ms).join(",")})(t.selectors),this.ngContentSelectors=t.ngContentSelectors?t.ngContentSelectors:[],this.isBoundToModule=!!n}get inputs(){return cf(this.componentDef.inputs)}get outputs(){return cf(this.componentDef.outputs)}create(t,n,e,a){const o=(a=a||this.ngModule)?(function r(t,n){return{get:(e,a,o)=>{const r=t.get(e,of,o);return r!==of||a===of?r:n.get(e,a,o)}}})(t,a.injector):t,i=o.get(vu,yr),c=o.get(zu,null),s=i.createRenderer(null,this.componentDef),l=this.componentDef.selectors[0][0]||"div",m=e?(function d(t,n,e){if(xr(t))return t.selectRootElement(n,e===bo.ShadowDom);let a="string"==typeof n?t.querySelector(n):n;return ngDevMode&&(function o(t,n){if(!t)throw(function e(t,n){return new Error(`Renderer: ${t} [${tr(n)}]`)})("string"==typeof n?"Host node with selector not found:":"Host node is required:",n)})(a,n),a.textContent="",a})(s,e,this.componentDef.encapsulation):pl(l,i.createRenderer(null,this.componentDef),(function g(t){const n=t.toLowerCase();return"svg"===n?_r:"math"===n?Cr:null})(l)),p=this.componentDef.onPush?576:528,b=(function u(t,n){return{components:[],scheduler:t||nr,clean:am,playerHandler:n||null,flags:0}})(),f=yl(0,null,null,1,0,null,null,null,null,null),h=bl(null,f,b,p,null,null,i,s,c,o);let _,C;ii(h);try{const t=(function M(t,n,e,a,o,r){const i=e[1];ngDevMode&&Na(e,20),e[20]=t;const c=ul(i,0,2,null,null),s=c.mergedAttrs=n.hostAttrs;null!==s&&(tg(c,s,!0),null!==t&&(Ei(o,t,s),null!==c.classes&&Am(o,t,c.classes),null!==c.styles&&Em(o,t,c.styles)));const l=a.createRenderer(t,n),m=bl(e,xl(n),null,n.onPush?64:16,e[20],c,a,l,r||null,null);return i.firstCreatePass&&(Wi(Bi(c,e),i,n.type),Fl(i,c),Hl(c,e.length,1)),Jl(e,m),e[20]=m})(m,this.componentDef,h,i,s);if(m)if(e)Ei(s,m,["ng-version",Tu.full]);else{const{attrs:t,classes:n}=(function O(t){const n=[],e=[];let a=1,o=2;for(;a<t.length;){let r=t[a];if("string"==typeof r)2===o?""!==r&&n.push(r,t[++a]):8===o&&e.push(r);else{if(!us(o))break;o=r}a++}return{attrs:n,classes:e}})(this.componentDef.selectors[0]);t&&Ei(s,m,t),n&&n.length>0&&Am(s,m,n.join(" "))}if(C=Sr(f,0),void 0!==n){const t=C.projection=[];for(let e=0;e<this.ngContentSelectors.length;e++){const a=n[e];t.push(null!=a?Array.from(a):null)}}_=(function P(t,n,e,a,o){const r=e[1],i=(function c(t,n,e){const a=Ur();t.firstCreatePass&&(e.providersResolver&&e.providersResolver(e),Nl(t,a,1),Bl(t,n,e));const o=Xi(n,t,n.length-1,a);os(o,n);const r=wr(a,n);return r&&os(r,n),o})(r,e,n);a.components.push(i),t[8]=i,o&&o.forEach((t=>t(i,n))),n.contentQueries&&n.contentQueries(1,i,e.length-1);const s=Ur();if(ngDevMode&&Ta(s,"tNode should have been already created"),r.firstCreatePass&&(null!==n.hostBindings||null!==n.hostAttrs)){pi(s.index-To);const t=e[1];Tl(t,n),Dl(t,e,n.hostVars),Il(n,i)}return i})(t,this.componentDef,h,b,[ug]),fl(f,h,null)}finally{di()}return new mf(this.componentType,_,Fm(xu,C,h),h,C)}}new rf;class mf extends class{}{constructor(t,n,e,a,o){super(),this.location=e,this._rootLView=a,this._tNode=o,this.destroyCbs=[],this.instance=n,this.hostView=this.changeDetectorRef=new Rm(a),this.componentType=t}get injector(){return new Ki(this._tNode,this._rootLView)}destroy(){this.destroyCbs&&(this.destroyCbs.forEach((t=>t())),this.destroyCbs=null,!this.hostView.destroyed&&this.hostView.destroy())}onDestroy(t){this.destroyCbs&&this.destroyCbs.push(t)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const df=new Map;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class gf extends no{constructor(t,n){super(),this._parent=n,this._bootstrapComponents=[],this.injector=this,this.destroyCbs=[],this.componentFactoryResolver=new rf(this);const e=Ro(t);ngDevMode&&Ta(e,`NgModule '${ta(t)}' is not a subtype of 'NgModuleType'.`);const a=(function o(t){return t[Ca]||null})(t);a&&hb(a),this._bootstrapComponents=ir(e.bootstrap),this._r3Injector=ud(t,n,[{provide:no,useValue:this},{provide:Pu,useValue:this.componentFactoryResolver}],ta(t)),this._r3Injector._resolveInjectorDefTypes(),this.instance=this.get(t)}get(t,n=yd.THROW_IF_NOT_FOUND,e=Ve.Default){return t===yd||t===no||t===La?this:this._r3Injector.get(t,n,e)}destroy(){ngDevMode&&Ta(this.destroyCbs,"NgModule already destroyed");const t=this._r3Injector;!t.destroyed&&t.destroy(),this.destroyCbs.forEach((t=>t())),this.destroyCbs=null}onDestroy(t){ngDevMode&&Ta(this.destroyCbs,"NgModule already destroyed"),this.destroyCbs.push(t)}}class pf extends class{}{constructor(t){super(),this.moduleType=t,null!==Ro(t)&&(function n(t){const n=new Set;!(function t(e){const a=Ro(e,!0),o=a.id;null!==o&&((function r(t,n,e){if(n&&n!==e)throw new Error(`Duplicate module registered for ${t} - ${ta(n)} vs ${ta(n.name)}`)})(o,df.get(o),e),df.set(o,e));const i=ir(a.imports);for(const e of i)n.has(e)||(n.add(e),t(e))})(t)})(t)}create(t){return new gf(this.moduleType,t)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function bf(t,n,e){const a=Xr()+t,o=Br();return o[a]===Os?Ag(o,a,e?n.call(e):n()):zg(o,a)}function uf(t,n,e,a){return Cf(Br(),Xr(),t,n,e,a)}function ff(t,n,e,a,o){return Mf(Br(),Xr(),t,n,e,a,o)}function hf(t,n,e,a,o,r){return Of(Br(),Xr(),t,n,e,a,o,r)}function _f(t,n){ngDevMode&&Na(t,n);const e=t[n];return e===Os?void 0:e}function Cf(t,n,e,a,o,r){const i=n+e;return Rg(t,i,o)?Ag(t,i+1,r?a.call(r,o):a(o)):_f(t,i+1)}function Mf(t,n,e,a,o,r,i){const c=n+e;return Tg(t,c,o,r)?Ag(t,c+2,i?a.call(i,o,r):a(o,r)):_f(t,c+2)}function Of(t,n,e,a,o,r,i,c){const s=n+e;return Dg(t,s,o,r,i)?Ag(t,s+3,c?a.call(c,o,r,i):a(o,r,i)):_f(t,s+3)}function Pf(t,n,e,a,o,r,i,c,s){const l=n+e;return Ig(t,l,o,r,i,c)?Ag(t,l+4,s?a.call(s,o,r,i,c):a(o,r,i,c)):_f(t,l+4)}function xf(t,n,e,a,o,r){let i=n+e,c=!1;for(let n=0;n<o.length;n++)Rg(t,i++,o[n])&&(c=!0);return c?Ag(t,i,a.apply(r,o)):_f(t,i)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function yf(t,n){const e=Vr();let a;const o=t+To;e.firstCreatePass?(a=(function r(t,n){if(n)for(let e=n.length-1;e>=0;e--){const a=n[e];if(t===a.name)return a}throw new Error(`The pipe '${t}' could not be found!`)})(n,e.pipeRegistry),e.data[o]=a,a.onDestroy&&(e.destroyHooks||(e.destroyHooks=[])).push(o,a.onDestroy)):a=e.data[o];const i=a.factory||(a.factory=zo(a.type,!0)),c=Ya(Zg);try{const n=Li(!1),a=i();return Li(n),(function s(t,n,e,a){const o=e+To;o>=t.data.length&&(t.data[o]=null,t.blueprint[o]=null),n[o]=a})(e,Br(),t,a),a}finally{Ya(c)}}function kf(t,n,e){const a=Br(),o=Er(a,t);return Sf(a,wf(a,t)?Cf(a,Xr(),n,o.transform,e,o):o.transform(e))}function vf(t,n,e,a){const o=Br(),r=Er(o,t);return Sf(o,wf(o,t)?Mf(o,Xr(),n,r.transform,e,a,r):r.transform(e,a))}function wf(t,n){return t[1].data[n+To].pure}function Sf(t,n){return wg.isWrapped(n)&&(n=wg.unwrap(n),t[Jr()]=Os),n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Ef=class extends x{constructor(t=!1){super(),this.__isAsync=t}emit(t){super.next(t)}subscribe(t,n,e){let a,o=t=>null,r=()=>null;t&&"object"==typeof t?(a=this.__isAsync?n=>{setTimeout((()=>t.next(n)))}:n=>{t.next(n)},t.error&&(o=this.__isAsync?n=>{setTimeout((()=>t.error(n)))}:n=>{t.error(n)}),t.complete&&(r=this.__isAsync?()=>{setTimeout((()=>t.complete()))}:()=>{t.complete()})):(a=this.__isAsync?n=>{setTimeout((()=>t(n)))}:n=>{t(n)},n&&(o=this.__isAsync?t=>{setTimeout((()=>n(t)))}:t=>{n(t)}),e&&(r=this.__isAsync?()=>{setTimeout((()=>e()))}:()=>{e()}));const i=super.subscribe(a,o,r);return t instanceof s&&t.add(i),i}};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Af(){return this._results[kg()]()}class zf{constructor(){this.dirty=!0,this._results=[],this.changes=new Ef,this.length=0;const t=kg(),n=zf.prototype;n[t]||(n[t]=Af)}map(t){return this._results.map(t)}filter(t){return this._results.filter(t)}find(t){return this._results.find(t)}reduce(t,n){return this._results.reduce(t,n)}forEach(t){this._results.forEach(t)}some(t){return this._results.some(t)}toArray(){return this._results.slice()}toString(){return this._results.toString()}reset(t){this._results=ao(t),this.dirty=!1,this.length=this._results.length,this.last=this._results[this.length-1],this.first=this._results[0]}notifyOnChanges(){this.changes.emit(this)}setDirty(){this.dirty=!0}destroy(){this.changes.complete(),this.changes.unsubscribe()}}class Rf{constructor(t){this.queryList=t,this.matches=null}clone(){return new Rf(this.queryList)}setDirty(){this.queryList.setDirty()}}class Tf{constructor(t=[]){this.queries=t}createEmbeddedView(t){const n=t.queries;if(null!==n){const e=null!==t.contentQueries?t.contentQueries[0]:n.length,a=[];for(let t=0;t<e;t++){const e=n.getByIndex(t);a.push(this.queries[e.indexInDeclarationView].clone())}return new Tf(a)}return null}insertView(t){this.dirtyQueriesWithMatches(t)}detachView(t){this.dirtyQueriesWithMatches(t)}dirtyQueriesWithMatches(t){for(let n=0;n<this.queries.length;n++)null!==Qf(t,n).matches&&this.queries[n].setDirty()}}class Df{constructor(t,n,e,a=null){this.predicate=t,this.descendants=n,this.isStatic=e,this.read=a}}class If{constructor(t=[]){this.queries=t}elementStart(t,n){ngDevMode&&Xo(t,"Queries should collect results on the first template pass only");for(let e=0;e<this.queries.length;e++)this.queries[e].elementStart(t,n)}elementEnd(t){for(let n=0;n<this.queries.length;n++)this.queries[n].elementEnd(t)}embeddedTView(t){let n=null;for(let e=0;e<this.length;e++){const a=null!==n?n.length:0,o=this.getByIndex(e).embeddedTView(t,a);o&&(o.indexInDeclarationView=e,null!==n?n.push(o):n=[o])}return null!==n?new If(n):null}template(t,n){ngDevMode&&Xo(t,"Queries should collect results on the first template pass only");for(let e=0;e<this.queries.length;e++)this.queries[e].template(t,n)}getByIndex(t){return ngDevMode&&Na(this.queries,t),this.queries[t]}get length(){return this.queries.length}track(t){this.queries.push(t)}}class Nf{constructor(t,n=-1){this.metadata=t,this.matches=null,this.indexInDeclarationView=-1,this.crossesNgTemplate=!1,this._appliesToNextNode=!0,this._declarationNodeIndex=n}elementStart(t,n){this.isApplyingToNode(n)&&this.matchTNode(t,n)}elementEnd(t){this._declarationNodeIndex===t.index&&(this._appliesToNextNode=!1)}template(t,n){this.elementStart(t,n)}embeddedTView(t,n){return this.isApplyingToNode(t)?(this.crossesNgTemplate=!0,this.addMatch(-t.index,n),new Nf(this.metadata)):null}isApplyingToNode(t){if(this._appliesToNextNode&&!1===this.metadata.descendants){const n=this._declarationNodeIndex;let e=t.parent;for(;null!==e&&3===e.type&&e.index!==n;)e=e.parent;return n===(null!==e?e.index:-1)}return this._appliesToNextNode}matchTNode(t,n){const e=this.metadata.predicate;if(Array.isArray(e))for(let a=0;a<e.length;a++){const o=e[a];this.matchTNodeWithReadOption(t,n,Ff(n,o)),this.matchTNodeWithReadOption(t,n,Zi(n,t,o,!1,!1))}else e===Ju?0===n.type&&this.matchTNodeWithReadOption(t,n,-1):this.matchTNodeWithReadOption(t,n,Zi(n,t,e,!1,!1))}matchTNodeWithReadOption(t,n,e){if(null!==e){const a=this.metadata.read;if(null!==a)if(a===xu||a===$u||a===Ju&&0===n.type)this.addMatch(n.index,-2);else{const e=Zi(n,t,a,!1,!1);null!==e&&this.addMatch(n.index,e)}else this.addMatch(n.index,e)}}addMatch(t,n){null===this.matches?this.matches=[t,n]:this.matches.push(t,n)}}function Ff(t,n){const e=t.localNames;if(null!==e)for(let t=0;t<e.length;t+=2)if(e[t]===n)return e[t+1];return null}function Lf(t,n,e,a){return-1===e?(function o(t,n){return 2===t.type||3===t.type?Fm(xu,t,n):0===t.type?Lm(Ju,xu,t,n):null})(n,t):-2===e?(function r(t,n,e){return e===xu?Fm(xu,n,t):e===Ju?Lm(Ju,xu,n,t):e===$u?(ngDevMode&&wi(n,[2,0,3]),Hm($u,xu,n,t)):void(ngDevMode&&Da(`Special token to read should be one of ElementRef, TemplateRef or ViewContainerRef but got ${ta(e)}.`))})(t,n,a):Xi(t,t[1],e,n)}function Hf(t,n,e,a){const o=n[19].queries[a];if(null===o.matches){const a=t.data,r=e.matches,i=[];for(let t=0;t<r.length;t+=2){const o=r[t];o<0?i.push(null):(ngDevMode&&Na(a,o),i.push(Lf(n,a[o],r[t+1],e.metadata.read)))}o.matches=i}return o.matches}function Bf(t,n,e,a){const o=t.queries.getByIndex(e),r=o.matches;if(null!==r){const i=Hf(t,n,o,e);for(let t=0;t<r.length;t+=2){const e=r[t];if(e>0)a.push(i[t/2]);else{const o=r[t+1],i=n[-e];ngDevMode&&Yo(i);for(let t=Io;t<i.length;t++){const n=i[t];n[17]===n[3]&&Bf(n[1],n,o,a)}if(null!==i[9]){const t=i[9];for(let n=0;n<t.length;n++){const e=t[n];Bf(e[1],e,o,a)}}}}}return a}function Vf(t){const n=Br(),e=Vr(),a=ai();oi(a+1);const o=Qf(e,a);if(t.dirty&&Tr(n)===o.metadata.isStatic){if(null===o.matches)t.reset([]);else{const r=o.crossesNgTemplate?Bf(e,n,a,[]):Hf(e,n,o,a);t.reset(r),t.notifyOnChanges()}return!0}return!1}function jf(t,n,e){Wf(Vr(),Br(),t,n,e,!0)}function Uf(t,n,e){Wf(Vr(),Br(),t,n,e,!1)}function Wf(t,n,e,a,o,r){t.firstCreatePass&&(Jf(t,new Df(e,a,r,o),-1),r&&(t.staticViewQueries=!0)),Xf(t,n)}function Gf(t,n,e,a){qf(Vr(),Br(),n,e,a,!1,Ur(),t)}function Yf(t,n,e,a){qf(Vr(),Br(),n,e,a,!0,Ur(),t)}function qf(t,n,e,a,o,r,i,c){t.firstCreatePass&&(Jf(t,new Df(e,a,r,o),i.index),(function s(t,n){const e=t.contentQueries||(t.contentQueries=[]);n!==(t.contentQueries.length?e[e.length-1]:-1)&&e.push(t.queries.length-1,n)})(t,c),r&&(t.staticContentQueries=!0)),Xf(t,n)}function Zf(){return(function t(n,e){return ngDevMode&&Ta(n[19],"LQueries should be defined when trying to load a query"),ngDevMode&&Na(n[19].queries,e),n[19].queries[e].queryList})(Br(),ai())}function Xf(t,n){const e=new zf;kl(t,n,e,e.destroy),null===n[19]&&(n[19]=new Tf),n[19].queries.push(new Rf(e))}function Jf(t,n,e){null===t.queries&&(t.queries=new If),t.queries.track(new Nf(n,e))}function Qf(t,n){return ngDevMode&&Ta(t.queries,"TQueries must be defined to retrieve a TQuery"),t.queries.getByIndex(n)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Kf(t,n){return Lm(Ju,xu,t,n)}function $f(t=Ve.Default){const n=Bm(!0);if(null!=n||t&Ve.Optional)return n;dr("ChangeDetectorRef")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const th={"ɵɵattribute":Ng,"ɵɵattributeInterpolate1":function t(n,e,a,o,r,i){const c=Br(),s=Lg(c,e,a,o);if(s!==Os){const t=bi();jl(t,c,n,s,r,i),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-1,e,o)}return t},"ɵɵattributeInterpolate2":function t(n,e,a,o,r,i,c,s){const l=Br(),m=Hg(l,e,a,o,r,i);if(m!==Os){const t=bi();jl(t,l,n,m,c,s),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-2,e,o,i)}return t},"ɵɵattributeInterpolate3":function t(n,e,a,o,r,i,c,s,l,m){const d=Br(),g=Bg(d,e,a,o,r,i,c,s);if(g!==Os){const t=bi();jl(t,d,n,g,l,m),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-3,e,o,i,s)}return t},"ɵɵattributeInterpolate4":function t(n,e,a,o,r,i,c,s,l,m,d,g){const p=Br(),b=Vg(p,e,a,o,r,i,c,s,l,m);if(b!==Os){const t=bi();jl(t,p,n,b,d,g),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-4,e,o,i,s,m)}return t},"ɵɵattributeInterpolate5":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b){const u=Br(),f=jg(u,e,a,o,r,i,c,s,l,m,d,g);if(f!==Os){const t=bi();jl(t,u,n,f,p,b),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-5,e,o,i,s,m,g)}return t},"ɵɵattributeInterpolate6":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f){const h=Br(),_=Ug(h,e,a,o,r,i,c,s,l,m,d,g,p,b);if(_!==Os){const t=bi();jl(t,h,n,_,u,f),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-6,e,o,i,s,m,g,b)}return t},"ɵɵattributeInterpolate7":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_){const C=Br(),M=Wg(C,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f);if(M!==Os){const t=bi();jl(t,C,n,M,h,_),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-7,e,o,i,s,m,g,b,f)}return t},"ɵɵattributeInterpolate8":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C,M){const O=Br(),P=Gg(O,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_);if(P!==Os){const t=bi();jl(t,O,n,P,C,M),ngDevMode&&em(Vr().data,t,"attr."+n,Jr()-8,e,o,i,s,m,g,b,f,_)}return t},"ɵɵattributeInterpolateV":function t(n,e,a,o){const r=Br(),i=Fg(r,e);if(i!==Os){const t=bi();if(jl(t,r,n,i,a,o),ngDevMode){const a=[e[0]];for(let t=2;t<e.length;t+=2)a.push(e[t]);em(Vr().data,t,"attr."+n,Jr()-a.length+1,...a)}}return t},"ɵɵdefineComponent":_o,"ɵɵdefineDirective":vo,"ɵɵdefineInjectable":We,"ɵɵdefineInjector":Ge,"ɵɵdefineNgModule":xo,"ɵɵdefinePipe":wo,"ɵɵdirectiveInject":Zg,"ɵɵgetFactoryOf":$i,"ɵɵgetInheritedFactory":tc,"ɵɵinject":Za,"ɵɵinjectAttribute":Xg,"ɵɵinvalidFactory":function nh(){const t=ngDevMode?"This constructor was not compatible with Dependency Injection.":"invalid";throw new Error(t)},"ɵɵinvalidFactoryDep":Xa,"ɵɵinjectPipeChangeDetectorRef":$f,"ɵɵtemplateRefExtractor":Kf,"ɵɵNgOnChangesFeature":pr,"ɵɵProvidersFeature":Mu,"ɵɵCopyDefinitionFeature":function eh(t){let n,e=fg(t.type);n=Vo(t)?e.ɵcmp:e.ɵdir;const a=t;for(const t of Pg)a[t]=n[t];if(Vo(n))for(const t of xg)a[t]=n[t]},"ɵɵInheritDefinitionFeature":hg,"ɵɵnextContext":gp,"ɵɵnamespaceHTML":fi,"ɵɵnamespaceMathML":function ah(){Lr.lFrame.currentNamespace=Cr},"ɵɵnamespaceSVG":ui,"ɵɵenableBindings":function oh(){Lr.bindingsEnabled=!0},"ɵɵdisableBindings":function rh(){Lr.bindingsEnabled=!1},"ɵɵelementStart":Kg,"ɵɵelementEnd":$g,"ɵɵelement":tp,"ɵɵelementContainerStart":np,"ɵɵelementContainerEnd":ep,"ɵɵelementContainer":ap,"ɵɵpureFunction0":bf,"ɵɵpureFunction1":uf,"ɵɵpureFunction2":ff,"ɵɵpureFunction3":hf,"ɵɵpureFunction4":function ih(t,n,e,a,o,r,i){return Pf(Br(),Xr(),t,n,e,a,o,r,i)},"ɵɵpureFunction5":function ch(t,n,e,a,o,r,i,c){const s=Xr()+t,l=Br(),m=Ig(l,s,e,a,o,r);return Rg(l,s+4,i)||m?Ag(l,s+5,c?n.call(c,e,a,o,r,i):n(e,a,o,r,i)):zg(l,s+5)},"ɵɵpureFunction6":function sh(t,n,e,a,o,r,i,c,s){const l=Xr()+t,m=Br(),d=Ig(m,l,e,a,o,r);return Tg(m,l+4,i,c)||d?Ag(m,l+6,s?n.call(s,e,a,o,r,i,c):n(e,a,o,r,i,c)):zg(m,l+6)},"ɵɵpureFunction7":function lh(t,n,e,a,o,r,i,c,s,l){const m=Xr()+t,d=Br();let g=Ig(d,m,e,a,o,r);return Dg(d,m+4,i,c,s)||g?Ag(d,m+7,l?n.call(l,e,a,o,r,i,c,s):n(e,a,o,r,i,c,s)):zg(d,m+7)},"ɵɵpureFunction8":function mh(t,n,e,a,o,r,i,c,s,l,m){const d=Xr()+t,g=Br(),p=Ig(g,d,e,a,o,r);return Ig(g,d+4,i,c,s,l)||p?Ag(g,d+8,m?n.call(m,e,a,o,r,i,c,s,l):n(e,a,o,r,i,c,s,l)):zg(g,d+8)},"ɵɵpureFunctionV":function dh(t,n,e,a){return xf(Br(),Xr(),t,n,e,a)},"ɵɵgetCurrentView":op,"ɵɵrestoreView":jr,"ɵɵlistener":cp,"ɵɵprojection":hp,"ɵɵsyntheticHostProperty":ab,"ɵɵsyntheticHostListener":sp,"ɵɵpipeBind1":kf,"ɵɵpipeBind2":vf,"ɵɵpipeBind3":function gh(t,n,e,a,o){const r=Br(),i=Er(r,t);return Sf(r,wf(r,t)?Of(r,Xr(),n,i.transform,e,a,o,i):i.transform(e,a,o))},"ɵɵpipeBind4":function ph(t,n,e,a,o,r){const i=Br(),c=Er(i,t);return Sf(i,wf(i,t)?Pf(i,Xr(),n,c.transform,e,a,o,r,c):c.transform(e,a,o,r))},"ɵɵpipeBindV":function bh(t,n,e){const a=Br(),o=Er(a,t);return Sf(a,wf(a,t)?xf(a,Xr(),n,o.transform,e,o):o.transform.apply(o,e))},"ɵɵprojectionDef":bp,"ɵɵhostProperty":eb,"ɵɵproperty":Jg,"ɵɵpropertyInterpolate":_p,"ɵɵpropertyInterpolate1":Cp,"ɵɵpropertyInterpolate2":function t(n,e,a,o,r,i,c){const s=Br(),l=Hg(s,e,a,o,r,i);if(l!==Os){const t=Vr(),a=bi();wl(t,a,s,n,l,s[11],c,!1),ngDevMode&&em(t.data,a,n,Jr()-2,e,o,i)}return t},"ɵɵpropertyInterpolate3":function t(n,e,a,o,r,i,c,s,l){const m=Br(),d=Bg(m,e,a,o,r,i,c,s);if(d!==Os){const t=Vr(),a=bi();wl(t,a,m,n,d,m[11],l,!1),ngDevMode&&em(t.data,a,n,Jr()-3,e,o,i,s)}return t},"ɵɵpropertyInterpolate4":function t(n,e,a,o,r,i,c,s,l,m,d){const g=Br(),p=Vg(g,e,a,o,r,i,c,s,l,m);if(p!==Os){const t=Vr(),a=bi();wl(t,a,g,n,p,g[11],d,!1),ngDevMode&&em(t.data,a,n,Jr()-4,e,o,i,s,m)}return t},"ɵɵpropertyInterpolate5":function t(n,e,a,o,r,i,c,s,l,m,d,g,p){const b=Br(),u=jg(b,e,a,o,r,i,c,s,l,m,d,g);if(u!==Os){const t=Vr(),a=bi();wl(t,a,b,n,u,b[11],p,!1),ngDevMode&&em(t.data,a,n,Jr()-5,e,o,i,s,m,g)}return t},"ɵɵpropertyInterpolate6":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u){const f=Br(),h=Ug(f,e,a,o,r,i,c,s,l,m,d,g,p,b);if(h!==Os){const t=Vr(),a=bi();wl(t,a,f,n,h,f[11],u,!1),ngDevMode&&em(t.data,a,n,Jr()-6,e,o,i,s,m,g,b)}return t},"ɵɵpropertyInterpolate7":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h){const _=Br(),C=Wg(_,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f);if(C!==Os){const t=Vr(),a=bi();wl(t,a,_,n,C,_[11],h,!1),ngDevMode&&em(t.data,a,n,Jr()-7,e,o,i,s,m,g,b,f)}return t},"ɵɵpropertyInterpolate8":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C){const M=Br(),O=Gg(M,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_);if(O!==Os){const t=Vr(),a=bi();wl(t,a,M,n,O,M[11],C,!1),ngDevMode&&em(t.data,a,n,Jr()-8,e,o,i,s,m,g,b,f,_)}return t},"ɵɵpropertyInterpolateV":function t(n,e,a){const o=Br(),r=Fg(o,e);if(r!==Os){const t=Vr(),i=bi();if(wl(t,i,o,n,r,o[11],a,!1),ngDevMode){const a=[e[0]];for(let t=2;t<e.length;t+=2)a.push(e[t]);em(t.data,i,n,Jr()-a.length+1,...a)}}return t},"ɵɵpipe":yf,"ɵɵqueryRefresh":Vf,"ɵɵviewQuery":Uf,"ɵɵstaticViewQuery":jf,"ɵɵstaticContentQuery":Yf,"ɵɵloadQuery":Zf,"ɵɵcontentQuery":Gf,"ɵɵreference":qg,"ɵɵclassMap":Fp,"ɵɵclassMapInterpolate1":nb,"ɵɵclassMapInterpolate2":function uh(t,n,e,a,o){Bp(so,Lp,Hg(Br(),t,n,e,a,o),!0)},"ɵɵclassMapInterpolate3":function fh(t,n,e,a,o,r,i){Bp(so,Lp,Bg(Br(),t,n,e,a,o,r,i),!0)},"ɵɵclassMapInterpolate4":function hh(t,n,e,a,o,r,i,c,s){Bp(so,Lp,Vg(Br(),t,n,e,a,o,r,i,c,s),!0)},"ɵɵclassMapInterpolate5":function _h(t,n,e,a,o,r,i,c,s,l,m){Bp(so,Lp,jg(Br(),t,n,e,a,o,r,i,c,s,l,m),!0)},"ɵɵclassMapInterpolate6":function Ch(t,n,e,a,o,r,i,c,s,l,m,d,g){Bp(so,Lp,Ug(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g),!0)},"ɵɵclassMapInterpolate7":function Mh(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b){Bp(so,Lp,Wg(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g,p,b),!0)},"ɵɵclassMapInterpolate8":function Oh(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f){Bp(so,Lp,Gg(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f),!0)},"ɵɵclassMapInterpolateV":function Ph(t){Bp(so,Lp,Fg(Br(),t),!0)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */,"ɵɵstyleMap":Ip,"ɵɵstyleMapInterpolate1":function xh(t,n,e){Ip(Lg(Br(),t,n,e))},"ɵɵstyleMapInterpolate2":function yh(t,n,e,a,o){Ip(Hg(Br(),t,n,e,a,o))},"ɵɵstyleMapInterpolate3":function kh(t,n,e,a,o,r,i){Ip(Bg(Br(),t,n,e,a,o,r,i))},"ɵɵstyleMapInterpolate4":function vh(t,n,e,a,o,r,i,c,s){Ip(Vg(Br(),t,n,e,a,o,r,i,c,s))},"ɵɵstyleMapInterpolate5":function wh(t,n,e,a,o,r,i,c,s,l,m){Ip(jg(Br(),t,n,e,a,o,r,i,c,s,l,m))},"ɵɵstyleMapInterpolate6":function Sh(t,n,e,a,o,r,i,c,s,l,m,d,g){Ip(Ug(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g))},"ɵɵstyleMapInterpolate7":function Eh(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b){Ip(Wg(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g,p,b))},"ɵɵstyleMapInterpolate8":function Ah(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f){Ip(Gg(Br(),t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f))},"ɵɵstyleMapInterpolateV":function zh(t){Ip(Fg(Br(),t))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */,"ɵɵstyleProp":Tp,"ɵɵstylePropInterpolate1":function t(n,e,a,o,r){return Hp(n,Lg(Br(),e,a,o),r,!1),t},"ɵɵstylePropInterpolate2":function t(n,e,a,o,r,i,c){return Hp(n,Hg(Br(),e,a,o,r,i),c,!1),t},"ɵɵstylePropInterpolate3":function t(n,e,a,o,r,i,c,s,l){return Hp(n,Bg(Br(),e,a,o,r,i,c,s),l,!1),t},"ɵɵstylePropInterpolate4":function t(n,e,a,o,r,i,c,s,l,m,d){return Hp(n,Vg(Br(),e,a,o,r,i,c,s,l,m),d,!1),t},"ɵɵstylePropInterpolate5":function t(n,e,a,o,r,i,c,s,l,m,d,g,p){return Hp(n,jg(Br(),e,a,o,r,i,c,s,l,m,d,g),p,!1),t},"ɵɵstylePropInterpolate6":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u){return Hp(n,Ug(Br(),e,a,o,r,i,c,s,l,m,d,g,p,b),u,!1),t},"ɵɵstylePropInterpolate7":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h){return Hp(n,Wg(Br(),e,a,o,r,i,c,s,l,m,d,g,p,b,u,f),h,!1),t},"ɵɵstylePropInterpolate8":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C){return Hp(n,Gg(Br(),e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_),C,!1),t},"ɵɵstylePropInterpolateV":function t(n,e,a){return Hp(n,Fg(Br(),e),a,!1),t},"ɵɵclassProp":Dp,"ɵɵadvance":ws,"ɵɵtemplate":Yg,"ɵɵtext":Jp,"ɵɵtextInterpolate":Qp,"ɵɵtextInterpolate1":Kp,"ɵɵtextInterpolate2":$p,"ɵɵtextInterpolate3":tb,"ɵɵtextInterpolate4":function t(n,e,a,o,r,i,c,s,l){const m=Br(),d=Vg(m,n,e,a,o,r,i,c,s,l);return d!==Os&&sm(m,gi(),d),t},"ɵɵtextInterpolate5":function t(n,e,a,o,r,i,c,s,l,m,d){const g=Br(),p=jg(g,n,e,a,o,r,i,c,s,l,m,d);return p!==Os&&sm(g,gi(),p),t},"ɵɵtextInterpolate6":function t(n,e,a,o,r,i,c,s,l,m,d,g,p){const b=Br(),u=Ug(b,n,e,a,o,r,i,c,s,l,m,d,g,p);return u!==Os&&sm(b,gi(),u),t},"ɵɵtextInterpolate7":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u){const f=Br(),h=Wg(f,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u);return h!==Os&&sm(f,gi(),h),t},"ɵɵtextInterpolate8":function t(n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h){const _=Br(),C=Gg(_,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h);return C!==Os&&sm(_,gi(),C),t},"ɵɵtextInterpolateV":function t(n){const e=Br(),a=Fg(e,n);return a!==Os&&sm(e,gi(),a),t},"ɵɵi18n":su,"ɵɵi18nAttributes":lu,"ɵɵi18nExp":mu,"ɵɵi18nStart":iu,"ɵɵi18nEnd":cu,"ɵɵi18nApply":du,"ɵɵi18nPostprocess":gu,"ɵɵresolveWindow":er,"ɵɵresolveDocument":ar,"ɵɵresolveBody":or,"ɵɵsetComponentScope":Co,"ɵɵsetNgModuleScope":yo,"ɵɵsanitizeHtml":
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function Rh(t){const n=Qc();return n?n.sanitize(Zc.HTML,t)||"":bc(t,"HTML")?pc(t):Yc(Or(),$o(t))},"ɵɵsanitizeStyle":function Th(t){const n=Qc();return n?n.sanitize(Zc.STYLE,t)||"":bc(t,"Style")?pc(t):$o(t)},"ɵɵsanitizeResourceUrl":Jc,"ɵɵsanitizeScript":function Dh(t){const n=Qc();if(n)return n.sanitize(Zc.SCRIPT,t)||"";if(bc(t,"Script"))return pc(t);throw new Error("unsafe value used in a script context")},"ɵɵsanitizeUrl":Xc,"ɵɵsanitizeUrlOrResourceUrl":function Ih(t,n,e){return(function a(t,n){return"src"===n&&("embed"===t||"frame"===t||"iframe"===t||"media"===t||"script"===t)||"href"===n&&("base"===t||"link"===t)?Jc:Xc})(n,e)(t)}};let Nh=null;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Fh=[],Lh=[];let Hh=!1;function Bh(t){return Array.isArray(t)?t.every(Bh):!!oa(t)}function Vh(t,n,e){if(Gh.get(t))return;let a;if(Gh.set(t,!0),t=oa(t),e){if(a=Ro(t),!a)throw new Error(`Unexpected value '${t.name}' imported by the module '${e.name}'. Please add an @NgModule annotation.`)}else a=Ro(t,!0);const o=[],r=ir(a.declarations),i=ir(a.imports);ao(i).map(jh).forEach((n=>{f(n,t),Vh(n,!1,t)}));const c=ir(a.exports);r.forEach((function s(n){So(n=oa(n))||Eo(n)||Ao(n)||o.push(`Unexpected value '${tr(n)}' declared by the module '${tr(t)}'. Please add a @Pipe/@Directive/@Component annotation.`)})),r.forEach((function l(t){const n=Eo(t=oa(t));!So(t)&&n&&0==n.selectors.length&&o.push(`Directive ${tr(t)} has no selector, please add it!`)}));const m=[...r.map(oa),...ao(i.map(Yh)).map(oa)];c.forEach((function d(n){const e=(So(n=oa(n))?"component":Eo(n)&&"directive")||Ao(n)&&"pipe";e&&-1===m.lastIndexOf(n)&&o.push(`Can't export ${e} ${tr(n)} from ${tr(t)} as it was neither declared nor imported!`)})),r.forEach((e=>(function a(n,e){n=oa(n);const a=Wh.get(n);if(a&&a!==t){if(!e){const e=[a,t].map(tr).sort();o.push(`Type ${tr(n)} is part of the declarations of 2 modules: ${e[0]} and ${e[1]}! Please consider moving ${tr(n)} to a higher module that imports ${e[0]} and ${e[1]}. You can also create a new NgModule that exports and includes ${tr(n)} then import that NgModule in ${e[0]} and ${e[1]}.`)}}else Wh.set(n,t)})(e,n))),r.forEach((function g(t){if(So(t=oa(t))){const n=Uh(t,"Component");n&&n.entryComponents&&oo(n.entryComponents,u)}}));const p=Uh(t,"NgModule");if(p&&(p.imports&&ao(p.imports).map(jh).forEach((n=>{f(n,t),Vh(n,!1,t)})),p.bootstrap&&oo(p.bootstrap,(function b(t){So(t=oa(t))||o.push(`${tr(t)} cannot be used as an entry component.`)})),p.bootstrap&&oo(p.bootstrap,u),p.entryComponents&&oo(p.entryComponents,u)),o.length)throw new Error(o.join("\n"));function u(t){t=oa(t),Wh.get(t)||o.push(`Component ${tr(t)} is not part of any NgModule or the module has not been imported into your module.`)}function f(t,n){if(So(t=oa(t))||Eo(t))throw new Error(`Unexpected directive '${t.name}' imported by the module '${n.name}'. Please add an @NgModule annotation.`);if(Ao(t))throw new Error(`Unexpected pipe '${t.name}' imported by the module '${n.name}'. Please add an @NgModule annotation.`)}}function jh(t){return(t=oa(t)).ngModule||t}function Uh(t,n){let e=null;return a(t.__annotations__),a(t.decorators),e;function a(t){t&&t.forEach(o)}function o(t){e||(Object.getPrototypeOf(t).ngMetadataName==n?e=t:t.type&&Object.getPrototypeOf(t.type).ngMetadataName==n&&(e=t.args[0]))}}let Wh=new Map,Gh=new Map;function Yh(t){return[...ao(ir(Ro(t=oa(t),!0).exports).map((t=>Ro(t)?(Vh(t,!1),Yh(t)):t)))]}function qh(t,n){const e=ao(n.declarations||Fh),a=Xh(t);e.forEach((n=>{n.hasOwnProperty(ua)?Zh(So(n),a):n.hasOwnProperty(fa)||n.hasOwnProperty(ha)||(n.ngSelectorScope=t)}))}function Zh(t,n){t.directiveDefs=()=>Array.from(n.compilation.directives).map((t=>t.hasOwnProperty(ua)?So(t):Eo(t))).filter((t=>!!t)),t.pipeDefs=()=>Array.from(n.compilation.pipes).map((t=>Ao(t))),t.schemas=n.schemas,t.tView=null}function Xh(t){if(!Qh(t))throw new Error(`${t.name} does not have a module def (ɵmod property)`);const n=Ro(t);if(null!==n.transitiveCompileScopes)return n.transitiveCompileScopes;const e={schemas:n.schemas||null,compilation:{directives:new Set,pipes:new Set},exported:{directives:new Set,pipes:new Set}};return ir(n.imports).forEach((t=>{const n=t;if(!Qh(n))throw new Error(`Importing ${n.name} which does not have a ɵmod property`);const a=Xh(n);a.exported.directives.forEach((t=>e.compilation.directives.add(t))),a.exported.pipes.forEach((t=>e.compilation.pipes.add(t)))})),ir(n.declarations).forEach((t=>{Ao(t)?e.compilation.pipes.add(t):e.compilation.directives.add(t)})),ir(n.exports).forEach((t=>{const n=t;if(Qh(n)){const t=Xh(n);t.exported.directives.forEach((t=>{e.compilation.directives.add(t),e.exported.directives.add(t)})),t.exported.pipes.forEach((t=>{e.compilation.pipes.add(t),e.exported.pipes.add(t)}))}else Ao(n)?e.exported.pipes.add(n):e.exported.directives.add(n)})),n.transitiveCompileScopes=e,e}function Jh(t){return(function n(t){return void 0!==t.ngModule})(t)?t.ngModule:t}function Qh(t){return!!Ro(t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let Kh=0;function $h(t,n){let e=null;n_(t,n||{}),Object.defineProperty(t,fa,{get:()=>{if(null===e){const a=t_(t,n||{});e=ba().compileDirective(th,a.sourceMapUrl,a.metadata)}return e},configurable:!!ngDevMode})}function t_(t,n){const e=t&&t.name,a=`ng:///${e}/ɵdir.js`,o=ba(),r=a_(t,n);return r.typeSourceSpan=o.createParseSourceSpan("Directive",e,a),r.usesInheritance&&o_(t),{metadata:r,sourceMapUrl:a}}function n_(t,n){let e=null;Object.defineProperty(t,Ma,{get:()=>{if(null===e){const a=t_(t,n),o=ba();e=o.compileFactory(th,`ng:///${t.name}/ɵfac.js`,Object.assign(Object.assign({},a.metadata),{injectFn:"directiveInject",target:o.R3FactoryTarget.Directive}))}return e},configurable:!!ngDevMode})}function e_(t){return Object.getPrototypeOf(t.prototype)===Object.prototype}function a_(t,n){const e=$m(),a=e.ownPropMetadata(t);return{name:t.name,type:t,typeArgumentCount:0,selector:void 0!==n.selector?n.selector:null,deps:td(t),host:n.host||uo,propMetadata:a,inputs:n.inputs||fo,outputs:n.outputs||fo,queries:c_(t,a,s_),lifecycle:{usesOnChanges:e.hasLifecycleHook(t,"ngOnChanges")},typeSourceSpan:null,usesInheritance:!e_(t),exportAs:(o=n.exportAs,void 0===o?null:d_(o)),providers:n.providers||null,viewQueries:c_(t,a,l_)};var o}function o_(t){const n=Object.prototype;let e=Object.getPrototypeOf(t.prototype).constructor;for(;e&&e!==n;)Eo(e)||So(e)||!p_(e)||$h(e,null),e=Object.getPrototypeOf(e)}function r_(t){return"string"==typeof t?d_(t):oa(t)}function i_(t,n){return{propertyName:t,predicate:r_(n.selector),descendants:n.descendants,first:n.first,read:n.read?n.read:null,static:!!n.static}}function c_(t,n,e){const a=[];for(const o in n)if(n.hasOwnProperty(o)){const r=n[o];r.forEach((n=>{if(e(n)){if(!n.selector)throw new Error(`Can't construct a query for the property "${o}" of "${tr(t)}" since the query selector wasn't defined.`);if(r.some(m_))throw new Error("Cannot combine @Input decorators with query decorators");a.push(i_(o,n))}}))}return a}function s_(t){const n=t.ngMetadataName;return"ContentChild"===n||"ContentChildren"===n}function l_(t){const n=t.ngMetadataName;return"ViewChild"===n||"ViewChildren"===n}function m_(t){return"Input"===t.ngMetadataName}function d_(t){return t.split(",").map((t=>t.trim()))}const g_=["ngOnChanges","ngOnInit","ngOnDestroy","ngDoCheck","ngAfterViewInit","ngAfterViewChecked","ngAfterContentInit","ngAfterContentChecked"];function p_(t){const n=$m();if(g_.some((e=>n.hasLifecycleHook(t,e))))return!0;const e=n.propMetadata(t);for(const t in e){const n=e[t];for(let t=0;t<n.length;t++){const e=n[t],a=e.ngMetadataName;if(m_(e)||s_(e)||l_(e)||"Output"===a||"HostBinding"===a||"HostListener"===a)return!0}}return!1}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function b_(t,n){return{type:t,typeArgumentCount:0,name:t.name,deps:td(t),pipeName:n.name,pure:void 0===n.pure||n.pure}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const u_=ze("Directive",((t={})=>t),void 0,void 0,((t,n)=>O_(t,n)));ze("Component",((t={})=>Object.assign({changeDetection:go.Default},t)),u_,void 0,((t,n)=>C_(t,n))),ze("Pipe",(t=>Object.assign({pure:!0},t)),void 0,void 0,((t,n)=>P_(t,n)));const f_=De("Input",(t=>({bindingPropertyName:t}))),h_=De("Output",(t=>({bindingPropertyName:t})));De("HostBinding",(t=>({hostPropertyName:t})));const __=De("HostListener",((t,n)=>({eventName:t,args:n}))),C_=function M_(t,n){("undefined"==typeof ngDevMode||ngDevMode)&&Pa();let e=null;!(function a(t,n){Kd(n)&&(Jd.set(t,n),Qd.add(t))})(t,n),n_(t,n),Object.defineProperty(t,ua,{get:()=>{if(null===e){const a=ba();if(Kd(n)){const e=[`Component '${t.name}' is not resolved:`];throw n.templateUrl&&e.push(` - templateUrl: ${n.templateUrl}`),n.styleUrls&&n.styleUrls.length&&e.push(` - styleUrls: ${JSON.stringify(n.styleUrls)}`),e.push("Did you run and wait for 'resolveComponentResources()'?"),new Error(e.join("\n"))}const o=(function a(){return Nh})();let r=n.preserveWhitespaces;void 0===r&&(r=null!==o&&void 0!==o.preserveWhitespaces&&o.preserveWhitespaces);let i=n.encapsulation;void 0===i&&(i=null!==o&&void 0!==o.defaultEncapsulation?o.defaultEncapsulation:bo.Emulated);const c=n.templateUrl||`ng:///${t.name}/template.html`,s=Object.assign(Object.assign({},a_(t,n)),{typeSourceSpan:a.createParseSourceSpan("Component",t.name,c),template:n.template||"",preserveWhitespaces:r,styles:n.styles||fo,animations:n.animations,directives:[],changeDetection:n.changeDetection,pipes:new Map,encapsulation:i,interpolation:n.interpolation,viewProviders:n.viewProviders||null});Kh++;try{s.usesInheritance&&o_(t),e=a.compileComponent(th,c,s)}finally{Kh--}if(0===Kh&&(function o(){if(!Hh){Hh=!0;try{for(let t=Lh.length-1;t>=0;t--){const{moduleType:n,ngModule:e}=Lh[t];e.declarations&&e.declarations.every(Bh)&&(Lh.splice(t,1),qh(n,e))}}finally{Hh=!1}}})(),(function r(t){return void 0!==t.ngSelectorScope})(t)){const n=Xh(t.ngSelectorScope);Zh(e,n)}}return e},configurable:!!ngDevMode})},O_=$h,P_=function x_(t,n){let e=null,a=null;Object.defineProperty(t,Ma,{get:()=>{if(null===a){const e=b_(t,n),o=ba();a=o.compileFactory(th,`ng:///${e.name}/ɵfac.js`,Object.assign(Object.assign({},e),{injectFn:"directiveInject",target:o.R3FactoryTarget.Pipe}))}return a},configurable:!!ngDevMode}),Object.defineProperty(t,ha,{get:()=>{if(null===e){const a=b_(t,n);e=ba().compilePipe(th,`ng:///${a.name}/ɵpipe.js`,a)}return e},configurable:!!ngDevMode})};ze("NgModule",(t=>t),void 0,void 0,((t,n)=>y_(t,n)));const y_=function k_(t,n={}){!(function e(t,n,a=!1){ngDevMode&&Ta(t,"Required value moduleType"),ngDevMode&&Ta(n,"Required value ngModule");const o=ao(n.declarations||Fh);let r=null;Object.defineProperty(t,_a,{configurable:!0,get:()=>{if(null===r){if(ngDevMode&&n.imports&&n.imports.indexOf(t)>-1)throw new Error(`'${tr(t)}' module can't import itself`);r=ba().compileNgModule(th,`ng:///${t.name}/ɵmod.js`,{type:t,bootstrap:ao(n.bootstrap||Fh).map(oa),declarations:o.map(oa),imports:ao(n.imports||Fh).map(oa).map(Jh),exports:ao(n.exports||Fh).map(oa).map(Jh),schemas:n.schemas?ao(n.schemas):null,id:n.id||null}),r.schemas||(r.schemas=[])}return r}});let i=null;Object.defineProperty(t,Je,{get:()=>{if(null===i){ngDevMode&&Vh(t,a);const e={name:t.name,type:t,deps:td(t),providers:n.providers||Fh,imports:[(n.imports||Fh).map(oa),(n.exports||Fh).map(oa)]};i=ba().compileInjector(th,`ng:///${t.name}/ɵinj.js`,e)}return i},configurable:!!ngDevMode})})(t,n),(function a(t,n){Lh.push({moduleType:t,ngModule:n})})(t,n)},v_=new Fa("Application Initializer");class w_{constructor(t){this.appInits=t,this.initialized=!1,this.done=!1,this.donePromise=new Promise(((t,n)=>{this.resolve=t,this.reject=n}))}runInitializers(){if(this.initialized)return;const t=[],n=()=>{this.done=!0,this.resolve()};if(this.appInits)for(let n=0;n<this.appInits.length;n++){const e=this.appInits[n]();rp(e)&&t.push(e)}Promise.all(t).then((()=>{n()})).catch((t=>{this.reject(t)})),0===t.length&&n(),this.initialized=!0}}w_.ɵfac=function t(n){return new(n||w_)(Za(v_,8))},w_.ɵprov=We({token:w_,factory:w_.ɵfac}),w_.ctorParameters=()=>[{type:Array,decorators:[{type:Ie,args:[v_]},{type:Ne}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const S_=new Fa("AppId"),E_={provide:S_,useFactory:function A_(){return`${z_()}${z_()}${z_()}`},deps:[]};function z_(){return String.fromCharCode(97+Math.floor(25*Math.random()))}const R_=new Fa("Platform Initializer"),T_=new Fa("Platform ID"),D_=new Fa("appBootstrapListener");new Fa("Application Packages Root URL");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class I_{log(t){console.log(t)}warn(t){console.warn(t)}}I_.ɵfac=function t(n){return new(n||I_)},I_.ɵprov=We({token:I_,factory:I_.ɵfac});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const N_=new Fa("LocaleId"),F_=new Fa("DefaultCurrencyCode");var L_;new Fa("Translations"),new Fa("TranslationsFormat"),(function(t){t[t.Error=0]="Error",t[t.Warning=1]="Warning",t[t.Ignore=2]="Ignore"})(L_||(L_={}));
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class H_{constructor(t,n){this.ngModuleFactory=t,this.componentFactories=n}}const B_=function(t){return new pf(t)},V_=B_,j_=function(t){return Promise.resolve(B_(t))},U_=function(t){const n=B_(t),e=ir(Ro(t).declarations).reduce(((t,n)=>{const e=So(n);return e&&t.push(new lf(e)),t}),[]);return new H_(n,e)},W_=U_,G_=function(t){return Promise.resolve(U_(t))};class Y_{constructor(){this.compileModuleSync=V_,this.compileModuleAsync=j_,this.compileModuleAndAllComponentsSync=W_,this.compileModuleAndAllComponentsAsync=G_}clearCache(){}clearCacheFor(t){}getModuleId(t){}}Y_.ɵfac=function t(n){return new(n||Y_)},Y_.ɵprov=We({token:Y_,factory:Y_.ɵfac});const q_=new Fa("compilerOptions"),Z_=Promise.resolve(0);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function X_(t){"undefined"==typeof Zone?Z_.then((()=>{t&&t.apply(null,null)})):Zone.current.scheduleMicroTask("scheduleMicrotask",t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class J_{constructor({enableLongStackTrace:t=!1,shouldCoalesceEventChangeDetection:n=!1}){if(this.hasPendingMacrotasks=!1,this.hasPendingMicrotasks=!1,this.isStable=!0,this.onUnstable=new Ef(!1),this.onMicrotaskEmpty=new Ef(!1),this.onStable=new Ef(!1),this.onError=new Ef(!1),"undefined"==typeof Zone)throw new Error("In this configuration Angular requires Zone.js");Zone.assertZonePatched();const e=this;e._nesting=0,e._outer=e._inner=Zone.current,Zone.wtfZoneSpec&&(e._inner=e._inner.fork(Zone.wtfZoneSpec)),Zone.TaskTrackingZoneSpec&&(e._inner=e._inner.fork(new Zone.TaskTrackingZoneSpec)),t&&Zone.longStackTraceZoneSpec&&(e._inner=e._inner.fork(Zone.longStackTraceZoneSpec)),e.shouldCoalesceEventChangeDetection=n,e.lastRequestAnimationFrameId=-1,e.nativeRequestAnimationFrame=(function a(){let t=ma.requestAnimationFrame,n=ma.cancelAnimationFrame;if("undefined"!=typeof Zone&&t&&n){const e=t[Zone.__symbol__("OriginalDelegate")];e&&(t=e);const a=n[Zone.__symbol__("OriginalDelegate")];a&&(n=a)}return{nativeRequestAnimationFrame:t,nativeCancelAnimationFrame:n}})().nativeRequestAnimationFrame,(function o(t){const n=!!t.shouldCoalesceEventChangeDetection&&t.nativeRequestAnimationFrame&&(()=>{!(function n(t){-1===t.lastRequestAnimationFrameId&&(t.lastRequestAnimationFrameId=t.nativeRequestAnimationFrame.call(ma,(()=>{t.fakeTopEventTask||(t.fakeTopEventTask=Zone.root.scheduleEventTask("fakeTopEventTask",(()=>{t.lastRequestAnimationFrameId=-1,tC(t),$_(t)}),void 0,(()=>{}),(()=>{}))),t.fakeTopEventTask.invoke()})),tC(t))})(t)});t._inner=t._inner.fork({name:"angular",properties:{isAngularZone:!0,maybeDelayChangeDetection:n},onInvokeTask:(e,a,o,r,i,c)=>{try{return nC(t),e.invokeTask(o,r,i,c)}finally{n&&"eventTask"===r.type&&n(),eC(t)}},onInvoke:(n,e,a,o,r,i,c)=>{try{return nC(t),n.invoke(a,o,r,i,c)}finally{eC(t)}},onHasTask:(n,e,a,o)=>{n.hasTask(a,o),e===a&&("microTask"==o.change?(t._hasPendingMicrotasks=o.microTask,tC(t),$_(t)):"macroTask"==o.change&&(t.hasPendingMacrotasks=o.macroTask))},onHandleError:(n,e,a,o)=>(n.handleError(a,o),t.runOutsideAngular((()=>t.onError.emit(o))),!1)})})(e)}static isInAngularZone(){return!0===Zone.current.get("isAngularZone")}static assertInAngularZone(){if(!J_.isInAngularZone())throw new Error("Expected to be in Angular Zone, but it is not!")}static assertNotInAngularZone(){if(J_.isInAngularZone())throw new Error("Expected to not be in Angular Zone, but it is!")}run(t,n,e){return this._inner.run(t,n,e)}runTask(t,n,e,a){const o=this._inner,r=o.scheduleEventTask("NgZoneEvent: "+a,t,K_,Q_,Q_);try{return o.runTask(r,n,e)}finally{o.cancelTask(r)}}runGuarded(t,n,e){return this._inner.runGuarded(t,n,e)}runOutsideAngular(t){return this._outer.run(t)}}function Q_(){}const K_={};function $_(t){if(0==t._nesting&&!t.hasPendingMicrotasks&&!t.isStable)try{t._nesting++,t.onMicrotaskEmpty.emit(null)}finally{if(t._nesting--,!t.hasPendingMicrotasks)try{t.runOutsideAngular((()=>t.onStable.emit(null)))}finally{t.isStable=!0}}}function tC(t){t.hasPendingMicrotasks=!!(t._hasPendingMicrotasks||t.shouldCoalesceEventChangeDetection&&-1!==t.lastRequestAnimationFrameId)}function nC(t){t._nesting++,t.isStable&&(t.isStable=!1,t.onUnstable.emit(null))}function eC(t){t._nesting--,$_(t)}class aC{constructor(){this.hasPendingMicrotasks=!1,this.hasPendingMacrotasks=!1,this.isStable=!0,this.onUnstable=new Ef,this.onMicrotaskEmpty=new Ef,this.onStable=new Ef,this.onError=new Ef}run(t,n,e){return t.apply(n,e)}runGuarded(t,n,e){return t.apply(n,e)}runOutsideAngular(t){return t()}runTask(t,n,e,a){return t.apply(n,e)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class oC{constructor(t){this._ngZone=t,this._pendingCount=0,this._isZoneStable=!0,this._didWork=!1,this._callbacks=[],this.taskTrackingZone=null,this._watchAngularEvents(),t.run((()=>{this.taskTrackingZone="undefined"==typeof Zone?null:Zone.current.get("TaskTrackingZone")}))}_watchAngularEvents(){this._ngZone.onUnstable.subscribe({next:()=>{this._didWork=!0,this._isZoneStable=!1}}),this._ngZone.runOutsideAngular((()=>{this._ngZone.onStable.subscribe({next:()=>{J_.assertNotInAngularZone(),X_((()=>{this._isZoneStable=!0,this._runCallbacksIfReady()}))}})}))}increasePendingRequestCount(){return this._pendingCount+=1,this._didWork=!0,this._pendingCount}decreasePendingRequestCount(){if(this._pendingCount-=1,this._pendingCount<0)throw new Error("pending async requests below zero");return this._runCallbacksIfReady(),this._pendingCount}isStable(){return this._isZoneStable&&0===this._pendingCount&&!this._ngZone.hasPendingMacrotasks}_runCallbacksIfReady(){if(this.isStable())X_((()=>{for(;0!==this._callbacks.length;){let t=this._callbacks.pop();clearTimeout(t.timeoutId),t.doneCb(this._didWork)}this._didWork=!1}));else{let t=this.getPendingTasks();this._callbacks=this._callbacks.filter((n=>!n.updateCb||!n.updateCb(t)||(clearTimeout(n.timeoutId),!1))),this._didWork=!0}}getPendingTasks(){return this.taskTrackingZone?this.taskTrackingZone.macroTasks.map((t=>({source:t.source,creationLocation:t.creationLocation,data:t.data}))):[]}addCallback(t,n,e){let a=-1;n&&n>0&&(a=setTimeout((()=>{this._callbacks=this._callbacks.filter((t=>t.timeoutId!==a)),t(this._didWork,this.getPendingTasks())}),n)),this._callbacks.push({doneCb:t,timeoutId:a,updateCb:e})}whenStable(t,n,e){if(e&&!this.taskTrackingZone)throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/dist/task-tracking.js" loaded?');this.addCallback(t,n,e),this._runCallbacksIfReady()}getPendingRequestCount(){return this._pendingCount}findProviders(t,n,e){return[]}}oC.ɵfac=function t(n){return new(n||oC)(Za(J_))},oC.ɵprov=We({token:oC,factory:oC.ɵfac}),oC.ctorParameters=()=>[{type:J_}];class rC{constructor(){this._applications=new Map,cC.addToWindow(this)}registerApplication(t,n){this._applications.set(t,n)}unregisterApplication(t){this._applications.delete(t)}unregisterAllApplications(){this._applications.clear()}getTestability(t){return this._applications.get(t)||null}getAllTestabilities(){return Array.from(this._applications.values())}getAllRootElements(){return Array.from(this._applications.keys())}findTestabilityInTree(t,n=!0){return cC.findTestabilityInTree(this,t,n)}}rC.ɵfac=function t(n){return new(n||rC)},rC.ɵprov=We({token:rC,factory:rC.ɵfac}),rC.ctorParameters=()=>[];let iC,cC=new class{addToWindow(t){}findTestabilityInTree(t,n,e){return null}};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const sC=new Fa("AllowMultipleToken");function lC(t,n,e=[]){const a=`Platform: ${n}`,o=new Fa(a);return(n=[])=>{let r=mC();if(!r||r.injector.get(sC,!1))if(t)t(e.concat(n).concat({provide:o,useValue:!0}));else{const t=e.concat(n).concat({provide:o,useValue:!0},{provide:ld,useValue:"platform"});!(function i(t){if(iC&&!iC.destroyed&&!iC.injector.get(sC,!1))throw new Error("There can be only one platform. Destroy the previous one to create a new one.");(function n(){ngDevMode&&(function t(){pg||(pg=!0,bg("getComponent",ng),bg("getContext",eg),bg("getListeners",lg),bg("getOwningComponent",ag),bg("getHostElement",sg),bg("getInjector",rg),bg("getRootComponents",og),bg("getDirectives",ig),bg("applyChanges",gg))})()})(),iC=t.get(dC);const e=t.get(R_,null);e&&e.forEach((t=>t()))})(yd.create({providers:t,name:a}))}return(function c(t){const n=mC();if(!n)throw new Error("No platform exists!");if(!n.injector.get(t,null))throw new Error("A platform with a different configuration has been created. Please destroy it first.");return n})(o)}}function mC(){return iC&&!iC.destroyed?iC:null}class dC{constructor(t){this._injector=t,this._modules=[],this._destroyListeners=[],this._destroyed=!1}bootstrapModuleFactory(t,n){const e=(function a(t,n){let e;return e="noop"===t?new aC:("zone.js"===t?void 0:t)||new J_({enableLongStackTrace:_c(),shouldCoalesceEventChangeDetection:n}),e})(n?n.ngZone:void 0,n&&n.ngZoneEventCoalescing||!1),o=[{provide:J_,useValue:e}];return e.run((()=>{const n=yd.create({providers:o,parent:this.injector,name:t.moduleType.name}),a=t.create(n),r=a.injector.get(oc,null);if(!r)throw new Error("No ErrorHandler. Is platform module (BrowserModule) included?");return a.onDestroy((()=>bC(this._modules,a))),e.runOutsideAngular((()=>e.onError.subscribe({next:t=>{r.handleError(t)}}))),(function i(t,n,e){try{const a=e();return rp(a)?a.catch((e=>{throw n.runOutsideAngular((()=>t.handleError(e))),e})):a}catch(e){throw n.runOutsideAngular((()=>t.handleError(e))),e}})(r,e,(()=>{const t=a.injector.get(w_);return t.runInitializers(),t.donePromise.then((()=>(hb(a.injector.get(N_,pb)||pb),this._moduleDoBootstrap(a),a)))}))}))}bootstrapModule(t,n=[]){const e=gC({},n);return(function a(t,n,e){ngDevMode&&(function a(t,n="Type passed in is not NgModuleType, it does not have 'ɵmod' property."){Ro(t)||Da(n)})(e);const o=new pf(e);if("undefined"!=typeof ngJitMode&&!ngJitMode)return Promise.resolve(o);const r=t.get(q_,[]).concat(n);if((function i(t){if(null!==Nh){if(t.defaultEncapsulation!==Nh.defaultEncapsulation)return void(ngDevMode&&console.error("Provided value for `defaultEncapsulation` can not be changed once it has been set."));if(t.preserveWhitespaces!==Nh.preserveWhitespaces)return void(ngDevMode&&console.error("Provided value for `preserveWhitespaces` can not be changed once it has been set."))}Nh=t})({defaultEncapsulation:uC(r.map((t=>t.defaultEncapsulation))),preserveWhitespaces:uC(r.map((t=>t.preserveWhitespaces)))}),(function c(){return 0===Jd.size})())return Promise.resolve(o);const s=(function l(t){const n=[];return t.forEach((t=>t&&n.push(...t))),n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(r.map((t=>t.providers)));if(0===s.length)return Promise.resolve(o);const m=ba(),d=yd.create({providers:s}).get(m.ResourceLoader);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
return(function g(t){const n=[],e=new Map;function a(n){let a=e.get(n);if(!a){const o=t(n);e.set(n,a=o.then($d))}return a}return Jd.forEach(((t,e)=>{const o=[];t.templateUrl&&o.push(a(t.templateUrl).then((n=>{t.template=n})));const r=t.styleUrls,i=t.styles||(t.styles=[]),c=t.styles.length;r&&r.forEach(((n,e)=>{i.push(""),o.push(a(n).then((a=>{i[c+e]=a,r.splice(r.indexOf(n),1),0==r.length&&(t.styleUrls=void 0)})))}));const s=Promise.all(o).then((()=>(function t(n){Qd.delete(n)})(e)));n.push(s)})),(function o(){Jd=new Map})(),Promise.all(n).then((()=>{}))})((t=>Promise.resolve(d.get(t)))).then((()=>o))})(this.injector,e,t).then((t=>this.bootstrapModuleFactory(t,e)))}_moduleDoBootstrap(t){const n=t.injector.get(pC);if(t._bootstrapComponents.length>0)t._bootstrapComponents.forEach((t=>n.bootstrap(t)));else{if(!t.instance.ngDoBootstrap)throw new Error(`The module ${ta(t.instance.constructor)} was bootstrapped, but it does not declare "@NgModule.bootstrap" components nor a "ngDoBootstrap" method. Please define one of these.`);t.instance.ngDoBootstrap(n)}this._modules.push(t)}onDestroy(t){this._destroyListeners.push(t)}get injector(){return this._injector}destroy(){if(this._destroyed)throw new Error("The platform has already been destroyed!");this._modules.slice().forEach((t=>t.destroy())),this._destroyListeners.forEach((t=>t())),this._destroyed=!0}get destroyed(){return this._destroyed}}function gC(t,n){return Array.isArray(n)?n.reduce(gC,t):Object.assign(Object.assign({},t),n)}dC.ɵfac=function t(n){return new(n||dC)(Za(yd))},dC.ɵprov=We({token:dC,factory:dC.ɵfac}),dC.ctorParameters=()=>[{type:yd}];class pC{constructor(t,n,e,a,o,r){this._zone=t,this._console=n,this._injector=e,this._exceptionHandler=a,this._componentFactoryResolver=o,this._initStatus=r,this._bootstrapListeners=[],this._views=[],this._runningTick=!1,this._enforceNoNewChanges=!1,this._stable=!0,this.componentTypes=[],this.components=[],this._enforceNoNewChanges=_c(),this._zone.onMicrotaskEmpty.subscribe({next:()=>{this._zone.run((()=>{this.tick()}))}});const i=new _((t=>{this._stable=this._zone.isStable&&!this._zone.hasPendingMacrotasks&&!this._zone.hasPendingMicrotasks,this._zone.runOutsideAngular((()=>{t.next(this._stable),t.complete()}))})),c=new _((t=>{let n;this._zone.runOutsideAngular((()=>{n=this._zone.onStable.subscribe((()=>{J_.assertNotInAngularZone(),X_((()=>{this._stable||this._zone.hasPendingMacrotasks||this._zone.hasPendingMicrotasks||(this._stable=!0,t.next(!0))}))}))}));const e=this._zone.onUnstable.subscribe((()=>{J_.assertInAngularZone(),this._stable&&(this._stable=!1,this._zone.runOutsideAngular((()=>{t.next(!1)})))}));return()=>{n.unsubscribe(),e.unsubscribe()}}));this.isStable=Wt(i,c.pipe(ee()))}bootstrap(t,n){if(!this._initStatus.done)throw new Error("Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.");let e;e=t instanceof Ou?t:this._componentFactoryResolver.resolveComponentFactory(t),this.componentTypes.push(e.componentType);const a=(function o(t){return t.isBoundToModule})(e)?void 0:this._injector.get(no),r=e.create(yd.NULL,[],n||e.selector,a);r.onDestroy((()=>{this._unloadComponent(r)}));const i=r.injector.get(oC,null);return i&&r.injector.get(rC).registerApplication(r.location.nativeElement,i),this._loadComponent(r),_c()&&this._console.log("Angular is running in development mode. Call enableProdMode() to enable production mode."),r}tick(){if(this._runningTick)throw new Error("ApplicationRef.tick is called recursively");try{this._runningTick=!0;for(let t of this._views)t.detectChanges();if(this._enforceNoNewChanges)for(let t of this._views)t.checkNoChanges()}catch(t){this._zone.runOutsideAngular((()=>this._exceptionHandler.handleError(t)))}finally{this._runningTick=!1}}attachView(t){const n=t;this._views.push(n),n.attachToAppRef(this)}detachView(t){const n=t;bC(this._views,n),n.detachFromAppRef()}_loadComponent(t){this.attachView(t.hostView),this.tick(),this.components.push(t),this._injector.get(D_,[]).concat(this._bootstrapListeners).forEach((n=>n(t)))}_unloadComponent(t){this.detachView(t.hostView),bC(this.components,t)}ngOnDestroy(){this._views.slice().forEach((t=>t.destroy()))}get viewCount(){return this._views.length}}function bC(t,n){const e=t.indexOf(n);e>-1&&t.splice(e,1)}function uC(t){for(let n=t.length-1;n>=0;n--)if(void 0!==t[n])return t[n]}pC.ɵfac=function t(n){return new(n||pC)(Za(J_),Za(I_),Za(yd),Za(oc),Za(Pu),Za(w_))},pC.ɵprov=We({token:pC,factory:pC.ɵfac}),pC.ctorParameters=()=>[{type:J_},{type:I_},{type:yd},{type:oc},{type:Pu},{type:w_}];class fC{}const hC={factoryPathPrefix:"",factoryPathSuffix:".ngfactory"};class _C{constructor(t,n){this._compiler=t,this._config=n||hC}load(t){return this.loadAndCompile(t)}loadAndCompile(t){let[n,e]=t.split("#");return void 0===e&&(e="default"),System.import(n).then((t=>t[e])).then((t=>CC(t,n,e))).then((t=>this._compiler.compileModuleAsync(t)))}loadFactory(t){let[n,e]=t.split("#"),a="NgFactory";return void 0===e&&(e="default",a=""),System.import(this._config.factoryPathPrefix+n+this._config.factoryPathSuffix).then((t=>t[e+a])).then((t=>CC(t,n,e)))}}function CC(t,n,e){if(!t)throw new Error(`Cannot find '${e}' in '${n}'`);return t}_C.ɵfac=function t(n){return new(n||_C)(Za(Y_),Za(fC,8))},_C.ɵprov=We({token:_C,factory:_C.ɵfac}),_C.ctorParameters=()=>[{type:Y_},{type:fC,decorators:[{type:Ne}]}];const MC=lC(null,"core",[{provide:T_,useValue:"unknown"},{provide:dC,deps:[yd]},{provide:rC,deps:[]},{provide:I_,deps:[]}]),OC=[{provide:pC,useClass:pC,deps:[J_,I_,yd,oc,Pu,w_]},{provide:sf,deps:[J_],useFactory:function PC(t){let n=[];return t.onStable.subscribe((()=>{for(;n.length;)n.pop()()})),function(t){n.push(t)}}},{provide:w_,useClass:w_,deps:[[new Ne,v_]]},{provide:Y_,useClass:Y_,deps:[]},E_,{provide:Wu,useFactory:
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function xC(){return Zu},deps:[]},{provide:Gu,useFactory:function yC(){return Xu},deps:[]},{provide:N_,useFactory:function kC(t){return hb(t=t||(function n(){return"undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode&&"undefined"!=typeof goog&&"en"!==goog.LOCALE?goog.LOCALE:"undefined"!=typeof $localize&&$localize.locale||pb})()),t},deps:[[new Ie(N_),new Ne,new Le]]},{provide:F_,useValue:"USD"}];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class vC{constructor(t){}}var wC,SC;vC.ɵmod=xo({type:vC}),vC.ɵinj=Ge({factory:function t(n){return new(n||vC)(Za(pC))},providers:OC}),vC.ctorParameters=()=>[{type:pC}],(function(t){t[t.CreateViewNodes=0]="CreateViewNodes",t[t.CheckNoChanges=1]="CheckNoChanges",t[t.CheckNoChangesProjectedViews=2]="CheckNoChangesProjectedViews",t[t.CheckAndUpdate=3]="CheckAndUpdate",t[t.CheckAndUpdateProjectedViews=4]="CheckAndUpdateProjectedViews",t[t.Destroy=5]="Destroy"})(wC||(wC={})),(function(t){t[t.create=0]="create",t[t.detectChanges=1]="detectChanges",t[t.checkNoChanges=2]="checkNoChanges",t[t.destroy=3]="destroy",t[t.handleEvent=4]="handleEvent"})(SC||(SC={})),
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
"undefined"!=typeof ngDevMode&&ngDevMode&&(ma.$localize=ma.$localize||function(){throw new Error("It looks like your application or one of its dependencies is using i18n.\nAngular 9 introduced a global `$localize()` function that needs to be loaded.\nPlease run `ng add @angular/localize` from the Angular CLI.\n(For non-CLI projects, add `import '@angular/localize/init';` to your `polyfills.ts` file.\nFor server-side rendering applications add the import to your `main.server.ts` file.)")})
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */;let EC=null;function AC(){return EC}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const zC=new Fa("DocumentToken");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class RC{}RC.ɵfac=function t(n){return new(n||RC)},RC.ɵprov=We({factory:function TC(){return Za(DC)},token:RC,providedIn:"platform"}),new Fa("Location Initialized");class DC extends RC{constructor(t){super(),this._doc=t,this._init()}_init(){this.location=AC().getLocation(),this._history=AC().getHistory()}getBaseHrefFromDOM(){return AC().getBaseHref(this._doc)}onPopState(t){AC().getGlobalEventTarget(this._doc,"window").addEventListener("popstate",t,!1)}onHashChange(t){AC().getGlobalEventTarget(this._doc,"window").addEventListener("hashchange",t,!1)}get href(){return this.location.href}get protocol(){return this.location.protocol}get hostname(){return this.location.hostname}get port(){return this.location.port}get pathname(){return this.location.pathname}get search(){return this.location.search}get hash(){return this.location.hash}set pathname(t){this.location.pathname=t}pushState(t,n,e){IC()?this._history.pushState(t,n,e):this.location.hash=e}replaceState(t,n,e){IC()?this._history.replaceState(t,n,e):this.location.hash=e}forward(){this._history.forward()}back(){this._history.back()}getState(){return this._history.state}}function IC(){return!!window.history.pushState}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function NC(t,n){if(0==t.length)return n;if(0==n.length)return t;let e=0;return t.endsWith("/")&&e++,n.startsWith("/")&&e++,2==e?t+n.substring(1):1==e?t+n:t+"/"+n}function FC(t){const n=t.match(/#|\?|$/),e=n&&n.index||t.length;return t.slice(0,e-("/"===t[e-1]?1:0))+t.slice(e)}function LC(t){return t&&"?"!==t[0]?"?"+t:t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */DC.ɵfac=function t(n){return new(n||DC)(Za(zC))},DC.ɵprov=We({factory:function HC(){return new DC(Za(zC))},token:DC,providedIn:"platform"}),DC.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class BC{}BC.ɵfac=function t(n){return new(n||BC)},BC.ɵprov=We({factory:function VC(t){const n=Za(zC).location;return new UC(Za(RC),n&&n.origin||"")},token:BC,providedIn:"root"});const jC=new Fa("appBaseHref");class UC extends BC{constructor(t,n){if(super(),this._platformLocation=t,null==n&&(n=this._platformLocation.getBaseHrefFromDOM()),null==n)throw new Error("No base href set. Please provide a value for the APP_BASE_HREF token or add a base element to the document.");this._baseHref=n}onPopState(t){this._platformLocation.onPopState(t),this._platformLocation.onHashChange(t)}getBaseHref(){return this._baseHref}prepareExternalUrl(t){return NC(this._baseHref,t)}path(t=!1){const n=this._platformLocation.pathname+LC(this._platformLocation.search),e=this._platformLocation.hash;return e&&t?`${n}${e}`:n}pushState(t,n,e,a){const o=this.prepareExternalUrl(e+LC(a));this._platformLocation.pushState(t,n,o)}replaceState(t,n,e,a){const o=this.prepareExternalUrl(e+LC(a));this._platformLocation.replaceState(t,n,o)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}}UC.ɵfac=function t(n){return new(n||UC)(Za(RC),Za(jC,8))},UC.ɵprov=We({token:UC,factory:UC.ɵfac}),UC.ctorParameters=()=>[{type:RC},{type:String,decorators:[{type:Ne},{type:Ie,args:[jC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class WC extends BC{constructor(t,n){super(),this._platformLocation=t,this._baseHref="",null!=n&&(this._baseHref=n)}onPopState(t){this._platformLocation.onPopState(t),this._platformLocation.onHashChange(t)}getBaseHref(){return this._baseHref}path(t=!1){let n=this._platformLocation.hash;return null==n&&(n="#"),n.length>0?n.substring(1):n}prepareExternalUrl(t){const n=NC(this._baseHref,t);return n.length>0?"#"+n:n}pushState(t,n,e,a){let o=this.prepareExternalUrl(e+LC(a));0==o.length&&(o=this._platformLocation.pathname),this._platformLocation.pushState(t,n,o)}replaceState(t,n,e,a){let o=this.prepareExternalUrl(e+LC(a));0==o.length&&(o=this._platformLocation.pathname),this._platformLocation.replaceState(t,n,o)}forward(){this._platformLocation.forward()}back(){this._platformLocation.back()}}WC.ɵfac=function t(n){return new(n||WC)(Za(RC),Za(jC,8))},WC.ɵprov=We({token:WC,factory:WC.ɵfac}),WC.ctorParameters=()=>[{type:RC},{type:String,decorators:[{type:Ne},{type:Ie,args:[jC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class GC{constructor(t,n){this._subject=new Ef,this._urlChangeListeners=[],this._platformStrategy=t;const e=this._platformStrategy.getBaseHref();this._platformLocation=n,this._baseHref=FC(YC(e)),this._platformStrategy.onPopState((t=>{this._subject.emit({url:this.path(!0),pop:!0,state:t.state,type:t.type})}))}path(t=!1){return this.normalize(this._platformStrategy.path(t))}getState(){return this._platformLocation.getState()}isCurrentPathEqualTo(t,n=""){return this.path()==this.normalize(t+LC(n))}normalize(t){return GC.stripTrailingSlash((function n(t,e){return t&&e.startsWith(t)?e.substring(t.length):e})(this._baseHref,YC(t)))}prepareExternalUrl(t){return t&&"/"!==t[0]&&(t="/"+t),this._platformStrategy.prepareExternalUrl(t)}go(t,n="",e=null){this._platformStrategy.pushState(e,"",t,n),this._notifyUrlChangeListeners(this.prepareExternalUrl(t+LC(n)),e)}replaceState(t,n="",e=null){this._platformStrategy.replaceState(e,"",t,n),this._notifyUrlChangeListeners(this.prepareExternalUrl(t+LC(n)),e)}forward(){this._platformStrategy.forward()}back(){this._platformStrategy.back()}onUrlChange(t){this._urlChangeListeners.push(t),this._urlChangeSubscription||(this._urlChangeSubscription=this.subscribe((t=>{this._notifyUrlChangeListeners(t.url,t.state)})))}_notifyUrlChangeListeners(t="",n){this._urlChangeListeners.forEach((e=>e(t,n)))}subscribe(t,n,e){return this._subject.subscribe({next:t,error:n,complete:e})}}function YC(t){return t.replace(/\/index.html$/,"")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */GC.ɵfac=function t(n){return new(n||GC)(Za(BC),Za(RC))},GC.normalizeQueryParams=LC,GC.joinWithSlash=NC,GC.stripTrailingSlash=FC,GC.ɵprov=We({factory:function qC(){return new GC(Za(BC),Za(RC))},token:GC,providedIn:"root"}),GC.ctorParameters=()=>[{type:BC},{type:RC}];const ZC={ADP:[void 0,void 0,0],AFN:[void 0,void 0,0],ALL:[void 0,void 0,0],AMD:[void 0,void 0,2],AOA:[void 0,"Kz"],ARS:[void 0,"$"],AUD:["A$","$"],BAM:[void 0,"KM"],BBD:[void 0,"$"],BDT:[void 0,"৳"],BHD:[void 0,void 0,3],BIF:[void 0,void 0,0],BMD:[void 0,"$"],BND:[void 0,"$"],BOB:[void 0,"Bs"],BRL:["R$"],BSD:[void 0,"$"],BWP:[void 0,"P"],BYN:[void 0,"р.",2],BYR:[void 0,void 0,0],BZD:[void 0,"$"],CAD:["CA$","$",2],CHF:[void 0,void 0,2],CLF:[void 0,void 0,4],CLP:[void 0,"$",0],CNY:["CN¥","¥"],COP:[void 0,"$",2],CRC:[void 0,"₡",2],CUC:[void 0,"$"],CUP:[void 0,"$"],CZK:[void 0,"Kč",2],DJF:[void 0,void 0,0],DKK:[void 0,"kr",2],DOP:[void 0,"$"],EGP:[void 0,"E£"],ESP:[void 0,"₧",0],EUR:["€"],FJD:[void 0,"$"],FKP:[void 0,"£"],GBP:["£"],GEL:[void 0,"₾"],GIP:[void 0,"£"],GNF:[void 0,"FG",0],GTQ:[void 0,"Q"],GYD:[void 0,"$",2],HKD:["HK$","$"],HNL:[void 0,"L"],HRK:[void 0,"kn"],HUF:[void 0,"Ft",2],IDR:[void 0,"Rp",2],ILS:["₪"],INR:["₹"],IQD:[void 0,void 0,0],IRR:[void 0,void 0,0],ISK:[void 0,"kr",0],ITL:[void 0,void 0,0],JMD:[void 0,"$"],JOD:[void 0,void 0,3],JPY:["¥",void 0,0],KHR:[void 0,"៛"],KMF:[void 0,"CF",0],KPW:[void 0,"₩",0],KRW:["₩",void 0,0],KWD:[void 0,void 0,3],KYD:[void 0,"$"],KZT:[void 0,"₸"],LAK:[void 0,"₭",0],LBP:[void 0,"L£",0],LKR:[void 0,"Rs"],LRD:[void 0,"$"],LTL:[void 0,"Lt"],LUF:[void 0,void 0,0],LVL:[void 0,"Ls"],LYD:[void 0,void 0,3],MGA:[void 0,"Ar",0],MGF:[void 0,void 0,0],MMK:[void 0,"K",0],MNT:[void 0,"₮",2],MRO:[void 0,void 0,0],MUR:[void 0,"Rs",2],MXN:["MX$","$"],MYR:[void 0,"RM"],NAD:[void 0,"$"],NGN:[void 0,"₦"],NIO:[void 0,"C$"],NOK:[void 0,"kr",2],NPR:[void 0,"Rs"],NZD:["NZ$","$"],OMR:[void 0,void 0,3],PHP:[void 0,"₱"],PKR:[void 0,"Rs",2],PLN:[void 0,"zł"],PYG:[void 0,"₲",0],RON:[void 0,"lei"],RSD:[void 0,void 0,0],RUB:[void 0,"₽"],RUR:[void 0,"р."],RWF:[void 0,"RF",0],SBD:[void 0,"$"],SEK:[void 0,"kr",2],SGD:[void 0,"$"],SHP:[void 0,"£"],SLL:[void 0,void 0,0],SOS:[void 0,void 0,0],SRD:[void 0,"$"],SSP:[void 0,"£"],STD:[void 0,void 0,0],STN:[void 0,"Db"],SYP:[void 0,"£",0],THB:[void 0,"฿"],TMM:[void 0,void 0,0],TND:[void 0,void 0,3],TOP:[void 0,"T$"],TRL:[void 0,void 0,0],TRY:[void 0,"₺"],TTD:[void 0,"$"],TWD:["NT$","$",2],TZS:[void 0,void 0,2],UAH:[void 0,"₴"],UGX:[void 0,void 0,0],USD:["$"],UYI:[void 0,void 0,0],UYU:[void 0,"$"],UYW:[void 0,void 0,4],UZS:[void 0,void 0,2],VEF:[void 0,"Bs",2],VND:["₫",void 0,0],VUV:[void 0,void 0,0],XAF:["FCFA",void 0,0],XCD:["EC$","$"],XOF:["CFA",void 0,0],XPF:["CFPF",void 0,0],XXX:["¤"],YER:[void 0,void 0,0],ZAR:[void 0,"R"],ZMK:[void 0,void 0,0],ZMW:[void 0,"ZK"],ZWD:[void 0,void 0,0]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */var XC,JC,QC,KC,$C,tM,nM;function eM(t,n){return lM(sb(t)[db.DateFormat],n)}function aM(t,n){return lM(sb(t)[db.TimeFormat],n)}function oM(t,n){return lM(sb(t)[db.DateTimeFormat],n)}function rM(t,n){const e=sb(t),a=e[db.NumberSymbols][n];if(void 0===a){if(n===tM.CurrencyDecimal)return e[db.NumberSymbols][tM.Decimal];if(n===tM.CurrencyGroup)return e[db.NumberSymbols][tM.Group]}return a}function iM(t,n){return sb(t)[db.NumberFormats][n]}!(function(t){t[t.Decimal=0]="Decimal",t[t.Percent=1]="Percent",t[t.Currency=2]="Currency",t[t.Scientific=3]="Scientific"})(XC||(XC={})),(function(t){t[t.Zero=0]="Zero",t[t.One=1]="One",t[t.Two=2]="Two",t[t.Few=3]="Few",t[t.Many=4]="Many",t[t.Other=5]="Other"})(JC||(JC={})),(function(t){t[t.Format=0]="Format",t[t.Standalone=1]="Standalone"})(QC||(QC={})),(function(t){t[t.Narrow=0]="Narrow",t[t.Abbreviated=1]="Abbreviated",t[t.Wide=2]="Wide",t[t.Short=3]="Short"})(KC||(KC={})),(function(t){t[t.Short=0]="Short",t[t.Medium=1]="Medium",t[t.Long=2]="Long",t[t.Full=3]="Full"})($C||($C={})),(function(t){t[t.Decimal=0]="Decimal",t[t.Group=1]="Group",t[t.List=2]="List",t[t.PercentSign=3]="PercentSign",t[t.PlusSign=4]="PlusSign",t[t.MinusSign=5]="MinusSign",t[t.Exponential=6]="Exponential",t[t.SuperscriptingExponent=7]="SuperscriptingExponent",t[t.PerMille=8]="PerMille",t[t[1/0]=9]="Infinity",t[t.NaN=10]="NaN",t[t.TimeSeparator=11]="TimeSeparator",t[t.CurrencyDecimal=12]="CurrencyDecimal",t[t.CurrencyGroup=13]="CurrencyGroup"})(tM||(tM={})),(function(t){t[t.Sunday=0]="Sunday",t[t.Monday=1]="Monday",t[t.Tuesday=2]="Tuesday",t[t.Wednesday=3]="Wednesday",t[t.Thursday=4]="Thursday",t[t.Friday=5]="Friday",t[t.Saturday=6]="Saturday"})(nM||(nM={}));const cM=lb;function sM(t){if(!t[db.ExtraData])throw new Error(`Missing extra locale data for the locale "${t[db.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`)}function lM(t,n){for(let e=n;e>-1;e--)if(void 0!==t[e])return t[e];throw new Error("Locale data API: locale data undefined")}function mM(t){const[n,e]=t.split(":");return{hours:+n,minutes:+e}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const dM=/^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/,gM={},pM=/((?:[^GyMLwWdEabBhHmsSzZO']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/;var bM,uM,fM;function hM(t,n,e,a){let o=(function r(t){if(wM(t))return t;if("number"==typeof t&&!isNaN(t))return new Date(t);if("string"==typeof t){t=t.trim();const n=parseFloat(t);if(!isNaN(t-n))return new Date(n);if(/^(\d{4}-\d{1,2}-\d{1,2})$/.test(t)){const[n,e,a]=t.split("-").map((t=>+t));return new Date(n,e-1,a)}let e;if(e=t.match(dM))return(function n(t){const n=new Date(0);let e=0,a=0;const o=t[8]?n.setUTCFullYear:n.setFullYear,r=t[8]?n.setUTCHours:n.setHours;t[9]&&(e=Number(t[9]+t[10]),a=Number(t[9]+t[11])),o.call(n,Number(t[1]),Number(t[2])-1,Number(t[3]));const i=Number(t[4]||0)-e,c=Number(t[5]||0)-a,s=Number(t[6]||0),l=Math.round(1e3*parseFloat("0."+(t[7]||0)));return r.call(n,i,c,s,l),n})(e)}const e=new Date(t);if(!wM(e))throw new Error(`Unable to convert "${t}" into a date`);return e})(t);n=_M(e,n)||n;let i,c=[];for(;n;){if(i=pM.exec(n),!i){c.push(n);break}{c=c.concat(i.slice(1));const t=c.pop();if(!t)break;n=t}}let s=o.getTimezoneOffset();a&&(s=vM(a,s),o=(function l(t,n,e){const a=e?-1:1,o=t.getTimezoneOffset();return(function r(t,n){return(t=new Date(t.getTime())).setMinutes(t.getMinutes()+n),t})(t,a*(vM(n,o)-o))})(o,a,!0));let m="";return c.forEach((t=>{const n=(function a(t){if(kM[t])return kM[t];let n;switch(t){case"G":case"GG":case"GGG":n=PM(fM.Eras,KC.Abbreviated);break;case"GGGG":n=PM(fM.Eras,KC.Wide);break;case"GGGGG":n=PM(fM.Eras,KC.Narrow);break;case"y":n=OM(uM.FullYear,1,0,!1,!0);break;case"yy":n=OM(uM.FullYear,2,0,!0,!0);break;case"yyy":n=OM(uM.FullYear,3,0,!1,!0);break;case"yyyy":n=OM(uM.FullYear,4,0,!1,!0);break;case"M":case"L":n=OM(uM.Month,1,1);break;case"MM":case"LL":n=OM(uM.Month,2,1);break;case"MMM":n=PM(fM.Months,KC.Abbreviated);break;case"MMMM":n=PM(fM.Months,KC.Wide);break;case"MMMMM":n=PM(fM.Months,KC.Narrow);break;case"LLL":n=PM(fM.Months,KC.Abbreviated,QC.Standalone);break;case"LLLL":n=PM(fM.Months,KC.Wide,QC.Standalone);break;case"LLLLL":n=PM(fM.Months,KC.Narrow,QC.Standalone);break;case"w":n=yM(1);break;case"ww":n=yM(2);break;case"W":n=yM(1,!0);break;case"d":n=OM(uM.Date,1);break;case"dd":n=OM(uM.Date,2);break;case"E":case"EE":case"EEE":n=PM(fM.Days,KC.Abbreviated);break;case"EEEE":n=PM(fM.Days,KC.Wide);break;case"EEEEE":n=PM(fM.Days,KC.Narrow);break;case"EEEEEE":n=PM(fM.Days,KC.Short);break;case"a":case"aa":case"aaa":n=PM(fM.DayPeriods,KC.Abbreviated);break;case"aaaa":n=PM(fM.DayPeriods,KC.Wide);break;case"aaaaa":n=PM(fM.DayPeriods,KC.Narrow);break;case"b":case"bb":case"bbb":n=PM(fM.DayPeriods,KC.Abbreviated,QC.Standalone,!0);break;case"bbbb":n=PM(fM.DayPeriods,KC.Wide,QC.Standalone,!0);break;case"bbbbb":n=PM(fM.DayPeriods,KC.Narrow,QC.Standalone,!0);break;case"B":case"BB":case"BBB":n=PM(fM.DayPeriods,KC.Abbreviated,QC.Format,!0);break;case"BBBB":n=PM(fM.DayPeriods,KC.Wide,QC.Format,!0);break;case"BBBBB":n=PM(fM.DayPeriods,KC.Narrow,QC.Format,!0);break;case"h":n=OM(uM.Hours,1,-12);break;case"hh":n=OM(uM.Hours,2,-12);break;case"H":n=OM(uM.Hours,1);break;case"HH":n=OM(uM.Hours,2);break;case"m":n=OM(uM.Minutes,1);break;case"mm":n=OM(uM.Minutes,2);break;case"s":n=OM(uM.Seconds,1);break;case"ss":n=OM(uM.Seconds,2);break;case"S":n=OM(uM.FractionalSeconds,1);break;case"SS":n=OM(uM.FractionalSeconds,2);break;case"SSS":n=OM(uM.FractionalSeconds,3);break;case"Z":case"ZZ":case"ZZZ":n=xM(bM.Short);break;case"ZZZZZ":n=xM(bM.Extended);break;case"O":case"OO":case"OOO":case"z":case"zz":case"zzz":n=xM(bM.ShortGMT);break;case"OOOO":case"ZZZZ":case"zzzz":n=xM(bM.Long);break;default:return null}return kM[t]=n,n})(t);m+=n?n(o,e,s):"''"===t?"'":t.replace(/(^'|'$)/g,"").replace(/''/g,"'")})),m}function _M(t,n){const e=(function a(t){return sb(t)[db.LocaleId]})(t);if(gM[e]=gM[e]||{},gM[e][n])return gM[e][n];let o="";switch(n){case"shortDate":o=eM(t,$C.Short);break;case"mediumDate":o=eM(t,$C.Medium);break;case"longDate":o=eM(t,$C.Long);break;case"fullDate":o=eM(t,$C.Full);break;case"shortTime":o=aM(t,$C.Short);break;case"mediumTime":o=aM(t,$C.Medium);break;case"longTime":o=aM(t,$C.Long);break;case"fullTime":o=aM(t,$C.Full);break;case"short":const n=_M(t,"shortTime"),e=_M(t,"shortDate");o=CM(oM(t,$C.Short),[n,e]);break;case"medium":const a=_M(t,"mediumTime"),r=_M(t,"mediumDate");o=CM(oM(t,$C.Medium),[a,r]);break;case"long":const i=_M(t,"longTime"),c=_M(t,"longDate");o=CM(oM(t,$C.Long),[i,c]);break;case"full":const s=_M(t,"fullTime"),l=_M(t,"fullDate");o=CM(oM(t,$C.Full),[s,l])}return o&&(gM[e][n]=o),o}function CM(t,n){return n&&(t=t.replace(/\{([^}]+)}/g,(function(t,e){return null!=n&&e in n?n[e]:t}))),t}function MM(t,n,e="-",a,o){let r="";(t<0||o&&t<=0)&&(o?t=1-t:(t=-t,r=e));let i=String(t);for(;i.length<n;)i="0"+i;return a&&(i=i.substr(i.length-n)),r+i}function OM(t,n,e=0,a=!1,o=!1){return function(r,i){let c=(function s(t,n){switch(t){case uM.FullYear:return n.getFullYear();case uM.Month:return n.getMonth();case uM.Date:return n.getDate();case uM.Hours:return n.getHours();case uM.Minutes:return n.getMinutes();case uM.Seconds:return n.getSeconds();case uM.FractionalSeconds:return n.getMilliseconds();case uM.Day:return n.getDay();default:throw new Error(`Unknown DateType value "${t}".`)}})(t,r);if((e>0||c>-e)&&(c+=e),t===uM.Hours)0===c&&-12===e&&(c=12);else if(t===uM.FractionalSeconds)return(function l(t,n){return MM(t,3).substr(0,n)})(c,n);const m=rM(i,tM.MinusSign);return MM(c,n,m,a,o)}}function PM(t,n,e=QC.Format,a=!1){return function(o,r){return(function i(t,n,e,a,o,r){switch(e){case fM.Months:return(function i(t,n,e){const a=sb(t),o=lM([a[db.MonthsFormat],a[db.MonthsStandalone]],n);return lM(o,e)})(n,o,a)[t.getMonth()];case fM.Days:return(function c(t,n,e){const a=sb(t),o=lM([a[db.DaysFormat],a[db.DaysStandalone]],n);return lM(o,e)})(n,o,a)[t.getDay()];case fM.DayPeriods:const i=t.getHours(),c=t.getMinutes();if(r){const t=(function s(t){const n=sb(t);return sM(n),(n[db.ExtraData][2]||[]).map((t=>"string"==typeof t?mM(t):[mM(t[0]),mM(t[1])]))})(n),e=(function l(t,n,e){const a=sb(t);sM(a);const o=lM([a[db.ExtraData][0],a[db.ExtraData][1]],n)||[];return lM(o,e)||[]})(n,o,a),r=t.findIndex((t=>{if(Array.isArray(t)){const[n,e]=t,a=i>=n.hours&&c>=n.minutes,o=i<e.hours||i===e.hours&&c<e.minutes;if(n.hours<e.hours){if(a&&o)return!0}else if(a||o)return!0}else if(t.hours===i&&t.minutes===c)return!0;return!1}));if(-1!==r)return e[r]}return(function m(t,n,e){const a=sb(t),o=lM([a[db.DayPeriodsFormat],a[db.DayPeriodsStandalone]],n);return lM(o,e)})(n,o,a)[i<12?0:1];case fM.Eras:return(function d(t,n){return lM(sb(t)[db.Eras],n)})(n,a)[t.getFullYear()<=0?0:1];default:throw new Error(`unexpected translation type ${e}`)}})(o,r,t,n,e,a)}}function xM(t){return function(n,e,a){const o=-1*a,r=rM(e,tM.MinusSign),i=o>0?Math.floor(o/60):Math.ceil(o/60);switch(t){case bM.Short:return(o>=0?"+":"")+MM(i,2,r)+MM(Math.abs(o%60),2,r);case bM.ShortGMT:return"GMT"+(o>=0?"+":"")+MM(i,1,r);case bM.Long:return"GMT"+(o>=0?"+":"")+MM(i,2,r)+":"+MM(Math.abs(o%60),2,r);case bM.Extended:return 0===a?"Z":(o>=0?"+":"")+MM(i,2,r)+":"+MM(Math.abs(o%60),2,r);default:throw new Error(`Unknown zone width "${t}"`)}}}function yM(t,n=!1){return function(e,a){let o;if(n){const t=new Date(e.getFullYear(),e.getMonth(),1).getDay()-1,n=e.getDate();o=1+Math.floor((n+t)/7)}else{const t=(function r(t){return new Date(t.getFullYear(),t.getMonth(),t.getDate()+(4-t.getDay()))})(e),n=(function i(t){const n=new Date(t,0,1).getDay();return new Date(t,0,1+(n<=4?4:11)-n)})(t.getFullYear()),a=t.getTime()-n.getTime();o=1+Math.round(a/6048e5)}return MM(o,t,rM(a,tM.MinusSign))}}!(function(t){t[t.Short=0]="Short",t[t.ShortGMT=1]="ShortGMT",t[t.Long=2]="Long",t[t.Extended=3]="Extended"})(bM||(bM={})),(function(t){t[t.FullYear=0]="FullYear",t[t.Month=1]="Month",t[t.Date=2]="Date",t[t.Hours=3]="Hours",t[t.Minutes=4]="Minutes",t[t.Seconds=5]="Seconds",t[t.FractionalSeconds=6]="FractionalSeconds",t[t.Day=7]="Day"})(uM||(uM={})),(function(t){t[t.DayPeriods=0]="DayPeriods",t[t.Days=1]="Days",t[t.Months=2]="Months",t[t.Eras=3]="Eras"})(fM||(fM={}));const kM={};function vM(t,n){t=t.replace(/:/g,"");const e=Date.parse("Jan 01, 1970 00:00:00 "+t)/6e4;return isNaN(e)?n:e}function wM(t){return t instanceof Date&&!isNaN(t.valueOf())}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const SM=/^(\d+)?\.((\d+)(-(\d+))?)?$/,EM=".",AM="0";function zM(t,n,e,a,o,r,i=!1){let c="",s=!1;if(isFinite(t)){let l=(function l(t){let n,e,a,o,r,i=Math.abs(t)+"",c=0;for((e=i.indexOf(EM))>-1&&(i=i.replace(EM,"")),(a=i.search(/e/i))>0?(e<0&&(e=a),e+=+i.slice(a+1),i=i.substring(0,a)):e<0&&(e=i.length),a=0;i.charAt(a)===AM;a++);if(a===(r=i.length))n=[0],e=1;else{for(r--;i.charAt(r)===AM;)r--;for(e-=a,n=[],o=0;a<=r;a++,o++)n[o]=Number(i.charAt(a))}return e>22&&(n=n.splice(0,21),c=e-1,e=1),{digits:n,exponent:c,integerLen:e}})(t);i&&(l=(function m(t){if(0===t.digits[0])return t;const n=t.digits.length-t.integerLen;return t.exponent?t.exponent+=2:(0===n?t.digits.push(0,0):1===n&&t.digits.push(0),t.integerLen+=2),t})(l));let m=n.minInt,d=n.minFrac,g=n.maxFrac;if(r){const t=r.match(SM);if(null===t)throw new Error(`${r} is not a valid digit info`);const n=t[1],e=t[3],a=t[5];null!=n&&(m=DM(n)),null!=e&&(d=DM(e)),null!=a?g=DM(a):null!=e&&d>g&&(g=d)}!(function d(t,n,e){if(n>e)throw new Error(`The minimum number of digits after fraction (${n}) is higher than the maximum (${e}).`);let a=t.digits,o=a.length-t.integerLen;const r=Math.min(Math.max(n,o),e);let i=r+t.integerLen,c=a[i];if(i>0){a.splice(Math.max(t.integerLen,i));for(let t=i;t<a.length;t++)a[t]=0}else{o=Math.max(0,o),t.integerLen=1,a.length=Math.max(1,i=r+1),a[0]=0;for(let t=1;t<i;t++)a[t]=0}if(c>=5)if(i-1<0){for(let n=0;n>i;n--)a.unshift(0),t.integerLen++;a.unshift(1),t.integerLen++}else a[i-1]++;for(;o<Math.max(0,r);o++)a.push(0);let s=0!==r;const l=n+t.integerLen,m=a.reduceRight((function(t,n,e,a){return a[e]=(n+=t)<10?n:n-10,s&&(0===a[e]&&e>=l?a.pop():s=!1),n>=10?1:0}),0);m&&(a.unshift(m),t.integerLen++)})(l,d,g);let p=l.digits,b=l.integerLen;const u=l.exponent;let f=[];for(s=p.every((t=>!t));b<m;b++)p.unshift(0);for(;b<0;b++)p.unshift(0);b>0?f=p.splice(b,p.length):(f=p,p=[0]);const h=[];for(p.length>=n.lgSize&&h.unshift(p.splice(-n.lgSize,p.length).join(""));p.length>n.gSize;)h.unshift(p.splice(-n.gSize,p.length).join(""));p.length&&h.unshift(p.join("")),c=h.join(rM(e,a)),f.length&&(c+=rM(e,o)+f.join("")),u&&(c+=rM(e,tM.Exponential)+"+"+u)}else c=rM(e,tM.Infinity);return c=t<0&&!s?n.negPre+c+n.negSuf:n.posPre+c+n.posSuf,c}function RM(t,n,e){return zM(t,TM(iM(n,XC.Decimal),rM(n,tM.MinusSign)),n,tM.Group,tM.Decimal,e)}function TM(t,n="-"){const e={minInt:1,minFrac:0,maxFrac:0,posPre:"",posSuf:"",negPre:"",negSuf:"",gSize:0,lgSize:0},a=t.split(";"),o=a[0],r=a[1],i=-1!==o.indexOf(EM)?o.split(EM):[o.substring(0,o.lastIndexOf(AM)+1),o.substring(o.lastIndexOf(AM)+1)],c=i[0],s=i[1]||"";e.posPre=c.substr(0,c.indexOf("#"));for(let t=0;t<s.length;t++){const n=s.charAt(t);n===AM?e.minFrac=e.maxFrac=t+1:"#"===n?e.maxFrac=t+1:e.posSuf+=n}const l=c.split(",");if(e.gSize=l[1]?l[1].length:0,e.lgSize=l[2]||l[1]?(l[2]||l[1]).length:0,r){const t=o.length-e.posPre.length-e.posSuf.length,n=r.indexOf("#");e.negPre=r.substr(0,n).replace(/'/g,""),e.negSuf=r.substr(n+t).replace(/'/g,"")}else e.negPre=n+e.posPre,e.negSuf=e.posSuf;return e}function DM(t){const n=parseInt(t);if(isNaN(n))throw new Error("Invalid integer literal when parsing "+t);return n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class IM{}function NM(t,n,e,a){let o=`=${t}`;if(n.indexOf(o)>-1)return o;if(o=e.getPluralCategory(t,a),n.indexOf(o)>-1)return o;if(n.indexOf("other")>-1)return"other";throw new Error(`No plural message found for value "${t}"`)}class FM extends IM{constructor(t){super(),this.locale=t}getPluralCategory(t,n){switch(cM(n||this.locale)(t)){case JC.Zero:return"zero";case JC.One:return"one";case JC.Two:return"two";case JC.Few:return"few";case JC.Many:return"many";default:return"other"}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function LM(t,n){n=encodeURIComponent(n);for(const e of t.split(";")){const t=e.indexOf("="),[a,o]=-1==t?[e,""]:[e.slice(0,t),e.slice(t+1)];if(a.trim()===n)return decodeURIComponent(o)}return null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */FM.ɵfac=function t(n){return new(n||FM)(Za(N_))},FM.ɵprov=We({token:FM,factory:FM.ɵfac}),FM.ctorParameters=()=>[{type:String,decorators:[{type:Ie,args:[N_]}]}];class HM{constructor(t,n,e,a){this._iterableDiffers=t,this._keyValueDiffers=n,this._ngEl=e,this._renderer=a,this._iterableDiffer=null,this._keyValueDiffer=null,this._initialClasses=[],this._rawClass=null}set klass(t){this._removeClasses(this._initialClasses),this._initialClasses="string"==typeof t?t.split(/\s+/):[],this._applyClasses(this._initialClasses),this._applyClasses(this._rawClass)}set ngClass(t){this._removeClasses(this._rawClass),this._applyClasses(this._initialClasses),this._iterableDiffer=null,this._keyValueDiffer=null,this._rawClass="string"==typeof t?t.split(/\s+/):t,this._rawClass&&(Sg(this._rawClass)?this._iterableDiffer=this._iterableDiffers.find(this._rawClass).create():this._keyValueDiffer=this._keyValueDiffers.find(this._rawClass).create())}ngDoCheck(){if(this._iterableDiffer){const t=this._iterableDiffer.diff(this._rawClass);t&&this._applyIterableChanges(t)}else if(this._keyValueDiffer){const t=this._keyValueDiffer.diff(this._rawClass);t&&this._applyKeyValueChanges(t)}}_applyKeyValueChanges(t){t.forEachAddedItem((t=>this._toggleClass(t.key,t.currentValue))),t.forEachChangedItem((t=>this._toggleClass(t.key,t.currentValue))),t.forEachRemovedItem((t=>{t.previousValue&&this._toggleClass(t.key,!1)}))}_applyIterableChanges(t){t.forEachAddedItem((t=>{if("string"!=typeof t.item)throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${ta(t.item)}`);this._toggleClass(t.item,!0)})),t.forEachRemovedItem((t=>this._toggleClass(t.item,!1)))}_applyClasses(t){t&&(Array.isArray(t)||t instanceof Set?t.forEach((t=>this._toggleClass(t,!0))):Object.keys(t).forEach((n=>this._toggleClass(n,!!t[n]))))}_removeClasses(t){t&&(Array.isArray(t)||t instanceof Set?t.forEach((t=>this._toggleClass(t,!1))):Object.keys(t).forEach((t=>this._toggleClass(t,!1))))}_toggleClass(t,n){(t=t.trim())&&t.split(/\s+/g).forEach((t=>{n?this._renderer.addClass(this._ngEl.nativeElement,t):this._renderer.removeClass(this._ngEl.nativeElement,t)}))}}HM.ɵfac=function t(n){return new(n||HM)(Zg(Wu),Zg(Gu),Zg(xu),Zg(Su))},HM.ɵdir=vo({type:HM,selectors:[["","ngClass",""]],inputs:{klass:["class","klass"],ngClass:"ngClass"}}),HM.ctorParameters=()=>[{type:Wu},{type:Gu},{type:xu},{type:Su}],HM.propDecorators={klass:[{type:f_,args:["class"]}],ngClass:[{type:f_,args:["ngClass"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class BM{constructor(t){this._viewContainerRef=t,this._componentRef=null,this._moduleRef=null}ngOnChanges(t){if(this._viewContainerRef.clear(),this._componentRef=null,this.ngComponentOutlet){const n=this.ngComponentOutletInjector||this._viewContainerRef.parentInjector;if(t.ngComponentOutletNgModuleFactory)if(this._moduleRef&&this._moduleRef.destroy(),this.ngComponentOutletNgModuleFactory){const t=n.get(no);this._moduleRef=this.ngComponentOutletNgModuleFactory.create(t.injector)}else this._moduleRef=null;const e=(this._moduleRef?this._moduleRef.componentFactoryResolver:n.get(Pu)).resolveComponentFactory(this.ngComponentOutlet);this._componentRef=this._viewContainerRef.createComponent(e,this._viewContainerRef.length,n,this.ngComponentOutletContent)}}ngOnDestroy(){this._moduleRef&&this._moduleRef.destroy()}}BM.ɵfac=function t(n){return new(n||BM)(Zg($u))},BM.ɵdir=vo({type:BM,selectors:[["","ngComponentOutlet",""]],inputs:{ngComponentOutlet:"ngComponentOutlet",ngComponentOutletInjector:"ngComponentOutletInjector",ngComponentOutletContent:"ngComponentOutletContent",ngComponentOutletNgModuleFactory:"ngComponentOutletNgModuleFactory"},features:[pr]}),BM.ctorParameters=()=>[{type:$u}],BM.propDecorators={ngComponentOutlet:[{type:f_}],ngComponentOutletInjector:[{type:f_}],ngComponentOutletContent:[{type:f_}],ngComponentOutletNgModuleFactory:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class VM{constructor(t,n,e,a){this.$implicit=t,this.ngForOf=n,this.index=e,this.count=a}get first(){return 0===this.index}get last(){return this.index===this.count-1}get even(){return this.index%2==0}get odd(){return!this.even}}class jM{constructor(t,n,e){this._viewContainer=t,this._template=n,this._differs=e,this._ngForOf=null,this._ngForOfDirty=!0,this._differ=null}set ngForOf(t){this._ngForOf=t,this._ngForOfDirty=!0}set ngForTrackBy(t){_c()&&null!=t&&"function"!=typeof t&&console&&console.warn&&console.warn(`trackBy must be a function, but received ${JSON.stringify(t)}. See https://angular.io/api/common/NgForOf#change-propagation for more information.`),this._trackByFn=t}get ngForTrackBy(){return this._trackByFn}set ngForTemplate(t){t&&(this._template=t)}ngDoCheck(){if(this._ngForOfDirty){this._ngForOfDirty=!1;const t=this._ngForOf;if(!this._differ&&t)try{this._differ=this._differs.find(t).create(this.ngForTrackBy)}catch(n){throw new Error(`Cannot find a differ supporting object '${t}' of type '${(function t(n){return n.name||typeof n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t)}'. NgFor only supports binding to Iterables such as Arrays.`)}}if(this._differ){const t=this._differ.diff(this._ngForOf);t&&this._applyChanges(t)}}_applyChanges(t){const n=[];t.forEachOperation(((t,e,a)=>{if(null==t.previousIndex){const e=this._viewContainer.createEmbeddedView(this._template,new VM(null,this._ngForOf,-1,-1),null===a?void 0:a),o=new UM(t,e);n.push(o)}else if(null==a)this._viewContainer.remove(null===e?void 0:e);else if(null!==e){const o=this._viewContainer.get(e);this._viewContainer.move(o,a);const r=new UM(t,o);n.push(r)}}));for(let t=0;t<n.length;t++)this._perViewChange(n[t].view,n[t].record);for(let t=0,n=this._viewContainer.length;t<n;t++){const e=this._viewContainer.get(t);e.context.index=t,e.context.count=n,e.context.ngForOf=this._ngForOf}t.forEachIdentityChange((t=>{this._viewContainer.get(t.currentIndex).context.$implicit=t.item}))}_perViewChange(t,n){t.context.$implicit=n.item}static ngTemplateContextGuard(t,n){return!0}}jM.ɵfac=function t(n){return new(n||jM)(Zg($u),Zg(Ju),Zg(Wu))},jM.ɵdir=vo({type:jM,selectors:[["","ngFor","","ngForOf",""]],inputs:{ngForOf:"ngForOf",ngForTrackBy:"ngForTrackBy",ngForTemplate:"ngForTemplate"}}),jM.ctorParameters=()=>[{type:$u},{type:Ju},{type:Wu}],jM.propDecorators={ngForOf:[{type:f_}],ngForTrackBy:[{type:f_}],ngForTemplate:[{type:f_}]};class UM{constructor(t,n){this.record=t,this.view=n}}class WM{constructor(t,n){this._viewContainer=t,this._context=new GM,this._thenTemplateRef=null,this._elseTemplateRef=null,this._thenViewRef=null,this._elseViewRef=null,this._thenTemplateRef=n}set ngIf(t){this._context.$implicit=this._context.ngIf=t,this._updateView()}set ngIfThen(t){YM("ngIfThen",t),this._thenTemplateRef=t,this._thenViewRef=null,this._updateView()}set ngIfElse(t){YM("ngIfElse",t),this._elseTemplateRef=t,this._elseViewRef=null,this._updateView()}_updateView(){this._context.$implicit?this._thenViewRef||(this._viewContainer.clear(),this._elseViewRef=null,this._thenTemplateRef&&(this._thenViewRef=this._viewContainer.createEmbeddedView(this._thenTemplateRef,this._context))):this._elseViewRef||(this._viewContainer.clear(),this._thenViewRef=null,this._elseTemplateRef&&(this._elseViewRef=this._viewContainer.createEmbeddedView(this._elseTemplateRef,this._context)))}static ngTemplateContextGuard(t,n){return!0}}WM.ɵfac=function t(n){return new(n||WM)(Zg($u),Zg(Ju))},WM.ɵdir=vo({type:WM,selectors:[["","ngIf",""]],inputs:{ngIf:"ngIf",ngIfThen:"ngIfThen",ngIfElse:"ngIfElse"}}),WM.ctorParameters=()=>[{type:$u},{type:Ju}],WM.propDecorators={ngIf:[{type:f_}],ngIfThen:[{type:f_}],ngIfElse:[{type:f_}]};class GM{constructor(){this.$implicit=null,this.ngIf=null}}function YM(t,n){if(n&&!n.createEmbeddedView)throw new Error(`${t} must be a TemplateRef, but received '${ta(n)}'.`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class qM{constructor(t,n){this._viewContainerRef=t,this._templateRef=n,this._created=!1}create(){this._created=!0,this._viewContainerRef.createEmbeddedView(this._templateRef)}destroy(){this._created=!1,this._viewContainerRef.clear()}enforceState(t){t&&!this._created?this.create():!t&&this._created&&this.destroy()}}class ZM{constructor(){this._defaultUsed=!1,this._caseCount=0,this._lastCaseCheckIndex=0,this._lastCasesMatched=!1}set ngSwitch(t){this._ngSwitch=t,0===this._caseCount&&this._updateDefaultCases(!0)}_addCase(){return this._caseCount++}_addDefault(t){this._defaultViews||(this._defaultViews=[]),this._defaultViews.push(t)}_matchCase(t){const n=t==this._ngSwitch;return this._lastCasesMatched=this._lastCasesMatched||n,this._lastCaseCheckIndex++,this._lastCaseCheckIndex===this._caseCount&&(this._updateDefaultCases(!this._lastCasesMatched),this._lastCaseCheckIndex=0,this._lastCasesMatched=!1),n}_updateDefaultCases(t){if(this._defaultViews&&t!==this._defaultUsed){this._defaultUsed=t;for(let n=0;n<this._defaultViews.length;n++)this._defaultViews[n].enforceState(t)}}}ZM.ɵfac=function t(n){return new(n||ZM)},ZM.ɵdir=vo({type:ZM,selectors:[["","ngSwitch",""]],inputs:{ngSwitch:"ngSwitch"}}),ZM.propDecorators={ngSwitch:[{type:f_}]};class XM{constructor(t,n,e){this.ngSwitch=e,e._addCase(),this._view=new qM(t,n)}ngDoCheck(){this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase))}}XM.ɵfac=function t(n){return new(n||XM)(Zg($u),Zg(Ju),Zg(ZM,1))},XM.ɵdir=vo({type:XM,selectors:[["","ngSwitchCase",""]],inputs:{ngSwitchCase:"ngSwitchCase"}}),XM.ctorParameters=()=>[{type:$u},{type:Ju},{type:ZM,decorators:[{type:He}]}],XM.propDecorators={ngSwitchCase:[{type:f_}]};class JM{constructor(t,n,e){e._addDefault(new qM(t,n))}}JM.ɵfac=function t(n){return new(n||JM)(Zg($u),Zg(Ju),Zg(ZM,1))},JM.ɵdir=vo({type:JM,selectors:[["","ngSwitchDefault",""]]}),JM.ctorParameters=()=>[{type:$u},{type:Ju},{type:ZM,decorators:[{type:He}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class QM{constructor(t){this._localization=t,this._caseViews={}}set ngPlural(t){this._switchValue=t,this._updateView()}addCase(t,n){this._caseViews[t]=n}_updateView(){this._clearViews();const t=Object.keys(this._caseViews),n=NM(this._switchValue,t,this._localization);this._activateView(this._caseViews[n])}_clearViews(){this._activeView&&this._activeView.destroy()}_activateView(t){t&&(this._activeView=t,this._activeView.create())}}QM.ɵfac=function t(n){return new(n||QM)(Zg(IM))},QM.ɵdir=vo({type:QM,selectors:[["","ngPlural",""]],inputs:{ngPlural:"ngPlural"}}),QM.ctorParameters=()=>[{type:IM}],QM.propDecorators={ngPlural:[{type:f_}]};class KM{constructor(t,n,e,a){this.value=t;const o=!isNaN(Number(t));a.addCase(o?`=${t}`:t,new qM(e,n))}}KM.ɵfac=function t(n){return new(n||KM)(Xg("ngPluralCase"),Zg(Ju),Zg($u),Zg(QM,1))},KM.ɵdir=vo({type:KM,selectors:[["","ngPluralCase",""]]}),KM.ctorParameters=()=>[{type:String,decorators:[{type:Be,args:["ngPluralCase"]}]},{type:Ju},{type:$u},{type:QM,decorators:[{type:He}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class $M{constructor(t,n,e){this._ngEl=t,this._differs=n,this._renderer=e,this._ngStyle=null,this._differ=null}set ngStyle(t){this._ngStyle=t,!this._differ&&t&&(this._differ=this._differs.find(t).create())}ngDoCheck(){if(this._differ){const t=this._differ.diff(this._ngStyle);t&&this._applyChanges(t)}}_setStyle(t,n){const[e,a]=t.split(".");null!=(n=null!=n&&a?`${n}${a}`:n)?this._renderer.setStyle(this._ngEl.nativeElement,e,n):this._renderer.removeStyle(this._ngEl.nativeElement,e)}_applyChanges(t){t.forEachRemovedItem((t=>this._setStyle(t.key,null))),t.forEachAddedItem((t=>this._setStyle(t.key,t.currentValue))),t.forEachChangedItem((t=>this._setStyle(t.key,t.currentValue)))}}$M.ɵfac=function t(n){return new(n||$M)(Zg(xu),Zg(Gu),Zg(Su))},$M.ɵdir=vo({type:$M,selectors:[["","ngStyle",""]],inputs:{ngStyle:"ngStyle"}}),$M.ctorParameters=()=>[{type:xu},{type:Gu},{type:Su}],$M.propDecorators={ngStyle:[{type:f_,args:["ngStyle"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class tO{constructor(t){this._viewContainerRef=t,this._viewRef=null,this.ngTemplateOutletContext=null,this.ngTemplateOutlet=null}ngOnChanges(t){if(this._shouldRecreateView(t)){const t=this._viewContainerRef;this._viewRef&&t.remove(t.indexOf(this._viewRef)),this._viewRef=this.ngTemplateOutlet?t.createEmbeddedView(this.ngTemplateOutlet,this.ngTemplateOutletContext):null}else this._viewRef&&this.ngTemplateOutletContext&&this._updateExistingContext(this.ngTemplateOutletContext)}_shouldRecreateView(t){const n=t.ngTemplateOutletContext;return!!t.ngTemplateOutlet||n&&this._hasContextShapeChanged(n)}_hasContextShapeChanged(t){const n=Object.keys(t.previousValue||{}),e=Object.keys(t.currentValue||{});if(n.length===e.length){for(let t of e)if(-1===n.indexOf(t))return!0;return!1}return!0}_updateExistingContext(t){for(let n of Object.keys(t))this._viewRef.context[n]=this.ngTemplateOutletContext[n]}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function nO(t,n){return Error(`InvalidPipeArgument: '${n}' for pipe '${ta(t)}'`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */tO.ɵfac=function t(n){return new(n||tO)(Zg($u))},tO.ɵdir=vo({type:tO,selectors:[["","ngTemplateOutlet",""]],inputs:{ngTemplateOutletContext:"ngTemplateOutletContext",ngTemplateOutlet:"ngTemplateOutlet"},features:[pr]}),tO.ctorParameters=()=>[{type:$u}],tO.propDecorators={ngTemplateOutletContext:[{type:f_}],ngTemplateOutlet:[{type:f_}]};const eO=new class{createSubscription(t,n){return t.then(n,(t=>{throw t}))}dispose(t){}onDestroy(t){}},aO=new class{createSubscription(t,n){return t.subscribe({next:n,error:t=>{throw t}})}dispose(t){t.unsubscribe()}onDestroy(t){t.unsubscribe()}};class oO{constructor(t){this._ref=t,this._latestValue=null,this._subscription=null,this._obj=null,this._strategy=null}ngOnDestroy(){this._subscription&&this._dispose()}transform(t){return this._obj?t!==this._obj?(this._dispose(),this.transform(t)):this._latestValue:(t&&this._subscribe(t),this._latestValue)}_subscribe(t){this._obj=t,this._strategy=this._selectStrategy(t),this._subscription=this._strategy.createSubscription(t,(n=>this._updateLatestValue(t,n)))}_selectStrategy(t){if(rp(t))return eO;if(ip(t))return aO;throw nO(oO,t)}_dispose(){this._strategy.dispose(this._subscription),this._latestValue=null,this._subscription=null,this._obj=null}_updateLatestValue(t,n){t===this._obj&&(this._latestValue=n,this._ref.markForCheck())}}oO.ɵfac=function t(n){return new(n||oO)($f())},oO.ɵpipe=wo({name:"async",type:oO,pure:!1}),oO.ctorParameters=()=>[{type:Vm}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class rO{transform(t){if(!t)return t;if("string"!=typeof t)throw nO(rO,t);return t.toLowerCase()}}rO.ɵfac=function t(n){return new(n||rO)},rO.ɵpipe=wo({name:"lowercase",type:rO,pure:!0});const iO=/(?:[A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D])\S*/g;class cO{transform(t){if(!t)return t;if("string"!=typeof t)throw nO(cO,t);return t.replace(iO,(t=>t[0].toUpperCase()+t.substr(1).toLowerCase()))}}cO.ɵfac=function t(n){return new(n||cO)},cO.ɵpipe=wo({name:"titlecase",type:cO,pure:!0});class sO{transform(t){if(!t)return t;if("string"!=typeof t)throw nO(sO,t);return t.toUpperCase()}}sO.ɵfac=function t(n){return new(n||sO)},sO.ɵpipe=wo({name:"uppercase",type:sO,pure:!0});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class lO{constructor(t){this.locale=t}transform(t,n="mediumDate",e,a){if(null==t||""===t||t!=t)return null;try{return hM(t,n,a||this.locale,e)}catch(t){throw nO(lO,t.message)}}}lO.ɵfac=function t(n){return new(n||lO)(Zg(N_))},lO.ɵpipe=wo({name:"date",type:lO,pure:!0}),lO.ctorParameters=()=>[{type:String,decorators:[{type:Ie,args:[N_]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const mO=/#/g;class dO{constructor(t){this._localization=t}transform(t,n,e){if(null==t)return"";if("object"!=typeof n||null===n)throw nO(dO,n);return n[NM(t,Object.keys(n),this._localization,e)].replace(mO,t.toString())}}dO.ɵfac=function t(n){return new(n||dO)(Zg(IM))},dO.ɵpipe=wo({name:"i18nPlural",type:dO,pure:!0}),dO.ctorParameters=()=>[{type:IM}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class gO{transform(t,n){if(null==t)return"";if("object"!=typeof n||"string"!=typeof t)throw nO(gO,n);return n.hasOwnProperty(t)?n[t]:n.hasOwnProperty("other")?n.other:""}}gO.ɵfac=function t(n){return new(n||gO)},gO.ɵpipe=wo({name:"i18nSelect",type:gO,pure:!0});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class pO{transform(t){return JSON.stringify(t,null,2)}}pO.ɵfac=function t(n){return new(n||pO)},pO.ɵpipe=wo({name:"json",type:pO,pure:!1});class bO{constructor(t){this.differs=t,this.keyValues=[]}transform(t,n=uO){if(!t||!(t instanceof Map)&&"object"!=typeof t)return null;this.differ||(this.differ=this.differs.find(t).create());const e=this.differ.diff(t);return e&&(this.keyValues=[],e.forEachItem((t=>{this.keyValues.push((
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function n(t,e){return{key:t,value:e}})(t.key,t.currentValue))})),this.keyValues.sort(n)),this.keyValues}}function uO(t,n){const e=t.key,a=n.key;if(e===a)return 0;if(void 0===e)return 1;if(void 0===a)return-1;if(null===e)return 1;if(null===a)return-1;if("string"==typeof e&&"string"==typeof a)return e<a?-1:1;if("number"==typeof e&&"number"==typeof a)return e-a;if("boolean"==typeof e&&"boolean"==typeof a)return e<a?-1:1;const o=String(e),r=String(a);return o==r?0:o<r?-1:1}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */bO.ɵfac=function t(n){return new(n||bO)(Zg(Gu))},bO.ɵpipe=wo({name:"keyvalue",type:bO,pure:!1}),bO.ctorParameters=()=>[{type:Gu}];class fO{constructor(t){this._locale=t}transform(t,n,e){if(CO(t))return null;e=e||this._locale;try{return RM(MO(t),e,n)}catch(t){throw nO(fO,t.message)}}}fO.ɵfac=function t(n){return new(n||fO)(Zg(N_))},fO.ɵpipe=wo({name:"number",type:fO,pure:!0}),fO.ctorParameters=()=>[{type:String,decorators:[{type:Ie,args:[N_]}]}];class hO{constructor(t){this._locale=t}transform(t,n,e){if(CO(t))return null;e=e||this._locale;try{return(function a(t,n,e){return zM(t,TM(iM(n,XC.Percent),rM(n,tM.MinusSign)),n,tM.Group,tM.Decimal,e,!0).replace(new RegExp("%","g"),rM(n,tM.PercentSign))})(MO(t),e,n)}catch(t){throw nO(hO,t.message)}}}hO.ɵfac=function t(n){return new(n||hO)(Zg(N_))},hO.ɵpipe=wo({name:"percent",type:hO,pure:!0}),hO.ctorParameters=()=>[{type:String,decorators:[{type:Ie,args:[N_]}]}];class _O{constructor(t,n="USD"){this._locale=t,this._defaultCurrencyCode=n}transform(t,n,e="symbol",a,o){if(CO(t))return null;o=o||this._locale,"boolean"==typeof e&&(console&&console.warn&&console.warn('Warning: the currency pipe has been changed in Angular v5. The symbolDisplay option (third parameter) is now a string instead of a boolean. The accepted values are "code", "symbol" or "symbol-narrow".'),e=e?"symbol":"code");let r=n||this._defaultCurrencyCode;"code"!==e&&(r="symbol"===e||"symbol-narrow"===e?(function i(t,n,e="en"){const a=(function o(t){return sb(t)[db.Currencies]})(e)[t]||ZC[t]||[],r=a[1];return"narrow"===n&&"string"==typeof r?r:a[0]||t})(r,"symbol"===e?"wide":"narrow",o):e);try{return(function c(t,n,e,a,o){const r=TM(iM(n,XC.Currency),rM(n,tM.MinusSign));return r.minFrac=(function i(t){let n;const e=ZC[t];return e&&(n=e[2]),"number"==typeof n?n:2})(a),r.maxFrac=r.minFrac,zM(t,r,n,tM.CurrencyGroup,tM.CurrencyDecimal,o).replace("¤",e).replace("¤","").trim()})(MO(t),o,r,n,a)}catch(t){throw nO(_O,t.message)}}}function CO(t){return null==t||""===t||t!=t}function MO(t){if("string"==typeof t&&!isNaN(Number(t)-parseFloat(t)))return Number(t);if("number"!=typeof t)throw new Error(`${t} is not a number`);return t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */_O.ɵfac=function t(n){return new(n||_O)(Zg(N_),Zg(F_))},_O.ɵpipe=wo({name:"currency",type:_O,pure:!0}),_O.ctorParameters=()=>[{type:String,decorators:[{type:Ie,args:[N_]}]},{type:String,decorators:[{type:Ie,args:[F_]}]}];class OO{transform(t,n,e){if(null==t)return t;if(!this.supports(t))throw nO(OO,t);return t.slice(n,e)}supports(t){return"string"==typeof t||Array.isArray(t)}}OO.ɵfac=function t(n){return new(n||OO)},OO.ɵpipe=wo({name:"slice",type:OO,pure:!1});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class PO{}PO.ɵmod=xo({type:PO}),PO.ɵinj=Ge({factory:function t(n){return new(n||PO)},providers:[{provide:IM,useClass:FM}]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(PO,{declarations:[HM,BM,jM,WM,tO,$M,ZM,XM,JM,QM,KM,oO,sO,rO,pO,OO,fO,hO,cO,_O,lO,dO,gO,bO],exports:[HM,BM,jM,WM,tO,$M,ZM,XM,JM,QM,KM,oO,sO,rO,pO,OO,fO,hO,cO,_O,lO,dO,gO,bO]}),
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
new Ru("10.2.4");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class xO{}xO.ɵprov=We({token:xO,providedIn:"root",factory:()=>new yO(Za(zC),window,Za(oc))});class yO{constructor(t,n,e){this.document=t,this.window=n,this.errorHandler=e,this.offset=()=>[0,0]}setOffset(t){this.offset=Array.isArray(t)?()=>t:t}getScrollPosition(){return this.supportsScrolling()?[this.window.scrollX,this.window.scrollY]:[0,0]}scrollToPosition(t){this.supportsScrolling()&&this.window.scrollTo(t[0],t[1])}scrollToAnchor(t){if(this.supportsScrolling()){const n=this.document.getElementById(t)||this.document.getElementsByName(t)[0];n&&this.scrollToElement(n)}}setHistoryScrollRestoration(t){if(this.supportScrollRestoration()){const n=this.window.history;n&&n.scrollRestoration&&(n.scrollRestoration=t)}}scrollToElement(t){const n=t.getBoundingClientRect(),e=n.left+this.window.pageXOffset,a=n.top+this.window.pageYOffset,o=this.offset();this.window.scrollTo(e-o[0],a-o[1])}supportScrollRestoration(){try{if(!this.window||!this.window.scrollTo)return!1;const t=kO(this.window.history)||kO(Object.getPrototypeOf(this.window.history));return!(!t||!t.writable&&!t.set)}catch(t){return!1}}supportsScrolling(){try{return!!this.window.scrollTo}catch(t){return!1}}}function kO(t){return Object.getOwnPropertyDescriptor(t,"scrollRestoration")}
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class vO extends class extends class{}{constructor(){super()}supportsDOMEvents(){return!0}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */{static makeCurrent(){!(function t(n){EC||(EC=n)})(new vO)}getProperty(t,n){return t[n]}log(t){window.console&&window.console.log&&window.console.log(t)}logGroup(t){window.console&&window.console.group&&window.console.group(t)}logGroupEnd(){window.console&&window.console.groupEnd&&window.console.groupEnd()}onAndCancel(t,n,e){return t.addEventListener(n,e,!1),()=>{t.removeEventListener(n,e,!1)}}dispatchEvent(t,n){t.dispatchEvent(n)}remove(t){return t.parentNode&&t.parentNode.removeChild(t),t}getValue(t){return t.value}createElement(t,n){return(n=n||this.getDefaultDocument()).createElement(t)}createHtmlDocument(){return document.implementation.createHTMLDocument("fakeTitle")}getDefaultDocument(){return document}isElementNode(t){return t.nodeType===Node.ELEMENT_NODE}isShadowRoot(t){return t instanceof DocumentFragment}getGlobalEventTarget(t,n){return"window"===n?window:"document"===n?t:"body"===n?t.body:null}getHistory(){return window.history}getLocation(){return window.location}getBaseHref(t){const n=(function e(){return SO||(SO=document.querySelector("base"),SO)?SO.getAttribute("href"):null})();return null==n?null:(function a(t){return wO||(wO=document.createElement("a")),wO.setAttribute("href",t),"/"===wO.pathname.charAt(0)?wO.pathname:"/"+wO.pathname}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(n)}resetBaseElement(){SO=null}getUserAgent(){return window.navigator.userAgent}performanceNow(){return window.performance&&window.performance.now?window.performance.now():(new Date).getTime()}supportsCookies(){return!0}getCookie(t){return LM(document.cookie,t)}}let wO,SO=null;const EO=new Fa("TRANSITION_ID"),AO=[{provide:v_,useFactory:function zO(t,n,e){return()=>{e.get(w_).donePromise.then((()=>{const e=AC();Array.prototype.slice.apply(n.querySelectorAll("style[ng-transition]")).filter((n=>n.getAttribute("ng-transition")===t)).forEach((t=>e.remove(t)))}))}},deps:[EO,zC,yd],multi:!0}];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class RO{static init(){!(function t(n){cC=n})(new RO)}addToWindow(t){ma.getAngularTestability=(n,e=!0)=>{const a=t.findTestabilityInTree(n,e);if(null==a)throw new Error("Could not find testability for element.");return a},ma.getAllAngularTestabilities=()=>t.getAllTestabilities(),ma.getAllAngularRootElements=()=>t.getAllRootElements(),ma.frameworkStabilizers||(ma.frameworkStabilizers=[]),ma.frameworkStabilizers.push((t=>{const n=ma.getAllAngularTestabilities();let e=n.length,a=!1;const o=function(n){a=a||n,e--,0==e&&t(a)};n.forEach((function(t){t.whenStable(o)}))}))}findTestabilityInTree(t,n,e){if(null==n)return null;const a=t.getTestability(n);return null!=a?a:e?AC().isShadowRoot(n)?this.findTestabilityInTree(t,n.host,!0):this.findTestabilityInTree(t,n.parentElement,!0):null}}new Ne;const TO=new Fa("EventManagerPlugins");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class DO{constructor(t,n){this._zone=n,this._eventNameToPlugin=new Map,t.forEach((t=>t.manager=this)),this._plugins=t.slice().reverse()}addEventListener(t,n,e){return this._findPluginFor(n).addEventListener(t,n,e)}addGlobalEventListener(t,n,e){return this._findPluginFor(n).addGlobalEventListener(t,n,e)}getZone(){return this._zone}_findPluginFor(t){const n=this._eventNameToPlugin.get(t);if(n)return n;const e=this._plugins;for(let n=0;n<e.length;n++){const a=e[n];if(a.supports(t))return this._eventNameToPlugin.set(t,a),a}throw new Error(`No event manager plugin found for event ${t}`)}}DO.ɵfac=function t(n){return new(n||DO)(Za(TO),Za(J_))},DO.ɵprov=We({token:DO,factory:DO.ɵfac}),DO.ctorParameters=()=>[{type:Array,decorators:[{type:Ie,args:[TO]}]},{type:J_}];class IO{constructor(t){this._doc=t}addGlobalEventListener(t,n,e){const a=AC().getGlobalEventTarget(this._doc,t);if(!a)throw new Error(`Unsupported event target ${a} for event ${n}`);return this.addEventListener(a,n,e)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class NO{constructor(){this._stylesSet=new Set}addStyles(t){const n=new Set;t.forEach((t=>{this._stylesSet.has(t)||(this._stylesSet.add(t),n.add(t))})),this.onStylesAdded(n)}onStylesAdded(t){}getAllStyles(){return Array.from(this._stylesSet)}}NO.ɵfac=function t(n){return new(n||NO)},NO.ɵprov=We({token:NO,factory:NO.ɵfac});class FO extends NO{constructor(t){super(),this._doc=t,this._hostNodes=new Set,this._styleNodes=new Set,this._hostNodes.add(t.head)}_addStylesToHost(t,n){t.forEach((t=>{const e=this._doc.createElement("style");e.textContent=t,this._styleNodes.add(n.appendChild(e))}))}addHost(t){this._addStylesToHost(this._stylesSet,t),this._hostNodes.add(t)}removeHost(t){this._hostNodes.delete(t)}onStylesAdded(t){this._hostNodes.forEach((n=>this._addStylesToHost(t,n)))}ngOnDestroy(){this._styleNodes.forEach((t=>AC().remove(t)))}}FO.ɵfac=function t(n){return new(n||FO)(Za(zC))},FO.ɵprov=We({token:FO,factory:FO.ɵfac}),FO.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const LO={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"},HO=/%COMP%/g,BO="undefined"==typeof ngDevMode||!!ngDevMode;function VO(t,n,e){for(let a=0;a<n.length;a++){let o=n[a];Array.isArray(o)?VO(t,o,e):(o=o.replace(HO,t),e.push(o))}return e}function jO(t){return n=>{if("__ngUnwrap__"===n)return t;!1===t(n)&&(n.preventDefault(),n.returnValue=!1)}}class UO{constructor(t,n,e){this.eventManager=t,this.sharedStylesHost=n,this.appId=e,this.rendererByCompId=new Map,this.defaultRenderer=new WO(t)}createRenderer(t,n){if(!t||!n)return this.defaultRenderer;switch(n.encapsulation){case bo.Emulated:{let e=this.rendererByCompId.get(n.id);return e||(e=new qO(this.eventManager,this.sharedStylesHost,n,this.appId),this.rendererByCompId.set(n.id,e)),e.applyToHost(t),e}case bo.Native:case bo.ShadowDom:return new ZO(this.eventManager,this.sharedStylesHost,t,n);default:if(!this.rendererByCompId.has(n.id)){const t=VO(n.id,n.styles,[]);this.sharedStylesHost.addStyles(t),this.rendererByCompId.set(n.id,this.defaultRenderer)}return this.defaultRenderer}}begin(){}end(){}}UO.ɵfac=function t(n){return new(n||UO)(Za(DO),Za(FO),Za(S_))},UO.ɵprov=We({token:UO,factory:UO.ɵfac}),UO.ctorParameters=()=>[{type:DO},{type:FO},{type:String,decorators:[{type:Ie,args:[S_]}]}];class WO{constructor(t){this.eventManager=t,this.data=Object.create(null)}destroy(){}createElement(t,n){return n?document.createElementNS(LO[n]||n,t):document.createElement(t)}createComment(t){return document.createComment(t)}createText(t){return document.createTextNode(t)}appendChild(t,n){t.appendChild(n)}insertBefore(t,n,e){t&&t.insertBefore(n,e)}removeChild(t,n){t&&t.removeChild(n)}selectRootElement(t,n){let e="string"==typeof t?document.querySelector(t):t;if(!e)throw new Error(`The selector "${t}" did not match any elements`);return n||(e.textContent=""),e}parentNode(t){return t.parentNode}nextSibling(t){return t.nextSibling}setAttribute(t,n,e,a){if(a){n=a+":"+n;const o=LO[a];o?t.setAttributeNS(o,n,e):t.setAttribute(n,e)}else t.setAttribute(n,e)}removeAttribute(t,n,e){if(e){const a=LO[e];a?t.removeAttributeNS(a,n):t.removeAttribute(`${e}:${n}`)}else t.removeAttribute(n)}addClass(t,n){t.classList.add(n)}removeClass(t,n){t.classList.remove(n)}setStyle(t,n,e,a){a&wu.DashCase?t.style.setProperty(n,e,a&wu.Important?"important":""):t.style[n]=e}removeStyle(t,n,e){e&wu.DashCase?t.style.removeProperty(n):t.style[n]=""}setProperty(t,n,e){BO&&YO(n,"property"),t[n]=e}setValue(t,n){t.nodeValue=n}listen(t,n,e){return BO&&YO(n,"listener"),"string"==typeof t?this.eventManager.addGlobalEventListener(t,n,jO(e)):this.eventManager.addEventListener(t,n,jO(e))}}const GO="@".charCodeAt(0);function YO(t,n){if(t.charCodeAt(0)===GO)throw new Error(`Found the synthetic ${n} ${t}. Please include either "BrowserAnimationsModule" or "NoopAnimationsModule" in your application.`)}class qO extends WO{constructor(t,n,e,a){super(t),this.component=e;const o=VO(a+"-"+e.id,e.styles,[]);n.addStyles(o),this.contentAttr=(function r(t){return"_ngcontent-%COMP%".replace(HO,t)})(a+"-"+e.id),this.hostAttr=(function i(t){return"_nghost-%COMP%".replace(HO,t)})(a+"-"+e.id)}applyToHost(t){super.setAttribute(t,this.hostAttr,"")}createElement(t,n){const e=super.createElement(t,n);return super.setAttribute(e,this.contentAttr,""),e}}class ZO extends WO{constructor(t,n,e,a){super(t),this.sharedStylesHost=n,this.hostEl=e,this.component=a,this.shadowRoot=a.encapsulation===bo.ShadowDom?e.attachShadow({mode:"open"}):e.createShadowRoot(),this.sharedStylesHost.addHost(this.shadowRoot);const o=VO(a.id,a.styles,[]);for(let t=0;t<o.length;t++){const n=document.createElement("style");n.textContent=o[t],this.shadowRoot.appendChild(n)}}nodeOrShadowRoot(t){return t===this.hostEl?this.shadowRoot:t}destroy(){this.sharedStylesHost.removeHost(this.shadowRoot)}appendChild(t,n){return super.appendChild(this.nodeOrShadowRoot(t),n)}insertBefore(t,n,e){return super.insertBefore(this.nodeOrShadowRoot(t),n,e)}removeChild(t,n){return super.removeChild(this.nodeOrShadowRoot(t),n)}parentNode(t){return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(t)))}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class XO extends IO{constructor(t){super(t)}supports(t){return!0}addEventListener(t,n,e){return t.addEventListener(n,e,!1),()=>this.removeEventListener(t,n,e)}removeEventListener(t,n,e){return t.removeEventListener(n,e)}}XO.ɵfac=function t(n){return new(n||XO)(Za(zC))},XO.ɵprov=We({token:XO,factory:XO.ɵfac}),XO.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const JO={pan:!0,panstart:!0,panmove:!0,panend:!0,pancancel:!0,panleft:!0,panright:!0,panup:!0,pandown:!0,pinch:!0,pinchstart:!0,pinchmove:!0,pinchend:!0,pinchcancel:!0,pinchin:!0,pinchout:!0,press:!0,pressup:!0,rotate:!0,rotatestart:!0,rotatemove:!0,rotateend:!0,rotatecancel:!0,swipe:!0,swipeleft:!0,swiperight:!0,swipeup:!0,swipedown:!0,tap:!0},QO=new Fa("HammerGestureConfig"),KO=new Fa("HammerLoader");class $O{constructor(){this.events=[],this.overrides={}}buildHammer(t){const n=new Hammer(t,this.options);n.get("pinch").set({enable:!0}),n.get("rotate").set({enable:!0});for(const t in this.overrides)n.get(t).set(this.overrides[t]);return n}}$O.ɵfac=function t(n){return new(n||$O)},$O.ɵprov=We({token:$O,factory:$O.ɵfac});class tP extends IO{constructor(t,n,e,a){super(t),this._config=n,this.console=e,this.loader=a}supports(t){return!(!JO.hasOwnProperty(t.toLowerCase())&&!this.isCustomEvent(t)||!window.Hammer&&!this.loader&&(this.console.warn(`The "${t}" event cannot be bound because Hammer.JS is not loaded and no custom loader has been specified.`),1))}addEventListener(t,n,e){const a=this.manager.getZone();if(n=n.toLowerCase(),!window.Hammer&&this.loader){let a=!1,o=()=>{a=!0};return this.loader().then((()=>{if(!window.Hammer)return this.console.warn("The custom HAMMER_LOADER completed, but Hammer.JS is not present."),void(o=()=>{});a||(o=this.addEventListener(t,n,e))})).catch((()=>{this.console.warn(`The "${n}" event cannot be bound because the custom Hammer.JS loader failed.`),o=()=>{}})),()=>{o()}}return a.runOutsideAngular((()=>{const o=this._config.buildHammer(t),r=function(t){a.runGuarded((function(){e(t)}))};return o.on(n,r),()=>{o.off(n,r),"function"==typeof o.destroy&&o.destroy()}}))}isCustomEvent(t){return this._config.events.indexOf(t)>-1}}tP.ɵfac=function t(n){return new(n||tP)(Za(zC),Za(QO),Za(I_),Za(KO,8))},tP.ɵprov=We({token:tP,factory:tP.ɵfac}),tP.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:$O,decorators:[{type:Ie,args:[QO]}]},{type:I_},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[KO]}]}];const nP=[{provide:TO,useClass:tP,multi:!0,deps:[zC,QO,I_,[new Ne,KO]]},{provide:QO,useClass:$O,deps:[]}];class eP{}eP.ɵmod=xo({type:eP}),eP.ɵinj=Ge({factory:function t(n){return new(n||eP)},providers:nP});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const aP=["alt","control","meta","shift"],oP={"\b":"Backspace","\t":"Tab","":"Delete","":"Escape",Del:"Delete",Esc:"Escape",Left:"ArrowLeft",Right:"ArrowRight",Up:"ArrowUp",Down:"ArrowDown",Menu:"ContextMenu",Scroll:"ScrollLock",Win:"OS"},rP={A:"1",B:"2",C:"3",D:"4",E:"5",F:"6",G:"7",H:"8",I:"9",J:"*",K:"+",M:"-",N:".",O:"/","`":"0","":"NumLock"},iP={alt:t=>t.altKey,control:t=>t.ctrlKey,meta:t=>t.metaKey,shift:t=>t.shiftKey};class cP extends IO{constructor(t){super(t)}supports(t){return null!=cP.parseEventName(t)}addEventListener(t,n,e){const a=cP.parseEventName(n),o=cP.eventCallback(a.fullKey,e,this.manager.getZone());return this.manager.getZone().runOutsideAngular((()=>AC().onAndCancel(t,a.domEventName,o)))}static parseEventName(t){const n=t.toLowerCase().split("."),e=n.shift();if(0===n.length||"keydown"!==e&&"keyup"!==e)return null;const a=cP._normalizeKey(n.pop());let o="";if(aP.forEach((t=>{const e=n.indexOf(t);e>-1&&(n.splice(e,1),o+=t+".")})),o+=a,0!=n.length||0===a.length)return null;const r={};return r.domEventName=e,r.fullKey=o,r}static getEventFullKey(t){let n="",e=(function a(t){let n=t.key;if(null==n){if(n=t.keyIdentifier,null==n)return"Unidentified";n.startsWith("U+")&&(n=String.fromCharCode(parseInt(n.substring(2),16)),3===t.location&&rP.hasOwnProperty(n)&&(n=rP[n]))}return oP[n]||n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t);return e=e.toLowerCase()," "===e?e="space":"."===e&&(e="dot"),aP.forEach((a=>{a!=e&&(0,iP[a])(t)&&(n+=a+".")})),n+=e,n}static eventCallback(t,n,e){return a=>{cP.getEventFullKey(a)===t&&e.runGuarded((()=>n(a)))}}static _normalizeKey(t){switch(t){case"esc":return"escape";default:return t}}}cP.ɵfac=function t(n){return new(n||cP)(Za(zC))},cP.ɵprov=We({token:cP,factory:cP.ɵfac}),cP.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class sP{}sP.ɵfac=function t(n){return new(n||sP)},sP.ɵprov=We({factory:function t(){return Za(lP)},token:sP,providedIn:"root"});class lP extends sP{constructor(t){super(),this._doc=t}sanitize(t,n){if(null==n)return null;switch(t){case Zc.NONE:return n;case Zc.HTML:return bc(n,"HTML")?pc(n):Yc(this._doc,String(n));case Zc.STYLE:return bc(n,"Style")?pc(n):n;case Zc.SCRIPT:if(bc(n,"Script"))return pc(n);throw new Error("unsafe value used in a script context");case Zc.URL:return uc(n),bc(n,"URL")?pc(n):yc(String(n));case Zc.RESOURCE_URL:if(bc(n,"ResourceURL"))return pc(n);throw new Error("unsafe value used in a resource URL context (see http://g.co/ng/security#xss)");default:throw new Error(`Unexpected SecurityContext ${t} (see http://g.co/ng/security#xss)`)}}bypassSecurityTrustHtml(t){return(function n(t){return new sc(t)})(t)}bypassSecurityTrustStyle(t){return(function n(t){return new lc(t)})(t)}bypassSecurityTrustScript(t){return(function n(t){return new mc(t)})(t)}bypassSecurityTrustUrl(t){return(function n(t){return new dc(t)})(t)}bypassSecurityTrustResourceUrl(t){return(function n(t){return new gc(t)})(t)}}lP.ɵfac=function t(n){return new(n||lP)(Za(zC))},lP.ɵprov=We({factory:function t(){return(function n(t){return new lP(t.get(zC))})(Za(La))},token:lP,providedIn:"root"}),lP.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const mP=lC(MC,"browser",[{provide:T_,useValue:"browser"},{provide:R_,useValue:function dP(){vO.makeCurrent(),RO.init()},multi:!0},{provide:zC,useFactory:function gP(){return(function t(n){Mr=n})(document),document},deps:[]}]),pP=[[],{provide:ld,useValue:"root"},{provide:oc,useFactory:function bP(){return new oc},deps:[]},{provide:TO,useClass:XO,multi:!0,deps:[zC,J_,T_]},{provide:TO,useClass:cP,multi:!0,deps:[zC]},[],{provide:UO,useClass:UO,deps:[DO,FO,S_]},{provide:vu,useExisting:UO},{provide:NO,useExisting:FO},{provide:FO,useClass:FO,deps:[zC]},{provide:oC,useClass:oC,deps:[J_]},{provide:DO,useClass:DO,deps:[TO,J_]},[]];class uP{constructor(t){if(t)throw new Error("BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.")}static withServerTransition(t){return{ngModule:uP,providers:[{provide:S_,useValue:t.appId},{provide:EO,useExisting:S_},AO]}}}uP.ɵmod=xo({type:uP}),uP.ɵinj=Ge({factory:function t(n){return new(n||uP)(Za(uP,12))},providers:pP,imports:[PO,vC]}),uP.ctorParameters=()=>[{type:uP,decorators:[{type:Ne},{type:Le},{type:Ie,args:[uP]}]}],("undefined"==typeof ngJitMode||ngJitMode)&&yo(uP,{exports:function(){return[PO,vC]}});class fP{constructor(t){this._doc=t,this._dom=AC()}addTag(t,n=!1){return t?this._getOrCreateElement(t,n):null}addTags(t,n=!1){return t?t.reduce(((t,e)=>(e&&t.push(this._getOrCreateElement(e,n)),t)),[]):[]}getTag(t){return t&&this._doc.querySelector(`meta[${t}]`)||null}getTags(t){if(!t)return[];const n=this._doc.querySelectorAll(`meta[${t}]`);return n?[].slice.call(n):[]}updateTag(t,n){if(!t)return null;n=n||this._parseSelector(t);const e=this.getTag(n);return e?this._setMetaElementAttributes(t,e):this._getOrCreateElement(t,!0)}removeTag(t){this.removeTagElement(this.getTag(t))}removeTagElement(t){t&&this._dom.remove(t)}_getOrCreateElement(t,n=!1){if(!n){const n=this._parseSelector(t),e=this.getTag(n);if(e&&this._containsAttributes(t,e))return e}const e=this._dom.createElement("meta");return this._setMetaElementAttributes(t,e),this._doc.getElementsByTagName("head")[0].appendChild(e),e}_setMetaElementAttributes(t,n){return Object.keys(t).forEach((e=>n.setAttribute(e,t[e]))),n}_parseSelector(t){const n=t.name?"name":"property";return`${n}="${t[n]}"`}_containsAttributes(t,n){return Object.keys(t).every((e=>n.getAttribute(e)===t[e]))}}fP.ɵfac=function t(n){return new(n||fP)(Za(zC))},fP.ɵprov=We({factory:
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function hP(){return new fP(Za(zC))},token:fP,providedIn:"root"}),fP.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class _P{constructor(t){this._doc=t}getTitle(){return this._doc.title}setTitle(t){this._doc.title=t||""}}_P.ɵfac=function t(n){return new(n||_P)(Za(zC))},_P.ɵprov=We({factory:function CP(){return new _P(Za(zC))},token:_P,providedIn:"root"}),_P.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class MP{constructor(){this.store={},this.onSerializeCallbacks={}}static init(t){const n=new MP;return n.store=t,n}get(t,n){return void 0!==this.store[t]?this.store[t]:n}set(t,n){this.store[t]=n}remove(t){delete this.store[t]}hasKey(t){return this.store.hasOwnProperty(t)}onSerialize(t,n){this.onSerializeCallbacks[t]=n}toJson(){for(const t in this.onSerializeCallbacks)if(this.onSerializeCallbacks.hasOwnProperty(t))try{this.store[t]=this.onSerializeCallbacks[t]()}catch(t){console.warn("Exception in onSerialize callback: ",t)}return JSON.stringify(this.store)}}MP.ɵfac=function t(n){return new(n||MP)},MP.ɵprov=We({token:MP,factory:MP.ɵfac});class OP{}OP.ɵmod=xo({type:OP}),OP.ɵinj=Ge({factory:function t(n){return new(n||OP)},providers:[{provide:MP,useFactory:function PP(t,n){const e=t.getElementById(n+"-state");let a={};if(e&&e.textContent)try{a=JSON.parse((function o(t){const n={"&a;":"&","&q;":'"',"&s;":"'","&l;":"<","&g;":">"};return t.replace(/&[^;]+;/g,(t=>n[t]))})(e.textContent))}catch(t){console.warn("Exception while restoring TransferState for app "+n,t)}return MP.init(a)},deps:[zC,S_]}]}),
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
new Ru("10.2.4");var xP="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function yP(t,n,e){return t(e={path:n,exports:{},require:function(t,n){return(function e(){throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs")}
/**
    * @license Angular v9.1.0-next.4+61.sha-e552591.with-local-changes
    * (c) 2010-2020 Google LLC. https://angular.io/
    * License: MIT
    */)()}},e.exports),e.exports}function kP(t){if(t.__esModule)return t;var n=Object.defineProperty({},"__esModule",{value:!0});return Object.keys(t).forEach((function(e){var a=Object.getOwnPropertyDescriptor(t,e);Object.defineProperty(n,e,a.get?a:{enumerable:!0,get:function(){return t[e]}})})),n}!(function(){
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
(function(t){var n=t.performance;function e(t){n&&n.mark&&n.mark(t)}function a(t,e){n&&n.measure&&n.measure(t,e)}e("Zone");var o=t.__Zone_symbol_prefix||"__zone_symbol__";function r(t){return o+t}var i=!0===t[r("forceDuplicateZoneCheck")];if(t.Zone){if(i||"function"!=typeof t.Zone.__symbol__)throw new Error("Zone already loaded.");return t.Zone}var c=(function(){function n(t,n){this._parent=t,this._name=n?n.name||"unnamed":"<root>",this._properties=n&&n.properties||{},this._zoneDelegate=new m(this,this._parent&&this._parent._zoneDelegate,n)}return n.assertZonePatched=function(){if(t.Promise!==E.ZoneAwarePromise)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(n,"root",{get:function(){for(var t=n.current;t.parent;)t=t.parent;return t},enumerable:!0,configurable:!0}),Object.defineProperty(n,"current",{get:function(){return z.zone},enumerable:!0,configurable:!0}),Object.defineProperty(n,"currentTask",{get:function(){return R},enumerable:!0,configurable:!0}),n.__load_patch=function(o,r){if(E.hasOwnProperty(o)){if(i)throw Error("Already loaded patch: "+o)}else if(!t["__Zone_disable_"+o]){var c="Zone:"+o;e(c),E[o]=r(t,n,A),a(c,c)}},Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),n.prototype.get=function(t){var n=this.getZoneWith(t);if(n)return n._properties[t]},n.prototype.getZoneWith=function(t){for(var n=this;n;){if(n._properties.hasOwnProperty(t))return n;n=n._parent}return null},n.prototype.fork=function(t){if(!t)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,t)},n.prototype.wrap=function(t,n){if("function"!=typeof t)throw new Error("Expecting function got: "+t);var e=this._zoneDelegate.intercept(this,t,n),a=this;return function(){return a.runGuarded(e,this,arguments,n)}},n.prototype.run=function(t,n,e,a){z={parent:z,zone:this};try{return this._zoneDelegate.invoke(this,t,n,e,a)}finally{z=z.parent}},n.prototype.runGuarded=function(t,n,e,a){void 0===n&&(n=null),z={parent:z,zone:this};try{try{return this._zoneDelegate.invoke(this,t,n,e,a)}catch(t){if(this._zoneDelegate.handleError(this,t))throw t}}finally{z=z.parent}},n.prototype.runTask=function(t,n,e){if(t.zone!=this)throw new Error("A task can only be run in the zone of creation! (Creation: "+(t.zone||C).name+"; Execution: "+this.name+")");if(t.state!==M||t.type!==S&&t.type!==w){var a=t.state!=x;a&&t._transitionTo(x,P),t.runCount++;var o=R;R=t,z={parent:z,zone:this};try{t.type==w&&t.data&&!t.data.isPeriodic&&(t.cancelFn=void 0);try{return this._zoneDelegate.invokeTask(this,t,n,e)}catch(t){if(this._zoneDelegate.handleError(this,t))throw t}}finally{t.state!==M&&t.state!==k&&(t.type==S||t.data&&t.data.isPeriodic?a&&t._transitionTo(P,x):(t.runCount=0,this._updateTaskCount(t,-1),a&&t._transitionTo(M,x,M))),z=z.parent,R=o}}},n.prototype.scheduleTask=function(t){if(t.zone&&t.zone!==this)for(var n=this;n;){if(n===t.zone)throw Error("can not reschedule task to "+this.name+" which is descendants of the original zone "+t.zone.name);n=n.parent}t._transitionTo(O,M);var e=[];t._zoneDelegates=e,t._zone=this;try{t=this._zoneDelegate.scheduleTask(this,t)}catch(n){throw t._transitionTo(k,O,M),this._zoneDelegate.handleError(this,n),n}return t._zoneDelegates===e&&this._updateTaskCount(t,1),t.state==O&&t._transitionTo(P,O),t},n.prototype.scheduleMicroTask=function(t,n,e,a){return this.scheduleTask(new d(v,t,n,e,a,void 0))},n.prototype.scheduleMacroTask=function(t,n,e,a,o){return this.scheduleTask(new d(w,t,n,e,a,o))},n.prototype.scheduleEventTask=function(t,n,e,a,o){return this.scheduleTask(new d(S,t,n,e,a,o))},n.prototype.cancelTask=function(t){if(t.zone!=this)throw new Error("A task can only be cancelled in the zone of creation! (Creation: "+(t.zone||C).name+"; Execution: "+this.name+")");t._transitionTo(y,P,x);try{this._zoneDelegate.cancelTask(this,t)}catch(n){throw t._transitionTo(k,y),this._zoneDelegate.handleError(this,n),n}return this._updateTaskCount(t,-1),t._transitionTo(M,y),t.runCount=0,t},n.prototype._updateTaskCount=function(t,n){var e=t._zoneDelegates;-1==n&&(t._zoneDelegates=null);for(var a=0;a<e.length;a++)e[a]._updateTaskCount(t.type,n)},n})();c.__symbol__=r;var s,l={name:"",onHasTask:function(t,n,e,a){return t.hasTask(e,a)},onScheduleTask:function(t,n,e,a){return t.scheduleTask(e,a)},onInvokeTask:function(t,n,e,a,o,r){return t.invokeTask(e,a,o,r)},onCancelTask:function(t,n,e,a){return t.cancelTask(e,a)}},m=(function(){function t(t,n,e){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=t,this._parentDelegate=n,this._forkZS=e&&(e&&e.onFork?e:n._forkZS),this._forkDlgt=e&&(e.onFork?n:n._forkDlgt),this._forkCurrZone=e&&(e.onFork?this.zone:n._forkCurrZone),this._interceptZS=e&&(e.onIntercept?e:n._interceptZS),this._interceptDlgt=e&&(e.onIntercept?n:n._interceptDlgt),this._interceptCurrZone=e&&(e.onIntercept?this.zone:n._interceptCurrZone),this._invokeZS=e&&(e.onInvoke?e:n._invokeZS),this._invokeDlgt=e&&(e.onInvoke?n:n._invokeDlgt),this._invokeCurrZone=e&&(e.onInvoke?this.zone:n._invokeCurrZone),this._handleErrorZS=e&&(e.onHandleError?e:n._handleErrorZS),this._handleErrorDlgt=e&&(e.onHandleError?n:n._handleErrorDlgt),this._handleErrorCurrZone=e&&(e.onHandleError?this.zone:n._handleErrorCurrZone),this._scheduleTaskZS=e&&(e.onScheduleTask?e:n._scheduleTaskZS),this._scheduleTaskDlgt=e&&(e.onScheduleTask?n:n._scheduleTaskDlgt),this._scheduleTaskCurrZone=e&&(e.onScheduleTask?this.zone:n._scheduleTaskCurrZone),this._invokeTaskZS=e&&(e.onInvokeTask?e:n._invokeTaskZS),this._invokeTaskDlgt=e&&(e.onInvokeTask?n:n._invokeTaskDlgt),this._invokeTaskCurrZone=e&&(e.onInvokeTask?this.zone:n._invokeTaskCurrZone),this._cancelTaskZS=e&&(e.onCancelTask?e:n._cancelTaskZS),this._cancelTaskDlgt=e&&(e.onCancelTask?n:n._cancelTaskDlgt),this._cancelTaskCurrZone=e&&(e.onCancelTask?this.zone:n._cancelTaskCurrZone),this._hasTaskZS=null,this._hasTaskDlgt=null,this._hasTaskDlgtOwner=null,this._hasTaskCurrZone=null;var a=e&&e.onHasTask;(a||n&&n._hasTaskZS)&&(this._hasTaskZS=a?e:l,this._hasTaskDlgt=n,this._hasTaskDlgtOwner=this,this._hasTaskCurrZone=t,e.onScheduleTask||(this._scheduleTaskZS=l,this._scheduleTaskDlgt=n,this._scheduleTaskCurrZone=this.zone),e.onInvokeTask||(this._invokeTaskZS=l,this._invokeTaskDlgt=n,this._invokeTaskCurrZone=this.zone),e.onCancelTask||(this._cancelTaskZS=l,this._cancelTaskDlgt=n,this._cancelTaskCurrZone=this.zone))}return t.prototype.fork=function(t,n){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,t,n):new c(t,n)},t.prototype.intercept=function(t,n,e){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,t,n,e):n},t.prototype.invoke=function(t,n,e,a,o){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,t,n,e,a,o):n.apply(e,a)},t.prototype.handleError=function(t,n){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,t,n)},t.prototype.scheduleTask=function(t,n){var e=n;if(this._scheduleTaskZS)this._hasTaskZS&&e._zoneDelegates.push(this._hasTaskDlgtOwner),(e=this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,t,n))||(e=n);else if(n.scheduleFn)n.scheduleFn(n);else{if(n.type!=v)throw new Error("Task is missing scheduleFn.");h(n)}return e},t.prototype.invokeTask=function(t,n,e,a){return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,t,n,e,a):n.callback.apply(e,a)},t.prototype.cancelTask=function(t,n){var e;if(this._cancelTaskZS)e=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,t,n);else{if(!n.cancelFn)throw Error("Task is not cancelable");e=n.cancelFn(n)}return e},t.prototype.hasTask=function(t,n){try{this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,t,n)}catch(n){this.handleError(t,n)}},t.prototype._updateTaskCount=function(t,n){var e=this._taskCounts,a=e[t],o=e[t]=a+n;if(o<0)throw new Error("More tasks executed then were scheduled.");0!=a&&0!=o||this.hasTask(this.zone,{microTask:e.microTask>0,macroTask:e.macroTask>0,eventTask:e.eventTask>0,change:t})},t})(),d=(function(){function n(e,a,o,r,i,c){if(this._zone=null,this.runCount=0,this._zoneDelegates=null,this._state="notScheduled",this.type=e,this.source=a,this.data=r,this.scheduleFn=i,this.cancelFn=c,!o)throw new Error("callback is not defined");this.callback=o;var s=this;this.invoke=e===S&&r&&r.useG?n.invokeTask:function(){return n.invokeTask.call(t,s,this,arguments)}}return n.invokeTask=function(t,n,e){t||(t=this),T++;try{return t.runCount++,t.zone.runTask(t,n,e)}finally{1==T&&_(),T--}},Object.defineProperty(n.prototype,"zone",{get:function(){return this._zone},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"state",{get:function(){return this._state},enumerable:!0,configurable:!0}),n.prototype.cancelScheduleRequest=function(){this._transitionTo(M,O)},n.prototype._transitionTo=function(t,n,e){if(this._state!==n&&this._state!==e)throw new Error(this.type+" '"+this.source+"': can not transition to '"+t+"', expecting state '"+n+"'"+(e?" or '"+e+"'":"")+", was '"+this._state+"'.");this._state=t,t==M&&(this._zoneDelegates=null)},n.prototype.toString=function(){return this.data&&void 0!==this.data.handleId?this.data.handleId.toString():Object.prototype.toString.call(this)},n.prototype.toJSON=function(){return{type:this.type,state:this.state,source:this.source,zone:this.zone.name,runCount:this.runCount}},n})(),g=r("setTimeout"),p=r("Promise"),b=r("then"),u=[],f=!1;function h(n){if(0===T&&0===u.length)if(s||t[p]&&(s=t[p].resolve(0)),s){var e=s[b];e||(e=s.then),e.call(s,_)}else t[g](_,0);n&&u.push(n)}function _(){if(!f){for(f=!0;u.length;){var t=u;u=[];for(var n=0;n<t.length;n++){var e=t[n];try{e.zone.runTask(e,null,null)}catch(t){A.onUnhandledError(t)}}}A.microtaskDrainDone(),f=!1}}var C={name:"NO ZONE"},M="notScheduled",O="scheduling",P="scheduled",x="running",y="canceling",k="unknown",v="microTask",w="macroTask",S="eventTask",E={},A={symbol:r,currentZoneFrame:function(){return z},onUnhandledError:D,microtaskDrainDone:D,scheduleMicroTask:h,showUncaughtError:function(){return!c[r("ignoreConsoleErrorUncaughtError")]},patchEventTarget:function(){return[]},patchOnProperties:D,patchMethod:function(){return D},bindArguments:function(){return[]},patchThen:function(){return D},patchMacroTask:function(){return D},setNativePromise:function(t){t&&"function"==typeof t.resolve&&(s=t.resolve(0))},patchEventPrototype:function(){return D},isIEOrEdge:function(){return!1},getGlobalObjects:function(){},ObjectDefineProperty:function(){return D},ObjectGetOwnPropertyDescriptor:function(){},ObjectCreate:function(){},ArraySlice:function(){return[]},patchClass:function(){return D},wrapWithCurrentZone:function(){return D},filterProperties:function(){return[]},attachOriginToPatched:function(){return D},_redefineProperty:function(){return D},patchCallbacks:function(){return D}},z={parent:null,zone:new c(null,null)},R=null,T=0;function D(){}a("Zone","Zone"),t.Zone=c})("undefined"!=typeof window&&window||"undefined"!=typeof self&&self||xP),
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
Zone.__load_patch("ZoneAwarePromise",(function(t,n,e){var a=Object.getOwnPropertyDescriptor,o=Object.defineProperty,r=e.symbol,i=[],c=!0===t[r("DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION")],s=r("Promise"),l=r("then");e.onUnhandledError=function(t){if(e.showUncaughtError()){var n=t&&t.rejection;n?console.error("Unhandled Promise rejection:",n instanceof Error?n.message:n,"; Zone:",t.zone.name,"; Task:",t.task&&t.task.source,"; Value:",n,n instanceof Error?n.stack:void 0):console.error(t)}},e.microtaskDrainDone=function(){for(var t=function(){var t=i.shift();try{t.zone.runGuarded((function(){throw t}))}catch(t){!(function a(t){e.onUnhandledError(t);try{var a=n[m];"function"==typeof a&&a.call(this,t)}catch(t){}})(t)}};i.length;)t()};var m=r("unhandledPromiseRejectionHandler");function d(t){return t&&t.then}function g(t){return t}function p(t){return E.reject(t)}var b=r("state"),u=r("value"),f=r("finally"),h=r("parentPromiseValue"),_=r("parentPromiseState"),C=null,M=!0,O=!1;function P(t,n){return function(e){try{y(t,n,e)}catch(n){y(t,!1,n)}}}var x=r("currentTaskTrace");function y(t,a,r){var s,l=(s=!1,function t(n){return function(){s||(s=!0,n.apply(null,arguments))}});if(t===r)throw new TypeError("Promise resolved with itself");if(t[b]===C){var m=null;try{"object"!=typeof r&&"function"!=typeof r||(m=r&&r.then)}catch(n){return l((function(){y(t,!1,n)}))(),t}if(a!==O&&r instanceof E&&r.hasOwnProperty(b)&&r.hasOwnProperty(u)&&r[b]!==C)v(r),y(t,r[b],r[u]);else if(a!==O&&"function"==typeof m)try{m.call(r,l(P(t,a)),l(P(t,!1)))}catch(n){l((function(){y(t,!1,n)}))()}else{t[b]=a;var d=t[u];if(t[u]=r,t[f]===f&&a===M&&(t[b]=t[_],t[u]=t[h]),a===O&&r instanceof Error){var g=n.currentTask&&n.currentTask.data&&n.currentTask.data.__creationTrace__;g&&o(r,x,{configurable:!0,enumerable:!1,writable:!0,value:g})}for(var p=0;p<d.length;)w(t,d[p++],d[p++],d[p++],d[p++]);if(0==d.length&&a==O){t[b]=0;var k=r;if(!c)try{throw new Error("Uncaught (in promise): "+(function S(t){return t&&t.toString===Object.prototype.toString?(t.constructor&&t.constructor.name||"")+": "+JSON.stringify(t):t?t.toString():Object.prototype.toString.call(t)})(r)+(r&&r.stack?"\n"+r.stack:""))}catch(t){k=t}k.rejection=r,k.promise=t,k.zone=n.current,k.task=n.currentTask,i.push(k),e.scheduleMicroTask()}}}return t}var k=r("rejectionHandledHandler");function v(t){if(0===t[b]){try{var e=n[k];e&&"function"==typeof e&&e.call(this,{rejection:t[u],promise:t})}catch(t){}t[b]=O;for(var a=0;a<i.length;a++)t===i[a].promise&&i.splice(a,1)}}function w(t,n,e,a,o){v(t);var r=t[b],i=r?"function"==typeof a?a:g:"function"==typeof o?o:p;n.scheduleMicroTask("Promise.then",(function(){try{var a=t[u],o=!!e&&f===e[f];o&&(e[h]=a,e[_]=r);var c=n.run(i,void 0,o&&i!==p&&i!==g?[]:[a]);y(e,!0,c)}catch(t){y(e,!1,t)}}),e)}var S=function(){},E=(function(){function t(n){var e=this;if(!(e instanceof t))throw new Error("Must be an instanceof Promise.");e[b]=C,e[u]=[];try{n&&n(P(e,M),P(e,O))}catch(t){y(e,!1,t)}}return t.toString=function(){return"function ZoneAwarePromise() { [native code] }"},t.resolve=function(t){return y(new this(null),M,t)},t.reject=function(t){return y(new this(null),O,t)},t.race=function(t){var n,e,a=new this((function(t,a){n=t,e=a}));function o(t){n(t)}function r(t){e(t)}for(var i=0,c=t;i<c.length;i++){var s=c[i];d(s)||(s=this.resolve(s)),s.then(o,r)}return a},t.all=function(n){return t.allWithCallback(n)},t.allSettled=function(n){return(this&&this.prototype instanceof t?this:t).allWithCallback(n,{thenCallback:function(t){return{status:"fulfilled",value:t}},errorCallback:function(t){return{status:"rejected",reason:t}}})},t.allWithCallback=function(t,n){for(var e,a,o=new this((function(t,n){e=t,a=n})),r=2,i=0,c=[],s=function(t){d(t)||(t=l.resolve(t));var o=i;try{t.then((function(t){c[o]=n?n.thenCallback(t):t,0==--r&&e(c)}),(function(t){n?(c[o]=n.errorCallback(t),0==--r&&e(c)):a(t)}))}catch(t){a(t)}r++,i++},l=this,m=0,g=t;m<g.length;m++)s(g[m]);return 0==(r-=2)&&e(c),o},Object.defineProperty(t.prototype,Symbol.toStringTag,{get:function(){return"Promise"},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,Symbol.species,{get:function(){return t},enumerable:!0,configurable:!0}),t.prototype.then=function(e,a){var o=this.constructor[Symbol.species];o&&"function"==typeof o||(o=this.constructor||t);var r=new o(S),i=n.current;return this[b]==C?this[u].push(i,r,e,a):w(this,i,r,e,a),r},t.prototype.catch=function(t){return this.then(null,t)},t.prototype.finally=function(e){var a=this.constructor[Symbol.species];a&&"function"==typeof a||(a=t);var o=new a(S);o[f]=f;var r=n.current;return this[b]==C?this[u].push(r,o,e,e):w(this,r,o,e,e),o},t})();E.resolve=E.resolve,E.reject=E.reject,E.race=E.race,E.all=E.all;var A=t[s]=t.Promise,z=n.__symbol__("ZoneAwarePromise"),R=a(t,"Promise");R&&!R.configurable||(R&&delete R.writable,R&&delete R.value,R||(R={configurable:!0,enumerable:!0}),R.get=function(){return t[z]?t[z]:t[s]},R.set=function(n){n===E?t[z]=n:(t[s]=n,n.prototype[l]||D(n),e.setNativePromise(n))},o(t,"Promise",R)),t.Promise=E;var T=r("thenPatched");function D(t){var n=t.prototype,e=a(n,"then");if(!e||!1!==e.writable&&e.configurable){var o=n.then;n[l]=o,t.prototype.then=function(t,n){var e=this;return new E((function(t,n){o.call(e,t,n)})).then(t,n)},t[T]=!0}}if(e.patchThen=D,A){D(A);var I=t.fetch;"function"==typeof I&&(t[e.symbol("fetch")]=I,t.fetch=(function N(t){return function(){var n=t.apply(this,arguments);if(n instanceof E)return n;var e=n.constructor;return e[T]||D(e),n}})(I))}return Promise[n.__symbol__("uncaughtPromiseErrors")]=i,E}));
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
var t=Object.getOwnPropertyDescriptor,n=Object.defineProperty,e=Object.getPrototypeOf,a=Object.create,o=Array.prototype.slice,r="addEventListener",i="removeEventListener",c=Zone.__symbol__(r),s=Zone.__symbol__(i),l="true",m="false",d=Zone.__symbol__("");function g(t,n){return Zone.current.wrap(t,n)}function p(t,n,e,a,o){return Zone.current.scheduleMacroTask(t,n,e,a,o)}var b=Zone.__symbol__,u="undefined"!=typeof window,f=u?window:void 0,h=u&&f||"object"==typeof self&&self||xP,_=[null];function C(t,n){for(var e=t.length-1;e>=0;e--)"function"==typeof t[e]&&(t[e]=g(t[e],n+"_"+e));return t}function M(t){return!t||!1!==t.writable&&!("function"==typeof t.get&&void 0===t.set)}var O="undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope,P=!("nw"in h)&&void 0!==h.process&&"[object process]"==={}.toString.call(h.process),x=!P&&!O&&!(!u||!f.HTMLElement),y=void 0!==h.process&&"[object process]"==={}.toString.call(h.process)&&!O&&!(!u||!f.HTMLElement),k={},v=function(t){if(t=t||h.event){var n=k[t.type];n||(n=k[t.type]=b("ON_PROPERTY"+t.type));var e,a=this||t.target||h,o=a[n];return x&&a===f&&"error"===t.type?!0===(e=o&&o.call(this,t.message,t.filename,t.lineno,t.colno,t.error))&&t.preventDefault():null==(e=o&&o.apply(this,arguments))||e||t.preventDefault(),e}};function w(e,a,o){var r=t(e,a);if(!r&&o&&t(o,a)&&(r={enumerable:!0,configurable:!0}),r&&r.configurable){var i=b("on"+a+"patched");if(!e.hasOwnProperty(i)||!e[i]){delete r.writable,delete r.value;var c=r.get,s=r.set,l=a.substr(2),m=k[l];m||(m=k[l]=b("ON_PROPERTY"+l)),r.set=function(t){var n=this;n||e!==h||(n=h),n&&(n[m]&&n.removeEventListener(l,v),s&&s.apply(n,_),"function"==typeof t?(n[m]=t,n.addEventListener(l,v,!1)):n[m]=null)},r.get=function(){var t=this;if(t||e!==h||(t=h),!t)return null;var n=t[m];if(n)return n;if(c){var o=c&&c.call(this);if(o)return r.set.call(this,o),"function"==typeof t.removeAttribute&&t.removeAttribute(a),o}return null},n(e,a,r),e[i]=!0}}}function S(t,n,e){if(n)for(var a=0;a<n.length;a++)w(t,"on"+n[a],e);else{var o=[];for(var r in t)"on"==r.substr(0,2)&&o.push(r);for(var i=0;i<o.length;i++)w(t,o[i],e)}}var E=b("originalInstance");function A(t){var e=h[t];if(e){h[b(t)]=e,h[t]=function(){var n=C(arguments,t);switch(n.length){case 0:this[E]=new e;break;case 1:this[E]=new e(n[0]);break;case 2:this[E]=new e(n[0],n[1]);break;case 3:this[E]=new e(n[0],n[1],n[2]);break;case 4:this[E]=new e(n[0],n[1],n[2],n[3]);break;default:throw new Error("Arg list too long.")}},T(h[t],e);var a,o=new e((function(){}));for(a in o)"XMLHttpRequest"===t&&"responseBlob"===a||(function(e){"function"==typeof o[e]?h[t].prototype[e]=function(){return this[E][e].apply(this[E],arguments)}:n(h[t].prototype,e,{set:function(n){"function"==typeof n?(this[E][e]=g(n,t+"."+e),T(this[E][e],n)):this[E][e]=n},get:function(){return this[E][e]}})})(a);for(a in e)"prototype"!==a&&e.hasOwnProperty(a)&&(h[t][a]=e[a])}}function z(n,a,o){for(var r=n;r&&!r.hasOwnProperty(a);)r=e(r);!r&&n[a]&&(r=n);var i=b(a),c=null;if(r&&!(c=r[i])&&(c=r[i]=r[a],M(r&&t(r,a)))){var s=o(c,i,a);r[a]=function(){return s(this,arguments)},T(r[a],c)}return c}function R(t,n,e){var a=null;function o(t){var n=t.data;return n.args[n.cbIdx]=function(){t.invoke.apply(this,arguments)},a.apply(n.target,n.args),t}a=z(t,n,(function(t){return function(n,a){var r=e(n,a);return r.cbIdx>=0&&"function"==typeof a[r.cbIdx]?p(r.name,a[r.cbIdx],r,o):t.apply(n,a)}}))}function T(t,n){t[b("OriginalDelegate")]=n}var D=!1,I=!1;function N(){try{var t=f.navigator.userAgent;if(-1!==t.indexOf("MSIE ")||-1!==t.indexOf("Trident/"))return!0}catch(t){}return!1}function F(){if(D)return I;D=!0;try{var t=f.navigator.userAgent;-1===t.indexOf("MSIE ")&&-1===t.indexOf("Trident/")&&-1===t.indexOf("Edge/")||(I=!0)}catch(t){}return I}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */Zone.__load_patch("toString",(function(t){var n=Function.prototype.toString,e=b("OriginalDelegate"),a=b("Promise"),o=b("Error"),r=function r(){if("function"==typeof this){var i=this[e];if(i)return"function"==typeof i?n.call(i):Object.prototype.toString.call(i);if(this===Promise){var c=t[a];if(c)return n.call(c)}if(this===Error){var s=t[o];if(s)return n.call(s)}}return n.call(this)};r[e]=n,Function.prototype.toString=r;var i=Object.prototype.toString;Object.prototype.toString=function(){return this instanceof Promise?"[object Promise]":i.call(this)}}));
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
var L=!1;if("undefined"!=typeof window)try{var H=Object.defineProperty({},"passive",{get:function(){L=!0}});window.addEventListener("test",H,H),window.removeEventListener("test",H,H)}catch(t){L=!1}var B={useG:!0},V={},j={},U=new RegExp("^"+d+"(\\w+)(true|false)$"),W=b("propagationStopped");function G(t,n){var e=(n?n(t):t)+m,a=(n?n(t):t)+l,o=d+e,r=d+a;V[t]={},V[t].false=o,V[t].true=r}function Y(t,n,a){var o=a&&a.add||r,c=a&&a.rm||i,s=a&&a.listeners||"eventListeners",g=a&&a.rmAll||"removeAllListeners",p=b(o),u="."+o+":",f=function(t,n,e){if(!t.isRemoved){var a=t.callback;"object"==typeof a&&a.handleEvent&&(t.callback=function(t){return a.handleEvent(t)},t.originalDelegate=a),t.invoke(t,n,[e]);var o=t.options;o&&"object"==typeof o&&o.once&&n[c].call(n,e.type,t.originalDelegate?t.originalDelegate:t.callback,o)}},h=function(n){if(n=n||t.event){var e=this||n.target||t,a=e[V[n.type].false];if(a)if(1===a.length)f(a[0],e,n);else for(var o=a.slice(),r=0;r<o.length&&(!n||!0!==n[W]);r++)f(o[r],e,n)}},_=function(n){if(n=n||t.event){var e=this||n.target||t,a=e[V[n.type].true];if(a)if(1===a.length)f(a[0],e,n);else for(var o=a.slice(),r=0;r<o.length&&(!n||!0!==n[W]);r++)f(o[r],e,n)}};function C(n,a){if(!n)return!1;var r=!0;a&&void 0!==a.useG&&(r=a.useG);var i=a&&a.vh,f=!0;a&&void 0!==a.chkDup&&(f=a.chkDup);var C=!1;a&&void 0!==a.rt&&(C=a.rt);for(var M=n;M&&!M.hasOwnProperty(o);)M=e(M);if(!M&&n[o]&&(M=n),!M)return!1;if(M[p])return!1;var O,x=a&&a.eventNameToString,y={},k=M[p]=M[o],v=M[b(c)]=M[c],w=M[b(s)]=M[s],S=M[b(g)]=M[g];function E(t,n){return!L&&"object"==typeof t&&t?!!t.capture:L&&n?"boolean"==typeof t?{capture:t,passive:!0}:t?"object"==typeof t&&!1!==t.passive?Object.assign(Object.assign({},t),{passive:!0}):t:{passive:!0}:t}a&&a.prepend&&(O=M[b(a.prepend)]=M[a.prepend]);var A=r?function(t){if(!y.isExisting)return k.call(y.target,y.eventName,y.capture?_:h,y.options)}:function(t){return k.call(y.target,y.eventName,t.invoke,y.options)},z=r?function(t){if(!t.isRemoved){var n=V[t.eventName],e=void 0;n&&(e=n[t.capture?l:m]);var a=e&&t.target[e];if(a)for(var o=0;o<a.length;o++)if(a[o]===t){a.splice(o,1),t.isRemoved=!0,0===a.length&&(t.allRemoved=!0,t.target[e]=null);break}}if(t.allRemoved)return v.call(t.target,t.eventName,t.capture?_:h,t.options)}:function(t){return v.call(t.target,t.eventName,t.invoke,t.options)},R=a&&a.diff?a.diff:function(t,n){var e=typeof n;return"function"===e&&t.callback===n||"object"===e&&t.originalDelegate===n},D=Zone[b("BLACK_LISTED_EVENTS")],I=t[b("PASSIVE_EVENTS")],N=function(n,e,o,c,s,d){return void 0===s&&(s=!1),void 0===d&&(d=!1),function(){var g=this||t,p=arguments[0];a&&a.transferEventName&&(p=a.transferEventName(p));var b=arguments[1];if(!b)return n.apply(this,arguments);if(P&&"uncaughtException"===p)return n.apply(this,arguments);var u=!1;if("function"!=typeof b){if(!b.handleEvent)return n.apply(this,arguments);u=!0}if(!i||i(n,b,g,arguments)){var h=L&&!!I&&-1!==I.indexOf(p),_=E(arguments[2],h);if(D)for(var C=0;C<D.length;C++)if(p===D[C])return h?n.call(g,p,b,_):n.apply(this,arguments);var M=!!_&&("boolean"==typeof _||_.capture),O=!(!_||"object"!=typeof _)&&_.once,k=Zone.current,v=V[p];v||(G(p,x),v=V[p]);var w,S=v[M?l:m],A=g[S],z=!1;if(A){if(z=!0,f)for(C=0;C<A.length;C++)if(R(A[C],b))return}else A=g[S]=[];var T=g.constructor.name,N=j[T];N&&(w=N[p]),w||(w=T+e+(x?x(p):p)),y.options=_,O&&(y.options.once=!1),y.target=g,y.capture=M,y.eventName=p,y.isExisting=z;var F=r?B:void 0;F&&(F.taskData=y);var H=k.scheduleEventTask(w,b,F,o,c);return y.target=null,F&&(F.taskData=null),O&&(_.once=!0),(L||"boolean"!=typeof H.options)&&(H.options=_),H.target=g,H.capture=M,H.eventName=p,u&&(H.originalDelegate=b),d?A.unshift(H):A.push(H),s?g:void 0}}};return M[o]=N(k,u,A,z,C),O&&(M.prependListener=N(O,".prependListener:",(function(t){return O.call(y.target,y.eventName,t.invoke,y.options)}),z,C,!0)),M[c]=function(){var n=this||t,e=arguments[0];a&&a.transferEventName&&(e=a.transferEventName(e));var o=arguments[2],r=!!o&&("boolean"==typeof o||o.capture),c=arguments[1];if(!c)return v.apply(this,arguments);if(!i||i(v,c,n,arguments)){var s,g=V[e];g&&(s=g[r?l:m]);var p=s&&n[s];if(p)for(var b=0;b<p.length;b++){var u=p[b];if(R(u,c))return p.splice(b,1),u.isRemoved=!0,0===p.length&&(u.allRemoved=!0,n[s]=null,"string"==typeof e&&(n[d+"ON_PROPERTY"+e]=null)),u.zone.cancelTask(u),C?n:void 0}return v.apply(this,arguments)}},M[s]=function(){var n=this||t,e=arguments[0];a&&a.transferEventName&&(e=a.transferEventName(e));for(var o=[],r=q(n,x?x(e):e),i=0;i<r.length;i++){var c=r[i];o.push(c.originalDelegate?c.originalDelegate:c.callback)}return o},M[g]=function(){var n=this||t,e=arguments[0];if(e){a&&a.transferEventName&&(e=a.transferEventName(e));var o=V[e];if(o){var r=n[o.false],i=n[o.true];if(r){var s=r.slice();for(d=0;d<s.length;d++)this[c].call(this,e,(l=s[d]).originalDelegate?l.originalDelegate:l.callback,l.options)}if(i)for(s=i.slice(),d=0;d<s.length;d++){var l;this[c].call(this,e,(l=s[d]).originalDelegate?l.originalDelegate:l.callback,l.options)}}}else{for(var m=Object.keys(n),d=0;d<m.length;d++){var p=U.exec(m[d]),b=p&&p[1];b&&"removeListener"!==b&&this[g].call(this,b)}this[g].call(this,"removeListener")}if(C)return this},T(M[o],k),T(M[c],v),S&&T(M[g],S),w&&T(M[s],w),!0}for(var M=[],O=0;O<n.length;O++)M[O]=C(n[O],a);return M}function q(t,n){if(!n){var e=[];for(var a in t){var o=U.exec(a),r=o&&o[1];if(r&&(!n||r===n)){var i=t[a];if(i)for(var c=0;c<i.length;c++)e.push(i[c])}}return e}var s=V[n];s||(G(n),s=V[n]);var l=t[s.false],m=t[s.true];return l?m?l.concat(m):l.slice():m?m.slice():[]}function Z(t,n){var e=t.Event;e&&e.prototype&&n.patchMethod(e.prototype,"stopImmediatePropagation",(function(t){return function(n,e){n[W]=!0,t&&t.apply(n,e)}}))}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */function X(t,n,e,a,o){var r=Zone.__symbol__(a);if(!n[r]){var i=n[r]=n[a];n[a]=function(r,c,s){return c&&c.prototype&&o.forEach((function(n){var o=e+"."+a+"::"+n,r=c.prototype;if(r.hasOwnProperty(n)){var i=t.ObjectGetOwnPropertyDescriptor(r,n);i&&i.value?(i.value=t.wrapWithCurrentZone(i.value,o),t._redefineProperty(c.prototype,n,i)):r[n]&&(r[n]=t.wrapWithCurrentZone(r[n],o))}else r[n]&&(r[n]=t.wrapWithCurrentZone(r[n],o))})),i.call(n,r,c,s)},t.attachOriginToPatched(n[a],i)}}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */var J,Q,K,$,tt,nt=["absolutedeviceorientation","afterinput","afterprint","appinstalled","beforeinstallprompt","beforeprint","beforeunload","devicelight","devicemotion","deviceorientation","deviceorientationabsolute","deviceproximity","hashchange","languagechange","message","mozbeforepaint","offline","online","paint","pageshow","pagehide","popstate","rejectionhandled","storage","unhandledrejection","unload","userproximity","vrdisplayconnected","vrdisplaydisconnected","vrdisplaypresentchange"],et=["encrypted","waitingforkey","msneedkey","mozinterruptbegin","mozinterruptend"],at=["load"],ot=["blur","error","focus","load","resize","scroll","messageerror"],rt=["bounce","finish","start"],it=["loadstart","progress","abort","error","load","progress","timeout","loadend","readystatechange"],ct=["upgradeneeded","complete","abort","success","error","blocked","versionchange","close"],st=["close","error","open","message"],lt=["error","message"],mt=["abort","animationcancel","animationend","animationiteration","auxclick","beforeinput","blur","cancel","canplay","canplaythrough","change","compositionstart","compositionupdate","compositionend","cuechange","click","close","contextmenu","curechange","dblclick","drag","dragend","dragenter","dragexit","dragleave","dragover","drop","durationchange","emptied","ended","error","focus","focusin","focusout","gotpointercapture","input","invalid","keydown","keypress","keyup","load","loadstart","loadeddata","loadedmetadata","lostpointercapture","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","mousewheel","orientationchange","pause","play","playing","pointercancel","pointerdown","pointerenter","pointerleave","pointerlockchange","mozpointerlockchange","webkitpointerlockerchange","pointerlockerror","mozpointerlockerror","webkitpointerlockerror","pointermove","pointout","pointerover","pointerup","progress","ratechange","reset","resize","scroll","seeked","seeking","select","selectionchange","selectstart","show","sort","stalled","submit","suspend","timeupdate","volumechange","touchcancel","touchmove","touchstart","touchend","transitioncancel","transitionend","waiting","wheel"].concat(["webglcontextrestored","webglcontextlost","webglcontextcreationerror"],["autocomplete","autocompleteerror"],["toggle"],["afterscriptexecute","beforescriptexecute","DOMContentLoaded","freeze","fullscreenchange","mozfullscreenchange","webkitfullscreenchange","msfullscreenchange","fullscreenerror","mozfullscreenerror","webkitfullscreenerror","msfullscreenerror","readystatechange","visibilitychange","resume"],nt,["beforecopy","beforecut","beforepaste","copy","cut","paste","dragstart","loadend","animationstart","search","transitionrun","transitionstart","webkitanimationend","webkitanimationiteration","webkitanimationstart","webkittransitionend"],["activate","afterupdate","ariarequest","beforeactivate","beforedeactivate","beforeeditfocus","beforeupdate","cellchange","controlselect","dataavailable","datasetchanged","datasetcomplete","errorupdate","filterchange","layoutcomplete","losecapture","move","moveend","movestart","propertychange","resizeend","resizestart","rowenter","rowexit","rowsdelete","rowsinserted","command","compassneedscalibration","deactivate","help","mscontentzoom","msmanipulationstatechanged","msgesturechange","msgesturedoubletap","msgestureend","msgesturehold","msgesturestart","msgesturetap","msgotpointercapture","msinertiastart","mslostpointercapture","mspointercancel","mspointerdown","mspointerenter","mspointerhover","mspointerleave","mspointermove","mspointerout","mspointerover","mspointerup","pointerout","mssitemodejumplistitemremoved","msthumbnailclick","stop","storagecommit"]);function dt(t,n,e){if(!e||0===e.length)return n;var a=e.filter((function(n){return n.target===t}));if(!a||0===a.length)return n;var o=a[0].ignoreProperties;return n.filter((function(t){return-1===o.indexOf(t)}))}function gt(t,n,e,a){t&&S(t,dt(t,n,e),a)}function pt(t,n){if((!P||y)&&!Zone[t.symbol("patchEvents")]){var a="undefined"!=typeof WebSocket,o=n.__Zone_ignore_on_properties;if(x){var r=window,i=N?[{target:r,ignoreProperties:["error"]}]:[];gt(r,mt.concat(["messageerror"]),o?o.concat(i):o,e(r)),gt(Document.prototype,mt,o),void 0!==r.SVGElement&&gt(r.SVGElement.prototype,mt,o),gt(Element.prototype,mt,o),gt(HTMLElement.prototype,mt,o),gt(HTMLMediaElement.prototype,et,o),gt(HTMLFrameSetElement.prototype,nt.concat(ot),o),gt(HTMLBodyElement.prototype,nt.concat(ot),o),gt(HTMLFrameElement.prototype,at,o),gt(HTMLIFrameElement.prototype,at,o);var c=r.HTMLMarqueeElement;c&&gt(c.prototype,rt,o);var s=r.Worker;s&&gt(s.prototype,lt,o)}var l=n.XMLHttpRequest;l&&gt(l.prototype,it,o);var m=n.XMLHttpRequestEventTarget;m&&gt(m&&m.prototype,it,o),"undefined"!=typeof IDBIndex&&(gt(IDBIndex.prototype,ct,o),gt(IDBRequest.prototype,ct,o),gt(IDBOpenDBRequest.prototype,ct,o),gt(IDBDatabase.prototype,ct,o),gt(IDBTransaction.prototype,ct,o),gt(IDBCursor.prototype,ct,o)),a&&gt(WebSocket.prototype,st,o)}}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */function bt(){J=Zone.__symbol__,Q=Object[J("defineProperty")]=Object.defineProperty,K=Object[J("getOwnPropertyDescriptor")]=Object.getOwnPropertyDescriptor,$=Object.create,tt=J("unconfigurables"),Object.defineProperty=function(t,n,e){if(ft(t,n))throw new TypeError("Cannot assign to read only property '"+n+"' of "+t);var a=e.configurable;return"prototype"!==n&&(e=ht(t,n,e)),_t(t,n,e,a)},Object.defineProperties=function(t,n){return Object.keys(n).forEach((function(e){Object.defineProperty(t,e,n[e])})),t},Object.create=function(t,n){return"object"!=typeof n||Object.isFrozen(n)||Object.keys(n).forEach((function(e){n[e]=ht(t,e,n[e])})),$(t,n)},Object.getOwnPropertyDescriptor=function(t,n){var e=K(t,n);return e&&ft(t,n)&&(e.configurable=!1),e}}function ut(t,n,e){var a=e.configurable;return _t(t,n,e=ht(t,n,e),a)}function ft(t,n){return t&&t[tt]&&t[tt][n]}function ht(t,n,e){return Object.isFrozen(e)||(e.configurable=!0),e.configurable||(t[tt]||Object.isFrozen(t)||Q(t,tt,{writable:!0,value:{}}),t[tt]&&(t[tt][n]=!0)),e}function _t(t,n,e,a){try{return Q(t,n,e)}catch(r){if(!e.configurable)throw r;void 0===a?delete e.configurable:e.configurable=a;try{return Q(t,n,e)}catch(a){var o=null;try{o=JSON.stringify(e)}catch(t){o=e.toString()}console.log("Attempting to configure '"+n+"' with descriptor '"+o+"' on object '"+t+"' and got error, giving up: "+a)}}}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */function Ct(t,n){var e=n.getGlobalObjects(),a=e.eventNames,o=e.globalSources,r=e.zoneSymbolEventNames,i=e.TRUE_STR,c=e.FALSE_STR,s=e.ZONE_SYMBOL_PREFIX,l="ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket".split(","),m=[],d=t.wtf,g="Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video".split(",");d?m=g.map((function(t){return"HTML"+t+"Element"})).concat(l):t.EventTarget?m.push("EventTarget"):m=l;for(var p=t.__Zone_disable_IE_check||!1,b=t.__Zone_enable_cross_context_check||!1,u=n.isIEOrEdge(),f="[object FunctionWrapper]",h="function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }",_={MSPointerCancel:"pointercancel",MSPointerDown:"pointerdown",MSPointerEnter:"pointerenter",MSPointerHover:"pointerhover",MSPointerLeave:"pointerleave",MSPointerMove:"pointermove",MSPointerOut:"pointerout",MSPointerOver:"pointerover",MSPointerUp:"pointerup"},C=0;C<a.length;C++){var M=s+((k=a[C])+c),O=s+(k+i);r[k]={},r[k][c]=M,r[k][i]=O}for(C=0;C<g.length;C++)for(var P=g[C],x=o[P]={},y=0;y<a.length;y++){var k;x[k=a[y]]=P+".addEventListener:"+k}var v=[];for(C=0;C<m.length;C++){var w=t[m[C]];v.push(w&&w.prototype)}return n.patchEventTarget(t,v,{vh:function(t,n,e,a){if(!p&&u){if(b)try{var o;if((o=n.toString())===f||o==h)return t.apply(e,a),!1}catch(n){return t.apply(e,a),!1}else if((o=n.toString())===f||o==h)return t.apply(e,a),!1}else if(b)try{n.toString()}catch(n){return t.apply(e,a),!1}return!0},transferEventName:function(t){return _[t]||t}}),Zone[n.symbol("patchEventTarget")]=!!t.EventTarget,!0}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
function Mt(t,n){var e=t.getGlobalObjects();if((!e.isNode||e.isMix)&&!(function a(t,n){var e=t.getGlobalObjects();if((e.isBrowser||e.isMix)&&!t.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&"undefined"!=typeof Element){var a=t.ObjectGetOwnPropertyDescriptor(Element.prototype,"onclick");if(a&&!a.configurable)return!1;if(a){t.ObjectDefineProperty(Element.prototype,"onclick",{enumerable:!0,configurable:!0,get:function(){return!0}});var o=!!document.createElement("div").onclick;return t.ObjectDefineProperty(Element.prototype,"onclick",a),o}}var r=n.XMLHttpRequest;if(!r)return!1;var i="onreadystatechange",c=r.prototype,s=t.ObjectGetOwnPropertyDescriptor(c,i);if(s)return t.ObjectDefineProperty(c,i,{enumerable:!0,configurable:!0,get:function(){return!0}}),o=!!(m=new r).onreadystatechange,t.ObjectDefineProperty(c,i,s||{}),o;var l=t.symbol("fake");t.ObjectDefineProperty(c,i,{enumerable:!0,configurable:!0,get:function(){return this[l]},set:function(t){this[l]=t}});var m,d=function(){};return(m=new r).onreadystatechange=d,o=m[l]===d,m.onreadystatechange=null,o})(t,n)){var o="undefined"!=typeof WebSocket;(function r(t){for(var n=t.getGlobalObjects().eventNames,e=t.symbol("unbound"),a=function(a){var o=n[a],r="on"+o;self.addEventListener(o,(function(n){var a,o,i=n.target;for(o=i?i.constructor.name+"."+r:"unknown."+r;i;)i[r]&&!i[r][e]&&((a=t.wrapWithCurrentZone(i[r],o))[e]=i[r],i[r]=a),i=i.parentElement}),!0)},o=0;o<n.length;o++)a(o)}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */)(t),t.patchClass("XMLHttpRequest"),o&&(function i(t,n){var e=t.getGlobalObjects(),a=e.ADD_EVENT_LISTENER_STR,o=e.REMOVE_EVENT_LISTENER_STR,r=n.WebSocket;n.EventTarget||t.patchEventTarget(n,[r.prototype]),n.WebSocket=function(n,e){var i,c,s=arguments.length>1?new r(n,e):new r(n),l=t.ObjectGetOwnPropertyDescriptor(s,"onmessage");return l&&!1===l.configurable?(i=t.ObjectCreate(s),c=s,[a,o,"send","close"].forEach((function(n){i[n]=function(){var e=t.ArraySlice.call(arguments);if(n===a||n===o){var r=e.length>0?e[0]:void 0;if(r){var c=Zone.__symbol__("ON_PROPERTY"+r);s[c]=i[c]}}return s[n].apply(s,e)}}))):i=s,t.patchOnProperties(i,["close","error","message","open"],c),i};var i=n.WebSocket;for(var c in r)i[c]=r[c]})(t,n),Zone[t.symbol("patchEvents")]=!0}}Zone.__load_patch("util",(function(e,c,s){s.patchOnProperties=S,s.patchMethod=z,s.bindArguments=C,s.patchMacroTask=R;var p=c.__symbol__("BLACK_LISTED_EVENTS"),b=c.__symbol__("UNPATCHED_EVENTS");e[b]&&(e[p]=e[b]),e[p]&&(c[p]=c[b]=e[p]),s.patchEventPrototype=Z,s.patchEventTarget=Y,s.isIEOrEdge=F,s.ObjectDefineProperty=n,s.ObjectGetOwnPropertyDescriptor=t,s.ObjectCreate=a,s.ArraySlice=o,s.patchClass=A,s.wrapWithCurrentZone=g,s.filterProperties=dt,s.attachOriginToPatched=T,s._redefineProperty=Object.defineProperty,s.patchCallbacks=X,s.getGlobalObjects=function(){return{globalSources:j,zoneSymbolEventNames:V,eventNames:mt,isBrowser:x,isMix:y,isNode:P,TRUE_STR:l,FALSE_STR:m,ZONE_SYMBOL_PREFIX:d,ADD_EVENT_LISTENER_STR:r,REMOVE_EVENT_LISTENER_STR:i}}})),
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
(function(t){var n=t.__Zone_symbol_prefix||"__zone_symbol__";t[(function e(t){return n+t})("legacyPatch")]=function(){var n=t.Zone;n.__load_patch("defineProperty",(function(t,n,e){e._redefineProperty=ut,bt()})),n.__load_patch("registerElement",(function(t,n,e){!(function a(t,n){var e=n.getGlobalObjects();(e.isBrowser||e.isMix)&&"registerElement"in t.document&&n.patchCallbacks(n,document,"Document","registerElement",["createdCallback","attachedCallback","detachedCallback","attributeChangedCallback"])})(t,e)})),n.__load_patch("EventTargetLegacy",(function(t,n,e){Ct(t,e),Mt(e,t)}))}})("undefined"!=typeof window?window:void 0!==xP?xP:"undefined"!=typeof self?self:{});
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
var Ot=b("zoneTask");function Pt(t,n,e,a){var o=null,r=null;e+=a;var i={};function c(n){var e=n.data;return e.args[0]=function a(){try{n.invoke.apply(this,arguments)}finally{n.data&&n.data.isPeriodic||("number"==typeof e.handleId?delete i[e.handleId]:e.handleId&&(e.handleId[Ot]=null))}},e.handleId=o.apply(t,e.args),n}function s(t){return r(t.data.handleId)}o=z(t,n+=a,(function(e){return function(o,r){if("function"==typeof r[0]){var l=p(n,r[0],{isPeriodic:"Interval"===a,delay:"Timeout"===a||"Interval"===a?r[1]||0:void 0,args:r},c,s);if(!l)return l;var m=l.data.handleId;return"number"==typeof m?i[m]=l:m&&(m[Ot]=l),m&&m.ref&&m.unref&&"function"==typeof m.ref&&"function"==typeof m.unref&&(l.ref=m.ref.bind(m),l.unref=m.unref.bind(m)),"number"==typeof m||m?m:l}return e.apply(t,r)}})),r=z(t,e,(function(n){return function(e,a){var o,r=a[0];"number"==typeof r?o=i[r]:(o=r&&r[Ot])||(o=r),o&&"string"==typeof o.type?"notScheduled"!==o.state&&(o.cancelFn&&o.data.isPeriodic||0===o.runCount)&&("number"==typeof r?delete i[r]:r&&(r[Ot]=null),o.zone.cancelTask(o)):n.apply(t,a)}}))}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
function xt(t,n){if(!Zone[n.symbol("patchEventTarget")]){for(var e=n.getGlobalObjects(),a=e.eventNames,o=e.zoneSymbolEventNames,r=e.TRUE_STR,i=e.FALSE_STR,c=e.ZONE_SYMBOL_PREFIX,s=0;s<a.length;s++){var l=a[s],m=c+(l+i),d=c+(l+r);o[l]={},o[l][i]=m,o[l][r]=d}var g=t.EventTarget;if(g&&g.prototype)return n.patchEventTarget(t,[g&&g.prototype]),!0}}
/**
         * @license
         * Copyright Google Inc. All Rights Reserved.
         *
         * Use of this source code is governed by an MIT-style license that can be
         * found in the LICENSE file at https://angular.io/license
         */
Zone.__load_patch("legacy",(function(t){var n=t[Zone.__symbol__("legacyPatch")];n&&n()})),Zone.__load_patch("timers",(function(t){var n="set",e="clear";Pt(t,n,e,"Timeout"),Pt(t,n,e,"Interval"),Pt(t,n,e,"Immediate")})),Zone.__load_patch("requestAnimationFrame",(function(t){Pt(t,"request","cancel","AnimationFrame"),Pt(t,"mozRequest","mozCancel","AnimationFrame"),Pt(t,"webkitRequest","webkitCancel","AnimationFrame")})),Zone.__load_patch("blocking",(function(t,n){for(var e=["alert","prompt","confirm"],a=0;a<e.length;a++)z(t,e[a],(function(e,a,o){return function(a,r){return n.current.run(e,t,r,o)}}))})),Zone.__load_patch("EventTarget",(function(t,n,e){(function a(t,n){n.patchEventPrototype(t,n)})(t,e),xt(t,e);var o=t.XMLHttpRequestEventTarget;o&&o.prototype&&e.patchEventTarget(t,[o.prototype]),A("MutationObserver"),A("WebKitMutationObserver"),A("IntersectionObserver"),A("FileReader")})),Zone.__load_patch("on_property",(function(t,n,e){pt(e,t)})),Zone.__load_patch("customElements",(function(t,n,e){!(function a(t,n){var e=n.getGlobalObjects();(e.isBrowser||e.isMix)&&t.customElements&&"customElements"in t&&n.patchCallbacks(n,t.customElements,"customElements","define",["connectedCallback","disconnectedCallback","adoptedCallback","attributeChangedCallback"])})(t,e)})),Zone.__load_patch("XHR",(function(t,n){!(function e(t){var e=t.XMLHttpRequest;if(e){var d=e.prototype,g=d[c],u=d[s];if(!g){var f=t.XMLHttpRequestEventTarget;if(f){var h=f.prototype;g=h[c],u=h[s]}}var _="readystatechange",C="scheduled",M=z(d,"open",(function(){return function(t,n){return t[o]=0==n[2],t[l]=n[1],M.apply(t,n)}})),O=b("fetchTaskAborting"),P=b("fetchTaskScheduling"),x=z(d,"send",(function(){return function(t,e){if(!0===n.current[P])return x.apply(t,e);if(t[o])return x.apply(t,e);var a={target:t,url:t[l],isPeriodic:!1,args:e,aborted:!1},r=p("XMLHttpRequest.send",v,a,k,w);t&&!0===t[m]&&!a.aborted&&r.state===C&&r.invoke()}})),y=z(d,"abort",(function(){return function(t,e){var o=(function r(t){return t[a]})(t);if(o&&"string"==typeof o.type){if(null==o.cancelFn||o.data&&o.data.aborted)return;o.zone.cancelTask(o)}else if(!0===n.current[O])return y.apply(t,e)}}))}function k(t){var e=t.data,o=e.target;o[i]=!1,o[m]=!1;var l=o[r];g||(g=o[c],u=o[s]),l&&u.call(o,_,l);var d=o[r]=function(){if(o.readyState===o.DONE)if(!e.aborted&&o[i]&&t.state===C){var a=o[n.__symbol__("loadfalse")];if(a&&a.length>0){var r=t.invoke;t.invoke=function(){for(var a=o[n.__symbol__("loadfalse")],i=0;i<a.length;i++)a[i]===t&&a.splice(i,1);e.aborted||t.state!==C||r.call(t)},a.push(t)}else t.invoke()}else e.aborted||!1!==o[i]||(o[m]=!0)};return g.call(o,_,d),o[a]||(o[a]=t),x.apply(o,e.args),o[i]=!0,t}function v(){}function w(t){var n=t.data;return n.aborted=!0,y.apply(n.target,n.args)}})(t);var a=b("xhrTask"),o=b("xhrSync"),r=b("xhrListener"),i=b("xhrScheduled"),l=b("xhrURL"),m=b("xhrErrorBeforeScheduled")})),Zone.__load_patch("geolocation",(function(n){n.navigator&&n.navigator.geolocation&&(function e(n,a){for(var o=n.constructor.name,r=function(e){var r=a[e],i=n[r];if(i){if(!M(t(n,r)))return"continue";n[r]=(function(t){var n=function(){return t.apply(this,C(arguments,o+"."+r))};return T(n,t),n})(i)}},i=0;i<a.length;i++)r(i)})(n.navigator.geolocation,["getCurrentPosition","watchPosition"])})),Zone.__load_patch("PromiseRejectionEvent",(function(t,n){function e(n){return function(e){q(t,n).forEach((function(a){var o=t.PromiseRejectionEvent;if(o){var r=new o(n,{promise:e.promise,reason:e.rejection});a.invoke(r)}}))}}t.PromiseRejectionEvent&&(n[b("unhandledPromiseRejectionHandler")]=e("unhandledrejection"),n[b("rejectionHandledHandler")]=e("rejectionhandled"))}))})();
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */
class vP{}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const wP="*";function SP(t,n){return{type:7,name:t,definitions:n,options:{}}}function EP(t,n=null){return{type:4,styles:n,timings:t}}function AP(t,n=null){return{type:2,steps:t,options:n}}function zP(t){return{type:6,styles:t,offset:null}}function RP(t,n,e){return{type:0,name:t,styles:n,options:e}}function TP(t){return{type:5,steps:t}}function DP(t,n,e=null){return{type:1,expr:t,animation:n,options:e}}function IP(t=null){return{type:9,options:t}}function NP(t,n,e=null){return{type:11,selector:t,animation:n,options:e}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function FP(t){Promise.resolve(null).then(t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class LP{constructor(t=0,n=0){this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._started=!1,this._destroyed=!1,this._finished=!1,this.parentPlayer=null,this.totalTime=t+n}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach((t=>t())),this._onDoneFns=[])}onStart(t){this._onStartFns.push(t)}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}init(){}play(){this.hasStarted()||(this._onStart(),this.triggerMicrotask()),this._started=!0}triggerMicrotask(){FP((()=>this._onFinish()))}_onStart(){this._onStartFns.forEach((t=>t())),this._onStartFns=[]}pause(){}restart(){}finish(){this._onFinish()}destroy(){this._destroyed||(this._destroyed=!0,this.hasStarted()||this._onStart(),this.finish(),this._onDestroyFns.forEach((t=>t())),this._onDestroyFns=[])}reset(){}setPosition(t){}getPosition(){return 0}triggerCallback(t){const n="start"==t?this._onStartFns:this._onDoneFns;n.forEach((t=>t())),n.length=0}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class HP{constructor(t){this._onDoneFns=[],this._onStartFns=[],this._finished=!1,this._started=!1,this._destroyed=!1,this._onDestroyFns=[],this.parentPlayer=null,this.totalTime=0,this.players=t;let n=0,e=0,a=0;const o=this.players.length;0==o?FP((()=>this._onFinish())):this.players.forEach((t=>{t.onDone((()=>{++n==o&&this._onFinish()})),t.onDestroy((()=>{++e==o&&this._onDestroy()})),t.onStart((()=>{++a==o&&this._onStart()}))})),this.totalTime=this.players.reduce(((t,n)=>Math.max(t,n.totalTime)),0)}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach((t=>t())),this._onDoneFns=[])}init(){this.players.forEach((t=>t.init()))}onStart(t){this._onStartFns.push(t)}_onStart(){this.hasStarted()||(this._started=!0,this._onStartFns.forEach((t=>t())),this._onStartFns=[])}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}hasStarted(){return this._started}play(){this.parentPlayer||this.init(),this._onStart(),this.players.forEach((t=>t.play()))}pause(){this.players.forEach((t=>t.pause()))}restart(){this.players.forEach((t=>t.restart()))}finish(){this._onFinish(),this.players.forEach((t=>t.finish()))}destroy(){this._onDestroy()}_onDestroy(){this._destroyed||(this._destroyed=!0,this._onFinish(),this.players.forEach((t=>t.destroy())),this._onDestroyFns.forEach((t=>t())),this._onDestroyFns=[])}reset(){this.players.forEach((t=>t.reset())),this._destroyed=!1,this._finished=!1,this._started=!1}setPosition(t){const n=t*this.totalTime;this.players.forEach((t=>{const e=t.totalTime?Math.min(1,n/t.totalTime):1;t.setPosition(e)}))}getPosition(){let t=0;return this.players.forEach((n=>{const e=n.getPosition();t=Math.min(e,t)})),t}beforeDestroy(){this.players.forEach((t=>{t.beforeDestroy&&t.beforeDestroy()}))}triggerCallback(t){const n="start"==t?this._onStartFns:this._onDoneFns;n.forEach((t=>t())),n.length=0}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function BP(){return"undefined"!=typeof process&&"[object process]"==={}.toString.call(process)}function VP(t){switch(t.length){case 0:return new LP;case 1:return t[0];default:return new HP(t)}}function jP(t,n,e,a,o={},r={}){const i=[],c=[];let s=-1,l=null;if(a.forEach((t=>{const e=t.offset,a=e==s,m=a&&l||{};Object.keys(t).forEach((e=>{let a=e,c=t[e];if("offset"!==e)switch(a=n.normalizePropertyName(a,i),c){case"!":c=o[e];break;case wP:c=r[e];break;default:c=n.normalizeStyleValue(e,a,c,i)}m[a]=c})),a||c.push(m),l=m,s=e})),i.length){const t="\n - ";throw new Error(`Unable to animate due to the following errors:${t}${i.join(t)}`)}return c}function UP(t,n,e,a){switch(n){case"start":t.onStart((()=>a(e&&WP(e,"start",t))));break;case"done":t.onDone((()=>a(e&&WP(e,"done",t))));break;case"destroy":t.onDestroy((()=>a(e&&WP(e,"destroy",t))))}}function WP(t,n,e){const a=e.totalTime,o=GP(t.element,t.triggerName,t.fromState,t.toState,n||t.phaseName,null==a?t.totalTime:a,!!e.disabled),r=t._data;return null!=r&&(o._data=r),o}function GP(t,n,e,a,o="",r=0,i){return{element:t,triggerName:n,fromState:e,toState:a,phaseName:o,totalTime:r,disabled:!!i}}function YP(t,n,e){let a;return t instanceof Map?(a=t.get(n),a||t.set(n,a=e)):(a=t[n],a||(a=t[n]=e)),a}function qP(t){const n=t.indexOf(":");return[t.substring(1,n),t.substr(n+1)]}let ZP=(t,n)=>!1,XP=(t,n)=>!1,JP=(t,n,e)=>[];const QP=BP();(QP||"undefined"!=typeof Element)&&(ZP=(t,n)=>t.contains(n),XP=(()=>{if(QP||Element.prototype.matches)return(t,n)=>t.matches(n);{const t=Element.prototype,n=t.matchesSelector||t.mozMatchesSelector||t.msMatchesSelector||t.oMatchesSelector||t.webkitMatchesSelector;return n?(t,e)=>n.apply(t,[e]):XP}})(),JP=(t,n,e)=>{let a=[];if(e)a.push(...t.querySelectorAll(n));else{const e=t.querySelector(n);e&&a.push(e)}return a});let KP=null,$P=!1;function tx(t){KP||(KP=(function n(){return"undefined"!=typeof document?document.body:null})()||{},$P=!!KP.style&&"WebkitAppearance"in KP.style);let e=!0;return KP.style&&!(function a(t){return"ebkit"==t.substring(1,6)})(t)&&(e=t in KP.style,!e&&$P)&&(e="Webkit"+t.charAt(0).toUpperCase()+t.substr(1)in KP.style),e}const nx=XP,ex=ZP,ax=JP;function ox(t){const n={};return Object.keys(t).forEach((e=>{const a=e.replace(/([a-z])([A-Z])/g,"$1-$2");n[a]=t[e]})),n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class rx{validateStyleProperty(t){return tx(t)}matchesElement(t,n){return nx(t,n)}containsElement(t,n){return ex(t,n)}query(t,n,e){return ax(t,n,e)}computeStyle(t,n,e){return e||""}animate(t,n,e,a,o,r=[],i){return new LP(e,a)}}rx.ɵfac=function t(n){return new(n||rx)},rx.ɵprov=We({token:rx,factory:rx.ɵfac});class ix{}ix.NOOP=new rx;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const cx="ng-enter",sx="ng-leave",lx="ng-trigger",mx=".ng-trigger",dx="ng-animating",gx=".ng-animating";function px(t){if("number"==typeof t)return t;const n=t.match(/^(-?[\.\d]+)(m?s)/);return!n||n.length<2?0:bx(parseFloat(n[1]),n[2])}function bx(t,n){switch(n){case"s":return 1e3*t;default:return t}}function ux(t,n,e){return t.hasOwnProperty("duration")?t:(function a(t,n,e){let a,o=0,r="";if("string"==typeof t){const e=t.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i);if(null===e)return n.push(`The provided timing value "${t}" is invalid.`),{duration:0,delay:0,easing:""};a=bx(parseFloat(e[1]),e[2]);const i=e[3];null!=i&&(o=bx(parseFloat(i),e[4]));const c=e[5];c&&(r=c)}else a=t;if(!e){let e=!1,r=n.length;a<0&&(n.push("Duration values below 0 are not allowed for this animation step."),e=!0),o<0&&(n.push("Delay values below 0 are not allowed for this animation step."),e=!0),e&&n.splice(r,0,`The provided timing value "${t}" is invalid.`)}return{duration:a,delay:o,easing:r}})(t,n,e)}function fx(t,n={}){return Object.keys(t).forEach((e=>{n[e]=t[e]})),n}function hx(t,n,e={}){if(n)for(let n in t)e[n]=t[n];else fx(t,e);return e}function _x(t,n,e){return e?n+":"+e+";":""}function Cx(t){let n="";for(let e=0;e<t.style.length;e++){const a=t.style.item(e);n+=_x(0,a,t.style.getPropertyValue(a))}for(const e in t.style)t.style.hasOwnProperty(e)&&!e.startsWith("_")&&(n+=_x(0,e.replace(/([a-z])([A-Z])/g,"$1-$2").toLowerCase(),t.style[e]));t.setAttribute("style",n)}function Mx(t,n,e){t.style&&(Object.keys(n).forEach((a=>{const o=Sx(a);e&&!e.hasOwnProperty(a)&&(e[a]=t.style[o]),t.style[o]=n[a]})),BP()&&Cx(t))}function Ox(t,n){t.style&&(Object.keys(n).forEach((n=>{const e=Sx(n);t.style[e]=""})),BP()&&Cx(t))}function Px(t){return Array.isArray(t)?1==t.length?t[0]:AP(t):t}const xx=new RegExp("{{\\s*(.+?)\\s*}}","g");function yx(t){let n=[];if("string"==typeof t){let e;for(;e=xx.exec(t);)n.push(e[1]);xx.lastIndex=0}return n}function kx(t,n,e){const a=t.toString(),o=a.replace(xx,((t,a)=>{let o=n[a];return n.hasOwnProperty(a)||(e.push(`Please provide a value for the animation param ${a}`),o=""),o.toString()}));return o==a?t:o}function vx(t){const n=[];let e=t.next();for(;!e.done;)n.push(e.value),e=t.next();return n}const wx=/-+([a-z0-9])/g;function Sx(t){return t.replace(wx,((...t)=>t[1].toUpperCase()))}function Ex(t,n){return 0===t||0===n}function Ax(t,n,e){const a=Object.keys(e);if(a.length&&n.length){let r=n[0],i=[];if(a.forEach((t=>{r.hasOwnProperty(t)||i.push(t),r[t]=e[t]})),i.length)for(var o=1;o<n.length;o++){let e=n[o];i.forEach((function(n){e[n]=Rx(t,n)}))}}return n}function zx(t,n,e){switch(n.type){case 7:return t.visitTrigger(n,e);case 0:return t.visitState(n,e);case 1:return t.visitTransition(n,e);case 2:return t.visitSequence(n,e);case 3:return t.visitGroup(n,e);case 4:return t.visitAnimate(n,e);case 5:return t.visitKeyframes(n,e);case 6:return t.visitStyle(n,e);case 8:return t.visitReference(n,e);case 9:return t.visitAnimateChild(n,e);case 10:return t.visitAnimateRef(n,e);case 11:return t.visitQuery(n,e);case 12:return t.visitStagger(n,e);default:throw new Error(`Unable to resolve animation metadata node #${n.type}`)}}function Rx(t,n){return window.getComputedStyle(t)[n]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Tx="*";function Dx(t,n){const e=[];return"string"==typeof t?t.split(/\s*,\s*/).forEach((t=>(function a(t,n,e){if(":"==t[0]){const a=(function a(t,n){switch(t){case":enter":return"void => *";case":leave":return"* => void";case":increment":return(t,n)=>parseFloat(n)>parseFloat(t);case":decrement":return(t,n)=>parseFloat(n)<parseFloat(t);default:return n.push(`The transition alias value "${t}" is not supported`),"* => *"}})(t,e);if("function"==typeof a)return void n.push(a);t=a}const o=t.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);if(null==o||o.length<4)return e.push(`The provided transition expression "${t}" is not supported`),n;const r=o[1],i=o[2],c=o[3];n.push(Fx(r,c)),"<"!=i[0]||r==Tx&&c==Tx||n.push(Fx(c,r))})(t,e,n))):e.push(t),e}const Ix=new Set(["true","1"]),Nx=new Set(["false","0"]);function Fx(t,n){const e=Ix.has(t)||Nx.has(t),a=Ix.has(n)||Nx.has(n);return(o,r)=>{let i=t==Tx||t==o,c=n==Tx||n==r;return!i&&e&&"boolean"==typeof o&&(i=o?Ix.has(t):Nx.has(t)),!c&&a&&"boolean"==typeof r&&(c=r?Ix.has(n):Nx.has(n)),i&&c}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Lx=new RegExp("s*:selfs*,?","g");function Hx(t,n,e){return new Bx(t).build(n,e)}class Bx{constructor(t){this._driver=t}build(t,n){const e=new Vx(n);return this._resetContextStyleTimingState(e),zx(this,Px(t),e)}_resetContextStyleTimingState(t){t.currentQuerySelector="",t.collectedStyles={},t.collectedStyles[""]={},t.currentTime=0}visitTrigger(t,n){let e=n.queryCount=0,a=n.depCount=0;const o=[],r=[];return"@"==t.name.charAt(0)&&n.errors.push("animation triggers cannot be prefixed with an `@` sign (e.g. trigger('@foo', [...]))"),t.definitions.forEach((t=>{if(this._resetContextStyleTimingState(n),0==t.type){const e=t,a=e.name;a.toString().split(/\s*,\s*/).forEach((t=>{e.name=t,o.push(this.visitState(e,n))})),e.name=a}else if(1==t.type){const o=this.visitTransition(t,n);e+=o.queryCount,a+=o.depCount,r.push(o)}else n.errors.push("only state() and transition() definitions can sit inside of a trigger()")})),{type:7,name:t.name,states:o,transitions:r,queryCount:e,depCount:a,options:null}}visitState(t,n){const e=this.visitStyle(t.styles,n),a=t.options&&t.options.params||null;if(e.containsDynamicStyles){const o=new Set,r=a||{};if(e.styles.forEach((t=>{if(jx(t)){const n=t;Object.keys(n).forEach((t=>{yx(n[t]).forEach((t=>{r.hasOwnProperty(t)||o.add(t)}))}))}})),o.size){const e=vx(o.values());n.errors.push(`state("${t.name}", ...) must define default values for all the following style substitutions: ${e.join(", ")}`)}}return{type:0,name:t.name,style:e,options:a?{params:a}:null}}visitTransition(t,n){n.queryCount=0,n.depCount=0;const e=zx(this,Px(t.animation),n);return{type:1,matchers:Dx(t.expr,n.errors),animation:e,queryCount:n.queryCount,depCount:n.depCount,options:Ux(t.options)}}visitSequence(t,n){return{type:2,steps:t.steps.map((t=>zx(this,t,n))),options:Ux(t.options)}}visitGroup(t,n){const e=n.currentTime;let a=0;const o=t.steps.map((t=>{n.currentTime=e;const o=zx(this,t,n);return a=Math.max(a,n.currentTime),o}));return n.currentTime=a,{type:3,steps:o,options:Ux(t.options)}}visitAnimate(t,n){const e=(function a(t,n){let e=null;if(t.hasOwnProperty("duration"))e=t;else if("number"==typeof t)return Wx(ux(t,n).duration,0,"");const a=t;if(a.split(/\s+/).some((t=>"{"==t.charAt(0)&&"{"==t.charAt(1)))){const t=Wx(0,0,"");return t.dynamic=!0,t.strValue=a,t}return e=e||ux(a,n),Wx(e.duration,e.delay,e.easing)})(t.timings,n.errors);let o;n.currentAnimateTimings=e;let r=t.styles?t.styles:zP({});if(5==r.type)o=this.visitKeyframes(r,n);else{let a=t.styles,r=!1;if(!a){r=!0;const t={};e.easing&&(t.easing=e.easing),a=zP(t)}n.currentTime+=e.duration+e.delay;const i=this.visitStyle(a,n);i.isEmptyStep=r,o=i}return n.currentAnimateTimings=null,{type:4,timings:e,style:o,options:null}}visitStyle(t,n){const e=this._makeStyleAst(t,n);return this._validateStyleAst(e,n),e}_makeStyleAst(t,n){const e=[];Array.isArray(t.styles)?t.styles.forEach((t=>{"string"==typeof t?t==wP?e.push(t):n.errors.push(`The provided style string value ${t} is not allowed.`):e.push(t)})):e.push(t.styles);let a=!1,o=null;return e.forEach((t=>{if(jx(t)){const n=t,e=n.easing;if(e&&(o=e,delete n.easing),!a)for(let t in n)if(n[t].toString().indexOf("{{")>=0){a=!0;break}}})),{type:6,styles:e,easing:o,offset:t.offset,containsDynamicStyles:a,options:null}}_validateStyleAst(t,n){const e=n.currentAnimateTimings;let a=n.currentTime,o=n.currentTime;e&&o>0&&(o-=e.duration+e.delay),t.styles.forEach((t=>{"string"!=typeof t&&Object.keys(t).forEach((e=>{if(!this._driver.validateStyleProperty(e))return void n.errors.push(`The provided animation property "${e}" is not a supported CSS property for animations`);const r=n.collectedStyles[n.currentQuerySelector],i=r[e];let c=!0;i&&(o!=a&&o>=i.startTime&&a<=i.endTime&&(n.errors.push(`The CSS property "${e}" that exists between the times of "${i.startTime}ms" and "${i.endTime}ms" is also being animated in a parallel animation between the times of "${o}ms" and "${a}ms"`),c=!1),o=i.startTime),c&&(r[e]={startTime:o,endTime:a}),n.options&&(function s(t,n,e){const a=n.params||{},o=yx(t);o.length&&o.forEach((t=>{a.hasOwnProperty(t)||e.push(`Unable to resolve the local animation param ${t} in the given list of values`)}))})(t[e],n.options,n.errors)}))}))}visitKeyframes(t,n){const e={type:5,styles:[],options:null};if(!n.currentAnimateTimings)return n.errors.push("keyframes() must be placed inside of a call to animate()"),e;let a=0;const o=[];let r=!1,i=!1,c=0;const s=t.steps.map((t=>{const e=this._makeStyleAst(t,n);let s=null!=e.offset?e.offset:(function l(t){if("string"==typeof t)return null;let n=null;if(Array.isArray(t))t.forEach((t=>{if(jx(t)&&t.hasOwnProperty("offset")){const e=t;n=parseFloat(e.offset),delete e.offset}}));else if(jx(t)&&t.hasOwnProperty("offset")){const e=t;n=parseFloat(e.offset),delete e.offset}return n})(e.styles),m=0;return null!=s&&(a++,m=e.offset=s),i=i||m<0||m>1,r=r||m<c,c=m,o.push(m),e}));i&&n.errors.push("Please ensure that all keyframe offsets are between 0 and 1"),r&&n.errors.push("Please ensure that all keyframe offsets are in order");const l=t.steps.length;let m=0;a>0&&a<l?n.errors.push("Not all style() steps within the declared keyframes() contain offsets"):0==a&&(m=1/(l-1));const d=l-1,g=n.currentTime,p=n.currentAnimateTimings,b=p.duration;return s.forEach(((t,a)=>{const r=m>0?a==d?1:m*a:o[a],i=r*b;n.currentTime=g+p.delay+i,p.duration=i,this._validateStyleAst(t,n),t.offset=r,e.styles.push(t)})),e}visitReference(t,n){return{type:8,animation:zx(this,Px(t.animation),n),options:Ux(t.options)}}visitAnimateChild(t,n){return n.depCount++,{type:9,options:Ux(t.options)}}visitAnimateRef(t,n){return{type:10,animation:this.visitReference(t.animation,n),options:Ux(t.options)}}visitQuery(t,n){const e=n.currentQuerySelector,a=t.options||{};n.queryCount++,n.currentQuery=t;const[o,r]=(function i(t){const n=!!t.split(/\s*,\s*/).find((t=>":self"==t));return n&&(t=t.replace(Lx,"")),[t=t.replace(/@\*/g,mx).replace(/@\w+/g,(t=>".ng-trigger-"+t.substr(1))).replace(/:animating/g,gx),n]})(t.selector);n.currentQuerySelector=e.length?e+" "+o:o,YP(n.collectedStyles,n.currentQuerySelector,{});const c=zx(this,Px(t.animation),n);return n.currentQuery=null,n.currentQuerySelector=e,{type:11,selector:o,limit:a.limit||0,optional:!!a.optional,includeSelf:r,animation:c,originalSelector:t.selector,options:Ux(t.options)}}visitStagger(t,n){n.currentQuery||n.errors.push("stagger() can only be used inside of query()");const e="full"===t.timings?{duration:0,delay:0,easing:"full"}:ux(t.timings,n.errors,!0);return{type:12,animation:zx(this,Px(t.animation),n),timings:e,options:null}}}class Vx{constructor(t){this.errors=t,this.queryCount=0,this.depCount=0,this.currentTransition=null,this.currentQuery=null,this.currentQuerySelector=null,this.currentAnimateTimings=null,this.currentTime=0,this.collectedStyles={},this.options=null}}function jx(t){return!Array.isArray(t)&&"object"==typeof t}function Ux(t){return t?(t=fx(t)).params&&(t.params=(function n(t){return t?fx(t):null})(t.params)):t={},t}function Wx(t,n,e){return{duration:t,delay:n,easing:e}}function Gx(t,n,e,a,o,r,i=null,c=!1){return{type:1,element:t,keyframes:n,preStyleProps:e,postStyleProps:a,duration:o,delay:r,totalTime:o+r,easing:i,subTimeline:c}}class Yx{constructor(){this._map=new Map}consume(t){let n=this._map.get(t);return n?this._map.delete(t):n=[],n}append(t,n){let e=this._map.get(t);e||this._map.set(t,e=[]),e.push(...n)}has(t){return this._map.has(t)}clear(){this._map.clear()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const qx=new RegExp(":enter","g"),Zx=new RegExp(":leave","g");function Xx(t,n,e,a,o,r={},i={},c,s,l=[]){return(new Jx).buildKeyframes(t,n,e,a,o,r,i,c,s,l)}class Jx{buildKeyframes(t,n,e,a,o,r,i,c,s,l=[]){s=s||new Yx;const m=new Kx(t,n,s,a,o,l,[]);m.options=c,m.currentTimeline.setStyles([r],null,m.errors,c),zx(this,e,m);const d=m.timelines.filter((t=>t.containsAnimation()));if(d.length&&Object.keys(i).length){const t=d[d.length-1];t.allowOnlyTimelineStyles()||t.setStyles([i],null,m.errors,c)}return d.length?d.map((t=>t.buildKeyframes())):[Gx(n,[],[],[],0,0,"",!1)]}visitTrigger(t,n){}visitState(t,n){}visitTransition(t,n){}visitAnimateChild(t,n){const e=n.subInstructions.consume(n.element);if(e){const a=n.createSubContext(t.options),o=n.currentTimeline.currentTime,r=this._visitSubInstructions(e,a,a.options);o!=r&&n.transformIntoNewTimeline(r)}n.previousNode=t}visitAnimateRef(t,n){const e=n.createSubContext(t.options);e.transformIntoNewTimeline(),this.visitReference(t.animation,e),n.transformIntoNewTimeline(e.currentTimeline.currentTime),n.previousNode=t}_visitSubInstructions(t,n,e){let a=n.currentTimeline.currentTime;const o=null!=e.duration?px(e.duration):null,r=null!=e.delay?px(e.delay):null;return 0!==o&&t.forEach((t=>{const e=n.appendInstructionToTimeline(t,o,r);a=Math.max(a,e.duration+e.delay)})),a}visitReference(t,n){n.updateOptions(t.options,!0),zx(this,t.animation,n),n.previousNode=t}visitSequence(t,n){const e=n.subContextCount;let a=n;const o=t.options;if(o&&(o.params||o.delay)&&(a=n.createSubContext(o),a.transformIntoNewTimeline(),null!=o.delay)){6==a.previousNode.type&&(a.currentTimeline.snapshotCurrentStyles(),a.previousNode=Qx);const t=px(o.delay);a.delayNextStep(t)}t.steps.length&&(t.steps.forEach((t=>zx(this,t,a))),a.currentTimeline.applyStylesToKeyframe(),a.subContextCount>e&&a.transformIntoNewTimeline()),n.previousNode=t}visitGroup(t,n){const e=[];let a=n.currentTimeline.currentTime;const o=t.options&&t.options.delay?px(t.options.delay):0;t.steps.forEach((r=>{const i=n.createSubContext(t.options);o&&i.delayNextStep(o),zx(this,r,i),a=Math.max(a,i.currentTimeline.currentTime),e.push(i.currentTimeline)})),e.forEach((t=>n.currentTimeline.mergeTimelineCollectedStyles(t))),n.transformIntoNewTimeline(a),n.previousNode=t}_visitTiming(t,n){if(t.dynamic){const e=t.strValue;return ux(n.params?kx(e,n.params,n.errors):e,n.errors)}return{duration:t.duration,delay:t.delay,easing:t.easing}}visitAnimate(t,n){const e=n.currentAnimateTimings=this._visitTiming(t.timings,n),a=n.currentTimeline;e.delay&&(n.incrementTime(e.delay),a.snapshotCurrentStyles());const o=t.style;5==o.type?this.visitKeyframes(o,n):(n.incrementTime(e.duration),this.visitStyle(o,n),a.applyStylesToKeyframe()),n.currentAnimateTimings=null,n.previousNode=t}visitStyle(t,n){const e=n.currentTimeline,a=n.currentAnimateTimings;!a&&e.getCurrentStyleProperties().length&&e.forwardFrame();const o=a&&a.easing||t.easing;t.isEmptyStep?e.applyEmptyStep(o):e.setStyles(t.styles,o,n.errors,n.options),n.previousNode=t}visitKeyframes(t,n){const e=n.currentAnimateTimings,a=n.currentTimeline.duration,o=e.duration,r=n.createSubContext().currentTimeline;r.easing=e.easing,t.styles.forEach((t=>{r.forwardTime((t.offset||0)*o),r.setStyles(t.styles,t.easing,n.errors,n.options),r.applyStylesToKeyframe()})),n.currentTimeline.mergeTimelineCollectedStyles(r),n.transformIntoNewTimeline(a+o),n.previousNode=t}visitQuery(t,n){const e=n.currentTimeline.currentTime,a=t.options||{},o=a.delay?px(a.delay):0;o&&(6===n.previousNode.type||0==e&&n.currentTimeline.getCurrentStyleProperties().length)&&(n.currentTimeline.snapshotCurrentStyles(),n.previousNode=Qx);let r=e;const i=n.invokeQuery(t.selector,t.originalSelector,t.limit,t.includeSelf,!!a.optional,n.errors);n.currentQueryTotal=i.length;let c=null;i.forEach(((e,a)=>{n.currentQueryIndex=a;const i=n.createSubContext(t.options,e);o&&i.delayNextStep(o),e===n.element&&(c=i.currentTimeline),zx(this,t.animation,i),i.currentTimeline.applyStylesToKeyframe(),r=Math.max(r,i.currentTimeline.currentTime)})),n.currentQueryIndex=0,n.currentQueryTotal=0,n.transformIntoNewTimeline(r),c&&(n.currentTimeline.mergeTimelineCollectedStyles(c),n.currentTimeline.snapshotCurrentStyles()),n.previousNode=t}visitStagger(t,n){const e=n.parentContext,a=n.currentTimeline,o=t.timings,r=Math.abs(o.duration),i=r*(n.currentQueryTotal-1);let c=r*n.currentQueryIndex;switch(o.duration<0?"reverse":o.easing){case"reverse":c=i-c;break;case"full":c=e.currentStaggerTime}const s=n.currentTimeline;c&&s.delayNextStep(c);const l=s.currentTime;zx(this,t.animation,n),n.previousNode=t,e.currentStaggerTime=a.currentTime-l+(a.startTime-e.currentTimeline.startTime)}}const Qx={};class Kx{constructor(t,n,e,a,o,r,i,c){this._driver=t,this.element=n,this.subInstructions=e,this._enterClassName=a,this._leaveClassName=o,this.errors=r,this.timelines=i,this.parentContext=null,this.currentAnimateTimings=null,this.previousNode=Qx,this.subContextCount=0,this.options={},this.currentQueryIndex=0,this.currentQueryTotal=0,this.currentStaggerTime=0,this.currentTimeline=c||new $x(this._driver,n,0),i.push(this.currentTimeline)}get params(){return this.options.params}updateOptions(t,n){if(!t)return;const e=t;let a=this.options;null!=e.duration&&(a.duration=px(e.duration)),null!=e.delay&&(a.delay=px(e.delay));const o=e.params;if(o){let t=a.params;t||(t=this.options.params={}),Object.keys(o).forEach((e=>{n&&t.hasOwnProperty(e)||(t[e]=kx(o[e],t,this.errors))}))}}_copyOptions(){const t={};if(this.options){const n=this.options.params;if(n){const e=t.params={};Object.keys(n).forEach((t=>{e[t]=n[t]}))}}return t}createSubContext(t=null,n,e){const a=n||this.element,o=new Kx(this._driver,a,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(a,e||0));return o.previousNode=this.previousNode,o.currentAnimateTimings=this.currentAnimateTimings,o.options=this._copyOptions(),o.updateOptions(t),o.currentQueryIndex=this.currentQueryIndex,o.currentQueryTotal=this.currentQueryTotal,o.parentContext=this,this.subContextCount++,o}transformIntoNewTimeline(t){return this.previousNode=Qx,this.currentTimeline=this.currentTimeline.fork(this.element,t),this.timelines.push(this.currentTimeline),this.currentTimeline}appendInstructionToTimeline(t,n,e){const a={duration:null!=n?n:t.duration,delay:this.currentTimeline.currentTime+(null!=e?e:0)+t.delay,easing:""},o=new ty(this._driver,t.element,t.keyframes,t.preStyleProps,t.postStyleProps,a,t.stretchStartingKeyframe);return this.timelines.push(o),a}incrementTime(t){this.currentTimeline.forwardTime(this.currentTimeline.duration+t)}delayNextStep(t){t>0&&this.currentTimeline.delayNextStep(t)}invokeQuery(t,n,e,a,o,r){let i=[];if(a&&i.push(this.element),t.length>0){t=(t=t.replace(qx,"."+this._enterClassName)).replace(Zx,"."+this._leaveClassName);let n=this._driver.query(this.element,t,1!=e);0!==e&&(n=e<0?n.slice(n.length+e,n.length):n.slice(0,e)),i.push(...n)}return o||0!=i.length||r.push(`\`query("${n}")\` returned zero elements. (Use \`query("${n}", { optional: true })\` if you wish to allow this.)`),i}}class $x{constructor(t,n,e,a){this._driver=t,this.element=n,this.startTime=e,this._elementTimelineStylesLookup=a,this.duration=0,this._previousKeyframe={},this._currentKeyframe={},this._keyframes=new Map,this._styleSummary={},this._pendingStyles={},this._backFill={},this._currentEmptyStepKeyframe=null,this._elementTimelineStylesLookup||(this._elementTimelineStylesLookup=new Map),this._localTimelineStyles=Object.create(this._backFill,{}),this._globalTimelineStyles=this._elementTimelineStylesLookup.get(n),this._globalTimelineStyles||(this._globalTimelineStyles=this._localTimelineStyles,this._elementTimelineStylesLookup.set(n,this._localTimelineStyles)),this._loadKeyframe()}containsAnimation(){switch(this._keyframes.size){case 0:return!1;case 1:return this.getCurrentStyleProperties().length>0;default:return!0}}getCurrentStyleProperties(){return Object.keys(this._currentKeyframe)}get currentTime(){return this.startTime+this.duration}delayNextStep(t){const n=1==this._keyframes.size&&Object.keys(this._pendingStyles).length;this.duration||n?(this.forwardTime(this.currentTime+t),n&&this.snapshotCurrentStyles()):this.startTime+=t}fork(t,n){return this.applyStylesToKeyframe(),new $x(this._driver,t,n||this.currentTime,this._elementTimelineStylesLookup)}_loadKeyframe(){this._currentKeyframe&&(this._previousKeyframe=this._currentKeyframe),this._currentKeyframe=this._keyframes.get(this.duration),this._currentKeyframe||(this._currentKeyframe=Object.create(this._backFill,{}),this._keyframes.set(this.duration,this._currentKeyframe))}forwardFrame(){this.duration+=1,this._loadKeyframe()}forwardTime(t){this.applyStylesToKeyframe(),this.duration=t,this._loadKeyframe()}_updateStyle(t,n){this._localTimelineStyles[t]=n,this._globalTimelineStyles[t]=n,this._styleSummary[t]={time:this.currentTime,value:n}}allowOnlyTimelineStyles(){return this._currentEmptyStepKeyframe!==this._currentKeyframe}applyEmptyStep(t){t&&(this._previousKeyframe.easing=t),Object.keys(this._globalTimelineStyles).forEach((t=>{this._backFill[t]=this._globalTimelineStyles[t]||wP,this._currentKeyframe[t]=wP})),this._currentEmptyStepKeyframe=this._currentKeyframe}setStyles(t,n,e,a){n&&(this._previousKeyframe.easing=n);const o=a&&a.params||{},r=(function i(t,n){const e={};let a;return t.forEach((t=>{"*"===t?(a=a||Object.keys(n),a.forEach((t=>{e[t]=wP}))):hx(t,!1,e)})),e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t,this._globalTimelineStyles);Object.keys(r).forEach((t=>{const n=kx(r[t],o,e);this._pendingStyles[t]=n,this._localTimelineStyles.hasOwnProperty(t)||(this._backFill[t]=this._globalTimelineStyles.hasOwnProperty(t)?this._globalTimelineStyles[t]:wP),this._updateStyle(t,n)}))}applyStylesToKeyframe(){const t=this._pendingStyles,n=Object.keys(t);0!=n.length&&(this._pendingStyles={},n.forEach((n=>{this._currentKeyframe[n]=t[n]})),Object.keys(this._localTimelineStyles).forEach((t=>{this._currentKeyframe.hasOwnProperty(t)||(this._currentKeyframe[t]=this._localTimelineStyles[t])})))}snapshotCurrentStyles(){Object.keys(this._localTimelineStyles).forEach((t=>{const n=this._localTimelineStyles[t];this._pendingStyles[t]=n,this._updateStyle(t,n)}))}getFinalKeyframe(){return this._keyframes.get(this.duration)}get properties(){const t=[];for(let n in this._currentKeyframe)t.push(n);return t}mergeTimelineCollectedStyles(t){Object.keys(t._styleSummary).forEach((n=>{const e=this._styleSummary[n],a=t._styleSummary[n];(!e||a.time>e.time)&&this._updateStyle(n,a.value)}))}buildKeyframes(){this.applyStylesToKeyframe();const t=new Set,n=new Set,e=1===this._keyframes.size&&0===this.duration;let a=[];this._keyframes.forEach(((o,r)=>{const i=hx(o,!0);Object.keys(i).forEach((e=>{const a=i[e];"!"==a?t.add(e):a==wP&&n.add(e)})),e||(i.offset=r/this.duration),a.push(i)}));const o=t.size?vx(t.values()):[],r=n.size?vx(n.values()):[];if(e){const t=a[0],n=fx(t);t.offset=0,n.offset=1,a=[t,n]}return Gx(this.element,a,o,r,this.duration,this.startTime,this.easing,!1)}}class ty extends $x{constructor(t,n,e,a,o,r,i=!1){super(t,n,r.delay),this.element=n,this.keyframes=e,this.preStyleProps=a,this.postStyleProps=o,this._stretchStartingKeyframe=i,this.timings={duration:r.duration,delay:r.delay,easing:r.easing}}containsAnimation(){return this.keyframes.length>1}buildKeyframes(){let t=this.keyframes,{delay:n,duration:e,easing:a}=this.timings;if(this._stretchStartingKeyframe&&n){const o=[],r=e+n,i=n/r,c=hx(t[0],!1);c.offset=0,o.push(c);const s=hx(t[0],!1);s.offset=ny(i),o.push(s);const l=t.length-1;for(let a=1;a<=l;a++){let i=hx(t[a],!1);i.offset=ny((n+i.offset*e)/r),o.push(i)}e=r,n=0,a="",t=o}return Gx(this.element,t,this.preStyleProps,this.postStyleProps,e,n,a,!0)}}function ny(t,n=3){const e=Math.pow(10,n-1);return Math.round(t*e)/e}class ey{}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class ay extends ey{normalizePropertyName(t,n){return Sx(t)}normalizeStyleValue(t,n,e,a){let o="";const r=e.toString().trim();if(oy[n]&&0!==e&&"0"!==e)if("number"==typeof e)o="px";else{const n=e.match(/^[+-]?[\d\.]+([a-z]*)$/);n&&0==n[1].length&&a.push(`Please provide a CSS unit value for ${t}:${e}`)}return r+o}}const oy=(function ry(t){const n={};return t.forEach((t=>n[t]=!0)),n})("width,height,minWidth,minHeight,maxWidth,maxHeight,left,top,bottom,right,fontSize,outlineWidth,outlineOffset,paddingTop,paddingLeft,paddingBottom,paddingRight,marginTop,marginLeft,marginBottom,marginRight,borderRadius,borderWidth,borderTopWidth,borderLeftWidth,borderRightWidth,borderBottomWidth,textIndent,perspective".split(","));function iy(t,n,e,a,o,r,i,c,s,l,m,d,g){return{type:0,element:t,triggerName:n,isRemovalTransition:o,fromState:e,fromStyles:r,toState:a,toStyles:i,timelines:c,queriedElements:s,preStyleProps:l,postStyleProps:m,totalTime:d,errors:g}}const cy={};class sy{constructor(t,n,e){this._triggerName=t,this.ast=n,this._stateStyles=e}match(t,n,e,a){return(function o(t,n,e,a,r){return t.some((t=>t(n,e,a,r)))})(this.ast.matchers,t,n,e,a)}buildStyles(t,n,e){const a=this._stateStyles["*"],o=this._stateStyles[t],r=a?a.buildStyles(n,e):{};return o?o.buildStyles(n,e):r}build(t,n,e,a,o,r,i,c,s,l){const m=[],d=this.ast.options&&this.ast.options.params||cy,g=this.buildStyles(e,i&&i.params||cy,m),p=c&&c.params||cy,b=this.buildStyles(a,p,m),u=new Set,f=new Map,h=new Map,_="void"===a,C={params:Object.assign(Object.assign({},d),p)},M=l?[]:Xx(t,n,this.ast.animation,o,r,g,b,C,s,m);let O=0;if(M.forEach((t=>{O=Math.max(t.duration+t.delay,O)})),m.length)return iy(n,this._triggerName,e,a,_,g,b,[],[],f,h,O,m);M.forEach((t=>{const e=t.element,a=YP(f,e,{});t.preStyleProps.forEach((t=>a[t]=!0));const o=YP(h,e,{});t.postStyleProps.forEach((t=>o[t]=!0)),e!==n&&u.add(e)}));const P=vx(u.values());return iy(n,this._triggerName,e,a,_,g,b,M,P,f,h,O)}}class ly{constructor(t,n){this.styles=t,this.defaultParams=n}buildStyles(t,n){const e={},a=fx(this.defaultParams);return Object.keys(t).forEach((n=>{const e=t[n];null!=e&&(a[n]=e)})),this.styles.styles.forEach((t=>{if("string"!=typeof t){const o=t;Object.keys(o).forEach((t=>{let r=o[t];r.length>1&&(r=kx(r,a,n)),e[t]=r}))}})),e}}class my{constructor(t,n){this.name=t,this.ast=n,this.transitionFactories=[],this.states={},n.states.forEach((t=>{this.states[t.name]=new ly(t.style,t.options&&t.options.params||{})})),dy(this.states,"true","1"),dy(this.states,"false","0"),n.transitions.forEach((n=>{this.transitionFactories.push(new sy(t,n,this.states))})),this.fallbackTransition=(function e(t,n){return new sy(t,{type:1,animation:{type:2,steps:[],options:null},matchers:[(t,n)=>!0],options:null,queryCount:0,depCount:0},n)})(t,this.states)}get containsQueries(){return this.ast.queryCount>0}matchTransition(t,n,e,a){return this.transitionFactories.find((o=>o.match(t,n,e,a)))||null}matchStyles(t,n,e){return this.fallbackTransition.buildStyles(t,n,e)}}function dy(t,n,e){t.hasOwnProperty(n)?t.hasOwnProperty(e)||(t[e]=t[n]):t.hasOwnProperty(e)&&(t[n]=t[e])}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const gy=new Yx;class py{constructor(t,n,e){this.bodyNode=t,this._driver=n,this._normalizer=e,this._animations={},this._playersById={},this.players=[]}register(t,n){const e=[],a=Hx(this._driver,n,e);if(e.length)throw new Error(`Unable to build the animation due to the following errors: ${e.join("\n")}`);this._animations[t]=a}_buildPlayer(t,n,e){const a=t.element,o=jP(0,this._normalizer,0,t.keyframes,n,e);return this._driver.animate(a,o,t.duration,t.delay,t.easing,[],!0)}create(t,n,e={}){const a=[],o=this._animations[t];let r;const i=new Map;if(o?(r=Xx(this._driver,n,o,cx,sx,{},{},e,gy,a),r.forEach((t=>{const n=YP(i,t.element,{});t.postStyleProps.forEach((t=>n[t]=null))}))):(a.push("The requested animation doesn't exist or has already been destroyed"),r=[]),a.length)throw new Error(`Unable to create the animation due to the following errors: ${a.join("\n")}`);i.forEach(((t,n)=>{Object.keys(t).forEach((e=>{t[e]=this._driver.computeStyle(n,e,wP)}))}));const c=VP(r.map((t=>{const n=i.get(t.element);return this._buildPlayer(t,{},n)})));return this._playersById[t]=c,c.onDestroy((()=>this.destroy(t))),this.players.push(c),c}destroy(t){const n=this._getPlayer(t);n.destroy(),delete this._playersById[t];const e=this.players.indexOf(n);e>=0&&this.players.splice(e,1)}_getPlayer(t){const n=this._playersById[t];if(!n)throw new Error(`Unable to find the timeline player referenced by ${t}`);return n}listen(t,n,e,a){const o=GP(n,"","","");return UP(this._getPlayer(t),e,o,a),()=>{}}command(t,n,e,a){if("register"==e)return void this.register(t,a[0]);if("create"==e)return void this.create(t,n,a[0]||{});const o=this._getPlayer(t);switch(e){case"play":o.play();break;case"pause":o.pause();break;case"reset":o.reset();break;case"restart":o.restart();break;case"finish":o.finish();break;case"init":o.init();break;case"setPosition":o.setPosition(parseFloat(a[0]));break;case"destroy":this.destroy(t)}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const by="ng-animate-queued",uy="ng-animate-disabled",fy=".ng-animate-disabled",hy=[],_y={namespaceId:"",setForRemoval:!1,setForMove:!1,hasAnimation:!1,removedBeforeQueried:!1},Cy={namespaceId:"",setForMove:!1,setForRemoval:!1,hasAnimation:!1,removedBeforeQueried:!0};class My{constructor(t,n=""){this.namespaceId=n;const e=t&&t.hasOwnProperty("value");if(this.value=(function a(t){return null!=t?t:null})(e?t.value:t),e){const n=fx(t);delete n.value,this.options=n}else this.options={};this.options.params||(this.options.params={})}get params(){return this.options.params}absorbOptions(t){const n=t.params;if(n){const t=this.options.params;Object.keys(n).forEach((e=>{null==t[e]&&(t[e]=n[e])}))}}}const Oy="void",Py=new My(Oy);class xy{constructor(t,n,e){this.id=t,this.hostElement=n,this._engine=e,this.players=[],this._triggers={},this._queue=[],this._elementListeners=new Map,this._hostClassName="ng-tns-"+t,Ay(n,this._hostClassName)}listen(t,n,e,a){if(!this._triggers.hasOwnProperty(n))throw new Error(`Unable to listen on the animation trigger event "${e}" because the animation trigger "${n}" doesn't exist!`);if(null==e||0==e.length)throw new Error(`Unable to listen on the animation trigger "${n}" because the provided event is undefined!`);if(!(function o(t){return"start"==t||"done"==t})(e))throw new Error(`The provided animation trigger event "${e}" for the animation trigger "${n}" is not supported!`);const r=YP(this._elementListeners,t,[]),i={name:n,phase:e,callback:a};r.push(i);const c=YP(this._engine.statesByElement,t,{});return c.hasOwnProperty(n)||(Ay(t,lx),Ay(t,"ng-trigger-"+n),c[n]=Py),()=>{this._engine.afterFlush((()=>{const t=r.indexOf(i);t>=0&&r.splice(t,1),this._triggers[n]||delete c[n]}))}}register(t,n){return!this._triggers[t]&&(this._triggers[t]=n,!0)}_getTrigger(t){const n=this._triggers[t];if(!n)throw new Error(`The provided animation trigger "${t}" has not been registered!`);return n}trigger(t,n,e,a=!0){const o=this._getTrigger(n),r=new ky(this.id,n,t);let i=this._engine.statesByElement.get(t);i||(Ay(t,lx),Ay(t,"ng-trigger-"+n),this._engine.statesByElement.set(t,i={}));let c=i[n];const s=new My(e,this.id);if(!(e&&e.hasOwnProperty("value"))&&c&&s.absorbOptions(c.options),i[n]=s,c||(c=Py),s.value!==Oy&&c.value===s.value){if(!(function l(t,n){const e=Object.keys(t),a=Object.keys(n);if(e.length!=a.length)return!1;for(let a=0;a<e.length;a++){const o=e[a];if(!n.hasOwnProperty(o)||t[o]!==n[o])return!1}return!0})(c.params,s.params)){const n=[],e=o.matchStyles(c.value,c.params,n),a=o.matchStyles(s.value,s.params,n);n.length?this._engine.reportError(n):this._engine.afterFlush((()=>{Ox(t,e),Mx(t,a)}))}return}const m=YP(this._engine.playersByElement,t,[]);m.forEach((t=>{t.namespaceId==this.id&&t.triggerName==n&&t.queued&&t.destroy()}));let d=o.matchTransition(c.value,s.value,t,s.params),g=!1;if(!d){if(!a)return;d=o.fallbackTransition,g=!0}return this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:n,transition:d,fromState:c,toState:s,player:r,isFallbackTransition:g}),g||(Ay(t,by),r.onStart((()=>{zy(t,by)}))),r.onDone((()=>{let n=this.players.indexOf(r);n>=0&&this.players.splice(n,1);const e=this._engine.playersByElement.get(t);if(e){let t=e.indexOf(r);t>=0&&e.splice(t,1)}})),this.players.push(r),m.push(r),r}deregister(t){delete this._triggers[t],this._engine.statesByElement.forEach(((n,e)=>{delete n[t]})),this._elementListeners.forEach(((n,e)=>{this._elementListeners.set(e,n.filter((n=>n.name!=t)))}))}clearElementCache(t){this._engine.statesByElement.delete(t),this._elementListeners.delete(t);const n=this._engine.playersByElement.get(t);n&&(n.forEach((t=>t.destroy())),this._engine.playersByElement.delete(t))}_signalRemovalForInnerTriggers(t,n){const e=this._engine.driver.query(t,mx,!0);e.forEach((t=>{if(t.__ng_removed)return;const e=this._engine.fetchNamespacesByElement(t);e.size?e.forEach((e=>e.triggerLeaveAnimation(t,n,!1,!0))):this.clearElementCache(t)})),this._engine.afterFlushAnimationsDone((()=>e.forEach((t=>this.clearElementCache(t)))))}triggerLeaveAnimation(t,n,e,a){const o=this._engine.statesByElement.get(t);if(o){const r=[];if(Object.keys(o).forEach((n=>{if(this._triggers[n]){const e=this.trigger(t,n,Oy,a);e&&r.push(e)}})),r.length)return this._engine.markElementAsRemoved(this.id,t,!0,n),e&&VP(r).onDone((()=>this._engine.processLeaveNode(t))),!0}return!1}prepareLeaveAnimationListeners(t){const n=this._elementListeners.get(t);if(n){const e=new Set;n.forEach((n=>{const a=n.name;if(e.has(a))return;e.add(a);const o=this._triggers[a].fallbackTransition,r=this._engine.statesByElement.get(t)[a]||Py,i=new My(Oy),c=new ky(this.id,a,t);this._engine.totalQueuedPlayers++,this._queue.push({element:t,triggerName:a,transition:o,fromState:r,toState:i,player:c,isFallbackTransition:!0})}))}}removeNode(t,n){const e=this._engine;if(t.childElementCount&&this._signalRemovalForInnerTriggers(t,n),this.triggerLeaveAnimation(t,n,!0))return;let a=!1;if(e.totalAnimations){const n=e.players.length?e.playersByQueriedElement.get(t):[];if(n&&n.length)a=!0;else{let n=t;for(;n=n.parentNode;)if(e.statesByElement.get(n)){a=!0;break}}}if(this.prepareLeaveAnimationListeners(t),a)e.markElementAsRemoved(this.id,t,!1,n);else{const a=t.__ng_removed;a&&a!==_y||(e.afterFlush((()=>this.clearElementCache(t))),e.destroyInnerAnimations(t),e._onRemovalComplete(t,n))}}insertNode(t,n){Ay(t,this._hostClassName)}drainQueuedTransitions(t){const n=[];return this._queue.forEach((e=>{const a=e.player;if(a.destroyed)return;const o=e.element,r=this._elementListeners.get(o);r&&r.forEach((n=>{if(n.name==e.triggerName){const a=GP(o,e.triggerName,e.fromState.value,e.toState.value);a._data=t,UP(e.player,n.phase,a,n.callback)}})),a.markedForDestroy?this._engine.afterFlush((()=>{a.destroy()})):n.push(e)})),this._queue=[],n.sort(((t,n)=>{const e=t.transition.ast.depCount,a=n.transition.ast.depCount;return 0==e||0==a?e-a:this._engine.driver.containsElement(t.element,n.element)?1:-1}))}destroy(t){this.players.forEach((t=>t.destroy())),this._signalRemovalForInnerTriggers(this.hostElement,t)}elementContainsData(t){let n=!1;return this._elementListeners.has(t)&&(n=!0),n=!!this._queue.find((n=>n.element===t))||n,n}}class yy{constructor(t,n,e){this.bodyNode=t,this.driver=n,this._normalizer=e,this.players=[],this.newHostElements=new Map,this.playersByElement=new Map,this.playersByQueriedElement=new Map,this.statesByElement=new Map,this.disabledNodes=new Set,this.totalAnimations=0,this.totalQueuedPlayers=0,this._namespaceLookup={},this._namespaceList=[],this._flushFns=[],this._whenQuietFns=[],this.namespacesByHostElement=new Map,this.collectedEnterElements=[],this.collectedLeaveElements=[],this.onRemovalComplete=(t,n)=>{}}_onRemovalComplete(t,n){this.onRemovalComplete(t,n)}get queuedPlayers(){const t=[];return this._namespaceList.forEach((n=>{n.players.forEach((n=>{n.queued&&t.push(n)}))})),t}createNamespace(t,n){const e=new xy(t,n,this);return n.parentNode?this._balanceNamespaceList(e,n):(this.newHostElements.set(n,e),this.collectEnterElement(n)),this._namespaceLookup[t]=e}_balanceNamespaceList(t,n){const e=this._namespaceList.length-1;if(e>=0){let a=!1;for(let o=e;o>=0;o--)if(this.driver.containsElement(this._namespaceList[o].hostElement,n)){this._namespaceList.splice(o+1,0,t),a=!0;break}a||this._namespaceList.splice(0,0,t)}else this._namespaceList.push(t);return this.namespacesByHostElement.set(n,t),t}register(t,n){let e=this._namespaceLookup[t];return e||(e=this.createNamespace(t,n)),e}registerTrigger(t,n,e){let a=this._namespaceLookup[t];a&&a.register(n,e)&&this.totalAnimations++}destroy(t,n){if(!t)return;const e=this._fetchNamespace(t);this.afterFlush((()=>{this.namespacesByHostElement.delete(e.hostElement),delete this._namespaceLookup[t];const n=this._namespaceList.indexOf(e);n>=0&&this._namespaceList.splice(n,1)})),this.afterFlushAnimationsDone((()=>e.destroy(n)))}_fetchNamespace(t){return this._namespaceLookup[t]}fetchNamespacesByElement(t){const n=new Set,e=this.statesByElement.get(t);if(e){const t=Object.keys(e);for(let a=0;a<t.length;a++){const o=e[t[a]].namespaceId;if(o){const t=this._fetchNamespace(o);t&&n.add(t)}}}return n}trigger(t,n,e,a){if(vy(n)){const o=this._fetchNamespace(t);if(o)return o.trigger(n,e,a),!0}return!1}insertNode(t,n,e,a){if(!vy(n))return;const o=n.__ng_removed;if(o&&o.setForRemoval){o.setForRemoval=!1,o.setForMove=!0;const t=this.collectedLeaveElements.indexOf(n);t>=0&&this.collectedLeaveElements.splice(t,1)}if(t){const a=this._fetchNamespace(t);a&&a.insertNode(n,e)}a&&this.collectEnterElement(n)}collectEnterElement(t){this.collectedEnterElements.push(t)}markElementAsDisabled(t,n){n?this.disabledNodes.has(t)||(this.disabledNodes.add(t),Ay(t,uy)):this.disabledNodes.has(t)&&(this.disabledNodes.delete(t),zy(t,uy))}removeNode(t,n,e,a){if(vy(n)){const o=t?this._fetchNamespace(t):null;if(o?o.removeNode(n,a):this.markElementAsRemoved(t,n,!1,a),e){const e=this.namespacesByHostElement.get(n);e&&e.id!==t&&e.removeNode(n,a)}}else this._onRemovalComplete(n,a)}markElementAsRemoved(t,n,e,a){this.collectedLeaveElements.push(n),n.__ng_removed={namespaceId:t,setForRemoval:a,hasAnimation:e,removedBeforeQueried:!1}}listen(t,n,e,a,o){return vy(n)?this._fetchNamespace(t).listen(n,e,a,o):()=>{}}_buildInstruction(t,n,e,a,o){return t.transition.build(this.driver,t.element,t.fromState.value,t.toState.value,e,a,t.fromState.options,t.toState.options,n,o)}destroyInnerAnimations(t){let n=this.driver.query(t,mx,!0);n.forEach((t=>this.destroyActiveAnimationsForElement(t))),0!=this.playersByQueriedElement.size&&(n=this.driver.query(t,gx,!0),n.forEach((t=>this.finishActiveQueriedAnimationOnElement(t))))}destroyActiveAnimationsForElement(t){const n=this.playersByElement.get(t);n&&n.forEach((t=>{t.queued?t.markedForDestroy=!0:t.destroy()}))}finishActiveQueriedAnimationOnElement(t){const n=this.playersByQueriedElement.get(t);n&&n.forEach((t=>t.finish()))}whenRenderingDone(){return new Promise((t=>{if(this.players.length)return VP(this.players).onDone((()=>t()));t()}))}processLeaveNode(t){const n=t.__ng_removed;if(n&&n.setForRemoval){if(t.__ng_removed=_y,n.namespaceId){this.destroyInnerAnimations(t);const e=this._fetchNamespace(n.namespaceId);e&&e.clearElementCache(t)}this._onRemovalComplete(t,n.setForRemoval)}this.driver.matchesElement(t,fy)&&this.markElementAsDisabled(t,!1),this.driver.query(t,fy,!0).forEach((t=>{this.markElementAsDisabled(t,!1)}))}flush(t=-1){let n=[];if(this.newHostElements.size&&(this.newHostElements.forEach(((t,n)=>this._balanceNamespaceList(t,n))),this.newHostElements.clear()),this.totalAnimations&&this.collectedEnterElements.length)for(let t=0;t<this.collectedEnterElements.length;t++)Ay(this.collectedEnterElements[t],"ng-star-inserted");if(this._namespaceList.length&&(this.totalQueuedPlayers||this.collectedLeaveElements.length)){const e=[];try{n=this._flushAnimations(e,t)}finally{for(let t=0;t<e.length;t++)e[t]()}}else for(let t=0;t<this.collectedLeaveElements.length;t++)this.processLeaveNode(this.collectedLeaveElements[t]);if(this.totalQueuedPlayers=0,this.collectedEnterElements.length=0,this.collectedLeaveElements.length=0,this._flushFns.forEach((t=>t())),this._flushFns=[],this._whenQuietFns.length){const t=this._whenQuietFns;this._whenQuietFns=[],n.length?VP(n).onDone((()=>{t.forEach((t=>t()))})):t.forEach((t=>t()))}}reportError(t){throw new Error(`Unable to process animations due to the following failed trigger transitions\n ${t.join("\n")}`)}_flushAnimations(t,n){const e=new Yx,a=[],o=new Map,r=[],i=new Map,c=new Map,s=new Map,l=new Set;this.disabledNodes.forEach((t=>{l.add(t);const n=this.driver.query(t,".ng-animate-queued",!0);for(let t=0;t<n.length;t++)l.add(n[t])}));const m=this.bodyNode,d=Array.from(this.statesByElement.keys()),g=Ey(d,this.collectedEnterElements),p=new Map;let b=0;g.forEach(((t,n)=>{const e=cx+b++;p.set(n,e),t.forEach((t=>Ay(t,e)))}));const u=[],f=new Set,h=new Set;for(let t=0;t<this.collectedLeaveElements.length;t++){const n=this.collectedLeaveElements[t],e=n.__ng_removed;e&&e.setForRemoval&&(u.push(n),f.add(n),e.hasAnimation?this.driver.query(n,".ng-star-inserted",!0).forEach((t=>f.add(t))):h.add(n))}const _=new Map,C=Ey(d,Array.from(f));C.forEach(((t,n)=>{const e=sx+b++;_.set(n,e),t.forEach((t=>Ay(t,e)))})),t.push((()=>{g.forEach(((t,n)=>{const e=p.get(n);t.forEach((t=>zy(t,e)))})),C.forEach(((t,n)=>{const e=_.get(n);t.forEach((t=>zy(t,e)))})),u.forEach((t=>{this.processLeaveNode(t)}))}));const M=[],O=[];for(let t=this._namespaceList.length-1;t>=0;t--)this._namespaceList[t].drainQueuedTransitions(n).forEach((t=>{const n=t.player,o=t.element;if(M.push(n),this.collectedEnterElements.length){const t=o.__ng_removed;if(t&&t.setForMove)return void n.destroy()}const l=!m||!this.driver.containsElement(m,o),d=_.get(o),g=p.get(o),b=this._buildInstruction(t,e,g,d,l);if(b.errors&&b.errors.length)O.push(b);else{if(l)return n.onStart((()=>Ox(o,b.fromStyles))),n.onDestroy((()=>Mx(o,b.toStyles))),void a.push(n);if(t.isFallbackTransition)return n.onStart((()=>Ox(o,b.fromStyles))),n.onDestroy((()=>Mx(o,b.toStyles))),void a.push(n);b.timelines.forEach((t=>t.stretchStartingKeyframe=!0)),e.append(o,b.timelines),r.push({instruction:b,player:n,element:o}),b.queriedElements.forEach((t=>YP(i,t,[]).push(n))),b.preStyleProps.forEach(((t,n)=>{const e=Object.keys(t);if(e.length){let t=c.get(n);t||c.set(n,t=new Set),e.forEach((n=>t.add(n)))}})),b.postStyleProps.forEach(((t,n)=>{const e=Object.keys(t);let a=s.get(n);a||s.set(n,a=new Set),e.forEach((t=>a.add(t)))}))}}));if(O.length){const t=[];O.forEach((n=>{t.push(`@${n.triggerName} has failed due to:\n`),n.errors.forEach((n=>t.push(`- ${n}\n`)))})),M.forEach((t=>t.destroy())),this.reportError(t)}const P=new Map,x=new Map;r.forEach((t=>{const n=t.element;e.has(n)&&(x.set(n,n),this._beforeAnimationBuild(t.player.namespaceId,t.instruction,P))})),a.forEach((t=>{const n=t.element;this._getPreviousPlayers(n,!1,t.namespaceId,t.triggerName,null).forEach((t=>{YP(P,n,[]).push(t),t.destroy()}))}));const y=u.filter((t=>Dy(t,c,s))),k=new Map;Sy(k,this.driver,h,s,wP).forEach((t=>{Dy(t,c,s)&&y.push(t)}));const v=new Map;g.forEach(((t,n)=>{Sy(v,this.driver,new Set(t),c,"!")})),y.forEach((t=>{const n=k.get(t),e=v.get(t);k.set(t,Object.assign(Object.assign({},n),e))}));const w=[],S=[],E={};r.forEach((t=>{const{element:n,player:r,instruction:i}=t;if(e.has(n)){if(l.has(n))return r.onDestroy((()=>Mx(n,i.toStyles))),r.disabled=!0,r.overrideTotalTime(i.totalTime),void a.push(r);let t=E;if(x.size>1){let e=n;const a=[];for(;e=e.parentNode;){const n=x.get(e);if(n){t=n;break}a.push(e)}a.forEach((n=>x.set(n,t)))}const e=this._buildAnimation(r.namespaceId,i,P,o,v,k);if(r.setRealPlayer(e),t===E)w.push(r);else{const n=this.playersByElement.get(t);n&&n.length&&(r.parentPlayer=VP(n)),a.push(r)}}else Ox(n,i.fromStyles),r.onDestroy((()=>Mx(n,i.toStyles))),S.push(r),l.has(n)&&a.push(r)})),S.forEach((t=>{const n=o.get(t.element);if(n&&n.length){const e=VP(n);t.setRealPlayer(e)}})),a.forEach((t=>{t.parentPlayer?t.syncPlayerEvents(t.parentPlayer):t.destroy()}));for(let t=0;t<u.length;t++){const n=u[t],e=n.__ng_removed;if(zy(n,sx),e&&e.hasAnimation)continue;let a=[];if(i.size){let t=i.get(n);t&&t.length&&a.push(...t);let e=this.driver.query(n,gx,!0);for(let t=0;t<e.length;t++){let n=i.get(e[t]);n&&n.length&&a.push(...n)}}const o=a.filter((t=>!t.destroyed));o.length?Ry(this,n,o):this.processLeaveNode(n)}return u.length=0,w.forEach((t=>{this.players.push(t),t.onDone((()=>{t.destroy();const n=this.players.indexOf(t);this.players.splice(n,1)})),t.play()})),w}elementContainsData(t,n){let e=!1;const a=n.__ng_removed;return a&&a.setForRemoval&&(e=!0),this.playersByElement.has(n)&&(e=!0),this.playersByQueriedElement.has(n)&&(e=!0),this.statesByElement.has(n)&&(e=!0),this._fetchNamespace(t).elementContainsData(n)||e}afterFlush(t){this._flushFns.push(t)}afterFlushAnimationsDone(t){this._whenQuietFns.push(t)}_getPreviousPlayers(t,n,e,a,o){let r=[];if(n){const n=this.playersByQueriedElement.get(t);n&&(r=n)}else{const n=this.playersByElement.get(t);if(n){const t=!o||o==Oy;n.forEach((n=>{n.queued||(t||n.triggerName==a)&&r.push(n)}))}}return(e||a)&&(r=r.filter((t=>!(e&&e!=t.namespaceId||a&&a!=t.triggerName)))),r}_beforeAnimationBuild(t,n,e){const a=n.element,o=n.isRemovalTransition?void 0:t,r=n.isRemovalTransition?void 0:n.triggerName;for(const t of n.timelines){const i=t.element,c=i!==a,s=YP(e,i,[]);this._getPreviousPlayers(i,c,o,r,n.toState).forEach((t=>{const n=t.getRealPlayer();n.beforeDestroy&&n.beforeDestroy(),t.destroy(),s.push(t)}))}Ox(a,n.fromStyles)}_buildAnimation(t,n,e,a,o,r){const i=n.triggerName,c=n.element,s=[],l=new Set,m=new Set,d=n.timelines.map((n=>{const d=n.element;l.add(d);const g=d.__ng_removed;if(g&&g.removedBeforeQueried)return new LP(n.duration,n.delay);const p=d!==c,b=(function u(t){const n=[];return Ty(t,n),n})((e.get(d)||hy).map((t=>t.getRealPlayer()))).filter((t=>!!t.element&&t.element===d)),f=o.get(d),h=r.get(d),_=jP(0,this._normalizer,0,n.keyframes,f,h),C=this._buildPlayer(n,_,b);if(n.subTimeline&&a&&m.add(d),p){const n=new ky(t,i,d);n.setRealPlayer(C),s.push(n)}return C}));s.forEach((t=>{YP(this.playersByQueriedElement,t.element,[]).push(t),t.onDone((()=>(function n(t,e,a){let o;if(t instanceof Map){if(o=t.get(e),o){if(o.length){const t=o.indexOf(a);o.splice(t,1)}0==o.length&&t.delete(e)}}else if(o=t[e],o){if(o.length){const t=o.indexOf(a);o.splice(t,1)}0==o.length&&delete t[e]}return o})(this.playersByQueriedElement,t.element,t)))})),l.forEach((t=>Ay(t,dx)));const g=VP(d);return g.onDestroy((()=>{l.forEach((t=>zy(t,dx))),Mx(c,n.toStyles)})),m.forEach((t=>{YP(a,t,[]).push(g)})),g}_buildPlayer(t,n,e){return n.length>0?this.driver.animate(t.element,n,t.duration,t.delay,t.easing,e):new LP(t.duration,t.delay)}}class ky{constructor(t,n,e){this.namespaceId=t,this.triggerName=n,this.element=e,this._player=new LP,this._containsRealPlayer=!1,this._queuedCallbacks={},this.destroyed=!1,this.markedForDestroy=!1,this.disabled=!1,this.queued=!0,this.totalTime=0}setRealPlayer(t){this._containsRealPlayer||(this._player=t,Object.keys(this._queuedCallbacks).forEach((n=>{this._queuedCallbacks[n].forEach((e=>UP(t,n,void 0,e)))})),this._queuedCallbacks={},this._containsRealPlayer=!0,this.overrideTotalTime(t.totalTime),this.queued=!1)}getRealPlayer(){return this._player}overrideTotalTime(t){this.totalTime=t}syncPlayerEvents(t){const n=this._player;n.triggerCallback&&t.onStart((()=>n.triggerCallback("start"))),t.onDone((()=>this.finish())),t.onDestroy((()=>this.destroy()))}_queueEvent(t,n){YP(this._queuedCallbacks,t,[]).push(n)}onDone(t){this.queued&&this._queueEvent("done",t),this._player.onDone(t)}onStart(t){this.queued&&this._queueEvent("start",t),this._player.onStart(t)}onDestroy(t){this.queued&&this._queueEvent("destroy",t),this._player.onDestroy(t)}init(){this._player.init()}hasStarted(){return!this.queued&&this._player.hasStarted()}play(){!this.queued&&this._player.play()}pause(){!this.queued&&this._player.pause()}restart(){!this.queued&&this._player.restart()}finish(){this._player.finish()}destroy(){this.destroyed=!0,this._player.destroy()}reset(){!this.queued&&this._player.reset()}setPosition(t){this.queued||this._player.setPosition(t)}getPosition(){return this.queued?0:this._player.getPosition()}triggerCallback(t){const n=this._player;n.triggerCallback&&n.triggerCallback(t)}}function vy(t){return t&&1===t.nodeType}function wy(t,n){const e=t.style.display;return t.style.display=null!=n?n:"none",e}function Sy(t,n,e,a,o){const r=[];e.forEach((t=>r.push(wy(t))));const i=[];a.forEach(((e,a)=>{const r={};e.forEach((t=>{const e=r[t]=n.computeStyle(a,t,o);e&&0!=e.length||(a.__ng_removed=Cy,i.push(a))})),t.set(a,r)}));let c=0;return e.forEach((t=>wy(t,r[c++]))),i}function Ey(t,n){const e=new Map;if(t.forEach((t=>e.set(t,[]))),0==n.length)return e;const a=new Set(n),o=new Map;function r(t){if(!t)return 1;let n=o.get(t);if(n)return n;const i=t.parentNode;return n=e.has(i)?i:a.has(i)?1:r(i),o.set(t,n),n}return n.forEach((t=>{const n=r(t);1!==n&&e.get(n).push(t)})),e}function Ay(t,n){if(t.classList)t.classList.add(n);else{let e=t.$$classes;e||(e=t.$$classes={}),e[n]=!0}}function zy(t,n){if(t.classList)t.classList.remove(n);else{let e=t.$$classes;e&&delete e[n]}}function Ry(t,n,e){VP(e).onDone((()=>t.processLeaveNode(n)))}function Ty(t,n){for(let e=0;e<t.length;e++){const a=t[e];a instanceof HP?Ty(a.players,n):n.push(a)}}function Dy(t,n,e){const a=e.get(t);if(!a)return!1;let o=n.get(t);return o?a.forEach((t=>o.add(t))):n.set(t,a),e.delete(t),!0}class Iy{constructor(t,n,e){this.bodyNode=t,this._driver=n,this._triggerCache={},this.onRemovalComplete=(t,n)=>{},this._transitionEngine=new yy(t,n,e),this._timelineEngine=new py(t,n,e),this._transitionEngine.onRemovalComplete=(t,n)=>this.onRemovalComplete(t,n)}registerTrigger(t,n,e,a,o){const r=t+"-"+a;let i=this._triggerCache[r];if(!i){const t=[],n=Hx(this._driver,o,t);if(t.length)throw new Error(`The animation trigger "${a}" has failed to build due to the following errors:\n - ${t.join("\n - ")}`);i=(function c(t,n){return new my(t,n)})(a,n),this._triggerCache[r]=i}this._transitionEngine.registerTrigger(n,a,i)}register(t,n){this._transitionEngine.register(t,n)}destroy(t,n){this._transitionEngine.destroy(t,n)}onInsert(t,n,e,a){this._transitionEngine.insertNode(t,n,e,a)}onRemove(t,n,e,a){this._transitionEngine.removeNode(t,n,a||!1,e)}disableAnimations(t,n){this._transitionEngine.markElementAsDisabled(t,n)}process(t,n,e,a){if("@"==e.charAt(0)){const[t,o]=qP(e);this._timelineEngine.command(t,n,o,a)}else this._transitionEngine.trigger(t,n,e,a)}listen(t,n,e,a,o){if("@"==e.charAt(0)){const[t,a]=qP(e);return this._timelineEngine.listen(t,n,a,o)}return this._transitionEngine.listen(t,n,e,a,o)}flush(t=-1){this._transitionEngine.flush(t)}get players(){return this._transitionEngine.players.concat(this._timelineEngine.players)}whenRenderingDone(){return this._transitionEngine.whenRenderingDone()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Ny(t,n){let e=null,a=null;return Array.isArray(n)&&n.length?(e=Ly(n[0]),n.length>1&&(a=Ly(n[n.length-1]))):n&&(e=Ly(n)),e||a?new Fy(t,e,a):null}class Fy{constructor(t,n,e){this._element=t,this._startStyles=n,this._endStyles=e,this._state=0;let a=Fy.initialStylesByElement.get(t);a||Fy.initialStylesByElement.set(t,a={}),this._initialStyles=a}start(){this._state<1&&(this._startStyles&&Mx(this._element,this._startStyles,this._initialStyles),this._state=1)}finish(){this.start(),this._state<2&&(Mx(this._element,this._initialStyles),this._endStyles&&(Mx(this._element,this._endStyles),this._endStyles=null),this._state=1)}destroy(){this.finish(),this._state<3&&(Fy.initialStylesByElement.delete(this._element),this._startStyles&&(Ox(this._element,this._startStyles),this._endStyles=null),this._endStyles&&(Ox(this._element,this._endStyles),this._endStyles=null),Mx(this._element,this._initialStyles),this._state=3)}}function Ly(t){let n=null;const e=Object.keys(t);for(let a=0;a<e.length;a++){const o=e[a];Hy(o)&&(n=n||{},n[o]=t[o])}return n}function Hy(t){return"display"===t||"position"===t}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */Fy.initialStylesByElement=new WeakMap;const By="animation",Vy="animationend";class jy{constructor(t,n,e,a,o,r,i){this._element=t,this._name=n,this._duration=e,this._delay=a,this._easing=o,this._fillMode=r,this._onDoneFn=i,this._finished=!1,this._destroyed=!1,this._startTime=0,this._position=0,this._eventFn=t=>this._handleCallback(t)}apply(){!(function t(n,e){const a=Zy(n,"").trim();let o=0;a.length&&((function r(t,n){let e=0;for(let a=0;a<t.length;a++)t.charAt(a)===n&&e++;return e})(a,",")+1,e=`${a}, ${e}`),qy(n,"",e)})(this._element,`${this._duration}ms ${this._easing} ${this._delay}ms 1 normal ${this._fillMode} ${this._name}`),Yy(this._element,this._eventFn,!1),this._startTime=Date.now()}pause(){Uy(this._element,this._name,"paused")}resume(){Uy(this._element,this._name,"running")}setPosition(t){const n=Wy(this._element,this._name);this._position=t*this._duration,qy(this._element,"Delay",`-${this._position}ms`,n)}getPosition(){return this._position}_handleCallback(t){const n=t._ngTestManualTimestamp||Date.now(),e=1e3*parseFloat(t.elapsedTime.toFixed(3));t.animationName==this._name&&Math.max(n-this._startTime,0)>=this._delay&&e>=this._duration&&this.finish()}finish(){this._finished||(this._finished=!0,this._onDoneFn(),Yy(this._element,this._eventFn,!0))}destroy(){this._destroyed||(this._destroyed=!0,this.finish(),(function t(n,e){const a=Zy(n,"").split(","),o=Gy(a,e);o>=0&&(a.splice(o,1),qy(n,"",a.join(",")))})(this._element,this._name))}}function Uy(t,n,e){qy(t,"PlayState",e,Wy(t,n))}function Wy(t,n){const e=Zy(t,"");return e.indexOf(",")>0?Gy(e.split(","),n):Gy([e],n)}function Gy(t,n){for(let e=0;e<t.length;e++)if(t[e].indexOf(n)>=0)return e;return-1}function Yy(t,n,e){e?t.removeEventListener(Vy,n):t.addEventListener(Vy,n)}function qy(t,n,e,a){const o=By+n;if(null!=a){const n=t.style[o];if(n.length){const t=n.split(",");t[a]=e,e=t.join(",")}}t.style[o]=e}function Zy(t,n){return t.style[By+n]}class Xy{constructor(t,n,e,a,o,r,i,c){this.element=t,this.keyframes=n,this.animationName=e,this._duration=a,this._delay=o,this._finalStyles=i,this._specialStyles=c,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._started=!1,this.currentSnapshot={},this._state=0,this.easing=r||"linear",this.totalTime=a+o,this._buildStyler()}onStart(t){this._onStartFns.push(t)}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}destroy(){this.init(),this._state>=4||(this._state=4,this._styler.destroy(),this._flushStartFns(),this._flushDoneFns(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach((t=>t())),this._onDestroyFns=[])}_flushDoneFns(){this._onDoneFns.forEach((t=>t())),this._onDoneFns=[]}_flushStartFns(){this._onStartFns.forEach((t=>t())),this._onStartFns=[]}finish(){this.init(),this._state>=3||(this._state=3,this._styler.finish(),this._flushStartFns(),this._specialStyles&&this._specialStyles.finish(),this._flushDoneFns())}setPosition(t){this._styler.setPosition(t)}getPosition(){return this._styler.getPosition()}hasStarted(){return this._state>=2}init(){this._state>=1||(this._state=1,this._styler.apply(),this._delay&&this._styler.pause())}play(){this.init(),this.hasStarted()||(this._flushStartFns(),this._state=2,this._specialStyles&&this._specialStyles.start()),this._styler.resume()}pause(){this.init(),this._styler.pause()}restart(){this.reset(),this.play()}reset(){this._styler.destroy(),this._buildStyler(),this._styler.apply()}_buildStyler(){this._styler=new jy(this.element,this.animationName,this._duration,this._delay,this.easing,"forwards",(()=>this.finish()))}triggerCallback(t){const n="start"==t?this._onStartFns:this._onDoneFns;n.forEach((t=>t())),n.length=0}beforeDestroy(){this.init();const t={};if(this.hasStarted()){const n=this._state>=3;Object.keys(this._finalStyles).forEach((e=>{"offset"!=e&&(t[e]=n?this._finalStyles[e]:Rx(this.element,e))}))}this.currentSnapshot=t}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Jy extends LP{constructor(t,n){super(),this.element=t,this._startingStyles={},this.__initialized=!1,this._styles=ox(n)}init(){!this.__initialized&&this._startingStyles&&(this.__initialized=!0,Object.keys(this._styles).forEach((t=>{this._startingStyles[t]=this.element.style[t]})),super.init())}play(){this._startingStyles&&(this.init(),Object.keys(this._styles).forEach((t=>this.element.style.setProperty(t,this._styles[t]))),super.play())}destroy(){this._startingStyles&&(Object.keys(this._startingStyles).forEach((t=>{const n=this._startingStyles[t];n?this.element.style.setProperty(t,n):this.element.style.removeProperty(t)})),this._startingStyles=null,super.destroy())}}class Qy{constructor(){this._count=0,this._head=document.querySelector("head"),this._warningIssued=!1}validateStyleProperty(t){return tx(t)}matchesElement(t,n){return nx(t,n)}containsElement(t,n){return ex(t,n)}query(t,n,e){return ax(t,n,e)}computeStyle(t,n,e){return window.getComputedStyle(t)[n]}buildKeyframeElement(t,n,e){e=e.map((t=>ox(t)));let a=`@keyframes ${n} {\n`,o="";e.forEach((t=>{o=" ";const n=parseFloat(t.offset);a+=`${o}${100*n}% {\n`,o+=" ",Object.keys(t).forEach((n=>{const e=t[n];switch(n){case"offset":return;case"easing":return void(e&&(a+=`${o}animation-timing-function: ${e};\n`));default:return void(a+=`${o}${n}: ${e};\n`)}})),a+=`${o}}\n`})),a+="}\n";const r=document.createElement("style");return r.textContent=a,r}animate(t,n,e,a,o,r=[],i){i&&this._notifyFaultyScrubber();const c=r.filter((t=>t instanceof Xy)),s={};Ex(e,a)&&c.forEach((t=>{let n=t.currentSnapshot;Object.keys(n).forEach((t=>s[t]=n[t]))}));const l=(function m(t){let n={};return t&&(Array.isArray(t)?t:[t]).forEach((t=>{Object.keys(t).forEach((e=>{"offset"!=e&&"easing"!=e&&(n[e]=t[e])}))})),n})(n=Ax(t,n,s));if(0==e)return new Jy(t,l);const d="gen_css_kf_"+this._count++,g=this.buildKeyframeElement(t,d,n);document.querySelector("head").appendChild(g);const p=Ny(t,n),b=new Xy(t,n,d,e,a,o,l,p);return b.onDestroy((()=>(function t(n){n.parentNode.removeChild(n)})(g))),b}_notifyFaultyScrubber(){this._warningIssued||(console.warn("@angular/animations: please load the web-animations.js polyfill to allow programmatic access...\n","  visit http://bit.ly/IWukam to learn more about using the web-animation-js polyfill."),this._warningIssued=!0)}}class Ky{constructor(t,n,e,a){this.element=t,this.keyframes=n,this.options=e,this._specialStyles=a,this._onDoneFns=[],this._onStartFns=[],this._onDestroyFns=[],this._initialized=!1,this._finished=!1,this._started=!1,this._destroyed=!1,this.time=0,this.parentPlayer=null,this.currentSnapshot={},this._duration=e.duration,this._delay=e.delay||0,this.time=this._duration+this._delay}_onFinish(){this._finished||(this._finished=!0,this._onDoneFns.forEach((t=>t())),this._onDoneFns=[])}init(){this._buildPlayer(),this._preparePlayerBeforeStart()}_buildPlayer(){if(this._initialized)return;this._initialized=!0;const t=this.keyframes;this.domPlayer=this._triggerWebAnimation(this.element,t,this.options),this._finalKeyframe=t.length?t[t.length-1]:{},this.domPlayer.addEventListener("finish",(()=>this._onFinish()))}_preparePlayerBeforeStart(){this._delay?this._resetDomPlayerState():this.domPlayer.pause()}_triggerWebAnimation(t,n,e){return t.animate(n,e)}onStart(t){this._onStartFns.push(t)}onDone(t){this._onDoneFns.push(t)}onDestroy(t){this._onDestroyFns.push(t)}play(){this._buildPlayer(),this.hasStarted()||(this._onStartFns.forEach((t=>t())),this._onStartFns=[],this._started=!0,this._specialStyles&&this._specialStyles.start()),this.domPlayer.play()}pause(){this.init(),this.domPlayer.pause()}finish(){this.init(),this._specialStyles&&this._specialStyles.finish(),this._onFinish(),this.domPlayer.finish()}reset(){this._resetDomPlayerState(),this._destroyed=!1,this._finished=!1,this._started=!1}_resetDomPlayerState(){this.domPlayer&&this.domPlayer.cancel()}restart(){this.reset(),this.play()}hasStarted(){return this._started}destroy(){this._destroyed||(this._destroyed=!0,this._resetDomPlayerState(),this._onFinish(),this._specialStyles&&this._specialStyles.destroy(),this._onDestroyFns.forEach((t=>t())),this._onDestroyFns=[])}setPosition(t){this.domPlayer.currentTime=t*this.time}getPosition(){return this.domPlayer.currentTime/this.time}get totalTime(){return this._delay+this._duration}beforeDestroy(){const t={};this.hasStarted()&&Object.keys(this._finalKeyframe).forEach((n=>{"offset"!=n&&(t[n]=this._finished?this._finalKeyframe[n]:Rx(this.element,n))})),this.currentSnapshot=t}triggerCallback(t){const n="start"==t?this._onStartFns:this._onDoneFns;n.forEach((t=>t())),n.length=0}}class $y{constructor(){this._isNativeImpl=/\{\s*\[native\s+code\]\s*\}/.test(tk().toString()),this._cssKeyframesDriver=new Qy}validateStyleProperty(t){return tx(t)}matchesElement(t,n){return nx(t,n)}containsElement(t,n){return ex(t,n)}query(t,n,e){return ax(t,n,e)}computeStyle(t,n,e){return window.getComputedStyle(t)[n]}overrideWebAnimationsSupport(t){this._isNativeImpl=t}animate(t,n,e,a,o,r=[],i){if(!i&&!this._isNativeImpl)return this._cssKeyframesDriver.animate(t,n,e,a,o,r);const c={duration:e,delay:a,fill:0==a?"both":"forwards"};o&&(c.easing=o);const s={},l=r.filter((t=>t instanceof Ky));Ex(e,a)&&l.forEach((t=>{let n=t.currentSnapshot;Object.keys(n).forEach((t=>s[t]=n[t]))}));const m=Ny(t,n=Ax(t,n=n.map((t=>hx(t,!1))),s));return new Ky(t,n,c,m)}}function tk(){
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */
return(function t(){return"undefined"!=typeof window&&void 0!==window.document})()&&Element.prototype.animate||{}}
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */class nk extends vP{constructor(t,n){super(),this._nextAnimationId=0,this._renderer=t.createRenderer(n.body,{id:"0",encapsulation:bo.None,styles:[],data:{animation:[]}})}build(t){const n=this._nextAnimationId.toString();this._nextAnimationId++;const e=Array.isArray(t)?AP(t):t;return ok(this._renderer,null,n,"register",[e]),new ek(n,this._renderer)}}nk.ɵfac=function t(n){return new(n||nk)(Za(vu),Za(zC))},nk.ɵprov=We({token:nk,factory:nk.ɵfac}),nk.ctorParameters=()=>[{type:vu},{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class ek extends class{}{constructor(t,n){super(),this._id=t,this._renderer=n}create(t,n){return new ak(this._id,t,n||{},this._renderer)}}class ak{constructor(t,n,e,a){this.id=t,this.element=n,this._renderer=a,this.parentPlayer=null,this._started=!1,this.totalTime=0,this._command("create",e)}_listen(t,n){return this._renderer.listen(this.element,`@@${this.id}:${t}`,n)}_command(t,...n){return ok(this._renderer,this.element,this.id,t,n)}onDone(t){this._listen("done",t)}onStart(t){this._listen("start",t)}onDestroy(t){this._listen("destroy",t)}init(){this._command("init")}hasStarted(){return this._started}play(){this._command("play"),this._started=!0}pause(){this._command("pause")}restart(){this._command("restart")}finish(){this._command("finish")}destroy(){this._command("destroy")}reset(){this._command("reset")}setPosition(t){this._command("setPosition",t)}getPosition(){return 0}}function ok(t,n,e,a,o){return t.setProperty(n,`@@${e}:${a}`,o)}const rk="@",ik="@.disabled";class ck{constructor(t,n,e){this.delegate=t,this.engine=n,this._zone=e,this._currentId=0,this._microtaskId=1,this._animationCallbacksBuffer=[],this._rendererCache=new Map,this._cdRecurDepth=0,this.promise=Promise.resolve(0),n.onRemovalComplete=(t,n)=>{n&&n.parentNode(t)&&n.removeChild(t.parentNode,t)}}createRenderer(t,n){const e=this.delegate.createRenderer(t,n);if(!(t&&n&&n.data&&n.data.animation)){let t=this._rendererCache.get(e);return t||(t=new sk("",e,this.engine),this._rendererCache.set(e,t)),t}const a=n.id,o=n.id+"-"+this._currentId;this._currentId++,this.engine.register(o,t);const r=n=>{Array.isArray(n)?n.forEach(r):this.engine.registerTrigger(a,o,t,n.name,n)};return n.data.animation.forEach(r),new lk(this,o,e,this.engine)}begin(){this._cdRecurDepth++,this.delegate.begin&&this.delegate.begin()}_scheduleCountTask(){this.promise.then((()=>{this._microtaskId++}))}scheduleListenerCallback(t,n,e){t>=0&&t<this._microtaskId?this._zone.run((()=>n(e))):(0==this._animationCallbacksBuffer.length&&Promise.resolve(null).then((()=>{this._zone.run((()=>{this._animationCallbacksBuffer.forEach((t=>{const[n,e]=t;n(e)})),this._animationCallbacksBuffer=[]}))})),this._animationCallbacksBuffer.push([n,e]))}end(){this._cdRecurDepth--,0==this._cdRecurDepth&&this._zone.runOutsideAngular((()=>{this._scheduleCountTask(),this.engine.flush(this._microtaskId)})),this.delegate.end&&this.delegate.end()}whenRenderingDone(){return this.engine.whenRenderingDone()}}ck.ɵfac=function t(n){return new(n||ck)(Za(vu),Za(Iy),Za(J_))},ck.ɵprov=We({token:ck,factory:ck.ɵfac}),ck.ctorParameters=()=>[{type:vu},{type:Iy},{type:J_}];class sk{constructor(t,n,e){this.namespaceId=t,this.delegate=n,this.engine=e,this.destroyNode=this.delegate.destroyNode?t=>n.destroyNode(t):null}get data(){return this.delegate.data}destroy(){this.engine.destroy(this.namespaceId,this.delegate),this.delegate.destroy()}createElement(t,n){return this.delegate.createElement(t,n)}createComment(t){return this.delegate.createComment(t)}createText(t){return this.delegate.createText(t)}appendChild(t,n){this.delegate.appendChild(t,n),this.engine.onInsert(this.namespaceId,n,t,!1)}insertBefore(t,n,e){this.delegate.insertBefore(t,n,e),this.engine.onInsert(this.namespaceId,n,t,!0)}removeChild(t,n,e){this.engine.onRemove(this.namespaceId,n,this.delegate,e)}selectRootElement(t,n){return this.delegate.selectRootElement(t,n)}parentNode(t){return this.delegate.parentNode(t)}nextSibling(t){return this.delegate.nextSibling(t)}setAttribute(t,n,e,a){this.delegate.setAttribute(t,n,e,a)}removeAttribute(t,n,e){this.delegate.removeAttribute(t,n,e)}addClass(t,n){this.delegate.addClass(t,n)}removeClass(t,n){this.delegate.removeClass(t,n)}setStyle(t,n,e,a){this.delegate.setStyle(t,n,e,a)}removeStyle(t,n,e){this.delegate.removeStyle(t,n,e)}setProperty(t,n,e){n.charAt(0)==rk&&n==ik?this.disableAnimations(t,!!e):this.delegate.setProperty(t,n,e)}setValue(t,n){this.delegate.setValue(t,n)}listen(t,n,e){return this.delegate.listen(t,n,e)}disableAnimations(t,n){this.engine.disableAnimations(t,n)}}class lk extends sk{constructor(t,n,e,a){super(n,e,a),this.factory=t,this.namespaceId=n}setProperty(t,n,e){n.charAt(0)==rk?"."==n.charAt(1)&&n==ik?this.disableAnimations(t,e=void 0===e||!!e):this.engine.process(this.namespaceId,t,n.substr(1),e):this.delegate.setProperty(t,n,e)}listen(t,n,e){if(n.charAt(0)==rk){const a=(function a(t){switch(t){case"body":return document.body;case"document":return document;case"window":return window;default:return t}})(t);let o=n.substr(1),r="";return o.charAt(0)!=rk&&([o,r]=(function o(t){const n=t.indexOf(".");return[t.substring(0,n),t.substr(n+1)]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(o)),this.engine.listen(this.namespaceId,a,o,r,(t=>{this.factory.scheduleListenerCallback(t._data||-1,e,t)}))}return this.delegate.listen(t,n,e)}}class mk extends Iy{constructor(t,n,e){super(t.body,n,e)}}mk.ɵfac=function t(n){return new(n||mk)(Za(zC),Za(ix),Za(ey))},mk.ɵprov=We({token:mk,factory:mk.ɵfac}),mk.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:ix},{type:ey}];const dk=new Fa("AnimationModuleType"),gk=[{provide:vP,useClass:nk},{provide:ey,useFactory:function pk(){return new ay}},{provide:Iy,useClass:mk},{provide:vu,useFactory:function bk(t,n,e){return new ck(t,n,e)},deps:[UO,Iy,J_]}],uk=[{provide:ix,useFactory:function fk(){return(function t(){return"function"==typeof tk()})()?new $y:new Qy}},{provide:dk,useValue:"BrowserAnimations"},...gk],hk=[{provide:ix,useClass:rx},{provide:dk,useValue:"NoopAnimations"},...gk];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class _k{}_k.ɵmod=xo({type:_k}),_k.ɵinj=Ge({factory:function t(n){return new(n||_k)},providers:uk,imports:[uP]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(_k,{exports:function(){return[uP]}});class Ck{}Ck.ɵmod=xo({type:Ck}),Ck.ɵinj=Ge({factory:function t(n){return new(n||Ck)},providers:hk,imports:[uP]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Ck,{exports:function(){return[uP]}});
/**
     * @license NgRx 9.2.1
     * (c) 2015-2018 Brandon Roberts, Mike Ryan, Rob Wormald, Victor Savkin
     * License: MIT
     */
let Mk={};function Ok(t,n){if(Mk[t]=(Mk[t]||0)+1,"function"==typeof n)return Pk(t,((...e)=>Object.assign(Object.assign({},n(...e)),{type:t})));switch(n?n._as:"empty"){case"empty":return Pk(t,(()=>({type:t})));case"props":return Pk(t,(n=>Object.assign(Object.assign({},n),{type:t})));default:throw new Error("Unexpected config.")}}function Pk(t,n){return Object.defineProperty(n,"type",{value:t,writable:!1})}const xk="@ngrx/store/init";class yk extends F{constructor(){super({type:xk})}next(t){if("function"==typeof t)throw new TypeError("\n        Dispatch expected an object, instead it received a function.\n        If you're using the createAction function, make sure to invoke the function\n        before dispatching the action. For example, someAction should be someAction().");if(void 0===t)throw new TypeError("Actions must be objects");if(void 0===t.type)throw new TypeError("Actions must have a type property");super.next(t)}complete(){}ngOnDestroy(){super.complete()}}yk.ɵfac=function t(n){return new(n||yk)},yk.ɵprov=We({token:yk,factory:yk.ɵfac}),yk.ctorParameters=()=>[];const kk=[yk],vk=new Fa("@ngrx/store Internal Root Guard"),wk=new Fa("@ngrx/store Internal Initial State"),Sk=new Fa("@ngrx/store Initial State"),Ek=new Fa("@ngrx/store Reducer Factory"),Ak=new Fa("@ngrx/store Internal Reducer Factory Provider"),zk=new Fa("@ngrx/store Initial Reducers"),Rk=new Fa("@ngrx/store Internal Initial Reducers"),Tk=new Fa("@ngrx/store Store Features"),Dk=new Fa("@ngrx/store Internal Store Reducers"),Ik=new Fa("@ngrx/store Internal Feature Reducers"),Nk=new Fa("@ngrx/store Internal Feature Configs"),Fk=new Fa("@ngrx/store Internal Store Features"),Lk=new Fa("@ngrx/store Internal Feature Reducers Token"),Hk=new Fa("@ngrx/store Feature Reducers"),Bk=new Fa("@ngrx/store User Provided Meta Reducers"),Vk=new Fa("@ngrx/store Meta Reducers"),jk=new Fa("@ngrx/store Internal Resolved Meta Reducers"),Uk=new Fa("@ngrx/store User Runtime Checks Config"),Wk=new Fa("@ngrx/store Internal User Runtime Checks Config"),Gk=new Fa("@ngrx/store Internal Runtime Checks"),Yk=new Fa("@ngrx/store Check if Action types are unique");function qk(t,n={}){const e=Object.keys(t),a={};for(let n=0;n<e.length;n++){const o=e[n];"function"==typeof t[o]&&(a[o]=t[o])}const o=Object.keys(a);return function t(e,r){e=void 0===e?n:e;let i=!1;const c={};for(let t=0;t<o.length;t++){const n=o[t],s=e[n],l=(0,a[n])(s,r);c[n]=l,i=i||l!==s}return i?c:e}}function Zk(...t){return function(n){if(0===t.length)return n;const e=t[t.length-1];return t.slice(0,-1).reduceRight(((t,n)=>n(t)),e(n))}}function Xk(t,n){return Array.isArray(n)&&n.length>0&&(t=Zk.apply(null,[...n,t])),(n,e)=>{const a=t(n);return(t,n)=>a(t=void 0===t?e:t,n)}}class Jk extends _{}class Qk extends yk{}class Kk extends F{constructor(t,n,e,a){super(a(e,n)),this.dispatcher=t,this.initialState=n,this.reducers=e,this.reducerFactory=a}addFeature(t){this.addFeatures([t])}addFeatures(t){const n=t.reduce(((t,{reducers:n,reducerFactory:e,metaReducers:a,initialState:o,key:r})=>{const i="function"==typeof n?(function c(t){const n=Array.isArray(t)&&t.length>0?Zk(...t):t=>t;return(t,e)=>(t=n(t),(n,a)=>t(n=void 0===n?e:n,a))})(a)(n,o):Xk(e,a)(n,o);return t[r]=i,t}),{});this.addReducers(n)}removeFeature(t){this.removeFeatures([t])}removeFeatures(t){this.removeReducers(t.map((t=>t.key)))}addReducer(t,n){this.addReducers({[t]:n})}addReducers(t){this.reducers=Object.assign(Object.assign({},this.reducers),t),this.updateReducers(Object.keys(t))}removeReducer(t){this.removeReducers([t])}removeReducers(t){t.forEach((t=>{this.reducers=(function n(t,e){return Object.keys(t).filter((t=>t!==e)).reduce(((n,e)=>Object.assign(n,{[e]:t[e]})),{})})(this.reducers,t)})),this.updateReducers(t)}updateReducers(t){this.next(this.reducerFactory(this.reducers,this.initialState)),this.dispatcher.next({type:"@ngrx/store/update-reducers",features:t})}ngOnDestroy(){this.complete()}}Kk.ɵfac=function t(n){return new(n||Kk)(Za(Qk),Za(Sk),Za(zk),Za(Ek))},Kk.ɵprov=We({token:Kk,factory:Kk.ɵfac}),Kk.ctorParameters=()=>[{type:Qk},{type:void 0,decorators:[{type:Ie,args:[Sk]}]},{type:void 0,decorators:[{type:Ie,args:[zk]}]},{type:void 0,decorators:[{type:Ie,args:[Ek]}]}];const $k=[Kk,{provide:Jk,useExisting:Kk},{provide:Qk,useExisting:yk}];class tv extends x{ngOnDestroy(){this.complete()}}tv.ɵfac=function t(n){return nv(n||tv)},tv.ɵprov=We({token:tv,factory:tv.ɵfac});const nv=tc(tv),ev=[tv];class av extends _{}class ov extends F{constructor(t,n,e,a){super(a);const o=t.pipe((function i(t,n=0){return function e(a){return a.lift(new $(t,n))}})(j)).pipe(ye(n)).pipe((function r(t,n){let e=!1;return arguments.length>=2&&(e=!0),function a(o){return o.lift(new Zn(t,n,e))}})(rv,{state:a}));this.stateSubscription=o.subscribe((({state:t,action:n})=>{this.next(t),e.next(n)}))}ngOnDestroy(){this.stateSubscription.unsubscribe(),this.complete()}}function rv(t={state:void 0},[n,e]){const{state:a}=t;return{state:e(a,n),action:n}}ov.ɵfac=function t(n){return new(n||ov)(Za(yk),Za(Jk),Za(tv),Za(Sk))},ov.ɵprov=We({token:ov,factory:ov.ɵfac}),ov.INIT=xk,ov.ctorParameters=()=>[{type:yk},{type:Jk},{type:tv},{type:void 0,decorators:[{type:Ie,args:[Sk]}]}];const iv=[ov,{provide:av,useExisting:ov}];class cv extends _{constructor(t,n,e){super(),this.actionsObserver=n,this.reducerManager=e,this.source=t}select(t,...n){return lv.call(null,t,...n)(this)}lift(t){const n=new cv(this,this.actionsObserver,this.reducerManager);return n.operator=t,n}dispatch(t){this.actionsObserver.next(t)}next(t){this.actionsObserver.next(t)}error(t){this.actionsObserver.error(t)}complete(){this.actionsObserver.complete()}addReducer(t,n){this.reducerManager.addReducer(t,n)}removeReducer(t){this.reducerManager.removeReducer(t)}}cv.ɵfac=function t(n){return new(n||cv)(Za(av),Za(yk),Za(Kk))},cv.ɵprov=We({token:cv,factory:cv.ɵfac}),cv.ctorParameters=()=>[{type:av},{type:yk},{type:Kk}];const sv=[cv];function lv(t,n,...e){return function a(o){let r;if("string"==typeof t){const a=[n,...e].filter(Boolean);r=o.pipe((function i(...t){const n=t.length;if(0===n)throw new Error("list of properties cannot be empty.");return ft((e=>{let a=e;for(let e=0;e<n;e++){const n=a[t[e]];if(void 0===n)return;a=n}return a}))})(t,...a))}else{if("function"!=typeof t)throw new TypeError(`Unexpected type '${typeof t}' in select operator, expected 'string' or 'function'`);r=o.pipe(ft((e=>t(e,n))))}return r.pipe(vn())}}function mv(t,n){return t===n}function dv(t,n,e){for(let a=0;a<t.length;a++)if(!e(t[a],n[a]))return!0;return!1}function gv(t,n=mv,e=mv){let a,o=null,r=null;return{memoized:function i(){if(void 0!==a)return a.result;if(!o)return r=t.apply(null,arguments),o=arguments,r;if(!dv(arguments,o,n))return r;const i=t.apply(null,arguments);return o=arguments,e(r,i)?r:(r=i,i)},reset:function c(){o=null,r=null},setResult:function s(t){a={result:t}},clearResult:function l(){a=void 0}}}function pv(...t){return(function n(t,e={stateFn:bv}){return function(...n){let a=n;if(Array.isArray(a[0])){const[t,...n]=a;a=[...t,...n]}const o=a.slice(0,a.length-1),r=a[a.length-1],i=o.filter((t=>t.release&&"function"==typeof t.release)),c=t((function(...t){return r.apply(null,t)})),s=gv((function(t,n){return e.stateFn.apply(null,[t,o,n,c])}));return Object.assign(s.memoized,{release:function l(){s.reset(),c.reset(),i.forEach((t=>t.release()))},projector:c.memoized,setResult:s.setResult,clearResult:s.clearResult})}})(gv)(...t)}function bv(t,n,e,a){if(void 0===e){const e=n.map((n=>n(t)));return a.memoized.apply(null,e)}const o=n.map((n=>n(t,e)));return a.memoized.apply(null,[...o,e])}function uv(t){return pv((n=>{const e=n[t];return _c()&&!(t in n)&&console.warn(`@ngrx/store: The feature name "${t}" does not exist in the state, therefore createFeatureSelector cannot access it.  Be sure it is imported in a loaded module using StoreModule.forRoot('${t}', ...) or StoreModule.forFeature('${t}', ...).  If the default state is intended to be undefined, as is the case with router state, this development-only warning message can be ignored.`),e}),(t=>t))}const fv="https://ngrx.io/guide/store/configuration/runtime-checks";function hv(t){return void 0===t}function _v(t){return null===t}function Cv(t){return Array.isArray(t)}function Mv(t){return"object"==typeof t&&null!==t}function Ov(t){return"function"==typeof t}function Pv(t){Object.freeze(t);const n=Ov(t);return Object.getOwnPropertyNames(t).forEach((e=>{if(!e.startsWith("ɵ")&&(function a(t,n){return Object.prototype.hasOwnProperty.call(t,n)})(t,e)&&(!n||"caller"!==e&&"callee"!==e&&"arguments"!==e)){const n=t[e];!Mv(n)&&!Ov(n)||Object.isFrozen(n)||Pv(n)}})),t}function xv(t,n=[]){return(hv(t)||_v(t))&&0===n.length?{path:["root"],value:t}:Object.keys(t).reduce(((e,a)=>{if(e)return e;const o=t[a];return(function r(t){return Ov(t)&&t.hasOwnProperty("ɵcmp")})(o)?e:!(hv(o)||_v(o)||(function i(t){return"number"==typeof t})(o)||(function c(t){return"boolean"==typeof t})(o)||(function s(t){return"string"==typeof t})(o)||Cv(o))&&((function l(t){if(!(function n(t){return Mv(t)&&!Cv(t)})(t))return!1;const e=Object.getPrototypeOf(t);return e===Object.prototype||null===e})(o)?xv(o,[...n,a]):{path:[...n,a],value:o})}),!1)}function yv(t,n){if(!1===t)return;const e=t.path.join("."),a=new Error(`Detected unserializable ${n} at "${e}". ${fv}#strict${n}serializability`);throw a.value=t.value,a.unserializablePath=e,a}function kv(t){return _c()?Object.assign({strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!0,strictActionImmutability:!0,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1},t):{strictStateSerializability:!1,strictActionSerializability:!1,strictStateImmutability:!1,strictActionImmutability:!1,strictActionWithinNgZone:!1,strictActionTypeUniqueness:!1}}function vv({strictActionSerializability:t,strictStateSerializability:n}){return e=>t||n?(function a(t,n){return function(e,a){n.action(a)&&yv(xv(a),"action");const o=t(e,a);return n.state()&&yv(xv(o),"state"),o}})(e,{action:n=>t&&!Sv(n),state:()=>n}):e}function wv({strictActionImmutability:t,strictStateImmutability:n}){return e=>t||n?(function a(t,n){return function(e,a){const o=n.action(a)?Pv(a):a,r=t(e,o);return n.state()?Pv(r):r}})(e,{action:n=>t&&!Sv(n),state:()=>n}):e}function Sv(t){return t.type.startsWith("@ngrx")}function Ev({strictActionWithinNgZone:t}){return n=>t?(function e(t,n){return function(e,a){if(n.action(a)&&!J_.isInAngularZone())throw new Error(`Action '${a.type}' running outside NgZone. ${fv}#strictactionwithinngzone`);return t(e,a)}})(n,{action:n=>t&&!Sv(n)}):n}function Av(){return[{provide:Yk,multi:!0,deps:[Gk],useFactory:Rv}]}function zv(t){return t}function Rv(t){if(!t.strictActionTypeUniqueness)return;const n=Object.entries(Mk).filter((([,t])=>t>1)).map((([t])=>t));if(n.length)throw new Error(`Action types are registered more than once, ${n.map((t=>`"${t}"`)).join(", ")}. ${fv}#strictactiontypeuniqueness`)}class Tv{constructor(t,n,e,a,o,r){}}Tv.ɵmod=xo({type:Tv}),Tv.ɵinj=Ge({factory:function t(n){return new(n||Tv)(Za(yk),Za(Jk),Za(tv),Za(cv),Za(vk,8),Za(Yk,8))}}),Tv.ctorParameters=()=>[{type:yk},{type:Jk},{type:tv},{type:cv},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[vk]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[Yk]}]}];class Dv{constructor(t,n,e,a,o){this.features=t,this.featureReducers=n,this.reducerManager=e;const r=t.map(((t,e)=>{const a=n.shift()[e];return Object.assign(Object.assign({},t),{reducers:a,initialState:Hv(t.initialState)})}));e.addFeatures(r)}ngOnDestroy(){this.reducerManager.removeFeatures(this.features)}}Dv.ɵmod=xo({type:Dv}),Dv.ɵinj=Ge({factory:function t(n){return new(n||Dv)(Za(Fk),Za(Hk),Za(Kk),Za(Tv),Za(Yk,8))}}),Dv.ctorParameters=()=>[{type:Array,decorators:[{type:Ie,args:[Fk]}]},{type:Array,decorators:[{type:Ie,args:[Hk]}]},{type:Kk},{type:Tv},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[Yk]}]}];class Iv{static forRoot(t,n={}){return{ngModule:Tv,providers:[{provide:vk,useFactory:Vv,deps:[[cv,new Ne,new Le]]},{provide:wk,useValue:n.initialState},{provide:Sk,useFactory:Hv,deps:[wk]},{provide:Rk,useValue:t},{provide:Dk,useExisting:t instanceof Fa?t:Rk},{provide:zk,deps:[yd,Rk,[new Ie(Dk)]],useFactory:Nv},{provide:Bk,useValue:n.metaReducers?n.metaReducers:[]},{provide:jk,deps:[Vk,Bk],useFactory:Bv},{provide:Ak,useValue:n.reducerFactory?n.reducerFactory:qk},{provide:Ek,deps:[Ak,jk],useFactory:Xk},kk,$k,ev,iv,sv,(e=n.runtimeChecks,[{provide:Wk,useValue:e},{provide:Uk,useFactory:zv,deps:[Wk]},{provide:Gk,deps:[Uk],useFactory:kv},{provide:Vk,multi:!0,deps:[Gk],useFactory:wv},{provide:Vk,multi:!0,deps:[Gk],useFactory:vv},{provide:Vk,multi:!0,deps:[Gk],useFactory:Ev}]),Av()]};var e}static forFeature(t,n,e={}){return{ngModule:Dv,providers:[{provide:Nk,multi:!0,useValue:e},{provide:Tk,multi:!0,useValue:{key:t,reducerFactory:e instanceof Fa||!e.reducerFactory?qk:e.reducerFactory,metaReducers:e instanceof Fa||!e.metaReducers?[]:e.metaReducers,initialState:e instanceof Fa||!e.initialState?void 0:e.initialState}},{provide:Fk,deps:[yd,Nk,Tk],useFactory:Fv},{provide:Ik,multi:!0,useValue:n},{provide:Lk,multi:!0,useExisting:n instanceof Fa?n:Ik},{provide:Hk,multi:!0,deps:[yd,Ik,[new Ie(Lk)]],useFactory:Lv},Av()]}}}function Nv(t,n){return n instanceof Fa?t.get(n):n}function Fv(t,n,e){return e.map(((e,a)=>{if(n[a]instanceof Fa){const o=t.get(n[a]);return{key:e.key,reducerFactory:o.reducerFactory?o.reducerFactory:qk,metaReducers:o.metaReducers?o.metaReducers:[],initialState:o.initialState}}return e}))}function Lv(t,n){return n.map((n=>n instanceof Fa?t.get(n):n))}function Hv(t){return"function"==typeof t?t():t}function Bv(t,n){return t.concat(n)}function Vv(t){if(t)throw new TypeError("StoreModule.forRoot() called twice. Feature modules should use StoreModule.forFeature() instead.");return"guarded"}function jv(...t){return{reducer:t.pop(),types:t.reduce(((t,n)=>[...t,n.type]),[])}}function Uv(t,...n){const e=new Map;for(let t of n)for(let n of t.types)if(e.has(n)){const a=e.get(n);e.set(n,((n,e)=>t.reducer(a(n,e),e)))}else e.set(n,t.reducer);return function(n=t,a){const o=e.get(a.type);return o?o(n,a):n}}
/**
     * @license NgRx 9.2.1
     * (c) 2015-2018 Brandon Roberts, Mike Ryan, Rob Wormald, Victor Savkin
     * License: MIT
     */Iv.ɵmod=xo({type:Iv}),Iv.ɵinj=Ge({factory:function t(n){return new(n||Iv)}});const Wv={dispatch:!0,useEffectsErrorHandler:!0},Gv="__@ngrx/effects_create__";function Yv(t,n){const e=t(),a=Object.assign(Object.assign({},Wv),n);return Object.defineProperty(e,Gv,{value:a}),e}function qv(t){return Object.getOwnPropertyNames(t).filter((n=>t[n]&&t[n].hasOwnProperty(Gv))).map((n=>Object.assign({propertyName:n},t[n][Gv])))}function Zv(t){return Object.getPrototypeOf(t)}const Xv="__@ngrx/effects__";function Jv(t){return Zk(Qv,Zv)(t)}function Qv(t){return(function n(t){return t.constructor.hasOwnProperty(Xv)})(t)?t.constructor[Xv]:[]}function Kv(t,n,e=10){return t.pipe(on((a=>(n&&n.handleError(a),e<=1?t:Kv(t,n,e-1)))))}class $v extends _{constructor(t){super(),t&&(this.source=t)}lift(t){const n=new $v;return n.source=this,n.operator=t,n}}function tw(...t){return Gt((n=>t.some((t=>"string"==typeof t?t===n.type:t.type===n.type))))}function nw(t){return ew(t,"ngrxOnInitEffects")}function ew(t,n){return t&&n in t&&"function"==typeof t[n]}$v.ɵfac=function t(n){return new(n||$v)(Za(tv))},$v.ɵprov=We({token:$v,factory:$v.ɵfac}),$v.ctorParameters=()=>[{type:_,decorators:[{type:Ie,args:[tv]}]}];const aw=new Fa("@ngrx/effects Internal Root Guard");new Fa("ngrx/effects: Immediate Effects");const ow=new Fa("ngrx/effects: User Provided Effects"),rw=new Fa("ngrx/effects: Internal Root Effects"),iw=new Fa("ngrx/effects: Root Effects"),cw=new Fa("ngrx/effects: Internal Feature Effects"),sw=new Fa("ngrx/effects: Feature Effects"),lw=new Fa("ngrx/effects: Effects Error Handler");class mw extends x{constructor(t,n){super(),this.errorHandler=t,this.effectsErrorHandler=n}addEffects(t){this.next(t)}toActions(){return this.pipe(z(Zv),Tt((t=>t.pipe(z(dw)))),Tt((t=>Wt(t.pipe(Nn((t=>(function n(t,e){return n=>{const a=(function o(t,n,e){const a=Zv(t).constructor.name;return Wt(...(function o(t){return[Jv,qv].reduce(((n,e)=>n.concat(e(t))),[])})(t).map((({propertyName:o,dispatch:r,useEffectsErrorHandler:i})=>{const c="function"==typeof t[o]?t[o]():t[o],s=i?e(c,n):c;return!1===r?s.pipe((function l(){return function t(n){return n.lift(new Vn)}})()):s.pipe((function m(){return function t(n){return n.lift(new Yn)}})()).pipe(ft((n=>({effect:t[o],notification:n,propertyName:o,sourceName:a,sourceInstance:t}))))})))})(n,t,e);return(function r(t){return ew(t,"ngrxOnRunEffects")})(n)?n.ngrxOnRunEffects(a):a}})(this.errorHandler,this.effectsErrorHandler)(t))),ft((t=>((function n(t,e){if("N"===t.notification.kind){const n=t.notification.value;!(function a(t){return"function"!=typeof t&&t&&t.type&&"string"==typeof t.type})(n)&&e.handleError(new Error(`Effect ${(function o({propertyName:t,sourceInstance:n,sourceName:e}){const a="function"==typeof n[t];return`"${e}.${String(t)}${a?"()":""}"`})(t)} dispatched an invalid action: ${(function r(t){try{return JSON.stringify(t)}catch(n){return t}})(n)}`))}})(t,this.errorHandler),t.notification))),Gt((t=>"N"===t.kind)),(function n(){return function t(n){return n.lift(new yn)}})()),t.pipe(Tn(1),Gt(nw),ft((t=>t.ngrxOnInitEffects())))))))}}function dw(t){return(function n(t){return ew(t,"ngrxOnIdentifyEffects")})(t)?t.ngrxOnIdentifyEffects():""}mw.ɵfac=function t(n){return new(n||mw)(Za(oc),Za(lw))},mw.ɵprov=We({token:mw,factory:mw.ɵfac}),mw.ctorParameters=()=>[{type:oc},{type:void 0,decorators:[{type:Ie,args:[lw]}]}];class gw{constructor(t,n){this.effectSources=t,this.store=n,this.effectsSubscription=null}start(){this.effectsSubscription||(this.effectsSubscription=this.effectSources.toActions().subscribe(this.store))}ngOnDestroy(){this.effectsSubscription&&(this.effectsSubscription.unsubscribe(),this.effectsSubscription=null)}}gw.ɵfac=function t(n){return new(n||gw)(Za(mw),Za(cv))},gw.ɵprov=We({token:gw,factory:gw.ɵfac}),gw.ctorParameters=()=>[{type:mw},{type:cv}];const pw="@ngrx/effects/init";Ok(pw);class bw{constructor(t,n,e,a,o,r,i){this.sources=t,n.start(),a.forEach((n=>t.addEffects(n))),e.dispatch({type:pw})}addEffects(t){this.sources.addEffects(t)}}bw.ɵmod=xo({type:bw}),bw.ɵinj=Ge({factory:function t(n){return new(n||bw)(Za(mw),Za(gw),Za(cv),Za(iw),Za(Tv,8),Za(Dv,8),Za(aw,8))}}),bw.ctorParameters=()=>[{type:mw},{type:gw},{type:cv},{type:Array,decorators:[{type:Ie,args:[iw]}]},{type:Tv,decorators:[{type:Ne}]},{type:Dv,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[aw]}]}];class uw{constructor(t,n,e,a){n.forEach((n=>n.forEach((n=>t.addEffects(n)))))}}uw.ɵmod=xo({type:uw}),uw.ɵinj=Ge({factory:function t(n){return new(n||uw)(Za(bw),Za(sw),Za(Tv,8),Za(Dv,8))}}),uw.ctorParameters=()=>[{type:bw},{type:Array,decorators:[{type:Ie,args:[sw]}]},{type:Tv,decorators:[{type:Ne}]},{type:Dv,decorators:[{type:Ne}]}];class fw{static forFeature(t=[]){return{ngModule:uw,providers:[t,{provide:cw,multi:!0,useValue:t},{provide:ow,multi:!0,useValue:[]},{provide:sw,multi:!0,useFactory:hw,deps:[yd,cw,ow]}]}}static forRoot(t=[]){return{ngModule:bw,providers:[{provide:aw,useFactory:_w,deps:[[gw,new Ne,new Le]]},{provide:lw,useValue:Kv},gw,mw,$v,t,{provide:rw,useValue:[t]},{provide:ow,multi:!0,useValue:[]},{provide:iw,useFactory:hw,deps:[yd,rw,ow]}]}}}function hw(t,n,e){const a=[];for(let t of n)a.push(...t);for(let t of e)a.push(...t);return(function o(t,n){return n.map((n=>t.get(n)))})(t,a)}function _w(t){if(t)throw new TypeError("EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.");return"guarded"}fw.ɵmod=xo({type:fw}),fw.ɵinj=Ge({factory:function t(n){return new(n||fw)}});const Cw=new Fa("[Alert] Action-To-Alert Provider");class Mw{constructor(t){this.providers=new Map;for(const n of t||[])for(const t of n){if(this.providers.has(t.actionCreator.type))throw new RangeError(`"${t.actionCreator.type}" is already registered for alerts. Multiple alerts for the same action is not allowed.`);this.providers.set(t.actionCreator.type,t.alertFromAction)}}getAlertFromAction(t){const n=this.providers.get(t.type);return n?n(t):null}static registerAlertActions(t){return{ngModule:Mw,providers:[{provide:Cw,multi:!0,useFactory:t}]}}}Mw.ɵmod=xo({type:Mw}),Mw.ɵinj=Ge({factory:function t(n){return new(n||Mw)(Za(Cw,8))}});const Ow=Ok("[Alert] Alert Reported",{_as:"props",_p:void 0});class Pw{constructor(t,n,e){this.actions$=t,this.store=n,this.alertActionModule=e,this.reportRegisteredActionAlerts$=Yv((()=>this.actions$.pipe(he((t=>{const n=this.alertActionModule.getAlertFromAction(t);n&&this.store.dispatch(Ow(n))})))),{dispatch:!1})}}Pw.ɵfac=function t(n){return new(n||Pw)(Za($v),Za(cv),Za(Mw))},Pw.ɵprov=We({token:Pw,factory:Pw.ɵfac});const xw=Uv({latestAlert:null},jv(Ow,((t,{localizedMessage:n,followupAction:e})=>Object.assign(Object.assign({},t),{latestAlert:{localizedMessage:n,followupAction:e,created:Date.now()}})))),yw="alerts",kw=pv(uv(yw),(t=>t.latestAlert));let vw,ww;try{vw="undefined"!=typeof Intl&&Intl.v8BreakIterator}catch(t){vw=!1}class Sw{constructor(t){this._platformId=t,this.isBrowser=this._platformId?(function n(t){return"browser"===t})(this._platformId):"object"==typeof document&&!!document,this.EDGE=this.isBrowser&&/(edge)/i.test(navigator.userAgent),this.TRIDENT=this.isBrowser&&/(msie|trident)/i.test(navigator.userAgent),this.BLINK=this.isBrowser&&!(!window.chrome&&!vw)&&"undefined"!=typeof CSS&&!this.EDGE&&!this.TRIDENT,this.WEBKIT=this.isBrowser&&/AppleWebKit/i.test(navigator.userAgent)&&!this.BLINK&&!this.EDGE&&!this.TRIDENT,this.IOS=this.isBrowser&&/iPad|iPhone|iPod/.test(navigator.userAgent)&&!("MSStream"in window),this.FIREFOX=this.isBrowser&&/(firefox|minefield)/i.test(navigator.userAgent),this.ANDROID=this.isBrowser&&/android/i.test(navigator.userAgent)&&!this.TRIDENT,this.SAFARI=this.isBrowser&&/safari/i.test(navigator.userAgent)&&this.WEBKIT}}Sw.ɵfac=function t(n){return new(n||Sw)(Za(T_))},Sw.ɵprov=We({factory:function t(){return new Sw(Za(T_))},token:Sw,providedIn:"root"}),Sw.ctorParameters=()=>[{type:Object,decorators:[{type:Ie,args:[T_]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class Ew{}Ew.ɵmod=xo({type:Ew}),Ew.ɵinj=Ge({factory:function t(n){return new(n||Ew)}});const Aw=["color","button","checkbox","date","datetime-local","email","file","hidden","image","month","number","password","radio","range","reset","search","submit","tel","text","time","url","week"];function zw(){if(ww)return ww;if("object"!=typeof document||!document)return ww=new Set(Aw),ww;let t=document.createElement("input");return ww=new Set(Aw.filter((n=>(t.setAttribute("type",n),t.type===n)))),ww}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let Rw,Tw,Dw,Iw;function Nw(t){return(function n(){if(null==Rw&&"undefined"!=typeof window)try{window.addEventListener("test",null,Object.defineProperty({},"passive",{get:()=>Rw=!0}))}finally{Rw=Rw||!1}return Rw})()?t:!!t.capture}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Fw(){if("object"!=typeof document||!document)return 0;if(null==Tw){const t=document.createElement("div"),n=t.style;t.dir="rtl",n.width="1px",n.overflow="auto",n.visibility="hidden",n.pointerEvents="none",n.position="absolute";const e=document.createElement("div"),a=e.style;a.width="2px",a.height="1px",t.appendChild(e),document.body.appendChild(t),Tw=0,0===t.scrollLeft&&(t.scrollLeft=1,Tw=0===t.scrollLeft?1:2),t.parentNode.removeChild(t)}return Tw}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Lw(t){if((function n(){if(null==Iw){const t="undefined"!=typeof document?document.head:null;Iw=!(!t||!t.createShadowRoot&&!t.attachShadow)}return Iw})()){const n=t.getRootNode?t.getRootNode():null;if("undefined"!=typeof ShadowRoot&&ShadowRoot&&n instanceof ShadowRoot)return n}return null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Hw=13,Bw=27,Vw=32,jw=38,Uw=40;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function Ww(t,...n){return n.length?n.some((n=>t[n])):t.altKey||t.shiftKey||t.ctrlKey||t.metaKey}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Gw(t){return null!=t&&"false"!=`${t}`}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Yw(t,n=0){return qw(t)?Number(t):n}function qw(t){return!isNaN(parseFloat(t))&&!isNaN(Number(t))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Zw(t){return Array.isArray(t)?t:[t]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Xw(t){return null==t?"":"string"==typeof t?t:`${t}px`}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Jw(t){return t instanceof xu?t.nativeElement:t}class Qw{create(t){return"undefined"==typeof MutationObserver?null:new MutationObserver(t)}}Qw.ɵfac=function t(n){return new(n||Qw)},Qw.ɵprov=We({factory:function t(){return new Qw},token:Qw,providedIn:"root"});class Kw{constructor(t){this._mutationObserverFactory=t,this._observedElements=new Map}ngOnDestroy(){this._observedElements.forEach(((t,n)=>this._cleanupObserver(n)))}observe(t){const n=Jw(t);return new _((t=>{const e=this._observeElement(n).subscribe(t);return()=>{e.unsubscribe(),this._unobserveElement(n)}}))}_observeElement(t){if(this._observedElements.has(t))this._observedElements.get(t).count++;else{const n=new x,e=this._mutationObserverFactory.create((t=>n.next(t)));e&&e.observe(t,{characterData:!0,childList:!0,subtree:!0}),this._observedElements.set(t,{observer:e,stream:n,count:1})}return this._observedElements.get(t).stream}_unobserveElement(t){this._observedElements.has(t)&&(this._observedElements.get(t).count--,this._observedElements.get(t).count||this._cleanupObserver(t))}_cleanupObserver(t){if(this._observedElements.has(t)){const{observer:n,stream:e}=this._observedElements.get(t);n&&n.disconnect(),e.complete(),this._observedElements.delete(t)}}}Kw.ɵfac=function t(n){return new(n||Kw)(Za(Qw))},Kw.ɵprov=We({factory:function t(){return new Kw(Za(Qw))},token:Kw,providedIn:"root"}),Kw.ctorParameters=()=>[{type:Qw}];class $w{constructor(t,n,e){this._contentObserver=t,this._elementRef=n,this._ngZone=e,this.event=new Ef,this._disabled=!1,this._currentSubscription=null}get disabled(){return this._disabled}set disabled(t){this._disabled=Gw(t),this._disabled?this._unsubscribe():this._subscribe()}get debounce(){return this._debounce}set debounce(t){this._debounce=Yw(t),this._subscribe()}ngAfterContentInit(){this._currentSubscription||this.disabled||this._subscribe()}ngOnDestroy(){this._unsubscribe()}_subscribe(){this._unsubscribe();const t=this._contentObserver.observe(this._elementRef);this._ngZone.runOutsideAngular((()=>{this._currentSubscription=(this.debounce?t.pipe(ln(this.debounce)):t).subscribe(this.event)}))}_unsubscribe(){this._currentSubscription&&this._currentSubscription.unsubscribe()}}$w.ɵfac=function t(n){return new(n||$w)(Zg(Kw),Zg(xu),Zg(J_))},$w.ɵdir=vo({type:$w,selectors:[["","cdkObserveContent",""]],inputs:{disabled:["cdkObserveContentDisabled","disabled"],debounce:"debounce"},outputs:{event:"cdkObserveContent"},exportAs:["cdkObserveContent"]}),$w.ctorParameters=()=>[{type:Kw},{type:xu},{type:J_}],$w.propDecorators={event:[{type:h_,args:["cdkObserveContent"]}],disabled:[{type:f_,args:["cdkObserveContentDisabled"]}],debounce:[{type:f_}]};class tS{}function nS(t,n){return(t.getAttribute(n)||"").match(/\S+/g)||[]}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */tS.ɵmod=xo({type:tS}),tS.ɵinj=Ge({factory:function t(n){return new(n||tS)},providers:[Qw]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(tS,{declarations:[$w],exports:[$w]});const eS="cdk-describedby-message-container",aS="cdk-describedby-host";let oS=0;const rS=new Map;let iS=null;class cS{constructor(t,n){this._platform=n,this._document=t}describe(t,n){this._canBeDescribed(t,n)&&("string"!=typeof n?(this._setMessageId(n),rS.set(n,{messageElement:n,referenceCount:0})):rS.has(n)||this._createMessageElement(n),this._isElementDescribedByMessage(t,n)||this._addMessageReference(t,n))}removeDescription(t,n){if(n&&this._isElementNode(t)){if(this._isElementDescribedByMessage(t,n)&&this._removeMessageReference(t,n),"string"==typeof n){const t=rS.get(n);t&&0===t.referenceCount&&this._deleteMessageElement(n)}iS&&0===iS.childNodes.length&&this._deleteMessagesContainer()}}ngOnDestroy(){const t=this._document.querySelectorAll("[cdk-describedby-host]");for(let n=0;n<t.length;n++)this._removeCdkDescribedByReferenceIds(t[n]),t[n].removeAttribute(aS);iS&&this._deleteMessagesContainer(),rS.clear()}_createMessageElement(t){const n=this._document.createElement("div");this._setMessageId(n),n.textContent=t,this._createMessagesContainer(),iS.appendChild(n),rS.set(t,{messageElement:n,referenceCount:0})}_setMessageId(t){t.id||(t.id="cdk-describedby-message-"+oS++)}_deleteMessageElement(t){const n=rS.get(t),e=n&&n.messageElement;iS&&e&&iS.removeChild(e),rS.delete(t)}_createMessagesContainer(){if(!iS){const t=!this._platform||!this._platform.EDGE&&!this._platform.TRIDENT,n=this._document.getElementById(eS);n&&n.parentNode&&n.parentNode.removeChild(n),iS=this._document.createElement("div"),iS.id=eS,iS.classList.add("cdk-visually-hidden"),iS.setAttribute("aria-hidden",t+""),this._document.body.appendChild(iS)}}_deleteMessagesContainer(){iS&&iS.parentNode&&(iS.parentNode.removeChild(iS),iS=null)}_removeCdkDescribedByReferenceIds(t){const n=nS(t,"aria-describedby").filter((t=>0!=t.indexOf("cdk-describedby-message")));t.setAttribute("aria-describedby",n.join(" "))}_addMessageReference(t,n){const e=rS.get(n);!(function a(t,n,e){const a=nS(t,n);a.some((t=>t.trim()==e.trim()))||(a.push(e.trim()),t.setAttribute(n,a.join(" ")))})(t,"aria-describedby",e.messageElement.id),t.setAttribute(aS,""),e.referenceCount++}_removeMessageReference(t,n){const e=rS.get(n);e.referenceCount--,(function a(t,n,e){const a=nS(t,n).filter((t=>t!=e.trim()));a.length?t.setAttribute(n,a.join(" ")):t.removeAttribute(n)})(t,"aria-describedby",e.messageElement.id),t.removeAttribute(aS)}_isElementDescribedByMessage(t,n){const e=nS(t,"aria-describedby"),a=rS.get(n),o=a&&a.messageElement.id;return!!o&&-1!=e.indexOf(o)}_canBeDescribed(t,n){if(!this._isElementNode(t))return!1;if(n&&"object"==typeof n)return!0;const e=null==n?"":`${n}`.trim(),a=t.getAttribute("aria-label");return!(!e||a&&a.trim()===e)}_isElementNode(t){return t.nodeType===this._document.ELEMENT_NODE}}cS.ɵfac=function t(n){return new(n||cS)(Za(zC),Za(Sw))},cS.ɵprov=We({factory:function t(){return new cS(Za(zC),Za(Sw))},token:cS,providedIn:"root"}),cS.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class sS{constructor(t){this._items=t,this._activeItemIndex=-1,this._activeItem=null,this._wrap=!1,this._letterKeyStream=new x,this._typeaheadSubscription=s.EMPTY,this._vertical=!0,this._allowedModifierKeys=[],this._homeAndEnd=!1,this._skipPredicateFn=t=>t.disabled,this._pressedLetters=[],this.tabOut=new x,this.change=new x,t instanceof zf&&t.changes.subscribe((t=>{if(this._activeItem){const n=t.toArray().indexOf(this._activeItem);n>-1&&n!==this._activeItemIndex&&(this._activeItemIndex=n)}}))}skipPredicate(t){return this._skipPredicateFn=t,this}withWrap(t=!0){return this._wrap=t,this}withVerticalOrientation(t=!0){return this._vertical=t,this}withHorizontalOrientation(t){return this._horizontal=t,this}withAllowedModifierKeys(t){return this._allowedModifierKeys=t,this}withTypeAhead(t=200){if(("undefined"==typeof ngDevMode||ngDevMode)&&this._items.length&&this._items.some((t=>"function"!=typeof t.getLabel)))throw Error("ListKeyManager items in typeahead mode must implement the `getLabel` method.");return this._typeaheadSubscription.unsubscribe(),this._typeaheadSubscription=this._letterKeyStream.pipe(he((t=>this._pressedLetters.push(t))),ln(t),Gt((()=>this._pressedLetters.length>0)),ft((()=>this._pressedLetters.join("")))).subscribe((t=>{const n=this._getItemsArray();for(let e=1;e<n.length+1;e++){const a=(this._activeItemIndex+e)%n.length,o=n[a];if(!this._skipPredicateFn(o)&&0===o.getLabel().toUpperCase().trim().indexOf(t)){this.setActiveItem(a);break}}this._pressedLetters=[]})),this}withHomeAndEnd(t=!0){return this._homeAndEnd=t,this}setActiveItem(t){const n=this._activeItem;this.updateActiveItem(t),this._activeItem!==n&&this.change.next(this._activeItemIndex)}onKeydown(t){const n=t.keyCode,e=["altKey","ctrlKey","metaKey","shiftKey"].every((n=>!t[n]||this._allowedModifierKeys.indexOf(n)>-1));switch(n){case 9:return void this.tabOut.next();case Uw:if(this._vertical&&e){this.setNextItemActive();break}return;case jw:if(this._vertical&&e){this.setPreviousItemActive();break}return;case 39:if(this._horizontal&&e){"rtl"===this._horizontal?this.setPreviousItemActive():this.setNextItemActive();break}return;case 37:if(this._horizontal&&e){"rtl"===this._horizontal?this.setNextItemActive():this.setPreviousItemActive();break}return;case 36:if(this._homeAndEnd&&e){this.setFirstItemActive();break}return;case 35:if(this._homeAndEnd&&e){this.setLastItemActive();break}return;default:return void((e||Ww(t,"shiftKey"))&&(t.key&&1===t.key.length?this._letterKeyStream.next(t.key.toLocaleUpperCase()):(n>=65&&n<=90||n>=48&&n<=57)&&this._letterKeyStream.next(String.fromCharCode(n))))}this._pressedLetters=[],t.preventDefault()}get activeItemIndex(){return this._activeItemIndex}get activeItem(){return this._activeItem}isTyping(){return this._pressedLetters.length>0}setFirstItemActive(){this._setActiveItemByIndex(0,1)}setLastItemActive(){this._setActiveItemByIndex(this._items.length-1,-1)}setNextItemActive(){this._activeItemIndex<0?this.setFirstItemActive():this._setActiveItemByDelta(1)}setPreviousItemActive(){this._activeItemIndex<0&&this._wrap?this.setLastItemActive():this._setActiveItemByDelta(-1)}updateActiveItem(t){const n=this._getItemsArray(),e="number"==typeof t?t:n.indexOf(t),a=n[e];this._activeItem=null==a?null:a,this._activeItemIndex=e}_setActiveItemByDelta(t){this._wrap?this._setActiveInWrapMode(t):this._setActiveInDefaultMode(t)}_setActiveInWrapMode(t){const n=this._getItemsArray();for(let e=1;e<=n.length;e++){const a=(this._activeItemIndex+t*e+n.length)%n.length;if(!this._skipPredicateFn(n[a]))return void this.setActiveItem(a)}}_setActiveInDefaultMode(t){this._setActiveItemByIndex(this._activeItemIndex+t,t)}_setActiveItemByIndex(t,n){const e=this._getItemsArray();if(e[t]){for(;this._skipPredicateFn(e[t]);)if(!e[t+=n])return;this.setActiveItem(t)}}_getItemsArray(){return this._items instanceof zf?this._items.toArray():this._items}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class lS extends sS{setActiveItem(t){this.activeItem&&this.activeItem.setInactiveStyles(),super.setActiveItem(t),this.activeItem&&this.activeItem.setActiveStyles()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class mS extends sS{constructor(){super(...arguments),this._origin="program"}setFocusOrigin(t){return this._origin=t,this}setActiveItem(t){super.setActiveItem(t),this.activeItem&&this.activeItem.focus(this._origin)}}class dS{constructor(t){this._platform=t}isDisabled(t){return t.hasAttribute("disabled")}isVisible(t){return(function n(t){return!!(t.offsetWidth||t.offsetHeight||"function"==typeof t.getClientRects&&t.getClientRects().length)})(t)&&"visible"===getComputedStyle(t).visibility}isTabbable(t){if(!this._platform.isBrowser)return!1;const n=(function a(t){try{return t.frameElement}catch(t){return null}})((function e(t){return t.ownerDocument&&t.ownerDocument.defaultView||window}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t));if(n){if(-1===pS(n))return!1;if(!this.isVisible(n))return!1}let o=t.nodeName.toLowerCase(),r=pS(t);return t.hasAttribute("contenteditable")?-1!==r:"iframe"!==o&&"object"!==o&&!(this._platform.WEBKIT&&this._platform.IOS&&!(function i(t){let n=t.nodeName.toLowerCase(),e="input"===n&&t.type;return"text"===e||"password"===e||"select"===n||"textarea"===n})(t))&&("audio"===o?!!t.hasAttribute("controls")&&-1!==r:"video"===o?-1!==r&&(null!==r||this._platform.FIREFOX||t.hasAttribute("controls")):t.tabIndex>=0)}isFocusable(t,n){return(function e(t){return!(function n(t){return(function n(t){return"input"==t.nodeName.toLowerCase()})(t)&&"hidden"==t.type})(t)&&((function e(t){let n=t.nodeName.toLowerCase();return"input"===n||"select"===n||"button"===n||"textarea"===n})(t)||(function a(t){return(function n(t){return"a"==t.nodeName.toLowerCase()})(t)&&t.hasAttribute("href")})(t)||t.hasAttribute("contenteditable")||gS(t))})(t)&&!this.isDisabled(t)&&((null==n?void 0:n.ignoreVisibility)||this.isVisible(t))}}function gS(t){if(!t.hasAttribute("tabindex")||void 0===t.tabIndex)return!1;let n=t.getAttribute("tabindex");return"-32768"!=n&&!(!n||isNaN(parseInt(n,10)))}function pS(t){if(!gS(t))return null;const n=parseInt(t.getAttribute("tabindex")||"",10);return isNaN(n)?-1:n}dS.ɵfac=function t(n){return new(n||dS)(Za(Sw))},dS.ɵprov=We({factory:function t(){return new dS(Za(Sw))},token:dS,providedIn:"root"}),dS.ctorParameters=()=>[{type:Sw}];class bS{constructor(t,n,e,a,o=!1){this._element=t,this._checker=n,this._ngZone=e,this._document=a,this._hasAttached=!1,this.startAnchorListener=()=>this.focusLastTabbableElement(),this.endAnchorListener=()=>this.focusFirstTabbableElement(),this._enabled=!0,o||this.attachAnchors()}get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}destroy(){const t=this._startAnchor,n=this._endAnchor;t&&(t.removeEventListener("focus",this.startAnchorListener),t.parentNode&&t.parentNode.removeChild(t)),n&&(n.removeEventListener("focus",this.endAnchorListener),n.parentNode&&n.parentNode.removeChild(n)),this._startAnchor=this._endAnchor=null,this._hasAttached=!1}attachAnchors(){return!!this._hasAttached||(this._ngZone.runOutsideAngular((()=>{this._startAnchor||(this._startAnchor=this._createAnchor(),this._startAnchor.addEventListener("focus",this.startAnchorListener)),this._endAnchor||(this._endAnchor=this._createAnchor(),this._endAnchor.addEventListener("focus",this.endAnchorListener))})),this._element.parentNode&&(this._element.parentNode.insertBefore(this._startAnchor,this._element),this._element.parentNode.insertBefore(this._endAnchor,this._element.nextSibling),this._hasAttached=!0),this._hasAttached)}focusInitialElementWhenReady(){return new Promise((t=>{this._executeOnStable((()=>t(this.focusInitialElement())))}))}focusFirstTabbableElementWhenReady(){return new Promise((t=>{this._executeOnStable((()=>t(this.focusFirstTabbableElement())))}))}focusLastTabbableElementWhenReady(){return new Promise((t=>{this._executeOnStable((()=>t(this.focusLastTabbableElement())))}))}_getRegionBoundary(t){let n=this._element.querySelectorAll(`[cdk-focus-region-${t}], [cdkFocusRegion${t}], [cdk-focus-${t}]`);for(let e=0;e<n.length;e++)n[e].hasAttribute(`cdk-focus-${t}`)?console.warn(`Found use of deprecated attribute 'cdk-focus-${t}', use 'cdkFocusRegion${t}' instead. The deprecated attribute will be removed in 8.0.0.`,n[e]):n[e].hasAttribute(`cdk-focus-region-${t}`)&&console.warn(`Found use of deprecated attribute 'cdk-focus-region-${t}', use 'cdkFocusRegion${t}' instead. The deprecated attribute will be removed in 8.0.0.`,n[e]);return"start"==t?n.length?n[0]:this._getFirstTabbableElement(this._element):n.length?n[n.length-1]:this._getLastTabbableElement(this._element)}focusInitialElement(){const t=this._element.querySelector("[cdk-focus-initial], [cdkFocusInitial]");return t?(t.hasAttribute("cdk-focus-initial")&&console.warn("Found use of deprecated attribute 'cdk-focus-initial', use 'cdkFocusInitial' instead. The deprecated attribute will be removed in 8.0.0",t),"undefined"!=typeof ngDevMode&&!ngDevMode||this._checker.isFocusable(t)||console.warn("Element matching '[cdkFocusInitial]' is not focusable.",t),t.focus(),!0):this.focusFirstTabbableElement()}focusFirstTabbableElement(){const t=this._getRegionBoundary("start");return t&&t.focus(),!!t}focusLastTabbableElement(){const t=this._getRegionBoundary("end");return t&&t.focus(),!!t}hasAttached(){return this._hasAttached}_getFirstTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let n=t.children||t.childNodes;for(let t=0;t<n.length;t++){let e=n[t].nodeType===this._document.ELEMENT_NODE?this._getFirstTabbableElement(n[t]):null;if(e)return e}return null}_getLastTabbableElement(t){if(this._checker.isFocusable(t)&&this._checker.isTabbable(t))return t;let n=t.children||t.childNodes;for(let t=n.length-1;t>=0;t--){let e=n[t].nodeType===this._document.ELEMENT_NODE?this._getLastTabbableElement(n[t]):null;if(e)return e}return null}_createAnchor(){const t=this._document.createElement("div");return this._toggleAnchorTabIndex(this._enabled,t),t.classList.add("cdk-visually-hidden"),t.classList.add("cdk-focus-trap-anchor"),t.setAttribute("aria-hidden","true"),t}_toggleAnchorTabIndex(t,n){t?n.setAttribute("tabindex","0"):n.removeAttribute("tabindex")}toggleAnchors(t){this._startAnchor&&this._endAnchor&&(this._toggleAnchorTabIndex(t,this._startAnchor),this._toggleAnchorTabIndex(t,this._endAnchor))}_executeOnStable(t){this._ngZone.isStable?t():this._ngZone.onStable.pipe(Tn(1)).subscribe(t)}}class uS{constructor(t,n,e){this._checker=t,this._ngZone=n,this._document=e}create(t,n=!1){return new bS(t,this._checker,this._ngZone,this._document,n)}}uS.ɵfac=function t(n){return new(n||uS)(Za(dS),Za(J_),Za(zC))},uS.ɵprov=We({factory:function t(){return new uS(Za(dS),Za(J_),Za(zC))},token:uS,providedIn:"root"}),uS.ctorParameters=()=>[{type:dS},{type:J_},{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class fS{constructor(t,n,e){this._elementRef=t,this._focusTrapFactory=n,this._previouslyFocusedElement=null,this._document=e,this.focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement,!0)}get enabled(){return this.focusTrap.enabled}set enabled(t){this.focusTrap.enabled=Gw(t)}get autoCapture(){return this._autoCapture}set autoCapture(t){this._autoCapture=Gw(t)}ngOnDestroy(){this.focusTrap.destroy(),this._previouslyFocusedElement&&(this._previouslyFocusedElement.focus(),this._previouslyFocusedElement=null)}ngAfterContentInit(){this.focusTrap.attachAnchors(),this.autoCapture&&this._captureFocus()}ngDoCheck(){this.focusTrap.hasAttached()||this.focusTrap.attachAnchors()}ngOnChanges(t){const n=t.autoCapture;n&&!n.firstChange&&this.autoCapture&&this.focusTrap.hasAttached()&&this._captureFocus()}_captureFocus(){this._previouslyFocusedElement=this._document.activeElement,this.focusTrap.focusInitialElementWhenReady()}}fS.ɵfac=function t(n){return new(n||fS)(Zg(xu),Zg(uS),Zg(zC))},fS.ɵdir=vo({type:fS,selectors:[["","cdkTrapFocus",""]],inputs:{enabled:["cdkTrapFocus","enabled"],autoCapture:["cdkTrapFocusAutoCapture","autoCapture"]},exportAs:["cdkTrapFocus"],features:[pr]}),fS.ctorParameters=()=>[{type:xu},{type:uS},{type:void 0,decorators:[{type:Ie,args:[zC]}]}],fS.propDecorators={enabled:[{type:f_,args:["cdkTrapFocus"]}],autoCapture:[{type:f_,args:["cdkTrapFocusAutoCapture"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class hS extends bS{constructor(t,n,e,a,o,r,i){super(t,n,e,a,i.defer),this._focusTrapManager=o,this._inertStrategy=r,this._focusTrapManager.register(this)}get enabled(){return this._enabled}set enabled(t){this._enabled=t,this._enabled?this._focusTrapManager.register(this):this._focusTrapManager.deregister(this)}destroy(){this._focusTrapManager.deregister(this),super.destroy()}_enable(){this._inertStrategy.preventFocus(this),this.toggleAnchors(!0)}_disable(){this._inertStrategy.allowFocus(this),this.toggleAnchors(!1)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const _S="undefined"!=typeof Element&&!!Element.prototype.closest;function CS(t,n){return t.matches?t.matches(n):t.msMatchesSelector(n)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class MS{constructor(){this._listener=null}preventFocus(t){this._listener&&t._document.removeEventListener("focus",this._listener,!0),this._listener=n=>this._trapFocus(t,n),t._ngZone.runOutsideAngular((()=>{t._document.addEventListener("focus",this._listener,!0)}))}allowFocus(t){this._listener&&(t._document.removeEventListener("focus",this._listener,!0),this._listener=null)}_trapFocus(t,n){const e=n.target,a=t._element;a.contains(e)||null!==(function o(t,n){if(!(t instanceof Node))return null;let e=t;for(;null!=e&&!(e instanceof Element);)e=e.parentNode;return e&&(_S?e.closest(n):(function a(t,n){let e=t;for(;null!=e&&!(e instanceof Element&&CS(e,n));)e=e.parentNode;return e||null})(e,n))})(e,"div.cdk-overlay-pane")||setTimeout((()=>{t.enabled&&!a.contains(t._document.activeElement)&&t.focusFirstTabbableElement()}))}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class OS{constructor(){this.defer=!1}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const PS=new Fa("FOCUS_TRAP_INERT_STRATEGY");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class xS{constructor(){this._focusTrapStack=[]}register(t){this._focusTrapStack=this._focusTrapStack.filter((n=>n!==t));let n=this._focusTrapStack;n.length&&n[n.length-1]._disable(),n.push(t),t._enable()}deregister(t){t._disable();const n=this._focusTrapStack,e=n.indexOf(t);-1!==e&&(n.splice(e,1),n.length&&n[n.length-1]._enable())}}xS.ɵfac=function t(n){return new(n||xS)},xS.ɵprov=We({factory:function t(){return new xS},token:xS,providedIn:"root"});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class yS{constructor(t,n,e,a,o){this._checker=t,this._ngZone=n,this._focusTrapManager=e,this._document=a,this._inertStrategy=o||new MS}create(t,n=new OS){let e;return"boolean"==typeof n?(e=new OS,e.defer=n):e=n,new hS(t,this._checker,this._ngZone,this._document,this._focusTrapManager,this._inertStrategy,e)}}yS.ɵfac=function t(n){return new(n||yS)(Za(dS),Za(J_),Za(xS),Za(zC),Za(PS,8))},yS.ɵprov=We({factory:function t(){return new yS(Za(dS),Za(J_),Za(xS),Za(zC),Za(PS,8))},token:yS,providedIn:"root"}),yS.ctorParameters=()=>[{type:dS},{type:J_},{type:xS},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[PS]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const kS=new Fa("liveAnnouncerElement",{providedIn:"root",factory:function vS(){return null}}),wS=new Fa("LIVE_ANNOUNCER_DEFAULT_OPTIONS");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class SS{constructor(t,n,e,a){this._ngZone=n,this._defaultOptions=a,this._document=e,this._liveElement=t||this._createLiveElement()}announce(t,...n){const e=this._defaultOptions;let a,o;return 1===n.length&&"number"==typeof n[0]?o=n[0]:[a,o]=n,this.clear(),clearTimeout(this._previousTimeout),a||(a=e&&e.politeness?e.politeness:"polite"),null==o&&e&&(o=e.duration),this._liveElement.setAttribute("aria-live",a),this._ngZone.runOutsideAngular((()=>new Promise((n=>{clearTimeout(this._previousTimeout),this._previousTimeout=setTimeout((()=>{this._liveElement.textContent=t,n(),"number"==typeof o&&(this._previousTimeout=setTimeout((()=>this.clear()),o))}),100)}))))}clear(){this._liveElement&&(this._liveElement.textContent="")}ngOnDestroy(){clearTimeout(this._previousTimeout),this._liveElement&&this._liveElement.parentNode&&(this._liveElement.parentNode.removeChild(this._liveElement),this._liveElement=null)}_createLiveElement(){const t="cdk-live-announcer-element",n=this._document.getElementsByClassName(t),e=this._document.createElement("div");for(let t=0;t<n.length;t++)n[t].parentNode.removeChild(n[t]);return e.classList.add(t),e.classList.add("cdk-visually-hidden"),e.setAttribute("aria-atomic","true"),e.setAttribute("aria-live","polite"),this._document.body.appendChild(e),e}}SS.ɵfac=function t(n){return new(n||SS)(Za(kS,8),Za(J_),Za(zC),Za(wS,8))},SS.ɵprov=We({factory:function t(){return new SS(Za(kS,8),Za(J_),Za(zC),Za(wS,8))},token:SS,providedIn:"root"}),SS.ctorParameters=()=>[{type:void 0,decorators:[{type:Ne},{type:Ie,args:[kS]}]},{type:J_},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[wS]}]}];class ES{constructor(t,n,e,a){this._elementRef=t,this._liveAnnouncer=n,this._contentObserver=e,this._ngZone=a,this._politeness="polite"}get politeness(){return this._politeness}set politeness(t){this._politeness="off"===t||"assertive"===t?t:"polite","off"===this._politeness?this._subscription&&(this._subscription.unsubscribe(),this._subscription=null):this._subscription||(this._subscription=this._ngZone.runOutsideAngular((()=>this._contentObserver.observe(this._elementRef).subscribe((()=>{const t=this._elementRef.nativeElement.textContent;t!==this._previousAnnouncedText&&(this._liveAnnouncer.announce(t,this._politeness),this._previousAnnouncedText=t)})))))}ngOnDestroy(){this._subscription&&this._subscription.unsubscribe()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function AS(t){return 0===t.buttons}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */ES.ɵfac=function t(n){return new(n||ES)(Zg(xu),Zg(SS),Zg(Kw),Zg(J_))},ES.ɵdir=vo({type:ES,selectors:[["","cdkAriaLive",""]],inputs:{politeness:["cdkAriaLive","politeness"]},exportAs:["cdkAriaLive"]}),ES.ctorParameters=()=>[{type:xu},{type:SS},{type:Kw},{type:J_}],ES.propDecorators={politeness:[{type:f_,args:["cdkAriaLive"]}]};const zS=new Fa("cdk-focus-monitor-default-options"),RS=Nw({passive:!0,capture:!0});class TS{constructor(t,n,e,a){this._ngZone=t,this._platform=n,this._origin=null,this._windowFocused=!1,this._elementInfo=new Map,this._monitoredElementCount=0,this._rootNodeFocusListenerCount=new Map,this._documentKeydownListener=()=>{this._lastTouchTarget=null,this._setOriginForCurrentEventQueue("keyboard")},this._documentMousedownListener=t=>{if(!this._lastTouchTarget){const n=AS(t)?"keyboard":"mouse";this._setOriginForCurrentEventQueue(n)}},this._documentTouchstartListener=t=>{null!=this._touchTimeoutId&&clearTimeout(this._touchTimeoutId),this._lastTouchTarget=DS(t),this._touchTimeoutId=setTimeout((()=>this._lastTouchTarget=null),650)},this._windowFocusListener=()=>{this._windowFocused=!0,this._windowFocusTimeoutId=setTimeout((()=>this._windowFocused=!1))},this._rootNodeFocusAndBlurListener=t=>{const n=DS(t),e="focus"===t.type?this._onFocus:this._onBlur;for(let a=n;a;a=a.parentElement)e.call(this,t,a)},this._document=e,this._detectionMode=(null==a?void 0:a.detectionMode)||0}monitor(t,n=!1){const e=Jw(t);if(!this._platform.isBrowser||1!==e.nodeType)return Z(null);const a=Lw(e)||this._getDocument(),o=this._elementInfo.get(e);if(o)return n&&(o.checkChildren=!0),o.subject;const r={checkChildren:n,subject:new x,rootNode:a};return this._elementInfo.set(e,r),this._registerGlobalListeners(r),r.subject}stopMonitoring(t){const n=Jw(t),e=this._elementInfo.get(n);e&&(e.subject.complete(),this._setClasses(n),this._elementInfo.delete(n),this._removeGlobalListeners(e))}focusVia(t,n,e){const a=Jw(t);this._setOriginForCurrentEventQueue(n),"function"==typeof a.focus&&a.focus(e)}ngOnDestroy(){this._elementInfo.forEach(((t,n)=>this.stopMonitoring(n)))}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_toggleClass(t,n,e){e?t.classList.add(n):t.classList.remove(n)}_getFocusOrigin(t){return this._origin?this._origin:this._windowFocused&&this._lastFocusOrigin?this._lastFocusOrigin:this._wasCausedByTouch(t)?"touch":"program"}_setClasses(t,n){this._toggleClass(t,"cdk-focused",!!n),this._toggleClass(t,"cdk-touch-focused","touch"===n),this._toggleClass(t,"cdk-keyboard-focused","keyboard"===n),this._toggleClass(t,"cdk-mouse-focused","mouse"===n),this._toggleClass(t,"cdk-program-focused","program"===n)}_setOriginForCurrentEventQueue(t){this._ngZone.runOutsideAngular((()=>{this._origin=t,0===this._detectionMode&&(this._originTimeoutId=setTimeout((()=>this._origin=null),1))}))}_wasCausedByTouch(t){const n=DS(t);return this._lastTouchTarget instanceof Node&&n instanceof Node&&(n===this._lastTouchTarget||n.contains(this._lastTouchTarget))}_onFocus(t,n){const e=this._elementInfo.get(n);if(!e||!e.checkChildren&&n!==DS(t))return;const a=this._getFocusOrigin(t);this._setClasses(n,a),this._emitOrigin(e.subject,a),this._lastFocusOrigin=a}_onBlur(t,n){const e=this._elementInfo.get(n);!e||e.checkChildren&&t.relatedTarget instanceof Node&&n.contains(t.relatedTarget)||(this._setClasses(n),this._emitOrigin(e.subject,null))}_emitOrigin(t,n){this._ngZone.run((()=>t.next(n)))}_registerGlobalListeners(t){if(!this._platform.isBrowser)return;const n=t.rootNode,e=this._rootNodeFocusListenerCount.get(n)||0;e||this._ngZone.runOutsideAngular((()=>{n.addEventListener("focus",this._rootNodeFocusAndBlurListener,RS),n.addEventListener("blur",this._rootNodeFocusAndBlurListener,RS)})),this._rootNodeFocusListenerCount.set(n,e+1),1==++this._monitoredElementCount&&this._ngZone.runOutsideAngular((()=>{const t=this._getDocument(),n=this._getWindow();t.addEventListener("keydown",this._documentKeydownListener,RS),t.addEventListener("mousedown",this._documentMousedownListener,RS),t.addEventListener("touchstart",this._documentTouchstartListener,RS),n.addEventListener("focus",this._windowFocusListener)}))}_removeGlobalListeners(t){const n=t.rootNode;if(this._rootNodeFocusListenerCount.has(n)){const t=this._rootNodeFocusListenerCount.get(n);t>1?this._rootNodeFocusListenerCount.set(n,t-1):(n.removeEventListener("focus",this._rootNodeFocusAndBlurListener,RS),n.removeEventListener("blur",this._rootNodeFocusAndBlurListener,RS),this._rootNodeFocusListenerCount.delete(n))}if(!--this._monitoredElementCount){const t=this._getDocument(),n=this._getWindow();t.removeEventListener("keydown",this._documentKeydownListener,RS),t.removeEventListener("mousedown",this._documentMousedownListener,RS),t.removeEventListener("touchstart",this._documentTouchstartListener,RS),n.removeEventListener("focus",this._windowFocusListener),clearTimeout(this._windowFocusTimeoutId),clearTimeout(this._touchTimeoutId),clearTimeout(this._originTimeoutId)}}}function DS(t){return t.composedPath?t.composedPath()[0]:t.target}TS.ɵfac=function t(n){return new(n||TS)(Za(J_),Za(Sw),Za(zC,8),Za(zS,8))},TS.ɵprov=We({factory:function t(){return new TS(Za(J_),Za(Sw),Za(zC,8),Za(zS,8))},token:TS,providedIn:"root"}),TS.ctorParameters=()=>[{type:J_},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zS]}]}];class IS{constructor(t,n){this._elementRef=t,this._focusMonitor=n,this.cdkFocusChange=new Ef}ngAfterViewInit(){const t=this._elementRef.nativeElement;this._monitorSubscription=this._focusMonitor.monitor(t,1===t.nodeType&&t.hasAttribute("cdkMonitorSubtreeFocus")).subscribe((t=>this.cdkFocusChange.emit(t)))}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._monitorSubscription&&this._monitorSubscription.unsubscribe()}}IS.ɵfac=function t(n){return new(n||IS)(Zg(xu),Zg(TS))},IS.ɵdir=vo({type:IS,selectors:[["","cdkMonitorElementFocus",""],["","cdkMonitorSubtreeFocus",""]],outputs:{cdkFocusChange:"cdkFocusChange"}}),IS.ctorParameters=()=>[{type:xu},{type:TS}],IS.propDecorators={cdkFocusChange:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const NS="cdk-high-contrast-black-on-white",FS="cdk-high-contrast-white-on-black",LS="cdk-high-contrast-active";class HS{constructor(t,n){this._platform=t,this._document=n}getHighContrastMode(){if(!this._platform.isBrowser)return 0;const t=this._document.createElement("div");t.style.backgroundColor="rgb(1,2,3)",t.style.position="absolute",this._document.body.appendChild(t);const n=this._document.defaultView||window,e=n&&n.getComputedStyle?n.getComputedStyle(t):null,a=(e&&e.backgroundColor||"").replace(/ /g,"");switch(this._document.body.removeChild(t),a){case"rgb(0,0,0)":return 2;case"rgb(255,255,255)":return 1}return 0}_applyBodyHighContrastModeCssClasses(){if(this._platform.isBrowser&&this._document.body){const t=this._document.body.classList;t.remove(LS),t.remove(NS),t.remove(FS);const n=this.getHighContrastMode();1===n?(t.add(LS),t.add(NS)):2===n&&(t.add(LS),t.add(FS))}}}HS.ɵfac=function t(n){return new(n||HS)(Za(Sw),Za(zC))},HS.ɵprov=We({factory:function t(){return new HS(Za(Sw),Za(zC))},token:HS,providedIn:"root"}),HS.ctorParameters=()=>[{type:Sw},{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class BS{constructor(t){t._applyBodyHighContrastModeCssClasses()}}BS.ɵmod=xo({type:BS}),BS.ɵinj=Ge({factory:function t(n){return new(n||BS)(Za(HS))},imports:[[Ew,tS]]}),BS.ctorParameters=()=>[{type:HS}],("undefined"==typeof ngJitMode||ngJitMode)&&yo(BS,{declarations:function(){return[ES,fS,IS]},imports:function(){return[Ew,tS]},exports:function(){return[ES,fS,IS]}});const VS=new Fa("cdk-dir-doc",{providedIn:"root",factory:function jS(){return Ja(zC)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */});class US{constructor(t){if(this.value="ltr",this.change=new Ef,t){const n=t.documentElement?t.documentElement.dir:null,e=(t.body?t.body.dir:null)||n;this.value="ltr"===e||"rtl"===e?e:"ltr"}}ngOnDestroy(){this.change.complete()}}US.ɵfac=function t(n){return new(n||US)(Za(VS,8))},US.ɵprov=We({factory:function t(){return new US(Za(VS,8))},token:US,providedIn:"root"}),US.ctorParameters=()=>[{type:void 0,decorators:[{type:Ne},{type:Ie,args:[VS]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class WS{constructor(){this._dir="ltr",this._isInitialized=!1,this.change=new Ef}get dir(){return this._dir}set dir(t){const n=this._dir,e=t?t.toLowerCase():t;this._rawDir=t,this._dir="ltr"===e||"rtl"===e?e:"ltr",n!==this._dir&&this._isInitialized&&this.change.emit(this._dir)}get value(){return this.dir}ngAfterContentInit(){this._isInitialized=!0}ngOnDestroy(){this.change.complete()}}WS.ɵfac=function t(n){return new(n||WS)},WS.ɵdir=vo({type:WS,selectors:[["","dir",""]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("dir",e._rawDir)},inputs:{dir:"dir"},outputs:{change:"dirChange"},exportAs:["dir"],features:[Mu([{provide:US,useExisting:WS}])]}),WS.propDecorators={change:[{type:h_,args:["dirChange"]}],dir:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class GS{}GS.ɵmod=xo({type:GS}),GS.ɵinj=Ge({factory:function t(n){return new(n||GS)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(GS,{declarations:[WS],exports:[WS]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const YS=new Ru("10.2.7"),qS=["*",[["mat-option"],["ng-container"]]];function ZS(t,n){if(1&t&&tp(0,"mat-pseudo-checkbox",3),2&t){const t=gp();Jg("state",t.selected?"checked":"unchecked")("disabled",t.disabled)}}new Ru("10.2.7");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class XS{}XS.STANDARD_CURVE="cubic-bezier(0.4,0.0,0.2,1)",XS.DECELERATION_CURVE="cubic-bezier(0.0,0.0,0.2,1)",XS.ACCELERATION_CURVE="cubic-bezier(0.4,0.0,1,1)",XS.SHARP_CURVE="cubic-bezier(0.4,0.0,0.6,1)";class JS{}JS.COMPLEX="375ms",JS.ENTERING="225ms",JS.EXITING="195ms";
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const QS=new Ru("10.2.7"),KS=new Fa("mat-sanity-checks",{providedIn:"root",factory:function $S(){return!0}});class tE{constructor(t,n,e){this._hasDoneGlobalChecks=!1,this._document=e,t._applyBodyHighContrastModeCssClasses(),this._sanityChecks=n,this._hasDoneGlobalChecks||(this._checkDoctypeIsDefined(),this._checkThemeIsPresent(),this._checkCdkVersionMatch(),this._hasDoneGlobalChecks=!0)}_getDocument(){const t=this._document||document;return"object"==typeof t&&t?t:null}_getWindow(){const t=this._getDocument(),n=(null==t?void 0:t.defaultView)||window;return"object"==typeof n&&n?n:null}_checksAreEnabled(){return _c()&&!this._isTestEnv()}_isTestEnv(){const t=this._getWindow();return t&&(t.__karma__||t.jasmine)}_checkDoctypeIsDefined(){const t=this._checksAreEnabled()&&(!0===this._sanityChecks||this._sanityChecks.doctype),n=this._getDocument();t&&n&&!n.doctype&&console.warn("Current document does not have a doctype. This may cause some Angular Material components not to behave as expected.")}_checkThemeIsPresent(){const t=!this._checksAreEnabled()||!1===this._sanityChecks||!this._sanityChecks.theme,n=this._getDocument();if(t||!n||!n.body||"function"!=typeof getComputedStyle)return;const e=n.createElement("div");e.classList.add("mat-theme-loaded-marker"),n.body.appendChild(e);const a=getComputedStyle(e);a&&"none"!==a.display&&console.warn("Could not find Angular Material core theme. Most Material components may not work as expected. For more info refer to the theming guide: https://material.angular.io/guide/theming"),n.body.removeChild(e)}_checkCdkVersionMatch(){this._checksAreEnabled()&&(!0===this._sanityChecks||this._sanityChecks.version)&&QS.full!==YS.full&&console.warn("The Angular Material version ("+QS.full+") does not match the Angular CDK version ("+YS.full+").\nPlease ensure the versions of these two packages exactly match.")}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function nE(t){return class extends t{constructor(...t){super(...t),this._disabled=!1}get disabled(){return this._disabled}set disabled(t){this._disabled=Gw(t)}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function eE(t,n){return class extends t{constructor(...t){super(...t),this.defaultColor=n,this.color=n}get color(){return this._color}set color(t){const n=t||this.defaultColor;n!==this._color&&(this._color&&this._elementRef.nativeElement.classList.remove(`mat-${this._color}`),n&&this._elementRef.nativeElement.classList.add(`mat-${n}`),this._color=n)}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function aE(t){return class extends t{constructor(...t){super(...t),this._disableRipple=!1}get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Gw(t)}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function oE(t,n=0){return class extends t{constructor(...t){super(...t),this._tabIndex=n,this.defaultTabIndex=n}get tabIndex(){return this.disabled?-1:this._tabIndex}set tabIndex(t){this._tabIndex=null!=t?Yw(t):this.defaultTabIndex}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function rE(t){return class extends t{constructor(...t){super(...t),this.errorState=!1,this.stateChanges=new x}updateErrorState(){const t=this.errorState,n=(this.errorStateMatcher||this._defaultErrorStateMatcher).isErrorState(this.ngControl?this.ngControl.control:null,this._parentFormGroup||this._parentForm);n!==t&&(this.errorState=n,this.stateChanges.next())}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function iE(t){return class extends t{constructor(...t){super(...t),this._isInitialized=!1,this._pendingSubscribers=[],this.initialized=new _((t=>{this._isInitialized?this._notifySubscriber(t):this._pendingSubscribers.push(t)}))}_markInitialized(){if(this._isInitialized&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("This directive has already been marked as initialized and should not be called twice.");this._isInitialized=!0,this._pendingSubscribers.forEach(this._notifySubscriber),this._pendingSubscribers=null}_notifySubscriber(t){t.next(),t.complete()}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */tE.ɵmod=xo({type:tE}),tE.ɵinj=Ge({factory:function t(n){return new(n||tE)(Za(HS),Za(KS,8),Za(zC,8))},imports:[[GS],GS]}),tE.ctorParameters=()=>[{type:HS},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[KS]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]}],("undefined"==typeof ngJitMode||ngJitMode)&&yo(tE,{imports:function(){return[GS]},exports:function(){return[GS]}});const cE=new Fa("MAT_DATE_LOCALE",{providedIn:"root",factory:function sE(){return Ja(N_)}});class lE{constructor(){this._localeChanges=new x,this.localeChanges=this._localeChanges}getValidDateOrNull(t){return this.isDateInstance(t)&&this.isValid(t)?t:null}deserialize(t){return null==t||this.isDateInstance(t)&&this.isValid(t)?t:this.invalid()}setLocale(t){this.locale=t,this._localeChanges.next()}compareDate(t,n){return this.getYear(t)-this.getYear(n)||this.getMonth(t)-this.getMonth(n)||this.getDate(t)-this.getDate(n)}sameDate(t,n){if(t&&n){let e=this.isValid(t),a=this.isValid(n);return e&&a?!this.compareDate(t,n):e==a}return t==n}clampDate(t,n,e){return n&&this.compareDate(t,n)<0?n:e&&this.compareDate(t,e)>0?e:t}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const mE=new Fa("mat-date-formats");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let dE;try{dE="undefined"!=typeof Intl}catch(t){dE=!1}const gE={long:["January","February","March","April","May","June","July","August","September","October","November","December"],short:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],narrow:["J","F","M","A","M","J","J","A","S","O","N","D"]},pE=fE(31,(t=>String(t+1))),bE={long:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],short:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],narrow:["S","M","T","W","T","F","S"]},uE=/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;function fE(t,n){const e=Array(t);for(let a=0;a<t;a++)e[a]=n(a);return e}class hE extends lE{constructor(t,n){super(),this.useUtcForDisplay=!0,super.setLocale(t),this.useUtcForDisplay=!n.TRIDENT,this._clampDate=n.TRIDENT||n.EDGE}getYear(t){return t.getFullYear()}getMonth(t){return t.getMonth()}getDate(t){return t.getDate()}getDayOfWeek(t){return t.getDay()}getMonthNames(t){if(dE){const n=new Intl.DateTimeFormat(this.locale,{month:t,timeZone:"utc"});return fE(12,(t=>this._stripDirectionalityCharacters(this._format(n,new Date(2017,t,1)))))}return gE[t]}getDateNames(){if(dE){const t=new Intl.DateTimeFormat(this.locale,{day:"numeric",timeZone:"utc"});return fE(31,(n=>this._stripDirectionalityCharacters(this._format(t,new Date(2017,0,n+1)))))}return pE}getDayOfWeekNames(t){if(dE){const n=new Intl.DateTimeFormat(this.locale,{weekday:t,timeZone:"utc"});return fE(7,(t=>this._stripDirectionalityCharacters(this._format(n,new Date(2017,0,t+1)))))}return bE[t]}getYearName(t){if(dE){const n=new Intl.DateTimeFormat(this.locale,{year:"numeric",timeZone:"utc"});return this._stripDirectionalityCharacters(this._format(n,t))}return String(this.getYear(t))}getFirstDayOfWeek(){return 0}getNumDaysInMonth(t){return this.getDate(this._createDateWithOverflow(this.getYear(t),this.getMonth(t)+1,0))}clone(t){return new Date(t.getTime())}createDate(t,n,e){if("undefined"==typeof ngDevMode||ngDevMode){if(n<0||n>11)throw Error(`Invalid month index "${n}". Month index has to be between 0 and 11.`);if(e<1)throw Error(`Invalid date "${e}". Date has to be greater than 0.`)}let a=this._createDateWithOverflow(t,n,e);if(a.getMonth()!=n&&("undefined"==typeof ngDevMode||ngDevMode))throw Error(`Invalid date "${e}" for month with index "${n}".`);return a}today(){return new Date}parse(t){return"number"==typeof t?new Date(t):t?new Date(Date.parse(t)):null}format(t,n){if(!this.isValid(t))throw Error("NativeDateAdapter: Cannot format invalid date.");if(dE){this._clampDate&&(t.getFullYear()<1||t.getFullYear()>9999)&&(t=this.clone(t)).setFullYear(Math.max(1,Math.min(9999,t.getFullYear()))),n=Object.assign(Object.assign({},n),{timeZone:"utc"});const e=new Intl.DateTimeFormat(this.locale,n);return this._stripDirectionalityCharacters(this._format(e,t))}return this._stripDirectionalityCharacters(t.toDateString())}addCalendarYears(t,n){return this.addCalendarMonths(t,12*n)}addCalendarMonths(t,n){let e=this._createDateWithOverflow(this.getYear(t),this.getMonth(t)+n,this.getDate(t));return this.getMonth(e)!=((this.getMonth(t)+n)%12+12)%12&&(e=this._createDateWithOverflow(this.getYear(e),this.getMonth(e),0)),e}addCalendarDays(t,n){return this._createDateWithOverflow(this.getYear(t),this.getMonth(t),this.getDate(t)+n)}toIso8601(t){return[t.getUTCFullYear(),this._2digit(t.getUTCMonth()+1),this._2digit(t.getUTCDate())].join("-")}deserialize(t){if("string"==typeof t){if(!t)return null;if(uE.test(t)){let n=new Date(t);if(this.isValid(n))return n}}return super.deserialize(t)}isDateInstance(t){return t instanceof Date}isValid(t){return!isNaN(t.getTime())}invalid(){return new Date(NaN)}_createDateWithOverflow(t,n,e){const a=new Date;return a.setFullYear(t,n,e),a.setHours(0,0,0,0),a}_2digit(t){return("00"+t).slice(-2)}_stripDirectionalityCharacters(t){return t.replace(/[\u200e\u200f]/g,"")}_format(t,n){const e=new Date;return e.setUTCFullYear(n.getFullYear(),n.getMonth(),n.getDate()),e.setUTCHours(n.getHours(),n.getMinutes(),n.getSeconds(),n.getMilliseconds()),t.format(e)}}hE.ɵfac=function t(n){return new(n||hE)(Za(cE,8),Za(Sw))},hE.ɵprov=We({token:hE,factory:hE.ɵfac}),hE.ctorParameters=()=>[{type:String,decorators:[{type:Ne},{type:Ie,args:[cE]}]},{type:Sw}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class _E{}_E.ɵmod=xo({type:_E}),_E.ɵinj=Ge({factory:function t(n){return new(n||_E)},providers:[{provide:lE,useClass:hE}],imports:[[Ew]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(_E,{imports:function(){return[Ew]}});class CE{}CE.ɵmod=xo({type:CE}),CE.ɵinj=Ge({factory:function t(n){return new(n||CE)},providers:[{provide:mE,useValue:{parse:{dateInput:null},display:{dateInput:{year:"numeric",month:"numeric",day:"numeric"},monthYearLabel:{year:"numeric",month:"short"},dateA11yLabel:{year:"numeric",month:"long",day:"numeric"},monthYearA11yLabel:{year:"numeric",month:"long"}}}}],imports:[[_E]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(CE,{imports:[_E]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class ME{isErrorState(t,n){return!!(t&&t.invalid&&(t.dirty||n&&n.submitted))}}ME.ɵfac=function t(n){return new(n||ME)},ME.ɵprov=We({token:ME,factory:ME.ɵfac});class OE{isErrorState(t,n){return!!(t&&t.invalid&&(t.touched||n&&n.submitted))}}OE.ɵfac=function t(n){return new(n||OE)},OE.ɵprov=We({factory:function t(){return new OE},token:OE,providedIn:"root"});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class PE{}PE.ɵfac=function t(n){return new(n||PE)},PE.ɵdir=vo({type:PE,selectors:[["","mat-line",""],["","matLine",""]],hostAttrs:[1,"mat-line"]});class xE{}xE.ɵmod=xo({type:xE}),xE.ɵinj=Ge({factory:function t(n){return new(n||xE)},imports:[[tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(xE,{declarations:[PE],imports:[tE],exports:[PE,tE]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class yE{constructor(t,n,e){this._renderer=t,this.element=n,this.config=e,this.state=3}fadeOut(){this._renderer.fadeOutRipple(this)}}const kE={enterDuration:450,exitDuration:400},vE=Nw({passive:!0}),wE=["mousedown","touchstart"],SE=["mouseup","mouseleave","touchend","touchcancel"];class EE{constructor(t,n,e,a){this._target=t,this._ngZone=n,this._isPointerDown=!1,this._activeRipples=new Set,this._pointerUpEventsRegistered=!1,a.isBrowser&&(this._containerElement=Jw(e))}fadeInRipple(t,n,e={}){const a=this._containerRect=this._containerRect||this._containerElement.getBoundingClientRect(),o=Object.assign(Object.assign({},kE),e.animation);e.centered&&(t=a.left+a.width/2,n=a.top+a.height/2);const r=e.radius||(function i(t,n,e){const a=Math.max(Math.abs(t-e.left),Math.abs(t-e.right)),o=Math.max(Math.abs(n-e.top),Math.abs(n-e.bottom));return Math.sqrt(a*a+o*o)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t,n,a),c=t-a.left,s=n-a.top,l=o.enterDuration,m=document.createElement("div");m.classList.add("mat-ripple-element"),m.style.left=c-r+"px",m.style.top=s-r+"px",m.style.height=2*r+"px",m.style.width=2*r+"px",null!=e.color&&(m.style.backgroundColor=e.color),m.style.transitionDuration=`${l}ms`,this._containerElement.appendChild(m),(function d(t){window.getComputedStyle(t).getPropertyValue("opacity")})(m),m.style.transform="scale(1)";const g=new yE(this,m,e);return g.state=0,this._activeRipples.add(g),e.persistent||(this._mostRecentTransientRipple=g),this._runTimeoutOutsideZone((()=>{const t=g===this._mostRecentTransientRipple;g.state=1,e.persistent||t&&this._isPointerDown||g.fadeOut()}),l),g}fadeOutRipple(t){const n=this._activeRipples.delete(t);if(t===this._mostRecentTransientRipple&&(this._mostRecentTransientRipple=null),this._activeRipples.size||(this._containerRect=null),!n)return;const e=t.element,a=Object.assign(Object.assign({},kE),t.config.animation);e.style.transitionDuration=`${a.exitDuration}ms`,e.style.opacity="0",t.state=2,this._runTimeoutOutsideZone((()=>{t.state=3,e.parentNode.removeChild(e)}),a.exitDuration)}fadeOutAll(){this._activeRipples.forEach((t=>t.fadeOut()))}setupTriggerEvents(t){const n=Jw(t);n&&n!==this._triggerElement&&(this._removeTriggerEvents(),this._triggerElement=n,this._registerEvents(wE))}handleEvent(t){"mousedown"===t.type?this._onMousedown(t):"touchstart"===t.type?this._onTouchStart(t):this._onPointerUp(),this._pointerUpEventsRegistered||(this._registerEvents(SE),this._pointerUpEventsRegistered=!0)}_onMousedown(t){const n=AS(t),e=this._lastTouchStartEvent&&Date.now()<this._lastTouchStartEvent+800;this._target.rippleDisabled||n||e||(this._isPointerDown=!0,this.fadeInRipple(t.clientX,t.clientY,this._target.rippleConfig))}_onTouchStart(t){if(!this._target.rippleDisabled){this._lastTouchStartEvent=Date.now(),this._isPointerDown=!0;const n=t.changedTouches;for(let t=0;t<n.length;t++)this.fadeInRipple(n[t].clientX,n[t].clientY,this._target.rippleConfig)}}_onPointerUp(){this._isPointerDown&&(this._isPointerDown=!1,this._activeRipples.forEach((t=>{!t.config.persistent&&(1===t.state||t.config.terminateOnPointerUp&&0===t.state)&&t.fadeOut()})))}_runTimeoutOutsideZone(t,n=0){this._ngZone.runOutsideAngular((()=>setTimeout(t,n)))}_registerEvents(t){this._ngZone.runOutsideAngular((()=>{t.forEach((t=>{this._triggerElement.addEventListener(t,this,vE)}))}))}_removeTriggerEvents(){this._triggerElement&&(wE.forEach((t=>{this._triggerElement.removeEventListener(t,this,vE)})),this._pointerUpEventsRegistered&&SE.forEach((t=>{this._triggerElement.removeEventListener(t,this,vE)})))}}const AE=new Fa("mat-ripple-global-options");class zE{constructor(t,n,e,a,o){this._elementRef=t,this._animationMode=o,this.radius=0,this._disabled=!1,this._isInitialized=!1,this._globalOptions=a||{},this._rippleRenderer=new EE(this,n,t,e)}get disabled(){return this._disabled}set disabled(t){this._disabled=t,this._setupTriggerEventsIfEnabled()}get trigger(){return this._trigger||this._elementRef.nativeElement}set trigger(t){this._trigger=t,this._setupTriggerEventsIfEnabled()}ngOnInit(){this._isInitialized=!0,this._setupTriggerEventsIfEnabled()}ngOnDestroy(){this._rippleRenderer._removeTriggerEvents()}fadeOutAll(){this._rippleRenderer.fadeOutAll()}get rippleConfig(){return{centered:this.centered,radius:this.radius,color:this.color,animation:Object.assign(Object.assign(Object.assign({},this._globalOptions.animation),"NoopAnimations"===this._animationMode?{enterDuration:0,exitDuration:0}:{}),this.animation),terminateOnPointerUp:this._globalOptions.terminateOnPointerUp}}get rippleDisabled(){return this.disabled||!!this._globalOptions.disabled}_setupTriggerEventsIfEnabled(){!this.disabled&&this._isInitialized&&this._rippleRenderer.setupTriggerEvents(this.trigger)}launch(t,n=0,e){return"number"==typeof t?this._rippleRenderer.fadeInRipple(t,n,Object.assign(Object.assign({},this.rippleConfig),e)):this._rippleRenderer.fadeInRipple(0,0,Object.assign(Object.assign({},this.rippleConfig),t))}}zE.ɵfac=function t(n){return new(n||zE)(Zg(xu),Zg(J_),Zg(Sw),Zg(AE,8),Zg(dk,8))},zE.ɵdir=vo({type:zE,selectors:[["","mat-ripple",""],["","matRipple",""]],hostAttrs:[1,"mat-ripple"],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("mat-ripple-unbounded",e.unbounded)},inputs:{radius:["matRippleRadius","radius"],disabled:["matRippleDisabled","disabled"],trigger:["matRippleTrigger","trigger"],color:["matRippleColor","color"],unbounded:["matRippleUnbounded","unbounded"],centered:["matRippleCentered","centered"],animation:["matRippleAnimation","animation"]},exportAs:["matRipple"]}),zE.ctorParameters=()=>[{type:xu},{type:J_},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[AE]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],zE.propDecorators={color:[{type:f_,args:["matRippleColor"]}],unbounded:[{type:f_,args:["matRippleUnbounded"]}],centered:[{type:f_,args:["matRippleCentered"]}],radius:[{type:f_,args:["matRippleRadius"]}],animation:[{type:f_,args:["matRippleAnimation"]}],disabled:[{type:f_,args:["matRippleDisabled"]}],trigger:[{type:f_,args:["matRippleTrigger"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class RE{}RE.ɵmod=xo({type:RE}),RE.ɵinj=Ge({factory:function t(n){return new(n||RE)},imports:[[tE,Ew],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(RE,{declarations:function(){return[zE]},imports:function(){return[tE,Ew]},exports:function(){return[zE,tE]}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class TE{constructor(t){this._animationMode=t,this.state="unchecked",this.disabled=!1}}TE.ɵfac=function t(n){return new(n||TE)(Zg(dk,8))},TE.ɵcmp=_o({type:TE,selectors:[["mat-pseudo-checkbox"]],hostAttrs:[1,"mat-pseudo-checkbox"],hostVars:8,hostBindings:function t(n,e){2&n&&Dp("mat-pseudo-checkbox-indeterminate","indeterminate"===e.state)("mat-pseudo-checkbox-checked","checked"===e.state)("mat-pseudo-checkbox-disabled",e.disabled)("_mat-animation-noopable","NoopAnimations"===e._animationMode)},inputs:{state:"state",disabled:"disabled"},decls:0,vars:0,template:function t(n,e){},styles:['.mat-pseudo-checkbox{width:16px;height:16px;border:2px solid;border-radius:2px;cursor:pointer;display:inline-block;vertical-align:middle;box-sizing:border-box;position:relative;flex-shrink:0;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1),background-color 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox::after{position:absolute;opacity:0;content:"";border-bottom:2px solid currentColor;transition:opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}.mat-pseudo-checkbox.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox.mat-pseudo-checkbox-indeterminate{border-color:transparent}._mat-animation-noopable.mat-pseudo-checkbox{transition:none;animation:none}._mat-animation-noopable.mat-pseudo-checkbox::after{transition:none}.mat-pseudo-checkbox-disabled{cursor:default}.mat-pseudo-checkbox-indeterminate::after{top:5px;left:1px;width:10px;opacity:1;border-radius:2px}.mat-pseudo-checkbox-checked::after{top:2.4px;left:1px;width:8px;height:3px;border-left:2px solid currentColor;transform:rotate(-45deg);opacity:1;box-sizing:content-box}\n'],encapsulation:2,changeDetection:0}),TE.ctorParameters=()=>[{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],TE.propDecorators={state:[{type:f_}],disabled:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class DE{}DE.ɵmod=xo({type:DE}),DE.ɵinj=Ge({factory:function t(n){return new(n||DE)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(DE,{declarations:[TE],exports:[TE]});const IE=nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{});let NE=0;class FE extends IE{constructor(){super(...arguments),this._labelId="mat-optgroup-label-"+NE++}}FE.ɵfac=function t(n){return LE(n||FE)},FE.ɵdir=vo({type:FE,inputs:{label:"label"},features:[hg]}),FE.propDecorators={label:[{type:f_}]};const LE=tc(FE),HE=new Fa("MatOptgroup");class BE extends FE{}BE.ɵfac=function t(n){return VE(n||BE)},BE.ɵcmp=_o({type:BE,selectors:[["mat-optgroup"]],hostAttrs:["role","group",1,"mat-optgroup"],hostVars:4,hostBindings:function t(n,e){2&n&&(Ng("aria-disabled",e.disabled.toString())("aria-labelledby",e._labelId),Dp("mat-optgroup-disabled",e.disabled))},inputs:{disabled:"disabled"},exportAs:["matOptgroup"],features:[Mu([{provide:HE,useExisting:BE}]),hg],ngContentSelectors:["*","mat-option, ng-container"],decls:4,vars:2,consts:[[1,"mat-optgroup-label",3,"id"]],template:function t(n,e){1&n&&(bp(qS),Kg(0,"label",0),Jp(1),hp(2),$g(),hp(3,1)),2&n&&(Jg("id",e._labelId),ws(1),Kp("",e.label," "))},styles:[".mat-optgroup-label{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup-label[disabled]{cursor:default}[dir=rtl] .mat-optgroup-label{text-align:right}.mat-optgroup-label .mat-icon{margin-right:16px;vertical-align:middle}.mat-optgroup-label .mat-icon svg{vertical-align:top}[dir=rtl] .mat-optgroup-label .mat-icon{margin-left:16px;margin-right:0}\n"],encapsulation:2,changeDetection:0});const VE=tc(BE);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let jE=0;class UE{constructor(t,n=!1){this.source=t,this.isUserInput=n}}const WE=new Fa("MAT_OPTION_PARENT_COMPONENT");class GE{constructor(t,n,e,a){this._element=t,this._changeDetectorRef=n,this._parent=e,this.group=a,this._selected=!1,this._active=!1,this._disabled=!1,this._mostRecentViewValue="",this.id="mat-option-"+jE++,this.onSelectionChange=new Ef,this._stateChanges=new x}get multiple(){return this._parent&&this._parent.multiple}get selected(){return this._selected}get disabled(){return this.group&&this.group.disabled||this._disabled}set disabled(t){this._disabled=Gw(t)}get disableRipple(){return this._parent&&this._parent.disableRipple}get active(){return this._active}get viewValue(){return(this._getHostElement().textContent||"").trim()}select(){this._selected||(this._selected=!0,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}deselect(){this._selected&&(this._selected=!1,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent())}focus(t,n){const e=this._getHostElement();"function"==typeof e.focus&&e.focus(n)}setActiveStyles(){this._active||(this._active=!0,this._changeDetectorRef.markForCheck())}setInactiveStyles(){this._active&&(this._active=!1,this._changeDetectorRef.markForCheck())}getLabel(){return this.viewValue}_handleKeydown(t){t.keyCode!==Hw&&t.keyCode!==Vw||Ww(t)||(this._selectViaInteraction(),t.preventDefault())}_selectViaInteraction(){this.disabled||(this._selected=!this.multiple||!this._selected,this._changeDetectorRef.markForCheck(),this._emitSelectionChangeEvent(!0))}_getAriaSelected(){return this.selected||!this.multiple&&null}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._element.nativeElement}ngAfterViewChecked(){if(this._selected){const t=this.viewValue;t!==this._mostRecentViewValue&&(this._mostRecentViewValue=t,this._stateChanges.next())}}ngOnDestroy(){this._stateChanges.complete()}_emitSelectionChangeEvent(t=!1){this.onSelectionChange.emit(new UE(this,t))}}GE.ɵfac=function t(n){return new(n||GE)(Zg(xu),Zg(Vm),Zg(void 0),Zg(FE))},GE.ɵdir=vo({type:GE,inputs:{id:"id",disabled:"disabled",value:"value"},outputs:{onSelectionChange:"onSelectionChange"}}),GE.ctorParameters=()=>[{type:xu},{type:Vm},{type:void 0},{type:FE}],GE.propDecorators={value:[{type:f_}],id:[{type:f_}],disabled:[{type:f_}],onSelectionChange:[{type:h_}]};class YE extends GE{constructor(t,n,e,a){super(t,n,e,a)}}function qE(t,n,e){if(e.length){let a=n.toArray(),o=e.toArray(),r=0;for(let n=0;n<t+1;n++)a[n].group&&a[n].group===o[r]&&r++;return r}return 0}function ZE(t,n,e,a){return t<e?t:t+n>e+a?Math.max(0,t-a+n):e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */YE.ɵfac=function t(n){return new(n||YE)(Zg(xu),Zg(Vm),Zg(WE,8),Zg(HE,8))},YE.ɵcmp=_o({type:YE,selectors:[["mat-option"]],hostAttrs:["role","option",1,"mat-option","mat-focus-indicator"],hostVars:12,hostBindings:function t(n,e){1&n&&cp("click",(function t(){return e._selectViaInteraction()}))("keydown",(function t(n){return e._handleKeydown(n)})),2&n&&(eb("id",e.id),Ng("tabindex",e._getTabIndex())("aria-selected",e._getAriaSelected())("aria-disabled",e.disabled.toString()),Dp("mat-selected",e.selected)("mat-option-multiple",e.multiple)("mat-active",e.active)("mat-option-disabled",e.disabled))},exportAs:["matOption"],features:[hg],ngContentSelectors:["*"],decls:4,vars:3,consts:[["class","mat-option-pseudo-checkbox",3,"state","disabled",4,"ngIf"],[1,"mat-option-text"],["mat-ripple","",1,"mat-option-ripple",3,"matRippleTrigger","matRippleDisabled"],[1,"mat-option-pseudo-checkbox",3,"state","disabled"]],template:function t(n,e){1&n&&(bp(),Yg(0,ZS,1,2,"mat-pseudo-checkbox",0),Kg(1,"span",1),hp(2),$g(),tp(3,"div",2)),2&n&&(Jg("ngIf",e.multiple),ws(3),Jg("matRippleTrigger",e._getHostElement())("matRippleDisabled",e.disabled||e.disableRipple))},directives:[WM,zE,TE],styles:[".mat-option{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative;cursor:pointer;outline:none;display:flex;flex-direction:row;max-width:100%;box-sizing:border-box;align-items:center;-webkit-tap-highlight-color:transparent}.mat-option[disabled]{cursor:default}[dir=rtl] .mat-option{text-align:right}.mat-option .mat-icon{margin-right:16px;vertical-align:middle}.mat-option .mat-icon svg{vertical-align:top}[dir=rtl] .mat-option .mat-icon{margin-left:16px;margin-right:0}.mat-option[aria-disabled=true]{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:32px}[dir=rtl] .mat-optgroup .mat-option:not(.mat-option-multiple){padding-left:16px;padding-right:32px}.cdk-high-contrast-active .mat-option{margin:0 1px}.cdk-high-contrast-active .mat-option.mat-active{border:solid 1px currentColor;margin:0}.mat-option-text{display:inline-block;flex-grow:1;overflow:hidden;text-overflow:ellipsis}.mat-option .mat-option-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.cdk-high-contrast-active .mat-option .mat-option-ripple{opacity:.5}.mat-option-pseudo-checkbox{margin-right:8px}[dir=rtl] .mat-option-pseudo-checkbox{margin-left:8px;margin-right:0}\n"],encapsulation:2,changeDetection:0}),YE.ctorParameters=()=>[{type:xu},{type:Vm},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[WE]}]},{type:BE,decorators:[{type:Ne},{type:Ie,args:[HE]}]}];class XE{}XE.ɵmod=xo({type:XE}),XE.ɵinj=Ge({factory:function t(n){return new(n||XE)},imports:[[RE,PO,DE]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(XE,{declarations:function(){return[YE,BE]},imports:function(){return[RE,PO,DE]},exports:function(){return[YE,BE]}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const JE=new Fa("mat-label-global-options"),QE=["mat-button",""],KE=["*"],$E=".mat-button .mat-button-focus-overlay,.mat-icon-button .mat-button-focus-overlay{opacity:0}.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:.04}@media(hover: none){.mat-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay,.mat-stroked-button:hover:not(.mat-button-disabled) .mat-button-focus-overlay{opacity:0}}.mat-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-button.mat-button-disabled,.mat-icon-button.mat-button-disabled,.mat-stroked-button.mat-button-disabled,.mat-flat-button.mat-button-disabled{cursor:default}.mat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-button.cdk-program-focused .mat-button-focus-overlay,.mat-icon-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-icon-button.cdk-program-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-stroked-button.cdk-program-focused .mat-button-focus-overlay,.mat-flat-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-flat-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-button::-moz-focus-inner,.mat-icon-button::-moz-focus-inner,.mat-stroked-button::-moz-focus-inner,.mat-flat-button::-moz-focus-inner{border:0}.mat-raised-button{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1)}.mat-raised-button::-moz-focus-inner{border:0}.mat-raised-button.mat-button-disabled{cursor:default}.mat-raised-button.cdk-keyboard-focused .mat-button-focus-overlay,.mat-raised-button.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-raised-button::-moz-focus-inner{border:0}._mat-animation-noopable.mat-raised-button{transition:none;animation:none}.mat-stroked-button{border:1px solid currentColor;padding:0 15px;line-height:34px}.mat-stroked-button .mat-button-ripple.mat-ripple,.mat-stroked-button .mat-button-focus-overlay{top:-1px;left:-1px;right:-1px;bottom:-1px}.mat-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:56px;height:56px;padding:0;flex-shrink:0}.mat-fab::-moz-focus-inner{border:0}.mat-fab.mat-button-disabled{cursor:default}.mat-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-fab{transition:none;animation:none}.mat-fab .mat-button-wrapper{padding:16px 0;display:inline-block;line-height:24px}.mat-mini-fab{box-sizing:border-box;position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;display:inline-block;white-space:nowrap;text-decoration:none;vertical-align:baseline;text-align:center;margin:0;min-width:64px;line-height:36px;padding:0 16px;border-radius:4px;overflow:visible;transform:translate3d(0, 0, 0);transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);min-width:0;border-radius:50%;width:40px;height:40px;padding:0;flex-shrink:0}.mat-mini-fab::-moz-focus-inner{border:0}.mat-mini-fab.mat-button-disabled{cursor:default}.mat-mini-fab.cdk-keyboard-focused .mat-button-focus-overlay,.mat-mini-fab.cdk-program-focused .mat-button-focus-overlay{opacity:.12}.mat-mini-fab::-moz-focus-inner{border:0}._mat-animation-noopable.mat-mini-fab{transition:none;animation:none}.mat-mini-fab .mat-button-wrapper{padding:8px 0;display:inline-block;line-height:24px}.mat-icon-button{padding:0;min-width:0;width:40px;height:40px;flex-shrink:0;line-height:40px;border-radius:50%}.mat-icon-button i,.mat-icon-button .mat-icon{line-height:24px}.mat-button-ripple.mat-ripple,.mat-button-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit}.mat-button-ripple.mat-ripple:not(:empty){transform:translateZ(0)}.mat-button-focus-overlay{opacity:0;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1),background-color 200ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable .mat-button-focus-overlay{transition:none}.mat-button-ripple-round{border-radius:50%;z-index:1}.mat-button .mat-button-wrapper>*,.mat-flat-button .mat-button-wrapper>*,.mat-stroked-button .mat-button-wrapper>*,.mat-raised-button .mat-button-wrapper>*,.mat-icon-button .mat-button-wrapper>*,.mat-fab .mat-button-wrapper>*,.mat-mini-fab .mat-button-wrapper>*{vertical-align:middle}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button{display:block;font-size:inherit;width:2.5em;height:2.5em}.cdk-high-contrast-active .mat-button,.cdk-high-contrast-active .mat-flat-button,.cdk-high-contrast-active .mat-raised-button,.cdk-high-contrast-active .mat-icon-button,.cdk-high-contrast-active .mat-fab,.cdk-high-contrast-active .mat-mini-fab{outline:solid 1px}.cdk-high-contrast-active .mat-button-base.cdk-keyboard-focused,.cdk-high-contrast-active .mat-button-base.cdk-program-focused{outline:solid 3px}\n",tA=["mat-button","mat-flat-button","mat-icon-button","mat-raised-button","mat-stroked-button","mat-mini-fab","mat-fab"],nA=eE(nE(aE(class{constructor(t){this._elementRef=t}})));class eA extends nA{constructor(t,n,e){super(t),this._focusMonitor=n,this._animationMode=e,this.isRoundButton=this._hasHostAttributes("mat-fab","mat-mini-fab"),this.isIconButton=this._hasHostAttributes("mat-icon-button");for(const t of tA)this._hasHostAttributes(t)&&this._getHostElement().classList.add(t);t.nativeElement.classList.add("mat-button-base"),this.isRoundButton&&(this.color="accent")}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}focus(t="program",n){this._focusMonitor.focusVia(this._getHostElement(),t,n)}_getHostElement(){return this._elementRef.nativeElement}_isRippleDisabled(){return this.disableRipple||this.disabled}_hasHostAttributes(...t){return t.some((t=>this._getHostElement().hasAttribute(t)))}}eA.ɵfac=function t(n){return new(n||eA)(Zg(xu),Zg(TS),Zg(dk,8))},eA.ɵcmp=_o({type:eA,selectors:[["button","mat-button",""],["button","mat-raised-button",""],["button","mat-icon-button",""],["button","mat-fab",""],["button","mat-mini-fab",""],["button","mat-stroked-button",""],["button","mat-flat-button",""]],viewQuery:function t(n,e){var a;1&n&&Uf(zE,!0),2&n&&Vf(a=Zf())&&(e.ripple=a.first)},hostAttrs:[1,"mat-focus-indicator"],hostVars:5,hostBindings:function t(n,e){2&n&&(Ng("disabled",e.disabled||null),Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode)("mat-button-disabled",e.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color"},exportAs:["matButton"],features:[hg],attrs:QE,ngContentSelectors:KE,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function t(n,e){1&n&&(bp(),Kg(0,"span",0),hp(1),$g(),tp(2,"span",1),tp(3,"span",2)),2&n&&(ws(2),Dp("mat-button-ripple-round",e.isRoundButton||e.isIconButton),Jg("matRippleDisabled",e._isRippleDisabled())("matRippleCentered",e.isIconButton)("matRippleTrigger",e._getHostElement()))},directives:[zE],styles:[$E],encapsulation:2,changeDetection:0}),eA.ctorParameters=()=>[{type:xu},{type:TS},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],eA.propDecorators={ripple:[{type:Xd,args:[zE]}]};class aA extends eA{constructor(t,n,e){super(n,t,e)}_haltDisabledEvents(t){this.disabled&&(t.preventDefault(),t.stopImmediatePropagation())}}aA.ɵfac=function t(n){return new(n||aA)(Zg(TS),Zg(xu),Zg(dk,8))},aA.ɵcmp=_o({type:aA,selectors:[["a","mat-button",""],["a","mat-raised-button",""],["a","mat-icon-button",""],["a","mat-fab",""],["a","mat-mini-fab",""],["a","mat-stroked-button",""],["a","mat-flat-button",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:7,hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e._haltDisabledEvents(n)})),2&n&&(Ng("tabindex",e.disabled?-1:e.tabIndex||0)("disabled",e.disabled||null)("aria-disabled",e.disabled.toString()),Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode)("mat-button-disabled",e.disabled))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex"},exportAs:["matButton","matAnchor"],features:[hg],attrs:QE,ngContentSelectors:KE,decls:4,vars:5,consts:[[1,"mat-button-wrapper"],["matRipple","",1,"mat-button-ripple",3,"matRippleDisabled","matRippleCentered","matRippleTrigger"],[1,"mat-button-focus-overlay"]],template:function t(n,e){1&n&&(bp(),Kg(0,"span",0),hp(1),$g(),tp(2,"span",1),tp(3,"span",2)),2&n&&(ws(2),Dp("mat-button-ripple-round",e.isRoundButton||e.isIconButton),Jg("matRippleDisabled",e._isRippleDisabled())("matRippleCentered",e.isIconButton)("matRippleTrigger",e._getHostElement()))},directives:[zE],styles:[$E],encapsulation:2,changeDetection:0}),aA.ctorParameters=()=>[{type:TS},{type:xu},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],aA.propDecorators={tabIndex:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class oA{}oA.ɵmod=xo({type:oA}),oA.ɵinj=Ge({factory:function t(n){return new(n||oA)},imports:[[RE,tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(oA,{declarations:function(){return[eA,aA]},imports:function(){return[RE,tE]},exports:function(){return[eA,aA,tE]}});class rA{}function iA(t){return t&&"function"==typeof t.connect}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class cA extends rA{constructor(t){super(),this._data=t}connect(){return pt(this._data)?this._data:Z(this._data)}disconnect(){}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class sA{applyChanges(t,n,e,a,o){t.forEachOperation(((t,a,r)=>{let i,c;if(null==t.previousIndex){const o=e(t,a,r);i=n.createEmbeddedView(o.templateRef,o.context,o.index),c=1}else null==r?(n.remove(a),c=3):(i=n.get(a),n.move(i,r),c=2);o&&o({context:null==i?void 0:i.context,operation:c,record:t})}))}detach(){}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class lA{constructor(){this.viewCacheSize=20,this._viewCache=[]}applyChanges(t,n,e,a,o){t.forEachOperation(((t,r,i)=>{let c,s;null==t.previousIndex?(c=this._insertView((()=>e(t,r,i)),i,n,a(t)),s=c?1:0):null==i?(this._detachAndCacheView(r,n),s=3):(c=this._moveView(r,i,n,a(t)),s=2),o&&o({context:null==c?void 0:c.context,operation:s,record:t})}))}detach(){for(const t of this._viewCache)t.destroy()}_insertView(t,n,e,a){let o=this._insertViewFromCache(n,e);if(o)return void(o.context.$implicit=a);const r=t();return e.createEmbeddedView(r.templateRef,r.context,r.index)}_detachAndCacheView(t,n){const e=this._detachView(t,n);this._maybeCacheView(e,n)}_moveView(t,n,e,a){const o=e.get(t);return e.move(o,n),o.context.$implicit=a,o}_maybeCacheView(t,n){if(this._viewCache.length<this.viewCacheSize)this._viewCache.push(t);else{const e=n.indexOf(t);-1===e?t.destroy():n.remove(e)}}_insertViewFromCache(t,n){const e=this._viewCache.pop();return e&&n.insert(e,t),e||null}_detachView(t,n){return n.detach(t)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class mA{constructor(t=!1,n,e=!0){this._multiple=t,this._emitChanges=e,this._selection=new Set,this._deselectedToEmit=[],this._selectedToEmit=[],this.changed=new x,n&&n.length&&(t?n.forEach((t=>this._markSelected(t))):this._markSelected(n[0]),this._selectedToEmit.length=0)}get selected(){return this._selected||(this._selected=Array.from(this._selection.values())),this._selected}select(...t){this._verifyValueAssignment(t),t.forEach((t=>this._markSelected(t))),this._emitChangeEvent()}deselect(...t){this._verifyValueAssignment(t),t.forEach((t=>this._unmarkSelected(t))),this._emitChangeEvent()}toggle(t){this.isSelected(t)?this.deselect(t):this.select(t)}clear(){this._unmarkAll(),this._emitChangeEvent()}isSelected(t){return this._selection.has(t)}isEmpty(){return 0===this._selection.size}hasValue(){return!this.isEmpty()}sort(t){this._multiple&&this.selected&&this._selected.sort(t)}isMultipleSelection(){return this._multiple}_emitChangeEvent(){this._selected=null,(this._selectedToEmit.length||this._deselectedToEmit.length)&&(this.changed.next({source:this,added:this._selectedToEmit,removed:this._deselectedToEmit}),this._deselectedToEmit=[],this._selectedToEmit=[])}_markSelected(t){this.isSelected(t)||(this._multiple||this._unmarkAll(),this._selection.add(t),this._emitChanges&&this._selectedToEmit.push(t))}_unmarkSelected(t){this.isSelected(t)&&(this._selection.delete(t),this._emitChanges&&this._deselectedToEmit.push(t))}_unmarkAll(){this.isEmpty()||this._selection.forEach((t=>this._unmarkSelected(t)))}_verifyValueAssignment(t){if(t.length>1&&!this._multiple&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("Cannot pass multiple values into SelectionModel with single-value mode.")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)()}}class dA{constructor(){this._listeners=[]}notify(t,n){for(let e of this._listeners)e(t,n)}listen(t){return this._listeners.push(t),()=>{this._listeners=this._listeners.filter((n=>t!==n))}}ngOnDestroy(){this._listeners=[]}}dA.ɵfac=function t(n){return new(n||dA)},dA.ɵprov=We({factory:function t(){return new dA},token:dA,providedIn:"root"});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const gA=new Fa("_ViewRepeater"),pA=["contentWrapper"],bA=new Fa("VIRTUAL_SCROLL_STRATEGY");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class uA{constructor(t,n,e){this._scrolledIndexChange=new x,this.scrolledIndexChange=this._scrolledIndexChange.pipe(vn()),this._viewport=null,this._itemSize=t,this._minBufferPx=n,this._maxBufferPx=e}attach(t){this._viewport=t,this._updateTotalContentSize(),this._updateRenderedRange()}detach(){this._scrolledIndexChange.complete(),this._viewport=null}updateItemAndBufferSize(t,n,e){if(e<n&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("CDK virtual scroll: maxBufferPx must be greater than or equal to minBufferPx");this._itemSize=t,this._minBufferPx=n,this._maxBufferPx=e,this._updateTotalContentSize(),this._updateRenderedRange()}onContentScrolled(){this._updateRenderedRange()}onDataLengthChanged(){this._updateTotalContentSize(),this._updateRenderedRange()}onContentRendered(){}onRenderedOffsetChanged(){}scrollToIndex(t,n){this._viewport&&this._viewport.scrollToOffset(t*this._itemSize,n)}_updateTotalContentSize(){this._viewport&&this._viewport.setTotalContentSize(this._viewport.getDataLength()*this._itemSize)}_updateRenderedRange(){if(!this._viewport)return;const t=this._viewport.getRenderedRange(),n={start:t.start,end:t.end},e=this._viewport.getViewportSize(),a=this._viewport.getDataLength();let o=this._viewport.measureScrollOffset(),r=o/this._itemSize;if(n.end>a){const t=Math.ceil(e/this._itemSize),i=Math.max(0,Math.min(r,a-t));r!=i&&(r=i,o=i*this._itemSize,n.start=Math.floor(r)),n.end=Math.max(0,Math.min(a,n.start+t))}const i=o-n.start*this._itemSize;if(i<this._minBufferPx&&0!=n.start){const t=Math.ceil((this._maxBufferPx-i)/this._itemSize);n.start=Math.max(0,n.start-t),n.end=Math.min(a,Math.ceil(r+(e+this._minBufferPx)/this._itemSize))}else{const t=n.end*this._itemSize-(o+e);if(t<this._minBufferPx&&n.end!=a){const e=Math.ceil((this._maxBufferPx-t)/this._itemSize);e>0&&(n.end=Math.min(a,n.end+e),n.start=Math.max(0,Math.floor(r-this._minBufferPx/this._itemSize)))}}this._viewport.setRenderedRange(n),this._viewport.setRenderedContentOffset(this._itemSize*n.start),this._scrolledIndexChange.next(Math.floor(r))}}class fA{constructor(){this._itemSize=20,this._minBufferPx=100,this._maxBufferPx=200,this._scrollStrategy=new uA(this.itemSize,this.minBufferPx,this.maxBufferPx)}get itemSize(){return this._itemSize}set itemSize(t){this._itemSize=Yw(t)}get minBufferPx(){return this._minBufferPx}set minBufferPx(t){this._minBufferPx=Yw(t)}get maxBufferPx(){return this._maxBufferPx}set maxBufferPx(t){this._maxBufferPx=Yw(t)}ngOnChanges(){this._scrollStrategy.updateItemAndBufferSize(this.itemSize,this.minBufferPx,this.maxBufferPx)}}fA.ɵfac=function t(n){return new(n||fA)},fA.ɵdir=vo({type:fA,selectors:[["cdk-virtual-scroll-viewport","itemSize",""]],inputs:{itemSize:"itemSize",minBufferPx:"minBufferPx",maxBufferPx:"maxBufferPx"},features:[Mu([{provide:bA,useFactory:function hA(t){return t._scrollStrategy},deps:[aa((()=>fA))]}]),pr]}),fA.propDecorators={itemSize:[{type:f_}],minBufferPx:[{type:f_}],maxBufferPx:[{type:f_}]};class _A{constructor(t,n,e){this._ngZone=t,this._platform=n,this._scrolled=new x,this._globalSubscription=null,this._scrolledCount=0,this.scrollContainers=new Map,this._document=e}register(t){this.scrollContainers.has(t)||this.scrollContainers.set(t,t.elementScrolled().subscribe((()=>this._scrolled.next(t))))}deregister(t){const n=this.scrollContainers.get(t);n&&(n.unsubscribe(),this.scrollContainers.delete(t))}scrolled(t=20){return this._platform.isBrowser?new _((n=>{this._globalSubscription||this._addGlobalListener();const e=t>0?this._scrolled.pipe(an(t)).subscribe(n):this._scrolled.subscribe(n);return this._scrolledCount++,()=>{e.unsubscribe(),this._scrolledCount--,this._scrolledCount||this._removeGlobalListener()}})):Z()}ngOnDestroy(){this._removeGlobalListener(),this.scrollContainers.forEach(((t,n)=>this.deregister(n))),this._scrolled.complete()}ancestorScrolled(t,n){const e=this.getAncestorScrollContainers(t);return this.scrolled(n).pipe(Gt((t=>!t||e.indexOf(t)>-1)))}getAncestorScrollContainers(t){const n=[];return this.scrollContainers.forEach(((e,a)=>{this._scrollableContainsElement(a,t)&&n.push(a)})),n}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_scrollableContainsElement(t,n){let e=n.nativeElement,a=t.getElementRef().nativeElement;do{if(e==a)return!0}while(e=e.parentElement);return!1}_addGlobalListener(){this._globalSubscription=this._ngZone.runOutsideAngular((()=>Vt(this._getWindow().document,"scroll").subscribe((()=>this._scrolled.next()))))}_removeGlobalListener(){this._globalSubscription&&(this._globalSubscription.unsubscribe(),this._globalSubscription=null)}}_A.ɵfac=function t(n){return new(n||_A)(Za(J_),Za(Sw),Za(zC,8))},_A.ɵprov=We({factory:function t(){return new _A(Za(J_),Za(Sw),Za(zC,8))},token:_A,providedIn:"root"}),_A.ctorParameters=()=>[{type:J_},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class CA{constructor(t,n,e,a){this.elementRef=t,this.scrollDispatcher=n,this.ngZone=e,this.dir=a,this._destroyed=new x,this._elementScrolled=new _((t=>this.ngZone.runOutsideAngular((()=>Vt(this.elementRef.nativeElement,"scroll").pipe(de(this._destroyed)).subscribe(t)))))}ngOnInit(){this.scrollDispatcher.register(this)}ngOnDestroy(){this.scrollDispatcher.deregister(this),this._destroyed.next(),this._destroyed.complete()}elementScrolled(){return this._elementScrolled}getElementRef(){return this.elementRef}scrollTo(t){const n=this.elementRef.nativeElement,e=this.dir&&"rtl"==this.dir.value;null==t.left&&(t.left=e?t.end:t.start),null==t.right&&(t.right=e?t.start:t.end),null!=t.bottom&&(t.top=n.scrollHeight-n.clientHeight-t.bottom),e&&0!=Fw()?(null!=t.left&&(t.right=n.scrollWidth-n.clientWidth-t.left),2==Fw()?t.left=t.right:1==Fw()&&(t.left=t.right?-t.right:t.right)):null!=t.right&&(t.left=n.scrollWidth-n.clientWidth-t.right),this._applyScrollToOptions(t)}_applyScrollToOptions(t){const n=this.elementRef.nativeElement;!(function e(){if(null==Dw)if("object"==typeof document&&document||(Dw=!1),"scrollBehavior"in document.documentElement.style)Dw=!0;else{const t=Element.prototype.scrollTo;Dw=!!t&&!/\{\s*\[native code\]\s*\}/.test(t.toString())}return Dw})()?(null!=t.top&&(n.scrollTop=t.top),null!=t.left&&(n.scrollLeft=t.left)):n.scrollTo(t)}measureScrollOffset(t){const n="left",e="right",a=this.elementRef.nativeElement;if("top"==t)return a.scrollTop;if("bottom"==t)return a.scrollHeight-a.clientHeight-a.scrollTop;const o=this.dir&&"rtl"==this.dir.value;return"start"==t?t=o?e:n:"end"==t&&(t=o?n:e),o&&2==Fw()?t==n?a.scrollWidth-a.clientWidth-a.scrollLeft:a.scrollLeft:o&&1==Fw()?t==n?a.scrollLeft+a.scrollWidth-a.clientWidth:-a.scrollLeft:t==n?a.scrollLeft:a.scrollWidth-a.clientWidth-a.scrollLeft}}CA.ɵfac=function t(n){return new(n||CA)(Zg(xu),Zg(_A),Zg(J_),Zg(US,8))},CA.ɵdir=vo({type:CA,selectors:[["","cdk-scrollable",""],["","cdkScrollable",""]]}),CA.ctorParameters=()=>[{type:xu},{type:_A},{type:J_},{type:US,decorators:[{type:Ne}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class MA{constructor(t,n,e){this._platform=t,this._change=new x,this._changeListener=t=>{this._change.next(t)},this._document=e,n.runOutsideAngular((()=>{if(t.isBrowser){const t=this._getWindow();t.addEventListener("resize",this._changeListener),t.addEventListener("orientationchange",this._changeListener)}this.change().subscribe((()=>this._updateViewportSize()))}))}ngOnDestroy(){if(this._platform.isBrowser){const t=this._getWindow();t.removeEventListener("resize",this._changeListener),t.removeEventListener("orientationchange",this._changeListener)}this._change.complete()}getViewportSize(){this._viewportSize||this._updateViewportSize();const t={width:this._viewportSize.width,height:this._viewportSize.height};return this._platform.isBrowser||(this._viewportSize=null),t}getViewportRect(){const t=this.getViewportScrollPosition(),{width:n,height:e}=this.getViewportSize();return{top:t.top,left:t.left,bottom:t.top+e,right:t.left+n,height:e,width:n}}getViewportScrollPosition(){if(!this._platform.isBrowser)return{top:0,left:0};const t=this._getDocument(),n=this._getWindow(),e=t.documentElement,a=e.getBoundingClientRect();return{top:-a.top||t.body.scrollTop||n.scrollY||e.scrollTop||0,left:-a.left||t.body.scrollLeft||n.scrollX||e.scrollLeft||0}}change(t=20){return t>0?this._change.pipe(an(t)):this._change}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_updateViewportSize(){const t=this._getWindow();this._viewportSize=this._platform.isBrowser?{width:t.innerWidth,height:t.innerHeight}:{width:0,height:0}}}MA.ɵfac=function t(n){return new(n||MA)(Za(Sw),Za(J_),Za(zC,8))},MA.ɵprov=We({factory:function t(){return new MA(Za(Sw),Za(J_),Za(zC,8))},token:MA,providedIn:"root"}),MA.ctorParameters=()=>[{type:Sw},{type:J_},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const OA="undefined"!=typeof requestAnimationFrame?dt:lt;class PA extends CA{constructor(t,n,e,a,o,r,i){if(super(t,r,e,o),this.elementRef=t,this._changeDetectorRef=n,this._scrollStrategy=a,this._detachedSubject=new x,this._renderedRangeSubject=new x,this._orientation="vertical",this.scrolledIndexChange=new _((t=>this._scrollStrategy.scrolledIndexChange.subscribe((n=>Promise.resolve().then((()=>this.ngZone.run((()=>t.next(n))))))))),this.renderedRangeStream=this._renderedRangeSubject,this._totalContentSize=0,this._totalContentWidth="",this._totalContentHeight="",this._renderedRange={start:0,end:0},this._dataLength=0,this._viewportSize=0,this._renderedContentOffset=0,this._renderedContentOffsetNeedsRewrite=!1,this._isChangeDetectionPending=!1,this._runAfterChangeDetection=[],this._viewportChanges=s.EMPTY,!a&&("undefined"==typeof ngDevMode||ngDevMode))throw Error('Error: cdk-virtual-scroll-viewport requires the "itemSize" property to be set.');i&&(this._viewportChanges=i.change().subscribe((()=>{this.checkViewportSize()})))}get orientation(){return this._orientation}set orientation(t){this._orientation!==t&&(this._orientation=t,this._calculateSpacerSize())}ngOnInit(){super.ngOnInit(),this.ngZone.runOutsideAngular((()=>Promise.resolve().then((()=>{this._measureViewportSize(),this._scrollStrategy.attach(this),this.elementScrolled().pipe(ce(null),an(0,OA)).subscribe((()=>this._scrollStrategy.onContentScrolled())),this._markChangeDetectionNeeded()}))))}ngOnDestroy(){this.detach(),this._scrollStrategy.detach(),this._renderedRangeSubject.complete(),this._detachedSubject.complete(),this._viewportChanges.unsubscribe(),super.ngOnDestroy()}attach(t){if(this._forOf&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("CdkVirtualScrollViewport is already attached.");this.ngZone.runOutsideAngular((()=>{this._forOf=t,this._forOf.dataStream.pipe(de(this._detachedSubject)).subscribe((t=>{const n=t.length;n!==this._dataLength&&(this._dataLength=n,this._scrollStrategy.onDataLengthChanged()),this._doChangeDetection()}))}))}detach(){this._forOf=null,this._detachedSubject.next()}getDataLength(){return this._dataLength}getViewportSize(){return this._viewportSize}getRenderedRange(){return this._renderedRange}setTotalContentSize(t){this._totalContentSize!==t&&(this._totalContentSize=t,this._calculateSpacerSize(),this._markChangeDetectionNeeded())}setRenderedRange(t){(function n(t,e){return t.start==e.start&&t.end==e.end})(this._renderedRange,t)||(this._renderedRangeSubject.next(this._renderedRange=t),this._markChangeDetectionNeeded((()=>this._scrollStrategy.onContentRendered())))}getOffsetToRenderedContentStart(){return this._renderedContentOffsetNeedsRewrite?null:this._renderedContentOffset}setRenderedContentOffset(t,n="to-start"){const e="horizontal"==this.orientation,a=e?"X":"Y";let o=`translate${a}(${Number((e&&this.dir&&"rtl"==this.dir.value?-1:1)*t)}px)`;this._renderedContentOffset=t,"to-end"===n&&(o+=` translate${a}(-100%)`,this._renderedContentOffsetNeedsRewrite=!0),this._renderedContentTransform!=o&&(this._renderedContentTransform=o,this._markChangeDetectionNeeded((()=>{this._renderedContentOffsetNeedsRewrite?(this._renderedContentOffset-=this.measureRenderedContentSize(),this._renderedContentOffsetNeedsRewrite=!1,this.setRenderedContentOffset(this._renderedContentOffset)):this._scrollStrategy.onRenderedOffsetChanged()})))}scrollToOffset(t,n="auto"){const e={behavior:n};"horizontal"===this.orientation?e.start=t:e.top=t,this.scrollTo(e)}scrollToIndex(t,n="auto"){this._scrollStrategy.scrollToIndex(t,n)}measureScrollOffset(t){return super.measureScrollOffset(t||("horizontal"===this.orientation?"start":"top"))}measureRenderedContentSize(){const t=this._contentWrapper.nativeElement;return"horizontal"===this.orientation?t.offsetWidth:t.offsetHeight}measureRangeSize(t){return this._forOf?this._forOf.measureRangeSize(t,this.orientation):0}checkViewportSize(){this._measureViewportSize(),this._scrollStrategy.onDataLengthChanged()}_measureViewportSize(){const t=this.elementRef.nativeElement;this._viewportSize="horizontal"===this.orientation?t.clientWidth:t.clientHeight}_markChangeDetectionNeeded(t){t&&this._runAfterChangeDetection.push(t),this._isChangeDetectionPending||(this._isChangeDetectionPending=!0,this.ngZone.runOutsideAngular((()=>Promise.resolve().then((()=>{this._doChangeDetection()})))))}_doChangeDetection(){this._isChangeDetectionPending=!1,this._contentWrapper.nativeElement.style.transform=this._renderedContentTransform,this.ngZone.run((()=>this._changeDetectorRef.markForCheck()));const t=this._runAfterChangeDetection;this._runAfterChangeDetection=[];for(const n of t)n()}_calculateSpacerSize(){this._totalContentHeight="horizontal"===this.orientation?"":`${this._totalContentSize}px`,this._totalContentWidth="horizontal"===this.orientation?`${this._totalContentSize}px`:""}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function xA(t,n,e){if(!e.getBoundingClientRect)return 0;const a=e.getBoundingClientRect();return"horizontal"===t?"start"===n?a.left:a.right:"start"===n?a.top:a.bottom}PA.ɵfac=function t(n){return new(n||PA)(Zg(xu),Zg(Vm),Zg(J_),Zg(bA,8),Zg(US,8),Zg(_A),Zg(MA))},PA.ɵcmp=_o({type:PA,selectors:[["cdk-virtual-scroll-viewport"]],viewQuery:function t(n,e){var a;1&n&&jf(pA,!0),2&n&&Vf(a=Zf())&&(e._contentWrapper=a.first)},hostAttrs:[1,"cdk-virtual-scroll-viewport"],hostVars:4,hostBindings:function t(n,e){2&n&&Dp("cdk-virtual-scroll-orientation-horizontal","horizontal"===e.orientation)("cdk-virtual-scroll-orientation-vertical","horizontal"!==e.orientation)},inputs:{orientation:"orientation"},outputs:{scrolledIndexChange:"scrolledIndexChange"},features:[Mu([{provide:CA,useExisting:PA}]),hg],ngContentSelectors:["*"],decls:4,vars:4,consts:[[1,"cdk-virtual-scroll-content-wrapper"],["contentWrapper",""],[1,"cdk-virtual-scroll-spacer"]],template:function t(n,e){1&n&&(bp(),Kg(0,"div",0,1),hp(2),$g(),tp(3,"div",2)),2&n&&(ws(3),Tp("width",e._totalContentWidth)("height",e._totalContentHeight))},styles:["cdk-virtual-scroll-viewport{display:block;position:relative;overflow:auto;contain:strict;transform:translateZ(0);will-change:scroll-position;-webkit-overflow-scrolling:touch}.cdk-virtual-scroll-content-wrapper{position:absolute;top:0;left:0;contain:content}[dir=rtl] .cdk-virtual-scroll-content-wrapper{right:0;left:auto}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper{min-height:100%}.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-horizontal .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-left:0;padding-right:0;margin-left:0;margin-right:0;border-left-width:0;border-right-width:0;outline:none}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper{min-width:100%}.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>dl:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ol:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>table:not([cdkVirtualFor]),.cdk-virtual-scroll-orientation-vertical .cdk-virtual-scroll-content-wrapper>ul:not([cdkVirtualFor]){padding-top:0;padding-bottom:0;margin-top:0;margin-bottom:0;border-top-width:0;border-bottom-width:0;outline:none}.cdk-virtual-scroll-spacer{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0}[dir=rtl] .cdk-virtual-scroll-spacer{right:0;left:auto;transform-origin:100% 0}\n"],encapsulation:2,changeDetection:0}),PA.ctorParameters=()=>[{type:xu},{type:Vm},{type:J_},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[bA]}]},{type:US,decorators:[{type:Ne}]},{type:_A},{type:MA}],PA.propDecorators={orientation:[{type:f_}],scrolledIndexChange:[{type:h_}],_contentWrapper:[{type:Xd,args:["contentWrapper",{static:!0}]}]};class yA{constructor(t,n,e,a,o,r){this._viewContainerRef=t,this._template=n,this._differs=e,this._viewRepeater=a,this._viewport=o,this.viewChange=new x,this._dataSourceChanges=new x,this.dataStream=this._dataSourceChanges.pipe(ce(null),(function i(){return t=>t.lift(new Qn)})(),se((([t,n])=>this._changeDataSource(t,n))),ae(1)),this._differ=null,this._needsUpdate=!1,this._destroyed=new x,this.dataStream.subscribe((t=>{this._data=t,this._onRenderedDataChange()})),this._viewport.renderedRangeStream.pipe(de(this._destroyed)).subscribe((t=>{this._renderedRange=t,r.run((()=>this.viewChange.next(this._renderedRange))),this._onRenderedDataChange()})),this._viewport.attach(this)}get cdkVirtualForOf(){return this._cdkVirtualForOf}set cdkVirtualForOf(t){this._cdkVirtualForOf=t,iA(t)?this._dataSourceChanges.next(t):this._dataSourceChanges.next(new cA(pt(t)?t:Array.from(t||[])))}get cdkVirtualForTrackBy(){return this._cdkVirtualForTrackBy}set cdkVirtualForTrackBy(t){this._needsUpdate=!0,this._cdkVirtualForTrackBy=t?(n,e)=>t(n+(this._renderedRange?this._renderedRange.start:0),e):void 0}set cdkVirtualForTemplate(t){t&&(this._needsUpdate=!0,this._template=t)}get cdkVirtualForTemplateCacheSize(){return this._viewRepeater.viewCacheSize}set cdkVirtualForTemplateCacheSize(t){this._viewRepeater.viewCacheSize=Yw(t)}measureRangeSize(t,n){if(t.start>=t.end)return 0;if((t.start<this._renderedRange.start||t.end>this._renderedRange.end)&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("Error: attempted to measure an item that isn't rendered.");const e=t.start-this._renderedRange.start,a=t.end-t.start;let o,r;for(let t=0;t<a;t++){const n=this._viewContainerRef.get(t+e);if(n&&n.rootNodes.length){o=r=n.rootNodes[0];break}}for(let t=a-1;t>-1;t--){const n=this._viewContainerRef.get(t+e);if(n&&n.rootNodes.length){r=n.rootNodes[n.rootNodes.length-1];break}}return o&&r?xA(n,"end",r)-xA(n,"start",o):0}ngDoCheck(){if(this._differ&&this._needsUpdate){const t=this._differ.diff(this._renderedItems);t?this._applyChanges(t):this._updateContext(),this._needsUpdate=!1}}ngOnDestroy(){this._viewport.detach(),this._dataSourceChanges.next(void 0),this._dataSourceChanges.complete(),this.viewChange.complete(),this._destroyed.next(),this._destroyed.complete(),this._viewRepeater.detach()}_onRenderedDataChange(){this._renderedRange&&(this._renderedItems=this._data.slice(this._renderedRange.start,this._renderedRange.end),this._differ||(this._differ=this._differs.find(this._renderedItems).create(this.cdkVirtualForTrackBy)),this._needsUpdate=!0)}_changeDataSource(t,n){return t&&t.disconnect(this),this._needsUpdate=!0,n?n.connect(this):Z()}_updateContext(){const t=this._data.length;let n=this._viewContainerRef.length;for(;n--;){let e=this._viewContainerRef.get(n);e.context.index=this._renderedRange.start+n,e.context.count=t,this._updateComputedContextProperties(e.context),e.detectChanges()}}_applyChanges(t){this._viewRepeater.applyChanges(t,this._viewContainerRef,((t,n,e)=>this._getEmbeddedViewArgs(t,e)),(t=>t.item)),t.forEachIdentityChange((t=>{this._viewContainerRef.get(t.currentIndex).context.$implicit=t.item}));const n=this._data.length;let e=this._viewContainerRef.length;for(;e--;){const t=this._viewContainerRef.get(e);t.context.index=this._renderedRange.start+e,t.context.count=n,this._updateComputedContextProperties(t.context)}}_updateComputedContextProperties(t){t.first=0===t.index,t.last=t.index===t.count-1,t.even=t.index%2==0,t.odd=!t.even}_getEmbeddedViewArgs(t,n){return{templateRef:this._template,context:{$implicit:t.item,cdkVirtualForOf:this._cdkVirtualForOf,index:-1,count:-1,first:!1,last:!1,odd:!1,even:!1},index:n}}}yA.ɵfac=function t(n){return new(n||yA)(Zg($u),Zg(Ju),Zg(Wu),Zg(gA),Zg(PA,4),Zg(J_))},yA.ɵdir=vo({type:yA,selectors:[["","cdkVirtualFor","","cdkVirtualForOf",""]],inputs:{cdkVirtualForOf:"cdkVirtualForOf",cdkVirtualForTrackBy:"cdkVirtualForTrackBy",cdkVirtualForTemplate:"cdkVirtualForTemplate",cdkVirtualForTemplateCacheSize:"cdkVirtualForTemplateCacheSize"},features:[Mu([{provide:gA,useClass:lA}])]}),yA.ctorParameters=()=>[{type:$u},{type:Ju},{type:Wu},{type:lA,decorators:[{type:Ie,args:[gA]}]},{type:PA,decorators:[{type:Le}]},{type:J_}],yA.propDecorators={cdkVirtualForOf:[{type:f_}],cdkVirtualForTrackBy:[{type:f_}],cdkVirtualForTemplate:[{type:f_}],cdkVirtualForTemplateCacheSize:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class kA{}kA.ɵmod=xo({type:kA}),kA.ɵinj=Ge({factory:function t(n){return new(n||kA)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(kA,{declarations:[CA],exports:[CA]});class vA{}function wA(){throw Error("Host already has a portal attached")}vA.ɵmod=xo({type:vA}),vA.ɵinj=Ge({factory:function t(n){return new(n||vA)},imports:[[GS,Ew,kA],GS,kA]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(vA,{declarations:function(){return[fA,yA,PA]},imports:function(){return[GS,Ew,kA]},exports:function(){return[GS,kA,fA,yA,PA]}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class SA{attach(t){return("undefined"==typeof ngDevMode||ngDevMode)&&(null==t&&(function n(){throw Error("Attempting to attach a portal to a null PortalOutlet")})(),t.hasAttached()&&wA()),this._attachedHost=t,t.attach(this)}detach(){let t=this._attachedHost;null!=t?(this._attachedHost=null,t.detach()):("undefined"==typeof ngDevMode||ngDevMode)&&(function n(){throw Error("Attempting to detach a portal that is not attached to a host")})()}get isAttached(){return null!=this._attachedHost}setAttachedHost(t){this._attachedHost=t}}class EA extends SA{constructor(t,n,e,a){super(),this.component=t,this.viewContainerRef=n,this.injector=e,this.componentFactoryResolver=a}}class AA extends SA{constructor(t,n,e){super(),this.templateRef=t,this.viewContainerRef=n,this.context=e}get origin(){return this.templateRef.elementRef}attach(t,n=this.context){return this.context=n,super.attach(t)}detach(){return this.context=void 0,super.detach()}}class zA extends SA{constructor(t){super(),this.element=t instanceof xu?t.nativeElement:t}}class RA{constructor(){this._isDisposed=!1,this.attachDomPortal=null}hasAttached(){return!!this._attachedPortal}attach(t){return("undefined"==typeof ngDevMode||ngDevMode)&&(t||(function n(){throw Error("Must provide a portal to attach")})(),this.hasAttached()&&wA(),this._isDisposed&&(function e(){throw Error("This PortalOutlet has already been disposed")})()),t instanceof EA?(this._attachedPortal=t,this.attachComponentPortal(t)):t instanceof AA?(this._attachedPortal=t,this.attachTemplatePortal(t)):this.attachDomPortal&&t instanceof zA?(this._attachedPortal=t,this.attachDomPortal(t)):void(("undefined"==typeof ngDevMode||ngDevMode)&&(function a(){throw Error("Attempting to attach an unknown Portal type. BasePortalOutlet accepts either a ComponentPortal or a TemplatePortal.")})())}detach(){this._attachedPortal&&(this._attachedPortal.setAttachedHost(null),this._attachedPortal=null),this._invokeDisposeFn()}dispose(){this.hasAttached()&&this.detach(),this._invokeDisposeFn(),this._isDisposed=!0}setDisposeFn(t){this._disposeFn=t}_invokeDisposeFn(){this._disposeFn&&(this._disposeFn(),this._disposeFn=null)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class TA extends RA{constructor(t,n,e,a,o){super(),this.outletElement=t,this._componentFactoryResolver=n,this._appRef=e,this._defaultInjector=a,this.attachDomPortal=t=>{if(!this._document&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("Cannot attach DOM portal without _document constructor parameter");const n=t.element;if(!n.parentNode&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("DOM portal content must be attached to a parent node.");const e=this._document.createComment("dom-portal");n.parentNode.insertBefore(e,n),this.outletElement.appendChild(n),super.setDisposeFn((()=>{e.parentNode&&e.parentNode.replaceChild(n,e)}))},this._document=o}attachComponentPortal(t){const n=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component);let e;return t.viewContainerRef?(e=t.viewContainerRef.createComponent(n,t.viewContainerRef.length,t.injector||t.viewContainerRef.injector),this.setDisposeFn((()=>e.destroy()))):(e=n.create(t.injector||this._defaultInjector),this._appRef.attachView(e.hostView),this.setDisposeFn((()=>{this._appRef.detachView(e.hostView),e.destroy()}))),this.outletElement.appendChild(this._getComponentRootNode(e)),e}attachTemplatePortal(t){let n=t.viewContainerRef,e=n.createEmbeddedView(t.templateRef,t.context);return e.rootNodes.forEach((t=>this.outletElement.appendChild(t))),e.detectChanges(),this.setDisposeFn((()=>{let t=n.indexOf(e);-1!==t&&n.remove(t)})),e}dispose(){super.dispose(),null!=this.outletElement.parentNode&&this.outletElement.parentNode.removeChild(this.outletElement)}_getComponentRootNode(t){return t.hostView.rootNodes[0]}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class DA extends AA{constructor(t,n){super(t,n)}}DA.ɵfac=function t(n){return new(n||DA)(Zg(Ju),Zg($u))},DA.ɵdir=vo({type:DA,selectors:[["","cdkPortal",""]],exportAs:["cdkPortal"],features:[hg]}),DA.ctorParameters=()=>[{type:Ju},{type:$u}];class IA extends DA{}IA.ɵfac=function t(n){return NA(n||IA)},IA.ɵdir=vo({type:IA,selectors:[["","cdk-portal",""],["","portal",""]],exportAs:["cdkPortal"],features:[Mu([{provide:DA,useExisting:IA}]),hg]});const NA=tc(IA);class FA extends RA{constructor(t,n,e){super(),this._componentFactoryResolver=t,this._viewContainerRef=n,this._isInitialized=!1,this.attached=new Ef,this.attachDomPortal=t=>{if(!this._document&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("Cannot attach DOM portal without _document constructor parameter");const n=t.element;if(!n.parentNode&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("DOM portal content must be attached to a parent node.");const e=this._document.createComment("dom-portal");t.setAttachedHost(this),n.parentNode.insertBefore(e,n),this._getRootNode().appendChild(n),super.setDisposeFn((()=>{e.parentNode&&e.parentNode.replaceChild(n,e)}))},this._document=e}get portal(){return this._attachedPortal}set portal(t){(!this.hasAttached()||t||this._isInitialized)&&(this.hasAttached()&&super.detach(),t&&super.attach(t),this._attachedPortal=t)}get attachedRef(){return this._attachedRef}ngOnInit(){this._isInitialized=!0}ngOnDestroy(){super.dispose(),this._attachedPortal=null,this._attachedRef=null}attachComponentPortal(t){t.setAttachedHost(this);const n=null!=t.viewContainerRef?t.viewContainerRef:this._viewContainerRef,e=(t.componentFactoryResolver||this._componentFactoryResolver).resolveComponentFactory(t.component),a=n.createComponent(e,n.length,t.injector||n.injector);return n!==this._viewContainerRef&&this._getRootNode().appendChild(a.hostView.rootNodes[0]),super.setDisposeFn((()=>a.destroy())),this._attachedPortal=t,this._attachedRef=a,this.attached.emit(a),a}attachTemplatePortal(t){t.setAttachedHost(this);const n=this._viewContainerRef.createEmbeddedView(t.templateRef,t.context);return super.setDisposeFn((()=>this._viewContainerRef.clear())),this._attachedPortal=t,this._attachedRef=n,this.attached.emit(n),n}_getRootNode(){const t=this._viewContainerRef.element.nativeElement;return t.nodeType===t.ELEMENT_NODE?t:t.parentNode}}FA.ɵfac=function t(n){return new(n||FA)(Zg(Pu),Zg($u),Zg(zC))},FA.ɵdir=vo({type:FA,selectors:[["","cdkPortalOutlet",""]],inputs:{portal:["cdkPortalOutlet","portal"]},outputs:{attached:"attached"},exportAs:["cdkPortalOutlet"],features:[hg]}),FA.ctorParameters=()=>[{type:Pu},{type:$u},{type:void 0,decorators:[{type:Ie,args:[zC]}]}],FA.propDecorators={attached:[{type:h_}]};class LA extends FA{}LA.ɵfac=function t(n){return HA(n||LA)},LA.ɵdir=vo({type:LA,selectors:[["","cdkPortalHost",""],["","portalHost",""]],inputs:{portal:["cdkPortalHost","portal"]},exportAs:["cdkPortalHost"],features:[Mu([{provide:FA,useExisting:LA}]),hg]});const HA=tc(LA);class BA{}BA.ɵmod=xo({type:BA}),BA.ɵinj=Ge({factory:function t(n){return new(n||BA)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(BA,{declarations:[DA,FA,IA,LA],exports:[DA,FA,IA,LA]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class VA{constructor(t,n){this._viewportRuler=t,this._previousHTMLStyles={top:"",left:""},this._isEnabled=!1,this._document=n}attach(){}enable(){if(this._canBeEnabled()){const t=this._document.documentElement;this._previousScrollPosition=this._viewportRuler.getViewportScrollPosition(),this._previousHTMLStyles.left=t.style.left||"",this._previousHTMLStyles.top=t.style.top||"",t.style.left=Xw(-this._previousScrollPosition.left),t.style.top=Xw(-this._previousScrollPosition.top),t.classList.add("cdk-global-scrollblock"),this._isEnabled=!0}}disable(){if(this._isEnabled){const t=this._document.documentElement,n=t.style,e=this._document.body.style,a=n.scrollBehavior||"",o=e.scrollBehavior||"";this._isEnabled=!1,n.left=this._previousHTMLStyles.left,n.top=this._previousHTMLStyles.top,t.classList.remove("cdk-global-scrollblock"),n.scrollBehavior=e.scrollBehavior="auto",window.scroll(this._previousScrollPosition.left,this._previousScrollPosition.top),n.scrollBehavior=a,e.scrollBehavior=o}}_canBeEnabled(){if(this._document.documentElement.classList.contains("cdk-global-scrollblock")||this._isEnabled)return!1;const t=this._document.body,n=this._viewportRuler.getViewportSize();return t.scrollHeight>n.height||t.scrollWidth>n.width}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function jA(){return Error("Scroll strategy has already been attached.")}class UA{constructor(t,n,e,a){this._scrollDispatcher=t,this._ngZone=n,this._viewportRuler=e,this._config=a,this._scrollSubscription=null,this._detach=()=>{this.disable(),this._overlayRef.hasAttached()&&this._ngZone.run((()=>this._overlayRef.detach()))}}attach(t){if(this._overlayRef&&("undefined"==typeof ngDevMode||ngDevMode))throw jA();this._overlayRef=t}enable(){if(this._scrollSubscription)return;const t=this._scrollDispatcher.scrolled(0);this._config&&this._config.threshold&&this._config.threshold>1?(this._initialScrollPosition=this._viewportRuler.getViewportScrollPosition().top,this._scrollSubscription=t.subscribe((()=>{const t=this._viewportRuler.getViewportScrollPosition().top;Math.abs(t-this._initialScrollPosition)>this._config.threshold?this._detach():this._overlayRef.updatePosition()}))):this._scrollSubscription=t.subscribe(this._detach)}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class WA{enable(){}disable(){}attach(){}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function GA(t,n){return n.some((n=>t.bottom<n.top||t.top>n.bottom||t.right<n.left||t.left>n.right))}function YA(t,n){return n.some((n=>t.top<n.top||t.bottom>n.bottom||t.left<n.left||t.right>n.right))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class qA{constructor(t,n,e,a){this._scrollDispatcher=t,this._viewportRuler=n,this._ngZone=e,this._config=a,this._scrollSubscription=null}attach(t){if(this._overlayRef&&("undefined"==typeof ngDevMode||ngDevMode))throw jA();this._overlayRef=t}enable(){this._scrollSubscription||(this._scrollSubscription=this._scrollDispatcher.scrolled(this._config?this._config.scrollThrottle:0).subscribe((()=>{if(this._overlayRef.updatePosition(),this._config&&this._config.autoClose){const t=this._overlayRef.overlayElement.getBoundingClientRect(),{width:n,height:e}=this._viewportRuler.getViewportSize();GA(t,[{width:n,height:e,bottom:e,right:n,top:0,left:0}])&&(this.disable(),this._ngZone.run((()=>this._overlayRef.detach())))}})))}disable(){this._scrollSubscription&&(this._scrollSubscription.unsubscribe(),this._scrollSubscription=null)}detach(){this.disable(),this._overlayRef=null}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class ZA{constructor(t,n,e,a){this._scrollDispatcher=t,this._viewportRuler=n,this._ngZone=e,this.noop=()=>new WA,this.close=t=>new UA(this._scrollDispatcher,this._ngZone,this._viewportRuler,t),this.block=()=>new VA(this._viewportRuler,this._document),this.reposition=t=>new qA(this._scrollDispatcher,this._viewportRuler,this._ngZone,t),this._document=a}}ZA.ɵfac=function t(n){return new(n||ZA)(Za(_A),Za(MA),Za(J_),Za(zC))},ZA.ɵprov=We({factory:function t(){return new ZA(Za(_A),Za(MA),Za(J_),Za(zC))},token:ZA,providedIn:"root"}),ZA.ctorParameters=()=>[{type:_A},{type:MA},{type:J_},{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class XA{constructor(t){if(this.scrollStrategy=new WA,this.panelClass="",this.hasBackdrop=!1,this.backdropClass="cdk-overlay-dark-backdrop",this.disposeOnNavigation=!1,t){const n=Object.keys(t);for(const e of n)void 0!==t[e]&&(this[e]=t[e])}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class JA{constructor(t,n,e,a,o){this.offsetX=e,this.offsetY=a,this.panelClass=o,this.originX=t.originX,this.originY=t.originY,this.overlayX=n.overlayX,this.overlayY=n.overlayY}}class QA{}class KA{constructor(t,n){this.connectionPair=t,this.scrollableViewProperties=n}}function $A(t,n){if("top"!==n&&"bottom"!==n&&"center"!==n)throw Error(`ConnectedPosition: Invalid ${t} "${n}". Expected "top", "bottom" or "center".`)}function tz(t,n){if("start"!==n&&"end"!==n&&"center"!==n)throw Error(`ConnectedPosition: Invalid ${t} "${n}". Expected "start", "end" or "center".`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */KA.ctorParameters=()=>[{type:JA},{type:QA,decorators:[{type:Ne}]}];class nz{constructor(t){this._attachedOverlays=[],this._document=t}ngOnDestroy(){this.detach()}add(t){this.remove(t),this._attachedOverlays.push(t)}remove(t){const n=this._attachedOverlays.indexOf(t);n>-1&&this._attachedOverlays.splice(n,1),0===this._attachedOverlays.length&&this.detach()}}nz.ɵfac=function t(n){return new(n||nz)(Za(zC))},nz.ɵprov=We({factory:function t(){return new nz(Za(zC))},token:nz,providedIn:"root"}),nz.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class ez extends nz{constructor(t){super(t),this._keydownListener=t=>{const n=this._attachedOverlays;for(let e=n.length-1;e>-1;e--)if(n[e]._keydownEvents.observers.length>0){n[e]._keydownEvents.next(t);break}}}add(t){super.add(t),this._isAttached||(this._document.body.addEventListener("keydown",this._keydownListener),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("keydown",this._keydownListener),this._isAttached=!1)}}ez.ɵfac=function t(n){return new(n||ez)(Za(zC))},ez.ɵprov=We({factory:function t(){return new ez(Za(zC))},token:ez,providedIn:"root"}),ez.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}],new Ne,new Le;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class az extends nz{constructor(t,n){super(t),this._platform=n,this._cursorStyleIsSet=!1,this._clickListener=t=>{const n=t.composedPath?t.composedPath()[0]:t.target,e=this._attachedOverlays.slice();for(let a=e.length-1;a>-1;a--){const o=e[a];if(!(o._outsidePointerEvents.observers.length<1)&&o.hasAttached()){if(o.overlayElement.contains(n))break;o._outsidePointerEvents.next(t)}}}}add(t){super.add(t),this._isAttached||(this._document.body.addEventListener("click",this._clickListener,!0),this._document.body.addEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&!this._cursorStyleIsSet&&(this._cursorOriginalValue=this._document.body.style.cursor,this._document.body.style.cursor="pointer",this._cursorStyleIsSet=!0),this._isAttached=!0)}detach(){this._isAttached&&(this._document.body.removeEventListener("click",this._clickListener,!0),this._document.body.removeEventListener("contextmenu",this._clickListener,!0),this._platform.IOS&&this._cursorStyleIsSet&&(this._document.body.style.cursor=this._cursorOriginalValue,this._cursorStyleIsSet=!1),this._isAttached=!1)}}az.ɵfac=function t(n){return new(n||az)(Za(zC),Za(Sw))},az.ɵprov=We({factory:function t(){return new az(Za(zC),Za(Sw))},token:az,providedIn:"root"}),az.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const oz=!("undefined"==typeof window||!window||!window.__karma__&&!window.jasmine);class rz{constructor(t,n){this._platform=n,this._document=t}ngOnDestroy(){const t=this._containerElement;t&&t.parentNode&&t.parentNode.removeChild(t)}getContainerElement(){return this._containerElement||this._createContainer(),this._containerElement}_createContainer(){const t=this._platform?this._platform.isBrowser:"undefined"!=typeof window,n="cdk-overlay-container";if(t||oz){const t=this._document.querySelectorAll(`.${n}[platform="server"], .${n}[platform="test"]`);for(let n=0;n<t.length;n++)t[n].parentNode.removeChild(t[n])}const e=this._document.createElement("div");e.classList.add(n),oz?e.setAttribute("platform","test"):t||e.setAttribute("platform","server"),this._document.body.appendChild(e),this._containerElement=e}}rz.ɵfac=function t(n){return new(n||rz)(Za(zC),Za(Sw))},rz.ɵprov=We({factory:function t(){return new rz(Za(zC),Za(Sw))},token:rz,providedIn:"root"}),rz.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw}],new Ne,new Le;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class iz{constructor(t,n,e,a,o,r,i,c,l){this._portalOutlet=t,this._host=n,this._pane=e,this._config=a,this._ngZone=o,this._keyboardDispatcher=r,this._document=i,this._location=c,this._outsideClickDispatcher=l,this._backdropElement=null,this._backdropClick=new x,this._attachments=new x,this._detachments=new x,this._locationChanges=s.EMPTY,this._backdropClickHandler=t=>this._backdropClick.next(t),this._keydownEvents=new x,this._outsidePointerEvents=new x,a.scrollStrategy&&(this._scrollStrategy=a.scrollStrategy,this._scrollStrategy.attach(this)),this._positionStrategy=a.positionStrategy}get overlayElement(){return this._pane}get backdropElement(){return this._backdropElement}get hostElement(){return this._host}attach(t){let n=this._portalOutlet.attach(t);return!this._host.parentElement&&this._previousHostParent&&this._previousHostParent.appendChild(this._host),this._positionStrategy&&this._positionStrategy.attach(this),this._updateStackingOrder(),this._updateElementSize(),this._updateElementDirection(),this._scrollStrategy&&this._scrollStrategy.enable(),this._ngZone.onStable.pipe(Tn(1)).subscribe((()=>{this.hasAttached()&&this.updatePosition()})),this._togglePointerEvents(!0),this._config.hasBackdrop&&this._attachBackdrop(),this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!0),this._attachments.next(),this._keyboardDispatcher.add(this),this._config.disposeOnNavigation&&this._location&&(this._locationChanges=this._location.subscribe((()=>this.dispose()))),this._outsideClickDispatcher&&this._outsideClickDispatcher.add(this),n}detach(){if(!this.hasAttached())return;this.detachBackdrop(),this._togglePointerEvents(!1),this._positionStrategy&&this._positionStrategy.detach&&this._positionStrategy.detach(),this._scrollStrategy&&this._scrollStrategy.disable();const t=this._portalOutlet.detach();return this._detachments.next(),this._keyboardDispatcher.remove(this),this._detachContentWhenStable(),this._locationChanges.unsubscribe(),this._outsideClickDispatcher&&this._outsideClickDispatcher.remove(this),t}dispose(){const t=this.hasAttached();this._positionStrategy&&this._positionStrategy.dispose(),this._disposeScrollStrategy(),this.detachBackdrop(),this._locationChanges.unsubscribe(),this._keyboardDispatcher.remove(this),this._portalOutlet.dispose(),this._attachments.complete(),this._backdropClick.complete(),this._keydownEvents.complete(),this._outsidePointerEvents.complete(),this._outsideClickDispatcher&&this._outsideClickDispatcher.remove(this),this._host&&this._host.parentNode&&(this._host.parentNode.removeChild(this._host),this._host=null),this._previousHostParent=this._pane=null,t&&this._detachments.next(),this._detachments.complete()}hasAttached(){return this._portalOutlet.hasAttached()}backdropClick(){return this._backdropClick}attachments(){return this._attachments}detachments(){return this._detachments}keydownEvents(){return this._keydownEvents}outsidePointerEvents(){return this._outsidePointerEvents}getConfig(){return this._config}updatePosition(){this._positionStrategy&&this._positionStrategy.apply()}updatePositionStrategy(t){t!==this._positionStrategy&&(this._positionStrategy&&this._positionStrategy.dispose(),this._positionStrategy=t,this.hasAttached()&&(t.attach(this),this.updatePosition()))}updateSize(t){this._config=Object.assign(Object.assign({},this._config),t),this._updateElementSize()}setDirection(t){this._config=Object.assign(Object.assign({},this._config),{direction:t}),this._updateElementDirection()}addPanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!0)}removePanelClass(t){this._pane&&this._toggleClasses(this._pane,t,!1)}getDirection(){const t=this._config.direction;return t?"string"==typeof t?t:t.value:"ltr"}updateScrollStrategy(t){t!==this._scrollStrategy&&(this._disposeScrollStrategy(),this._scrollStrategy=t,this.hasAttached()&&(t.attach(this),t.enable()))}_updateElementDirection(){this._host.setAttribute("dir",this.getDirection())}_updateElementSize(){if(!this._pane)return;const t=this._pane.style;t.width=Xw(this._config.width),t.height=Xw(this._config.height),t.minWidth=Xw(this._config.minWidth),t.minHeight=Xw(this._config.minHeight),t.maxWidth=Xw(this._config.maxWidth),t.maxHeight=Xw(this._config.maxHeight)}_togglePointerEvents(t){this._pane.style.pointerEvents=t?"auto":"none"}_attachBackdrop(){const t="cdk-overlay-backdrop-showing";this._backdropElement=this._document.createElement("div"),this._backdropElement.classList.add("cdk-overlay-backdrop"),this._config.backdropClass&&this._toggleClasses(this._backdropElement,this._config.backdropClass,!0),this._host.parentElement.insertBefore(this._backdropElement,this._host),this._backdropElement.addEventListener("click",this._backdropClickHandler),"undefined"!=typeof requestAnimationFrame?this._ngZone.runOutsideAngular((()=>{requestAnimationFrame((()=>{this._backdropElement&&this._backdropElement.classList.add(t)}))})):this._backdropElement.classList.add(t)}_updateStackingOrder(){this._host.nextSibling&&this._host.parentNode.appendChild(this._host)}detachBackdrop(){let t,n=this._backdropElement;if(!n)return;let e=()=>{n&&(n.removeEventListener("click",this._backdropClickHandler),n.removeEventListener("transitionend",e),n.parentNode&&n.parentNode.removeChild(n)),this._backdropElement==n&&(this._backdropElement=null),this._config.backdropClass&&this._toggleClasses(n,this._config.backdropClass,!1),clearTimeout(t)};n.classList.remove("cdk-overlay-backdrop-showing"),this._ngZone.runOutsideAngular((()=>{n.addEventListener("transitionend",e)})),n.style.pointerEvents="none",t=this._ngZone.runOutsideAngular((()=>setTimeout(e,500)))}_toggleClasses(t,n,e){const a=t.classList;Zw(n).forEach((t=>{t&&(e?a.add(t):a.remove(t))}))}_detachContentWhenStable(){this._ngZone.runOutsideAngular((()=>{const t=this._ngZone.onStable.pipe(de(Wt(this._attachments,this._detachments))).subscribe((()=>{this._pane&&this._host&&0!==this._pane.children.length||(this._pane&&this._config.panelClass&&this._toggleClasses(this._pane,this._config.panelClass,!1),this._host&&this._host.parentElement&&(this._previousHostParent=this._host.parentElement,this._previousHostParent.removeChild(this._host)),t.unsubscribe())}))}))}_disposeScrollStrategy(){const t=this._scrollStrategy;t&&(t.disable(),t.detach&&t.detach())}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const cz="cdk-overlay-connected-position-bounding-box",sz=/([A-Za-z%]+)$/;class lz{constructor(t,n,e,a,o){this._viewportRuler=n,this._document=e,this._platform=a,this._overlayContainer=o,this._lastBoundingBoxSize={width:0,height:0},this._isPushed=!1,this._canPush=!0,this._growAfterOpen=!1,this._hasFlexibleDimensions=!0,this._positionLocked=!1,this._viewportMargin=0,this._scrollables=[],this._preferredPositions=[],this._positionChanges=new x,this._resizeSubscription=s.EMPTY,this._offsetX=0,this._offsetY=0,this._appliedPanelClasses=[],this.positionChanges=this._positionChanges,this.setOrigin(t)}get positions(){return this._preferredPositions}attach(t){if(this._overlayRef&&t!==this._overlayRef&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("This position strategy is already attached to an overlay");this._validatePositions(),t.hostElement.classList.add(cz),this._overlayRef=t,this._boundingBox=t.hostElement,this._pane=t.overlayElement,this._isDisposed=!1,this._isInitialRender=!0,this._lastPosition=null,this._resizeSubscription.unsubscribe(),this._resizeSubscription=this._viewportRuler.change().subscribe((()=>{this._isInitialRender=!0,this.apply()}))}apply(){if(this._isDisposed||!this._platform.isBrowser)return;if(!this._isInitialRender&&this._positionLocked&&this._lastPosition)return void this.reapplyLastPosition();this._clearPanelClasses(),this._resetOverlayElementStyles(),this._resetBoundingBoxStyles(),this._viewportRect=this._getNarrowedViewportRect(),this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect();const t=this._originRect,n=this._overlayRect,e=this._viewportRect,a=[];let o;for(let r of this._preferredPositions){let i=this._getOriginPoint(t,r),c=this._getOverlayPoint(i,n,r),s=this._getOverlayFit(c,n,e,r);if(s.isCompletelyWithinViewport)return this._isPushed=!1,void this._applyPosition(r,i);this._canFitWithFlexibleDimensions(s,c,e)?a.push({position:r,origin:i,overlayRect:n,boundingBoxRect:this._calculateBoundingBoxRect(i,r)}):(!o||o.overlayFit.visibleArea<s.visibleArea)&&(o={overlayFit:s,overlayPoint:c,originPoint:i,position:r,overlayRect:n})}if(a.length){let t=null,n=-1;for(const e of a){const a=e.boundingBoxRect.width*e.boundingBoxRect.height*(e.position.weight||1);a>n&&(n=a,t=e)}return this._isPushed=!1,void this._applyPosition(t.position,t.origin)}if(this._canPush)return this._isPushed=!0,void this._applyPosition(o.position,o.originPoint);this._applyPosition(o.position,o.originPoint)}detach(){this._clearPanelClasses(),this._lastPosition=null,this._previousPushAmount=null,this._resizeSubscription.unsubscribe()}dispose(){this._isDisposed||(this._boundingBox&&mz(this._boundingBox.style,{top:"",left:"",right:"",bottom:"",height:"",width:"",alignItems:"",justifyContent:""}),this._pane&&this._resetOverlayElementStyles(),this._overlayRef&&this._overlayRef.hostElement.classList.remove(cz),this.detach(),this._positionChanges.complete(),this._overlayRef=this._boundingBox=null,this._isDisposed=!0)}reapplyLastPosition(){if(!this._isDisposed&&(!this._platform||this._platform.isBrowser)){this._originRect=this._getOriginRect(),this._overlayRect=this._pane.getBoundingClientRect(),this._viewportRect=this._getNarrowedViewportRect();const t=this._lastPosition||this._preferredPositions[0],n=this._getOriginPoint(this._originRect,t);this._applyPosition(t,n)}}withScrollableContainers(t){return this._scrollables=t,this}withPositions(t){return this._preferredPositions=t,-1===t.indexOf(this._lastPosition)&&(this._lastPosition=null),this._validatePositions(),this}withViewportMargin(t){return this._viewportMargin=t,this}withFlexibleDimensions(t=!0){return this._hasFlexibleDimensions=t,this}withGrowAfterOpen(t=!0){return this._growAfterOpen=t,this}withPush(t=!0){return this._canPush=t,this}withLockedPosition(t=!0){return this._positionLocked=t,this}setOrigin(t){return this._origin=t,this}withDefaultOffsetX(t){return this._offsetX=t,this}withDefaultOffsetY(t){return this._offsetY=t,this}withTransformOriginOn(t){return this._transformOriginSelector=t,this}_getOriginPoint(t,n){let e,a;if("center"==n.originX)e=t.left+t.width/2;else{const a=this._isRtl()?t.right:t.left,o=this._isRtl()?t.left:t.right;e="start"==n.originX?a:o}return a="center"==n.originY?t.top+t.height/2:"top"==n.originY?t.top:t.bottom,{x:e,y:a}}_getOverlayPoint(t,n,e){let a,o;return a="center"==e.overlayX?-n.width/2:"start"===e.overlayX?this._isRtl()?-n.width:0:this._isRtl()?0:-n.width,o="center"==e.overlayY?-n.height/2:"top"==e.overlayY?0:-n.height,{x:t.x+a,y:t.y+o}}_getOverlayFit(t,n,e,a){let{x:o,y:r}=t,i=this._getOffset(a,"x"),c=this._getOffset(a,"y");i&&(o+=i),c&&(r+=c);let s=0-r,l=r+n.height-e.height,m=this._subtractOverflows(n.width,0-o,o+n.width-e.width),d=this._subtractOverflows(n.height,s,l),g=m*d;return{visibleArea:g,isCompletelyWithinViewport:n.width*n.height===g,fitsInViewportVertically:d===n.height,fitsInViewportHorizontally:m==n.width}}_canFitWithFlexibleDimensions(t,n,e){if(this._hasFlexibleDimensions){const a=e.bottom-n.y,o=e.right-n.x,r=dz(this._overlayRef.getConfig().minHeight),i=dz(this._overlayRef.getConfig().minWidth),c=t.fitsInViewportHorizontally||null!=i&&i<=o;return(t.fitsInViewportVertically||null!=r&&r<=a)&&c}return!1}_pushOverlayOnScreen(t,n,e){if(this._previousPushAmount&&this._positionLocked)return{x:t.x+this._previousPushAmount.x,y:t.y+this._previousPushAmount.y};const a=this._viewportRect,o=Math.max(t.x+n.width-a.width,0),r=Math.max(t.y+n.height-a.height,0),i=Math.max(a.top-e.top-t.y,0),c=Math.max(a.left-e.left-t.x,0);let s=0,l=0;return s=n.width<=a.width?c||-o:t.x<this._viewportMargin?a.left-e.left-t.x:0,l=n.height<=a.height?i||-r:t.y<this._viewportMargin?a.top-e.top-t.y:0,this._previousPushAmount={x:s,y:l},{x:t.x+s,y:t.y+l}}_applyPosition(t,n){if(this._setTransformOrigin(t),this._setOverlayElementStyles(n,t),this._setBoundingBoxStyles(n,t),t.panelClass&&this._addPanelClasses(t.panelClass),this._lastPosition=t,this._positionChanges.observers.length){const n=this._getScrollVisibility(),e=new KA(t,n);this._positionChanges.next(e)}this._isInitialRender=!1}_setTransformOrigin(t){if(!this._transformOriginSelector)return;const n=this._boundingBox.querySelectorAll(this._transformOriginSelector);let e,a=t.overlayY;e="center"===t.overlayX?"center":this._isRtl()?"start"===t.overlayX?"right":"left":"start"===t.overlayX?"left":"right";for(let t=0;t<n.length;t++)n[t].style.transformOrigin=`${e} ${a}`}_calculateBoundingBoxRect(t,n){const e=this._viewportRect,a=this._isRtl();let o,r,i,c,s,l;if("top"===n.overlayY)r=t.y,o=e.height-r+this._viewportMargin;else if("bottom"===n.overlayY)i=e.height-t.y+2*this._viewportMargin,o=e.height-i+this._viewportMargin;else{const n=Math.min(e.bottom-t.y+e.top,t.y),a=this._lastBoundingBoxSize.height;o=2*n,r=t.y-n,o>a&&!this._isInitialRender&&!this._growAfterOpen&&(r=t.y-a/2)}if("end"===n.overlayX&&!a||"start"===n.overlayX&&a)l=e.width-t.x+this._viewportMargin,c=t.x-this._viewportMargin;else if("start"===n.overlayX&&!a||"end"===n.overlayX&&a)s=t.x,c=e.right-t.x;else{const n=Math.min(e.right-t.x+e.left,t.x),a=this._lastBoundingBoxSize.width;c=2*n,s=t.x-n,c>a&&!this._isInitialRender&&!this._growAfterOpen&&(s=t.x-a/2)}return{top:r,left:s,bottom:i,right:l,width:c,height:o}}_setBoundingBoxStyles(t,n){const e=this._calculateBoundingBoxRect(t,n);this._isInitialRender||this._growAfterOpen||(e.height=Math.min(e.height,this._lastBoundingBoxSize.height),e.width=Math.min(e.width,this._lastBoundingBoxSize.width));const a={};if(this._hasExactPosition())a.top=a.left="0",a.bottom=a.right=a.maxHeight=a.maxWidth="",a.width=a.height="100%";else{const t=this._overlayRef.getConfig().maxHeight,o=this._overlayRef.getConfig().maxWidth;a.height=Xw(e.height),a.top=Xw(e.top),a.bottom=Xw(e.bottom),a.width=Xw(e.width),a.left=Xw(e.left),a.right=Xw(e.right),a.alignItems="center"===n.overlayX?"center":"end"===n.overlayX?"flex-end":"flex-start",a.justifyContent="center"===n.overlayY?"center":"bottom"===n.overlayY?"flex-end":"flex-start",t&&(a.maxHeight=Xw(t)),o&&(a.maxWidth=Xw(o))}this._lastBoundingBoxSize=e,mz(this._boundingBox.style,a)}_resetBoundingBoxStyles(){mz(this._boundingBox.style,{top:"0",left:"0",right:"0",bottom:"0",height:"",width:"",alignItems:"",justifyContent:""})}_resetOverlayElementStyles(){mz(this._pane.style,{top:"",left:"",bottom:"",right:"",position:"",transform:""})}_setOverlayElementStyles(t,n){const e={},a=this._hasExactPosition(),o=this._hasFlexibleDimensions,r=this._overlayRef.getConfig();if(a){const a=this._viewportRuler.getViewportScrollPosition();mz(e,this._getExactOverlayY(n,t,a)),mz(e,this._getExactOverlayX(n,t,a))}else e.position="static";let i="",c=this._getOffset(n,"x"),s=this._getOffset(n,"y");c&&(i+=`translateX(${c}px) `),s&&(i+=`translateY(${s}px)`),e.transform=i.trim(),r.maxHeight&&(a?e.maxHeight=Xw(r.maxHeight):o&&(e.maxHeight="")),r.maxWidth&&(a?e.maxWidth=Xw(r.maxWidth):o&&(e.maxWidth="")),mz(this._pane.style,e)}_getExactOverlayY(t,n,e){let a={top:"",bottom:""},o=this._getOverlayPoint(n,this._overlayRect,t);this._isPushed&&(o=this._pushOverlayOnScreen(o,this._overlayRect,e));let r=this._overlayContainer.getContainerElement().getBoundingClientRect().top;return o.y-=r,"bottom"===t.overlayY?a.bottom=this._document.documentElement.clientHeight-(o.y+this._overlayRect.height)+"px":a.top=Xw(o.y),a}_getExactOverlayX(t,n,e){let a,o={left:"",right:""},r=this._getOverlayPoint(n,this._overlayRect,t);return this._isPushed&&(r=this._pushOverlayOnScreen(r,this._overlayRect,e)),a=this._isRtl()?"end"===t.overlayX?"left":"right":"end"===t.overlayX?"right":"left","right"===a?o.right=this._document.documentElement.clientWidth-(r.x+this._overlayRect.width)+"px":o.left=Xw(r.x),o}_getScrollVisibility(){const t=this._getOriginRect(),n=this._pane.getBoundingClientRect(),e=this._scrollables.map((t=>t.getElementRef().nativeElement.getBoundingClientRect()));return{isOriginClipped:YA(t,e),isOriginOutsideView:GA(t,e),isOverlayClipped:YA(n,e),isOverlayOutsideView:GA(n,e)}}_subtractOverflows(t,...n){return n.reduce(((t,n)=>t-Math.max(n,0)),t)}_getNarrowedViewportRect(){const t=this._document.documentElement.clientWidth,n=this._document.documentElement.clientHeight,e=this._viewportRuler.getViewportScrollPosition();return{top:e.top+this._viewportMargin,left:e.left+this._viewportMargin,right:e.left+t-this._viewportMargin,bottom:e.top+n-this._viewportMargin,width:t-2*this._viewportMargin,height:n-2*this._viewportMargin}}_isRtl(){return"rtl"===this._overlayRef.getDirection()}_hasExactPosition(){return!this._hasFlexibleDimensions||this._isPushed}_getOffset(t,n){return"x"===n?null==t.offsetX?this._offsetX:t.offsetX:null==t.offsetY?this._offsetY:t.offsetY}_validatePositions(){if("undefined"==typeof ngDevMode||ngDevMode){if(!this._preferredPositions.length)throw Error("FlexibleConnectedPositionStrategy: At least one position is required.");this._preferredPositions.forEach((t=>{tz("originX",t.originX),$A("originY",t.originY),tz("overlayX",t.overlayX),$A("overlayY",t.overlayY)}))}}_addPanelClasses(t){this._pane&&Zw(t).forEach((t=>{""!==t&&-1===this._appliedPanelClasses.indexOf(t)&&(this._appliedPanelClasses.push(t),this._pane.classList.add(t))}))}_clearPanelClasses(){this._pane&&(this._appliedPanelClasses.forEach((t=>{this._pane.classList.remove(t)})),this._appliedPanelClasses=[])}_getOriginRect(){const t=this._origin;if(t instanceof xu)return t.nativeElement.getBoundingClientRect();if(t instanceof Element)return t.getBoundingClientRect();const n=t.width||0,e=t.height||0;return{top:t.y,bottom:t.y+e,left:t.x,right:t.x+n,height:e,width:n}}}function mz(t,n){for(let e in n)n.hasOwnProperty(e)&&(t[e]=n[e]);return t}function dz(t){if("number"!=typeof t&&null!=t){const[n,e]=t.split(sz);return e&&"px"!==e?null:parseFloat(n)}return t||null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class gz{constructor(t,n,e,a,o,r,i){this._preferredPositions=[],this._positionStrategy=new lz(e,a,o,r,i).withFlexibleDimensions(!1).withPush(!1).withViewportMargin(0),this.withFallbackPosition(t,n),this.onPositionChange=this._positionStrategy.positionChanges}get positions(){return this._preferredPositions}attach(t){this._overlayRef=t,this._positionStrategy.attach(t),this._direction&&(t.setDirection(this._direction),this._direction=null)}dispose(){this._positionStrategy.dispose()}detach(){this._positionStrategy.detach()}apply(){this._positionStrategy.apply()}recalculateLastPosition(){this._positionStrategy.reapplyLastPosition()}withScrollableContainers(t){this._positionStrategy.withScrollableContainers(t)}withFallbackPosition(t,n,e,a){const o=new JA(t,n,e,a);return this._preferredPositions.push(o),this._positionStrategy.withPositions(this._preferredPositions),this}withDirection(t){return this._overlayRef?this._overlayRef.setDirection(t):this._direction=t,this}withOffsetX(t){return this._positionStrategy.withDefaultOffsetX(t),this}withOffsetY(t){return this._positionStrategy.withDefaultOffsetY(t),this}withLockedPosition(t){return this._positionStrategy.withLockedPosition(t),this}withPositions(t){return this._preferredPositions=t.slice(),this._positionStrategy.withPositions(this._preferredPositions),this}setOrigin(t){return this._positionStrategy.setOrigin(t),this}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const pz="cdk-global-overlay-wrapper";class bz{constructor(){this._cssPosition="static",this._topOffset="",this._bottomOffset="",this._leftOffset="",this._rightOffset="",this._alignItems="",this._justifyContent="",this._width="",this._height=""}attach(t){const n=t.getConfig();this._overlayRef=t,this._width&&!n.width&&t.updateSize({width:this._width}),this._height&&!n.height&&t.updateSize({height:this._height}),t.hostElement.classList.add(pz),this._isDisposed=!1}top(t=""){return this._bottomOffset="",this._topOffset=t,this._alignItems="flex-start",this}left(t=""){return this._rightOffset="",this._leftOffset=t,this._justifyContent="flex-start",this}bottom(t=""){return this._topOffset="",this._bottomOffset=t,this._alignItems="flex-end",this}right(t=""){return this._leftOffset="",this._rightOffset=t,this._justifyContent="flex-end",this}width(t=""){return this._overlayRef?this._overlayRef.updateSize({width:t}):this._width=t,this}height(t=""){return this._overlayRef?this._overlayRef.updateSize({height:t}):this._height=t,this}centerHorizontally(t=""){return this.left(t),this._justifyContent="center",this}centerVertically(t=""){return this.top(t),this._alignItems="center",this}apply(){if(!this._overlayRef||!this._overlayRef.hasAttached())return;const t=this._overlayRef.overlayElement.style,n=this._overlayRef.hostElement.style,e=this._overlayRef.getConfig(),{width:a,height:o,maxWidth:r,maxHeight:i}=e,c=!("100%"!==a&&"100vw"!==a||r&&"100%"!==r&&"100vw"!==r),s=!("100%"!==o&&"100vh"!==o||i&&"100%"!==i&&"100vh"!==i);t.position=this._cssPosition,t.marginLeft=c?"0":this._leftOffset,t.marginTop=s?"0":this._topOffset,t.marginBottom=this._bottomOffset,t.marginRight=this._rightOffset,c?n.justifyContent="flex-start":"center"===this._justifyContent?n.justifyContent="center":"rtl"===this._overlayRef.getConfig().direction?"flex-start"===this._justifyContent?n.justifyContent="flex-end":"flex-end"===this._justifyContent&&(n.justifyContent="flex-start"):n.justifyContent=this._justifyContent,n.alignItems=s?"flex-start":this._alignItems}dispose(){if(this._isDisposed||!this._overlayRef)return;const t=this._overlayRef.overlayElement.style,n=this._overlayRef.hostElement,e=n.style;n.classList.remove(pz),e.justifyContent=e.alignItems=t.marginTop=t.marginBottom=t.marginLeft=t.marginRight=t.position="",this._overlayRef=null,this._isDisposed=!0}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class uz{constructor(t,n,e,a){this._viewportRuler=t,this._document=n,this._platform=e,this._overlayContainer=a}global(){return new bz}connectedTo(t,n,e){return new gz(n,e,t,this._viewportRuler,this._document,this._platform,this._overlayContainer)}flexibleConnectedTo(t){return new lz(t,this._viewportRuler,this._document,this._platform,this._overlayContainer)}}uz.ɵfac=function t(n){return new(n||uz)(Za(MA),Za(zC),Za(Sw),Za(rz))},uz.ɵprov=We({factory:function t(){return new uz(Za(MA),Za(zC),Za(Sw),Za(rz))},token:uz,providedIn:"root"}),uz.ctorParameters=()=>[{type:MA},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw},{type:rz}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;let fz=0;class hz{constructor(t,n,e,a,o,r,i,c,s,l,m){this.scrollStrategies=t,this._overlayContainer=n,this._componentFactoryResolver=e,this._positionBuilder=a,this._keyboardDispatcher=o,this._injector=r,this._ngZone=i,this._document=c,this._directionality=s,this._location=l,this._outsideClickDispatcher=m}create(t){const n=this._createHostElement(),e=this._createPaneElement(n),a=this._createPortalOutlet(e),o=new XA(t);return o.direction=o.direction||this._directionality.value,new iz(a,n,e,o,this._ngZone,this._keyboardDispatcher,this._document,this._location,this._outsideClickDispatcher)}position(){return this._positionBuilder}_createPaneElement(t){const n=this._document.createElement("div");return n.id="cdk-overlay-"+fz++,n.classList.add("cdk-overlay-pane"),t.appendChild(n),n}_createHostElement(){const t=this._document.createElement("div");return this._overlayContainer.getContainerElement().appendChild(t),t}_createPortalOutlet(t){return this._appRef||(this._appRef=this._injector.get(pC)),new TA(t,this._componentFactoryResolver,this._appRef,this._injector,this._document)}}hz.ɵfac=function t(n){return new(n||hz)(Za(ZA),Za(rz),Za(Pu),Za(uz),Za(ez),Za(yd),Za(J_),Za(zC),Za(US),Za(GC),Za(az))},hz.ɵprov=We({token:hz,factory:hz.ɵfac}),hz.ctorParameters=()=>[{type:ZA},{type:rz},{type:Pu},{type:uz},{type:ez},{type:yd},{type:J_},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:US},{type:GC},{type:az}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const _z=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom"},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],Cz=new Fa("cdk-connected-overlay-scroll-strategy");class Mz{constructor(t){this.elementRef=t}}Mz.ɵfac=function t(n){return new(n||Mz)(Zg(xu))},Mz.ɵdir=vo({type:Mz,selectors:[["","cdk-overlay-origin",""],["","overlay-origin",""],["","cdkOverlayOrigin",""]],exportAs:["cdkOverlayOrigin"]}),Mz.ctorParameters=()=>[{type:xu}];class Oz{constructor(t,n,e,a,o){this._overlay=t,this._dir=o,this._hasBackdrop=!1,this._lockPosition=!1,this._growAfterOpen=!1,this._flexibleDimensions=!1,this._push=!1,this._backdropSubscription=s.EMPTY,this._attachSubscription=s.EMPTY,this._detachSubscription=s.EMPTY,this._positionSubscription=s.EMPTY,this.viewportMargin=0,this.open=!1,this.backdropClick=new Ef,this.positionChange=new Ef,this.attach=new Ef,this.detach=new Ef,this.overlayKeydown=new Ef,this.overlayOutsideClick=new Ef,this._templatePortal=new AA(n,e),this._scrollStrategyFactory=a,this.scrollStrategy=this._scrollStrategyFactory()}get offsetX(){return this._offsetX}set offsetX(t){this._offsetX=t,this._position&&this._updatePositionStrategy(this._position)}get offsetY(){return this._offsetY}set offsetY(t){this._offsetY=t,this._position&&this._updatePositionStrategy(this._position)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(t){this._hasBackdrop=Gw(t)}get lockPosition(){return this._lockPosition}set lockPosition(t){this._lockPosition=Gw(t)}get flexibleDimensions(){return this._flexibleDimensions}set flexibleDimensions(t){this._flexibleDimensions=Gw(t)}get growAfterOpen(){return this._growAfterOpen}set growAfterOpen(t){this._growAfterOpen=Gw(t)}get push(){return this._push}set push(t){this._push=Gw(t)}get overlayRef(){return this._overlayRef}get dir(){return this._dir?this._dir.value:"ltr"}ngOnDestroy(){this._attachSubscription.unsubscribe(),this._detachSubscription.unsubscribe(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this._overlayRef&&this._overlayRef.dispose()}ngOnChanges(t){this._position&&(this._updatePositionStrategy(this._position),this._overlayRef.updateSize({width:this.width,minWidth:this.minWidth,height:this.height,minHeight:this.minHeight}),t.origin&&this.open&&this._position.apply()),t.open&&(this.open?this._attachOverlay():this._detachOverlay())}_createOverlay(){this.positions&&this.positions.length||(this.positions=_z);const t=this._overlayRef=this._overlay.create(this._buildConfig());this._attachSubscription=t.attachments().subscribe((()=>this.attach.emit())),this._detachSubscription=t.detachments().subscribe((()=>this.detach.emit())),t.keydownEvents().subscribe((t=>{this.overlayKeydown.next(t),t.keyCode!==Bw||Ww(t)||(t.preventDefault(),this._detachOverlay())})),this._overlayRef.outsidePointerEvents().subscribe((t=>{this.overlayOutsideClick.next(t)}))}_buildConfig(){const t=this._position=this.positionStrategy||this._createPositionStrategy(),n=new XA({direction:this._dir,positionStrategy:t,scrollStrategy:this.scrollStrategy,hasBackdrop:this.hasBackdrop});return(this.width||0===this.width)&&(n.width=this.width),(this.height||0===this.height)&&(n.height=this.height),(this.minWidth||0===this.minWidth)&&(n.minWidth=this.minWidth),(this.minHeight||0===this.minHeight)&&(n.minHeight=this.minHeight),this.backdropClass&&(n.backdropClass=this.backdropClass),this.panelClass&&(n.panelClass=this.panelClass),n}_updatePositionStrategy(t){const n=this.positions.map((t=>({originX:t.originX,originY:t.originY,overlayX:t.overlayX,overlayY:t.overlayY,offsetX:t.offsetX||this.offsetX,offsetY:t.offsetY||this.offsetY,panelClass:t.panelClass||void 0})));return t.setOrigin(this.origin.elementRef).withPositions(n).withFlexibleDimensions(this.flexibleDimensions).withPush(this.push).withGrowAfterOpen(this.growAfterOpen).withViewportMargin(this.viewportMargin).withLockedPosition(this.lockPosition).withTransformOriginOn(this.transformOriginSelector)}_createPositionStrategy(){const t=this._overlay.position().flexibleConnectedTo(this.origin.elementRef);return this._updatePositionStrategy(t),t}_attachOverlay(){this._overlayRef?this._overlayRef.getConfig().hasBackdrop=this.hasBackdrop:this._createOverlay(),this._overlayRef.hasAttached()||this._overlayRef.attach(this._templatePortal),this.hasBackdrop?this._backdropSubscription=this._overlayRef.backdropClick().subscribe((t=>{this.backdropClick.emit(t)})):this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe(),this.positionChange.observers.length>0&&(this._positionSubscription=this._position.positionChanges.pipe(be((()=>this.positionChange.observers.length>0))).subscribe((t=>{this.positionChange.emit(t),0===this.positionChange.observers.length&&this._positionSubscription.unsubscribe()})))}_detachOverlay(){this._overlayRef&&this._overlayRef.detach(),this._backdropSubscription.unsubscribe(),this._positionSubscription.unsubscribe()}}Oz.ɵfac=function t(n){return new(n||Oz)(Zg(hz),Zg(Ju),Zg($u),Zg(Cz),Zg(US,8))},Oz.ɵdir=vo({type:Oz,selectors:[["","cdk-connected-overlay",""],["","connected-overlay",""],["","cdkConnectedOverlay",""]],inputs:{viewportMargin:["cdkConnectedOverlayViewportMargin","viewportMargin"],open:["cdkConnectedOverlayOpen","open"],scrollStrategy:["cdkConnectedOverlayScrollStrategy","scrollStrategy"],offsetX:["cdkConnectedOverlayOffsetX","offsetX"],offsetY:["cdkConnectedOverlayOffsetY","offsetY"],hasBackdrop:["cdkConnectedOverlayHasBackdrop","hasBackdrop"],lockPosition:["cdkConnectedOverlayLockPosition","lockPosition"],flexibleDimensions:["cdkConnectedOverlayFlexibleDimensions","flexibleDimensions"],growAfterOpen:["cdkConnectedOverlayGrowAfterOpen","growAfterOpen"],push:["cdkConnectedOverlayPush","push"],positions:["cdkConnectedOverlayPositions","positions"],origin:["cdkConnectedOverlayOrigin","origin"],positionStrategy:["cdkConnectedOverlayPositionStrategy","positionStrategy"],width:["cdkConnectedOverlayWidth","width"],height:["cdkConnectedOverlayHeight","height"],minWidth:["cdkConnectedOverlayMinWidth","minWidth"],minHeight:["cdkConnectedOverlayMinHeight","minHeight"],backdropClass:["cdkConnectedOverlayBackdropClass","backdropClass"],panelClass:["cdkConnectedOverlayPanelClass","panelClass"],transformOriginSelector:["cdkConnectedOverlayTransformOriginOn","transformOriginSelector"]},outputs:{backdropClick:"backdropClick",positionChange:"positionChange",attach:"attach",detach:"detach",overlayKeydown:"overlayKeydown",overlayOutsideClick:"overlayOutsideClick"},exportAs:["cdkConnectedOverlay"],features:[pr]}),Oz.ctorParameters=()=>[{type:hz},{type:Ju},{type:$u},{type:void 0,decorators:[{type:Ie,args:[Cz]}]},{type:US,decorators:[{type:Ne}]}],Oz.propDecorators={origin:[{type:f_,args:["cdkConnectedOverlayOrigin"]}],positions:[{type:f_,args:["cdkConnectedOverlayPositions"]}],positionStrategy:[{type:f_,args:["cdkConnectedOverlayPositionStrategy"]}],offsetX:[{type:f_,args:["cdkConnectedOverlayOffsetX"]}],offsetY:[{type:f_,args:["cdkConnectedOverlayOffsetY"]}],width:[{type:f_,args:["cdkConnectedOverlayWidth"]}],height:[{type:f_,args:["cdkConnectedOverlayHeight"]}],minWidth:[{type:f_,args:["cdkConnectedOverlayMinWidth"]}],minHeight:[{type:f_,args:["cdkConnectedOverlayMinHeight"]}],backdropClass:[{type:f_,args:["cdkConnectedOverlayBackdropClass"]}],panelClass:[{type:f_,args:["cdkConnectedOverlayPanelClass"]}],viewportMargin:[{type:f_,args:["cdkConnectedOverlayViewportMargin"]}],scrollStrategy:[{type:f_,args:["cdkConnectedOverlayScrollStrategy"]}],open:[{type:f_,args:["cdkConnectedOverlayOpen"]}],transformOriginSelector:[{type:f_,args:["cdkConnectedOverlayTransformOriginOn"]}],hasBackdrop:[{type:f_,args:["cdkConnectedOverlayHasBackdrop"]}],lockPosition:[{type:f_,args:["cdkConnectedOverlayLockPosition"]}],flexibleDimensions:[{type:f_,args:["cdkConnectedOverlayFlexibleDimensions"]}],growAfterOpen:[{type:f_,args:["cdkConnectedOverlayGrowAfterOpen"]}],push:[{type:f_,args:["cdkConnectedOverlayPush"]}],backdropClick:[{type:h_}],positionChange:[{type:h_}],attach:[{type:h_}],detach:[{type:h_}],overlayKeydown:[{type:h_}],overlayOutsideClick:[{type:h_}]};const Pz={provide:Cz,deps:[hz],useFactory:function xz(t){return()=>t.scrollStrategies.reposition()}};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class yz{}yz.ɵmod=xo({type:yz}),yz.ɵinj=Ge({factory:function t(n){return new(n||yz)},providers:[hz,Pz],imports:[[GS,BA,vA],vA]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(yz,{declarations:function(){return[Oz,Mz]},imports:function(){return[GS,BA,vA]},exports:function(){return[Oz,Mz,vA]}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class kz extends rz{constructor(t,n){super(t,n)}ngOnDestroy(){super.ngOnDestroy(),this._fullScreenEventName&&this._fullScreenListener&&this._document.removeEventListener(this._fullScreenEventName,this._fullScreenListener)}_createContainer(){super._createContainer(),this._adjustParentForFullscreenChange(),this._addFullscreenChangeListener((()=>this._adjustParentForFullscreenChange()))}_adjustParentForFullscreenChange(){this._containerElement&&(this.getFullscreenElement()||this._document.body).appendChild(this._containerElement)}_addFullscreenChangeListener(t){const n=this._getEventName();n&&(this._fullScreenListener&&this._document.removeEventListener(n,this._fullScreenListener),this._document.addEventListener(n,t),this._fullScreenListener=t)}_getEventName(){if(!this._fullScreenEventName){const t=this._document;t.fullscreenEnabled?this._fullScreenEventName="fullscreenchange":t.webkitFullscreenEnabled?this._fullScreenEventName="webkitfullscreenchange":t.mozFullScreenEnabled?this._fullScreenEventName="mozfullscreenchange":t.msFullscreenEnabled&&(this._fullScreenEventName="MSFullscreenChange")}return this._fullScreenEventName}getFullscreenElement(){const t=this._document;return t.fullscreenElement||t.webkitFullscreenElement||t.mozFullScreenElement||t.msFullscreenElement||null}}kz.ɵfac=function t(n){return new(n||kz)(Za(zC),Za(Sw))},kz.ɵprov=We({factory:function t(){return new kz(Za(zC),Za(Sw))},token:kz,providedIn:"root"}),kz.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw}];class vz{}vz.ɵmod=xo({type:vz}),vz.ɵinj=Ge({factory:function t(n){return new(n||vz)}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const wz=new Set;let Sz;class Ez{constructor(t){this._platform=t,this._matchMedia=this._platform.isBrowser&&window.matchMedia?window.matchMedia.bind(window):Az}matchMedia(t){return this._platform.WEBKIT&&(function n(t){if(!wz.has(t))try{Sz||(Sz=document.createElement("style"),Sz.setAttribute("type","text/css"),document.head.appendChild(Sz)),Sz.sheet&&(Sz.sheet.insertRule(`@media ${t} {.fx-query-test{ }}`,0),wz.add(t))}catch(t){console.error(t)}})(t),this._matchMedia(t)}}function Az(t){return{matches:"all"===t||""===t,media:t,addListener:()=>{},removeListener:()=>{}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */Ez.ɵfac=function t(n){return new(n||Ez)(Za(Sw))},Ez.ɵprov=We({factory:function t(){return new Ez(Za(Sw))},token:Ez,providedIn:"root"}),Ez.ctorParameters=()=>[{type:Sw}];class zz{constructor(t,n){this._mediaMatcher=t,this._zone=n,this._queries=new Map,this._destroySubject=new x}ngOnDestroy(){this._destroySubject.next(),this._destroySubject.complete()}isMatched(t){return Rz(Zw(t)).some((t=>this._registerQuery(t).mql.matches))}observe(t){let n=Et(Rz(Zw(t)).map((t=>this._registerQuery(t).observable)));return n=Ft(n.pipe(Tn(1)),n.pipe(oe(1),ln(0))),n.pipe(ft((t=>{const n={matches:!1,breakpoints:{}};return t.forEach((({matches:t,query:e})=>{n.matches=n.matches||t,n.breakpoints[e]=t})),n})))}_registerQuery(t){if(this._queries.has(t))return this._queries.get(t);const n=this._mediaMatcher.matchMedia(t),e={observable:new _((t=>{const e=n=>this._zone.run((()=>t.next(n)));return n.addListener(e),()=>{n.removeListener(e)}})).pipe(ce(n),ft((({matches:n})=>({query:t,matches:n}))),de(this._destroySubject)),mql:n};return this._queries.set(t,e),e}}function Rz(t){return t.map((t=>t.split(","))).reduce(((t,n)=>t.concat(n))).map((t=>t.trim()))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function Tz(t,n){if(1&t){const t=op();Kg(0,"div",1),Kg(1,"button",2),cp("click",(function n(){return jr(t),gp().action()})),Jp(2),$g(),$g()}if(2&t){const t=gp();ws(2),Qp(t.data.action)}}function Dz(t,n){}zz.ɵfac=function t(n){return new(n||zz)(Za(Ez),Za(J_))},zz.ɵprov=We({factory:function t(){return new zz(Za(Ez),Za(J_))},token:zz,providedIn:"root"}),zz.ctorParameters=()=>[{type:Ez},{type:J_}];const Iz=new Fa("MatSnackBarData");class Nz{constructor(){this.politeness="assertive",this.announcementMessage="",this.duration=0,this.data=null,this.horizontalPosition="center",this.verticalPosition="bottom"}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const Fz=Math.pow(2,31)-1;class Lz{constructor(t,n){this._overlayRef=n,this._afterDismissed=new x,this._afterOpened=new x,this._onAction=new x,this._dismissedByAction=!1,this.containerInstance=t,this.onAction().subscribe((()=>this.dismiss())),t._onExit.subscribe((()=>this._finishDismiss()))}dismiss(){this._afterDismissed.closed||this.containerInstance.exit(),clearTimeout(this._durationTimeoutId)}dismissWithAction(){this._onAction.closed||(this._dismissedByAction=!0,this._onAction.next(),this._onAction.complete())}closeWithAction(){this.dismissWithAction()}_dismissAfter(t){this._durationTimeoutId=setTimeout((()=>this.dismiss()),Math.min(t,Fz))}_open(){this._afterOpened.closed||(this._afterOpened.next(),this._afterOpened.complete())}_finishDismiss(){this._overlayRef.dispose(),this._onAction.closed||this._onAction.complete(),this._afterDismissed.next({dismissedByAction:this._dismissedByAction}),this._afterDismissed.complete(),this._dismissedByAction=!1}afterDismissed(){return this._afterDismissed}afterOpened(){return this.containerInstance._onEnter}onAction(){return this._onAction}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Hz{constructor(t,n){this.snackBarRef=t,this.data=n}action(){this.snackBarRef.dismissWithAction()}get hasAction(){return!!this.data.action}}Hz.ɵfac=function t(n){return new(n||Hz)(Zg(Lz),Zg(Iz))},Hz.ɵcmp=_o({type:Hz,selectors:[["simple-snack-bar"]],hostAttrs:[1,"mat-simple-snackbar"],decls:3,vars:2,consts:[["class","mat-simple-snackbar-action",4,"ngIf"],[1,"mat-simple-snackbar-action"],["mat-button","",3,"click"]],template:function t(n,e){1&n&&(Kg(0,"span"),Jp(1),$g(),Yg(2,Tz,3,1,"div",0)),2&n&&(ws(1),Qp(e.data.message),ws(1),Jg("ngIf",e.hasAction))},directives:[WM,eA],styles:[".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}\n"],encapsulation:2,changeDetection:0}),Hz.ctorParameters=()=>[{type:Lz},{type:void 0,decorators:[{type:Ie,args:[Iz]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const Bz={snackBarState:SP("state",[RP("void, hidden",zP({transform:"scale(0.8)",opacity:0})),RP("visible",zP({transform:"scale(1)",opacity:1})),DP("* => visible",EP("150ms cubic-bezier(0, 0, 0.2, 1)")),DP("* => void, * => hidden",EP("75ms cubic-bezier(0.4, 0.0, 1, 1)",zP({opacity:0})))])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Vz extends RA{constructor(t,n,e,a){super(),this._ngZone=t,this._elementRef=n,this._changeDetectorRef=e,this.snackBarConfig=a,this._destroyed=!1,this._onExit=new x,this._onEnter=new x,this._animationState="void",this.attachDomPortal=t=>(this._assertNotAttached(),this._applySnackBarClasses(),this._portalOutlet.attachDomPortal(t)),this._role="assertive"!==a.politeness||a.announcementMessage?"off"===a.politeness?null:"status":"alert"}attachComponentPortal(t){return this._assertNotAttached(),this._applySnackBarClasses(),this._portalOutlet.attachComponentPortal(t)}attachTemplatePortal(t){return this._assertNotAttached(),this._applySnackBarClasses(),this._portalOutlet.attachTemplatePortal(t)}onAnimationEnd(t){const{fromState:n,toState:e}=t;if(("void"===e&&"void"!==n||"hidden"===e)&&this._completeExit(),"visible"===e){const t=this._onEnter;this._ngZone.run((()=>{t.next(),t.complete()}))}}enter(){this._destroyed||(this._animationState="visible",this._changeDetectorRef.detectChanges())}exit(){return this._animationState="hidden",this._elementRef.nativeElement.setAttribute("mat-exit",""),this._onExit}ngOnDestroy(){this._destroyed=!0,this._completeExit()}_completeExit(){this._ngZone.onMicrotaskEmpty.pipe(Tn(1)).subscribe((()=>{this._onExit.next(),this._onExit.complete()}))}_applySnackBarClasses(){const t=this._elementRef.nativeElement,n=this.snackBarConfig.panelClass;n&&(Array.isArray(n)?n.forEach((n=>t.classList.add(n))):t.classList.add(n)),"center"===this.snackBarConfig.horizontalPosition&&t.classList.add("mat-snack-bar-center"),"top"===this.snackBarConfig.verticalPosition&&t.classList.add("mat-snack-bar-top")}_assertNotAttached(){if(this._portalOutlet.hasAttached()&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("Attempting to attach snack bar content after content is already attached")}}Vz.ɵfac=function t(n){return new(n||Vz)(Zg(J_),Zg(xu),Zg(Vm),Zg(Nz))},Vz.ɵcmp=_o({type:Vz,selectors:[["snack-bar-container"]],viewQuery:function t(n,e){var a;1&n&&jf(FA,!0),2&n&&Vf(a=Zf())&&(e._portalOutlet=a.first)},hostAttrs:[1,"mat-snack-bar-container"],hostVars:2,hostBindings:function t(n,e){1&n&&sp("@state.done",(function t(n){return e.onAnimationEnd(n)})),2&n&&(Ng("role",e._role),ab("@state",e._animationState))},features:[hg],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function t(n,e){1&n&&Yg(0,Dz,0,0,"ng-template",0)},directives:[FA],styles:[".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}\n"],encapsulation:2,data:{animation:[Bz.snackBarState]}}),Vz.ctorParameters=()=>[{type:J_},{type:xu},{type:Vm},{type:Nz}],Vz.propDecorators={_portalOutlet:[{type:Xd,args:[FA,{static:!0}]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class jz{}jz.ɵmod=xo({type:jz}),jz.ɵinj=Ge({factory:function t(n){return new(n||jz)},imports:[[yz,BA,PO,oA,tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(jz,{declarations:function(){return[Vz,Hz]},imports:function(){return[yz,BA,PO,oA,tE]},exports:function(){return[Vz,tE]}});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Uz=new Fa("mat-snack-bar-default-options",{providedIn:"root",factory:function Wz(){return new Nz}});class Gz{constructor(t,n,e,a,o,r){this._overlay=t,this._live=n,this._injector=e,this._breakpointObserver=a,this._parentSnackBar=o,this._defaultConfig=r,this._snackBarRefAtThisLevel=null,this.simpleSnackBarComponent=Hz,this.snackBarContainerComponent=Vz,this.handsetCssClass="mat-snack-bar-handset"}get _openedSnackBarRef(){const t=this._parentSnackBar;return t?t._openedSnackBarRef:this._snackBarRefAtThisLevel}set _openedSnackBarRef(t){this._parentSnackBar?this._parentSnackBar._openedSnackBarRef=t:this._snackBarRefAtThisLevel=t}openFromComponent(t,n){return this._attach(t,n)}openFromTemplate(t,n){return this._attach(t,n)}open(t,n="",e){const a=Object.assign(Object.assign({},this._defaultConfig),e);return a.data={message:t,action:n},a.announcementMessage===t&&(a.announcementMessage=void 0),this.openFromComponent(this.simpleSnackBarComponent,a)}dismiss(){this._openedSnackBarRef&&this._openedSnackBarRef.dismiss()}ngOnDestroy(){this._snackBarRefAtThisLevel&&this._snackBarRefAtThisLevel.dismiss()}_attachSnackBarContainer(t,n){const e=yd.create({parent:n&&n.viewContainerRef&&n.viewContainerRef.injector||this._injector,providers:[{provide:Nz,useValue:n}]}),a=new EA(this.snackBarContainerComponent,n.viewContainerRef,e),o=t.attach(a);return o.instance.snackBarConfig=n,o.instance}_attach(t,n){const e=Object.assign(Object.assign(Object.assign({},new Nz),this._defaultConfig),n),a=this._createOverlay(e),o=this._attachSnackBarContainer(a,e),r=new Lz(o,a);if(t instanceof Ju){const n=new AA(t,null,{$implicit:e.data,snackBarRef:r});r.instance=o.attachTemplatePortal(n)}else{const n=this._createInjector(e,r),a=new EA(t,void 0,n),i=o.attachComponentPortal(a);r.instance=i.instance}return this._breakpointObserver.observe("(max-width: 599.99px) and (orientation: portrait)").pipe(de(a.detachments())).subscribe((t=>{const n=a.overlayElement.classList;t.matches?n.add(this.handsetCssClass):n.remove(this.handsetCssClass)})),this._animateSnackBar(r,e),this._openedSnackBarRef=r,this._openedSnackBarRef}_animateSnackBar(t,n){t.afterDismissed().subscribe((()=>{this._openedSnackBarRef==t&&(this._openedSnackBarRef=null),n.announcementMessage&&this._live.clear()})),this._openedSnackBarRef?(this._openedSnackBarRef.afterDismissed().subscribe((()=>{t.containerInstance.enter()})),this._openedSnackBarRef.dismiss()):t.containerInstance.enter(),n.duration&&n.duration>0&&t.afterOpened().subscribe((()=>t._dismissAfter(n.duration))),n.announcementMessage&&this._live.announce(n.announcementMessage,n.politeness)}_createOverlay(t){const n=new XA;n.direction=t.direction;let e=this._overlay.position().global();const a="rtl"===t.direction,o="left"===t.horizontalPosition||"start"===t.horizontalPosition&&!a||"end"===t.horizontalPosition&&a,r=!o&&"center"!==t.horizontalPosition;return o?e.left("0"):r?e.right("0"):e.centerHorizontally(),"top"===t.verticalPosition?e.top("0"):e.bottom("0"),n.positionStrategy=e,this._overlay.create(n)}_createInjector(t,n){return yd.create({parent:t&&t.viewContainerRef&&t.viewContainerRef.injector||this._injector,providers:[{provide:Lz,useValue:n},{provide:Iz,useValue:t.data}]})}}var Yz;Gz.ɵfac=function t(n){return new(n||Gz)(Za(hz),Za(SS),Za(yd),Za(zz),Za(Gz,12),Za(Uz))},Gz.ɵprov=We({factory:function t(){return new Gz(Za(hz),Za(SS),Za(La),Za(zz),Za(Gz,12),Za(Uz))},token:Gz,providedIn:jz}),Gz.ctorParameters=()=>[{type:hz},{type:SS},{type:yd},{type:zz},{type:Gz,decorators:[{type:Ne},{type:Le}]},{type:Nz,decorators:[{type:Ie,args:[Uz]}]}],(function(t){t[t.UNKNOWN=0]="UNKNOWN",t[t.EXPERIMENTS=1]="EXPERIMENTS",t[t.EXPERIMENT=2]="EXPERIMENT",t[t.COMPARE_EXPERIMENT=3]="COMPARE_EXPERIMENT"})(Yz||(Yz={}));const qz="defaultExperimentId";function Zz(t){return t.split(",").map((t=>{const n=t.indexOf(":");if(n<0)throw new Error(`Expect colon delimiting name and ID: ${t}`);const e=t.slice(0,n),a=t.slice(n+1);if(!e)throw new Error(`Expect name to be non-falsy: ${t}`);if(!a)throw new Error(`Expect id to be non-falsy: ${t}`);return{name:e,id:a}}))}function Xz(t,n){switch(t){case Yz.COMPARE_EXPERIMENT:return`${t}/${n.experimentIds}`;case Yz.EXPERIMENT:return`${t}/${n.experimentId}`;case Yz.EXPERIMENTS:return String(t);default:return""}}const Jz="app_routing",Qz=uv(Jz),Kz=pv(Qz,(t=>t.activeRoute)),$z=pv(Qz,(t=>t.nextRoute)),tR=pv(Kz,(t=>t?t.routeKind:Yz.UNKNOWN)),nR=pv(Kz,(t=>t?t.params:{})),eR=pv(tR,nR,((t,n)=>(function e(t,n){switch(t){case Yz.EXPERIMENT:return Object.prototype.hasOwnProperty.call(n,"experimentId")?[n.experimentId]:[qz];case Yz.COMPARE_EXPERIMENT:return Zz(n.experimentIds).map((({id:t})=>t));case Yz.EXPERIMENTS:default:return null}})(t,n))),aR=pv(tR,nR,((t,n)=>Xz(t,n))),oR=pv(tR,nR,((t,n)=>{const e={};if(t!==Yz.COMPARE_EXPERIMENT)return e;const a=Zz(n.experimentIds);for(const{id:t,name:n}of a)e[t]=n;return e})),rR="experiments",iR=pv(uv(rR),(t=>t.data)),cR=pv(iR,((t,n)=>{const{experimentId:e}=n;return t.experimentMap[e]||null})),sR="feature",lR=uv(sR),mR=pv(lR,(t=>t.isFeatureFlagsLoaded)),dR=pv(lR,(t=>Object.assign(Object.assign({},t.defaultFlags),t.flagOverrides))),gR=pv(lR,(t=>t.flagOverrides||{})),pR=pv(dR,(t=>t.enabledExperimentalPlugins)),bR=pv(dR,(t=>t.inColab)),uR=pv(dR,(t=>t.enableGpuChart));var fR,hR;
/*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
function _R(t,n){var e={};for(var a in t)Object.prototype.hasOwnProperty.call(t,a)&&n.indexOf(a)<0&&(e[a]=t[a]);if(null!=t&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(a=Object.getOwnPropertySymbols(t);o<a.length;o++)n.indexOf(a[o])<0&&Object.prototype.propertyIsEnumerable.call(t,a[o])&&(e[a[o]]=t[a[o]])}return e}function CR(t,n,e,a){return new(e||(e=Promise))((function(o,r){function i(t){try{s(a.next(t))}catch(t){r(t)}}function c(t){try{s(a.throw(t))}catch(t){r(t)}}function s(t){t.done?o(t.value):(function n(t){return t instanceof e?t:new e((function(n){n(t)}))})(t.value).then(i,c)}s((a=a.apply(t,n||[])).next())}))}
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */!(function(t){t[t.NOT_LOADED=0]="NOT_LOADED",t[t.LOADED=1]="LOADED",t[t.LOADING=2]="LOADING",t[t.FAILED=3]="FAILED"})(fR||(fR={}));class MR{}class OR{}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class PR{constructor(t){this.normalizedNames=new Map,this.lazyUpdate=null,t?this.lazyInit="string"==typeof t?()=>{this.headers=new Map,t.split("\n").forEach((t=>{const n=t.indexOf(":");if(n>0){const e=t.slice(0,n),a=e.toLowerCase(),o=t.slice(n+1).trim();this.maybeSetNormalizedName(e,a),this.headers.has(a)?this.headers.get(a).push(o):this.headers.set(a,[o])}}))}:()=>{this.headers=new Map,Object.keys(t).forEach((n=>{let e=t[n];const a=n.toLowerCase();"string"==typeof e&&(e=[e]),e.length>0&&(this.headers.set(a,e),this.maybeSetNormalizedName(n,a))}))}:this.headers=new Map}has(t){return this.init(),this.headers.has(t.toLowerCase())}get(t){this.init();const n=this.headers.get(t.toLowerCase());return n&&n.length>0?n[0]:null}keys(){return this.init(),Array.from(this.normalizedNames.values())}getAll(t){return this.init(),this.headers.get(t.toLowerCase())||null}append(t,n){return this.clone({name:t,value:n,op:"a"})}set(t,n){return this.clone({name:t,value:n,op:"s"})}delete(t,n){return this.clone({name:t,value:n,op:"d"})}maybeSetNormalizedName(t,n){this.normalizedNames.has(n)||this.normalizedNames.set(n,t)}init(){this.lazyInit&&(this.lazyInit instanceof PR?this.copyFrom(this.lazyInit):this.lazyInit(),this.lazyInit=null,this.lazyUpdate&&(this.lazyUpdate.forEach((t=>this.applyUpdate(t))),this.lazyUpdate=null))}copyFrom(t){t.init(),Array.from(t.headers.keys()).forEach((n=>{this.headers.set(n,t.headers.get(n)),this.normalizedNames.set(n,t.normalizedNames.get(n))}))}clone(t){const n=new PR;return n.lazyInit=this.lazyInit&&this.lazyInit instanceof PR?this.lazyInit:this,n.lazyUpdate=(this.lazyUpdate||[]).concat([t]),n}applyUpdate(t){const n=t.name.toLowerCase();switch(t.op){case"a":case"s":let e=t.value;if("string"==typeof e&&(e=[e]),0===e.length)return;this.maybeSetNormalizedName(t.name,n);const a=("a"===t.op?this.headers.get(n):void 0)||[];a.push(...e),this.headers.set(n,a);break;case"d":const o=t.value;if(o){let t=this.headers.get(n);if(!t)return;t=t.filter((t=>-1===o.indexOf(t))),0===t.length?(this.headers.delete(n),this.normalizedNames.delete(n)):this.headers.set(n,t)}else this.headers.delete(n),this.normalizedNames.delete(n)}}forEach(t){this.init(),Array.from(this.normalizedNames.keys()).forEach((n=>t(this.normalizedNames.get(n),this.headers.get(n))))}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class xR{encodeKey(t){return yR(t)}encodeValue(t){return yR(t)}decodeKey(t){return decodeURIComponent(t)}decodeValue(t){return decodeURIComponent(t)}}function yR(t){return encodeURIComponent(t).replace(/%40/gi,"@").replace(/%3A/gi,":").replace(/%24/gi,"$").replace(/%2C/gi,",").replace(/%3B/gi,";").replace(/%2B/gi,"+").replace(/%3D/gi,"=").replace(/%3F/gi,"?").replace(/%2F/gi,"/")}class kR{constructor(t={}){if(this.updates=null,this.cloneFrom=null,this.encoder=t.encoder||new xR,t.fromString){if(t.fromObject)throw new Error("Cannot specify both fromString and fromObject.");this.map=(function n(t,e){const a=new Map;return t.length>0&&t.split("&").forEach((t=>{const n=t.indexOf("="),[o,r]=-1==n?[e.decodeKey(t),""]:[e.decodeKey(t.slice(0,n)),e.decodeValue(t.slice(n+1))],i=a.get(o)||[];i.push(r),a.set(o,i)})),a})(t.fromString,this.encoder)}else t.fromObject?(this.map=new Map,Object.keys(t.fromObject).forEach((n=>{const e=t.fromObject[n];this.map.set(n,Array.isArray(e)?e:[e])}))):this.map=null}has(t){return this.init(),this.map.has(t)}get(t){this.init();const n=this.map.get(t);return n?n[0]:null}getAll(t){return this.init(),this.map.get(t)||null}keys(){return this.init(),Array.from(this.map.keys())}append(t,n){return this.clone({param:t,value:n,op:"a"})}set(t,n){return this.clone({param:t,value:n,op:"s"})}delete(t,n){return this.clone({param:t,value:n,op:"d"})}toString(){return this.init(),this.keys().map((t=>{const n=this.encoder.encodeKey(t);return this.map.get(t).map((t=>n+"="+this.encoder.encodeValue(t))).join("&")})).filter((t=>""!==t)).join("&")}clone(t){const n=new kR({encoder:this.encoder});return n.cloneFrom=this.cloneFrom||this,n.updates=(this.updates||[]).concat([t]),n}init(){null===this.map&&(this.map=new Map),null!==this.cloneFrom&&(this.cloneFrom.init(),this.cloneFrom.keys().forEach((t=>this.map.set(t,this.cloneFrom.map.get(t)))),this.updates.forEach((t=>{switch(t.op){case"a":case"s":const n=("a"===t.op?this.map.get(t.param):void 0)||[];n.push(t.value),this.map.set(t.param,n);break;case"d":if(void 0===t.value){this.map.delete(t.param);break}{let n=this.map.get(t.param)||[];const e=n.indexOf(t.value);-1!==e&&n.splice(e,1),n.length>0?this.map.set(t.param,n):this.map.delete(t.param)}}})),this.cloneFrom=this.updates=null)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function vR(t){return"undefined"!=typeof ArrayBuffer&&t instanceof ArrayBuffer}function wR(t){return"undefined"!=typeof Blob&&t instanceof Blob}function SR(t){return"undefined"!=typeof FormData&&t instanceof FormData}class ER{constructor(t,n,e,a){let o;if(this.url=n,this.body=null,this.reportProgress=!1,this.withCredentials=!1,this.responseType="json",this.method=t.toUpperCase(),(function r(t){switch(t){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"JSONP":return!1;default:return!0}})(this.method)||a?(this.body=void 0!==e?e:null,o=a):o=e,o&&(this.reportProgress=!!o.reportProgress,this.withCredentials=!!o.withCredentials,o.responseType&&(this.responseType=o.responseType),o.headers&&(this.headers=o.headers),o.params&&(this.params=o.params)),this.headers||(this.headers=new PR),this.params){const t=this.params.toString();if(0===t.length)this.urlWithParams=n;else{const e=n.indexOf("?");this.urlWithParams=n+(-1===e?"?":e<n.length-1?"&":"")+t}}else this.params=new kR,this.urlWithParams=n}serializeBody(){return null===this.body?null:vR(this.body)||wR(this.body)||SR(this.body)||"string"==typeof this.body?this.body:this.body instanceof kR?this.body.toString():"object"==typeof this.body||"boolean"==typeof this.body||Array.isArray(this.body)?JSON.stringify(this.body):this.body.toString()}detectContentTypeHeader(){return null===this.body||SR(this.body)?null:wR(this.body)?this.body.type||null:vR(this.body)?null:"string"==typeof this.body?"text/plain":this.body instanceof kR?"application/x-www-form-urlencoded;charset=UTF-8":"object"==typeof this.body||"number"==typeof this.body||Array.isArray(this.body)?"application/json":null}clone(t={}){const n=t.method||this.method,e=t.url||this.url,a=t.responseType||this.responseType,o=void 0!==t.body?t.body:this.body,r=void 0!==t.withCredentials?t.withCredentials:this.withCredentials,i=void 0!==t.reportProgress?t.reportProgress:this.reportProgress;let c=t.headers||this.headers,s=t.params||this.params;return void 0!==t.setHeaders&&(c=Object.keys(t.setHeaders).reduce(((n,e)=>n.set(e,t.setHeaders[e])),c)),t.setParams&&(s=Object.keys(t.setParams).reduce(((n,e)=>n.set(e,t.setParams[e])),s)),new ER(n,e,o,{params:s,headers:c,reportProgress:i,responseType:a,withCredentials:r})}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */!(function(t){t[t.Sent=0]="Sent",t[t.UploadProgress=1]="UploadProgress",t[t.ResponseHeader=2]="ResponseHeader",t[t.DownloadProgress=3]="DownloadProgress",t[t.Response=4]="Response",t[t.User=5]="User"})(hR||(hR={}));class AR{constructor(t,n=200,e="OK"){this.headers=t.headers||new PR,this.status=void 0!==t.status?t.status:n,this.statusText=t.statusText||e,this.url=t.url||null,this.ok=this.status>=200&&this.status<300}}class zR extends AR{constructor(t={}){super(t),this.type=hR.ResponseHeader}clone(t={}){return new zR({headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}}class RR extends AR{constructor(t={}){super(t),this.type=hR.Response,this.body=void 0!==t.body?t.body:null}clone(t={}){return new RR({body:void 0!==t.body?t.body:this.body,headers:t.headers||this.headers,status:void 0!==t.status?t.status:this.status,statusText:t.statusText||this.statusText,url:t.url||this.url||void 0})}}class TR extends AR{constructor(t){super(t,0,"Unknown Error"),this.name="HttpErrorResponse",this.ok=!1,this.message=this.status>=200&&this.status<300?`Http failure during parsing for ${t.url||"(unknown url)"}`:`Http failure response for ${t.url||"(unknown url)"}: ${t.status} ${t.statusText}`,this.error=t.error||null}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function DR(t,n){return{body:n,headers:t.headers,observe:t.observe,params:t.params,reportProgress:t.reportProgress,responseType:t.responseType,withCredentials:t.withCredentials}}class IR{constructor(t){this.handler=t}request(t,n,e={}){let a;if(t instanceof ER)a=t;else{let o,r;o=e.headers instanceof PR?e.headers:new PR(e.headers),e.params&&(r=e.params instanceof kR?e.params:new kR({fromObject:e.params})),a=new ER(t,n,void 0!==e.body?e.body:null,{headers:o,params:r,reportProgress:e.reportProgress,responseType:e.responseType||"json",withCredentials:e.withCredentials})}const o=Z(a).pipe((function r(t,n){return"function"==typeof n?Tt(t,n,1):Tt(t,1)})((t=>this.handler.handle(t))));if(t instanceof ER||"events"===e.observe)return o;const i=o.pipe(Gt((t=>t instanceof RR)));switch(e.observe||"body"){case"body":switch(a.responseType){case"arraybuffer":return i.pipe(ft((t=>{if(null!==t.body&&!(t.body instanceof ArrayBuffer))throw new Error("Response is not an ArrayBuffer.");return t.body})));case"blob":return i.pipe(ft((t=>{if(null!==t.body&&!(t.body instanceof Blob))throw new Error("Response is not a Blob.");return t.body})));case"text":return i.pipe(ft((t=>{if(null!==t.body&&"string"!=typeof t.body)throw new Error("Response is not a string.");return t.body})));case"json":default:return i.pipe(ft((t=>t.body)))}case"response":return i;default:throw new Error(`Unreachable: unhandled observe type ${e.observe}}`)}}delete(t,n={}){return this.request("DELETE",t,n)}get(t,n={}){return this.request("GET",t,n)}head(t,n={}){return this.request("HEAD",t,n)}jsonp(t,n){return this.request("JSONP",t,{params:(new kR).append(n,"JSONP_CALLBACK"),observe:"body",responseType:"json"})}options(t,n={}){return this.request("OPTIONS",t,n)}patch(t,n,e={}){return this.request("PATCH",t,DR(e,n))}post(t,n,e={}){return this.request("POST",t,DR(e,n))}put(t,n,e={}){return this.request("PUT",t,DR(e,n))}}IR.ɵfac=function t(n){return new(n||IR)(Za(MR))},IR.ɵprov=We({token:IR,factory:IR.ɵfac}),IR.ctorParameters=()=>[{type:MR}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class NR{constructor(t,n){this.next=t,this.interceptor=n}handle(t){return this.interceptor.intercept(t,this.next)}}const FR=new Fa("HTTP_INTERCEPTORS");class LR{intercept(t,n){return n.handle(t)}}LR.ɵfac=function t(n){return new(n||LR)},LR.ɵprov=We({token:LR,factory:LR.ɵfac});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let HR=0;class BR{}class VR{constructor(t,n){this.callbackMap=t,this.document=n}nextCallback(){return"ng_jsonp_callback_"+HR++}handle(t){if("JSONP"!==t.method)throw new Error("JSONP requests must use JSONP request method.");if("json"!==t.responseType)throw new Error("JSONP requests must use Json response type.");return new _((n=>{const e=this.nextCallback(),a=t.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/,`=${e}$1`),o=this.document.createElement("script");o.src=a;let r=null,i=!1,c=!1;this.callbackMap[e]=t=>{delete this.callbackMap[e],c||(r=t,i=!0)};const s=()=>{o.parentNode&&o.parentNode.removeChild(o),delete this.callbackMap[e]},l=t=>{c||(s(),i?(n.next(new RR({body:r,status:200,statusText:"OK",url:a})),n.complete()):n.error(new TR({url:a,status:0,statusText:"JSONP Error",error:new Error("JSONP injected script did not invoke callback.")})))},m=t=>{c||(s(),n.error(new TR({error:t,status:0,statusText:"JSONP Error",url:a})))};return o.addEventListener("load",l),o.addEventListener("error",m),this.document.body.appendChild(o),n.next({type:hR.Sent}),()=>{c=!0,o.removeEventListener("load",l),o.removeEventListener("error",m),s()}}))}}VR.ɵfac=function t(n){return new(n||VR)(Za(BR),Za(zC))},VR.ɵprov=We({token:VR,factory:VR.ɵfac}),VR.ctorParameters=()=>[{type:BR},{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class jR{constructor(t){this.jsonp=t}intercept(t,n){return"JSONP"===t.method?this.jsonp.handle(t):n.handle(t)}}jR.ɵfac=function t(n){return new(n||jR)(Za(VR))},jR.ɵprov=We({token:jR,factory:jR.ɵfac}),jR.ctorParameters=()=>[{type:VR}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const UR=/^\)\]\}',?\n/;class WR{}class GR{constructor(){}build(){return new XMLHttpRequest}}GR.ɵfac=function t(n){return new(n||GR)},GR.ɵprov=We({token:GR,factory:GR.ɵfac}),GR.ctorParameters=()=>[];class YR{constructor(t){this.xhrFactory=t}handle(t){if("JSONP"===t.method)throw new Error("Attempted to construct Jsonp request without HttpClientJsonpModule installed.");return new _((n=>{const e=this.xhrFactory.build();if(e.open(t.method,t.urlWithParams),t.withCredentials&&(e.withCredentials=!0),t.headers.forEach(((t,n)=>e.setRequestHeader(t,n.join(",")))),t.headers.has("Accept")||e.setRequestHeader("Accept","application/json, text/plain, */*"),!t.headers.has("Content-Type")){const n=t.detectContentTypeHeader();null!==n&&e.setRequestHeader("Content-Type",n)}if(t.responseType){const n=t.responseType.toLowerCase();e.responseType="json"!==n?n:"text"}const a=t.serializeBody();let o=null;const r=()=>{if(null!==o)return o;const n=1223===e.status?204:e.status,a=e.statusText||"OK",r=new PR(e.getAllResponseHeaders()),i=(function c(t){return"responseURL"in t&&t.responseURL?t.responseURL:/^X-Request-URL:/m.test(t.getAllResponseHeaders())?t.getResponseHeader("X-Request-URL"):null})(e)||t.url;return o=new zR({headers:r,status:n,statusText:a,url:i}),o},i=()=>{let{headers:a,status:o,statusText:i,url:c}=r(),s=null;204!==o&&(s=void 0===e.response?e.responseText:e.response),0===o&&(o=s?200:0);let l=o>=200&&o<300;if("json"===t.responseType&&"string"==typeof s){const t=s;s=s.replace(UR,"");try{s=""!==s?JSON.parse(s):null}catch(n){s=t,l&&(l=!1,s={error:n,text:s})}}l?(n.next(new RR({body:s,headers:a,status:o,statusText:i,url:c||void 0})),n.complete()):n.error(new TR({error:s,headers:a,status:o,statusText:i,url:c||void 0}))},c=t=>{const{url:a}=r(),o=new TR({error:t,status:e.status||0,statusText:e.statusText||"Unknown Error",url:a||void 0});n.error(o)};let s=!1;const l=a=>{s||(n.next(r()),s=!0);let o={type:hR.DownloadProgress,loaded:a.loaded};a.lengthComputable&&(o.total=a.total),"text"===t.responseType&&e.responseText&&(o.partialText=e.responseText),n.next(o)},m=t=>{let e={type:hR.UploadProgress,loaded:t.loaded};t.lengthComputable&&(e.total=t.total),n.next(e)};return e.addEventListener("load",i),e.addEventListener("error",c),t.reportProgress&&(e.addEventListener("progress",l),null!==a&&e.upload&&e.upload.addEventListener("progress",m)),e.send(a),n.next({type:hR.Sent}),()=>{e.removeEventListener("error",c),e.removeEventListener("load",i),t.reportProgress&&(e.removeEventListener("progress",l),null!==a&&e.upload&&e.upload.removeEventListener("progress",m)),e.readyState!==e.DONE&&e.abort()}}))}}YR.ɵfac=function t(n){return new(n||YR)(Za(WR))},YR.ɵprov=We({token:YR,factory:YR.ɵfac}),YR.ctorParameters=()=>[{type:WR}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const qR=new Fa("XSRF_COOKIE_NAME"),ZR=new Fa("XSRF_HEADER_NAME");class XR{}class JR{constructor(t,n,e){this.doc=t,this.platform=n,this.cookieName=e,this.lastCookieString="",this.lastToken=null,this.parseCount=0}getToken(){if("server"===this.platform)return null;const t=this.doc.cookie||"";return t!==this.lastCookieString&&(this.parseCount++,this.lastToken=LM(t,this.cookieName),this.lastCookieString=t),this.lastToken}}JR.ɵfac=function t(n){return new(n||JR)(Za(zC),Za(T_),Za(qR))},JR.ɵprov=We({token:JR,factory:JR.ɵfac}),JR.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:String,decorators:[{type:Ie,args:[T_]}]},{type:String,decorators:[{type:Ie,args:[qR]}]}];class QR{constructor(t,n){this.tokenService=t,this.headerName=n}intercept(t,n){const e=t.url.toLowerCase();if("GET"===t.method||"HEAD"===t.method||e.startsWith("http://")||e.startsWith("https://"))return n.handle(t);const a=this.tokenService.getToken();return null===a||t.headers.has(this.headerName)||(t=t.clone({headers:t.headers.set(this.headerName,a)})),n.handle(t)}}QR.ɵfac=function t(n){return new(n||QR)(Za(XR),Za(ZR))},QR.ɵprov=We({token:QR,factory:QR.ɵfac}),QR.ctorParameters=()=>[{type:XR},{type:String,decorators:[{type:Ie,args:[ZR]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class KR{constructor(t,n){this.backend=t,this.injector=n,this.chain=null}handle(t){if(null===this.chain){const t=this.injector.get(FR,[]);this.chain=t.reduceRight(((t,n)=>new NR(t,n)),this.backend)}return this.chain.handle(t)}}KR.ɵfac=function t(n){return new(n||KR)(Za(OR),Za(yd))},KR.ɵprov=We({token:KR,factory:KR.ɵfac}),KR.ctorParameters=()=>[{type:OR},{type:yd}];class $R{static disable(){return{ngModule:$R,providers:[{provide:QR,useClass:LR}]}}static withOptions(t={}){return{ngModule:$R,providers:[t.cookieName?{provide:qR,useValue:t.cookieName}:[],t.headerName?{provide:ZR,useValue:t.headerName}:[]]}}}$R.ɵmod=xo({type:$R}),$R.ɵinj=Ge({factory:function t(n){return new(n||$R)},providers:[QR,{provide:FR,useExisting:QR,multi:!0},{provide:XR,useClass:JR},{provide:qR,useValue:"XSRF-TOKEN"},{provide:ZR,useValue:"X-XSRF-TOKEN"}]});class tT{}tT.ɵmod=xo({type:tT}),tT.ɵinj=Ge({factory:function t(n){return new(n||tT)},providers:[IR,{provide:MR,useClass:KR},YR,{provide:OR,useExisting:YR},GR,{provide:WR,useExisting:GR}],imports:[[$R.withOptions({cookieName:"XSRF-TOKEN",headerName:"X-XSRF-TOKEN"})]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(tT,{imports:[$R]});class nT{}nT.ɵmod=xo({type:nT}),nT.ɵinj=Ge({factory:function t(n){return new(n||nT)},providers:[VR,{provide:BR,useFactory:function eT(){return"object"==typeof window?window:{}}},{provide:FR,useClass:jR,multi:!0}]});const aT=()=>window.location.href;class oT{getHref(){return aT()}getSearch(){const t=new URLSearchParams(window.location.search),n=[];return t.forEach(((t,e)=>{n.push({key:e,value:t})})),n}getHash(){return window.location.hash}getPath(){return window.location.pathname}replaceState(t){window.history.replaceState(null,"",t)}pushState(t){window.history.pushState(null,"",t)}onPopState(){return Vt(window,"popstate").pipe(ft((()=>({pathname:this.getPath(),queryParams:this.getSearch()}))))}getResolvedPath(t){return new URL(t,aT()).pathname}getFullPathFromRouteOrNav(t,n){const e=this.getResolvedPath(t.pathname);let a="";return!(function o(t){return t.hasOwnProperty("pathname")&&!t.hasOwnProperty("queryParams")})(t)&&t.queryParams.length&&(a="?"+(function r(t){const n=new URLSearchParams;for(const{key:e,value:a}of t)n.append(e,a);return n})(t.queryParams).toString()),`${e}${a}${n?this.getHash():""}`}}oT.ɵfac=function t(n){return new(n||oT)},oT.ɵprov=We({token:oT,factory:oT.ɵfac});class rT{constructor(t){this.appRoot=this.getAppRootFromMetaElement(t)}getAppRootFromMetaElement(t){const n=document.querySelector('head meta[name="tb-relative-root"]');if(!n)return"/";const{pathname:e}=new URL(n.content,t.getHref());return e.replace(/\/*$/,"/")}getAbsPathnameWithAppRoot(t){return this.appRoot.slice(0,-1)+t}getAppRootlessPathname(t){return t.startsWith(this.appRoot)?"/"+t.slice(this.appRoot.length):t}}rT.ɵfac=function t(n){return new(n||rT)(Za(oT))},rT.ɵprov=We({token:rT,factory:rT.ɵfac});class iT extends rT{getAppRoot(){return this.appRoot}setAppRoot(t){this.appRoot=t}}iT.ɵfac=function t(n){return cT(n||iT)},iT.ɵprov=We({token:iT,factory:iT.ɵfac});const cT=tc(iT);function sT(t){const n={};for(const[e,a]of t.entries())n[e]=a;return n}function lT(t){let n=t.headers||new PR;return n=n.append("X-XSRF-Protected","1"),Object.assign(Object.assign({},t),{headers:n})}class mT{constructor(t,n,e){this.appRootProvider=t,this.http=n,this.store=e}resolveAppRoot(t){return t.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(t):t}get(t,n={}){return this.http.get(this.resolveAppRoot(t),n)}post(t,n,e={}){return e=lT(e),this.store.select(mR).pipe(Gt((t=>Boolean(t))),Tn(1),ye(this.store.select(bR)),Tt((([,a])=>{const o=this.resolveAppRoot(t);return a?this.http.get(o,{headers:e.headers,params:sT(n)}):this.http.post(o,n,e)})))}put(t,n,e={}){return this.http.put(this.resolveAppRoot(t),n,lT(e))}delete(t,n={}){return this.http.delete(this.resolveAppRoot(t),lT(n))}}mT.ɵfac=function t(n){return new(n||mT)(Za(rT),Za(IR),Za(cv))},mT.ɵprov=We({token:mT,factory:mT.ɵfac});const dT="timeseries";var gT;!(function(t){t.SCALARS="scalars",t.HISTOGRAMS="histograms",t.IMAGES="images"})(gT||(gT={}));const pT=[gT.IMAGES];function bT(t){return pT.includes(t)}const uT=[gT.HISTOGRAMS,gT.IMAGES];function fT(t){return uT.includes(t)}function hT(t){return fT(t.plugin)}class _T{}function CT(t){return t.hasOwnProperty("error")}const MT="data/plugin/timeseries";function OT(t){const n=t.indexOf("/");return{run:t.substring(n+1),experimentId:t.substring(0,n)}}function PT(t,n){return`${n}/${t}`}function xT(t,n){const{runToSeries:e,run:a}=t,o=_R(t,["runToSeries","run"]),r=Object.assign({},o);return e&&(r.runToSeries=yT(e,n)),a&&(r.runId=PT(a,n)),r}function yT(t,n){const e={};for(const a in t)t.hasOwnProperty(a)&&(e[PT(a,n)]=t[a]);return e}class kT{constructor(t){this.http=t}fetchTagMetadata(t){return Ht(t.map((t=>this.http.get(`/experiment/${t}/${MT}/tags`).pipe(ft((n=>(function e(t,n){const e={};for(const a of Object.keys(t)){const o=a;if(bT(o)){const a=t[o],{tagRunSampledInfo:r}=a,i=_R(a,["tagRunSampledInfo"]),c={};for(const t in r)r.hasOwnProperty(t)&&(c[t]=yT(r[t],n));e[o]=Object.assign(Object.assign({},i),{tagRunSampledInfo:c})}else{const a=t[o],{runTagInfo:r}=a,i=_R(a,["runTagInfo"]);e[o]=Object.assign(Object.assign({},i),{runTagInfo:yT(r,n)})}}return e})(n,t))))))).pipe(ft((t=>(function n(t){const n={};for(const e of t)for(const t of Object.values(gT))if(bT(t)){n[t]=n[t]||{tagDescriptions:{},tagRunSampledInfo:{}};const{tagDescriptions:a,tagRunSampledInfo:o}=e[t];n[t].tagDescriptions=Object.assign(Object.assign({},n[t].tagDescriptions),a);const r=n[t].tagRunSampledInfo;for(const t of Object.keys(o)){r[t]=r[t]||{};for(const n of Object.keys(o[t]))r[t][n]=o[t][n]}}else{n[t]=n[t]||{tagDescriptions:{},runTagInfo:{}};const{tagDescriptions:a,runTagInfo:o}=e[t];n[t].tagDescriptions=Object.assign(Object.assign({},n[t].tagDescriptions),a),n[t].runTagInfo=Object.assign(Object.assign({},n[t].runTagInfo),o)}return n})(t))))}fetchTimeSeries(t){const n=t.map((t=>{if(fT(t.plugin)){const n=t,{runId:e}=n,a=_R(n,["runId"]),{run:o,experimentId:r}=OT(e),i=Object.assign(Object.assign({},a),{run:o});return this.fetchTimeSeriesBackendRequest(i,r).pipe(ft((({response:t,experimentId:n})=>xT(t,n))))}const n=t,{experimentIds:e}=n,a=_R(n,["experimentIds"]);return Ht(e.map((t=>this.fetchTimeSeriesBackendRequest(a,t)))).pipe(ft((t=>{const n=_R(t[0].response,["runToSeries","error"]);for(const{response:e,experimentId:a}of t){const t=xT(e,a);if(n.error)continue;const{runToSeries:o,error:r}=t;if(r)n.error=r,n.runToSeries=void 0;else{n.runToSeries=n.runToSeries||{};for(const t of Object.keys(o))n.runToSeries[t]=o[t]}}return n})))}));return Ht(n)}fetchTimeSeriesBackendRequest(t,n){const e=new FormData;return e.append("requests",JSON.stringify([t])),this.http.post(`/experiment/${n}/${MT}/timeSeries`,e).pipe(ft((t=>({response:t[0],experimentId:n}))))}imageUrl(t){return`${MT}/imageData?imageId=${t}`}downloadUrl(t,n,e,a){const{run:o,experimentId:r}=OT(e);let i;switch(t){case gT.SCALARS:i="scalars/scalars";break;default:throw new Error(`Not implemented: downloadUrl for ${t} is not implemented yet`)}if(!r)throw new Error("experimentId is empty; it is required to form downloadUrl.");return`/experiment/${r}/data/plugin/${i}?${new URLSearchParams({tag:n,run:o,format:a})}`}}kT.ɵfac=function t(n){return new(n||kT)(Za(mT))},kT.ɵprov=We({token:kT,factory:kT.ɵfac});class vT{}vT.ɵmod=xo({type:vT}),vT.ɵinj=Ge({factory:function t(n){return new(n||vT)},providers:[oT]});class wT{}wT.ɵmod=xo({type:wT}),wT.ɵinj=Ge({factory:function t(n){return new(n||wT)},providers:[rT],imports:[[vT]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(wT,{imports:[vT]});class ST{}ST.ɵmod=xo({type:ST}),ST.ɵinj=Ge({factory:function t(n){return new(n||ST)},providers:[mT],imports:[[tT,wT]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(ST,{imports:[tT,wT]});class ET{}function AT(t,n,e,a){return t[n].hasOwnProperty(e)?bT(n)?t[n][e].hasOwnProperty(a)?t[n][e][a]:null:t[n][e]:null}function zT(t,n,e,a){if(bT(n)){const o=Object.assign({},t[n]),r=(function o(t,n,e){const a=t.hasOwnProperty(n)?Object.assign({},t[n]):{},o=a.hasOwnProperty(e);return a[e]=o?Object.assign({},a[e]):{runToSeries:{},runToLoadState:{}},a})(o,e,a);return o[e]=r,o}const r=Object.assign({},t[n]),i=r.hasOwnProperty(e);return r[e]=i?Object.assign({},r[e]):{runToSeries:{},runToLoadState:{}},r}function RT(t){return JSON.stringify(t)}function TT(t,n,e){const a=Object.assign({},e);for(const e of n)a[e]=t;return a}function DT(t,n,e,a){if(bT(n)){const o=t[n].tagRunSampledInfo;return o.hasOwnProperty(e)?Object.keys(o[e]).filter((t=>a<o[e][t].maxSamplesPerStep)):[]}const o=t[n].tagToRuns;return o.hasOwnProperty(e)?o[e]:[]}function IT(t,n,e,a,o,r){const i=new Set(t),c=[];for(const a of t)for(const t of n)if((s=e[t]).plugin===(l=a).plugin&&s.tag===l.tag&&s.sample===l.sample&&(s.runId===l.runId||!s.runId&&!l.runId)){c.push(t),i.delete(a);break}var s,l;if(!c.length)return{unresolvedImportedPinnedCards:t,cardMetadataMap:e,cardToPinnedCopy:a,pinnedCardToOriginal:o,cardStepIndex:r};let m={cardToPinnedCopy:a,pinnedCardToOriginal:o,cardStepIndex:r,cardMetadataMap:e};for(const t of c)m=NT(t,m.cardToPinnedCopy,m.pinnedCardToOriginal,m.cardStepIndex,m.cardMetadataMap);return Object.assign(Object.assign({},m),{unresolvedImportedPinnedCards:[...i]})}function NT(t,n,e,a,o){if(n.has(t))return{cardToPinnedCopy:n,pinnedCardToOriginal:e,cardStepIndex:a,cardMetadataMap:o};const r=new Map(n),i=new Map(e),c=Object.assign({},a),s=Object.assign({},o),l=(function m(t){return JSON.stringify({baseCardId:t})})(t);r.set(t,l),i.set(l,t),a.hasOwnProperty(t)&&(c[l]=a[t]);const d=o[t];if(!d)throw new Error("Cannot pin a card without metadata");return s[l]=d,{cardToPinnedCopy:r,pinnedCardToOriginal:i,cardStepIndex:c,cardMetadataMap:s}}function FT(t){return t.pinnedCardToOriginal.size+t.unresolvedImportedPinnedCards.length<10}var LT,HT,BT,VT,jT,UT,WT;ET.ɵmod=xo({type:ET}),ET.ɵinj=Ge({factory:function t(n){return new(n||ET)},providers:[{provide:_T,useClass:kT}],imports:[[ST]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(ET,{imports:[ST]}),(function(t){t.STEP="step",t.WALL_TIME="wall_time",t.RELATIVE="relative"})(LT||(LT={})),(function(t){t.OFFSET="offset",t.OVERLAY="overlay"})(HT||(HT={})),(function(t){t.BOTTOM="bottom",t.RIGHT="right",t.AUTO="auto"})(BT||(BT={})),(function(t){t.DEFAULT="default",t.ASCENDING="ascending",t.DESCENDING="descending",t.NEAREST="nearest"})(VT||(VT={})),(function(t){t.STEP="step",t.RELATIVE="relative",t.WALL_TIME="wall_time"})(jT||(jT={})),(function(t){t.LINEAR="linear",t.LOG="log"})(UT||(UT={})),(function(t){t[t.STEP=0]="STEP",t[t.RELATIVE=1]="RELATIVE",t[t.WALL_TIME=2]="WALL_TIME"})(WT||(WT={}));const GT="metrics",YT={tooltipSort:VT.DEFAULT,ignoreOutliers:!0,xAxisType:WT.STEP,scalarSmoothing:.6,scalarPartitionNonMonotonicX:!1,imageBrightnessInMilli:1e3,imageContrastInMilli:1e3,imageShowActualSize:!1,histogramMode:HT.OFFSET},qT=uv(GT),ZT=pv(qT,(t=>t.tagMetadataLoaded));pv(qT,(t=>t.tagMetadata));const XT=pv(qT,(t=>t.cardList)),JT=pv(qT,((t,n)=>{if(!t.cardMetadataMap.hasOwnProperty(n))return fR.NOT_LOADED;const{plugin:e,tag:a,runId:o,sample:r}=t.cardMetadataMap[n],i=AT(t.timeSeriesData,e,a,r);if(!i)return fR.NOT_LOADED;const c=i.runToLoadState;if(o)return c.hasOwnProperty(o)?c[o]:fR.NOT_LOADED;const s=DT(t.tagMetadata,e,a,r);if(!s.length)throw new Error("Cannot load a card whose tag has no runs");return s.every((t=>c[t]===fR.LOADED))?fR.LOADED:s.some((t=>c[t]===fR.LOADING))?fR.LOADING:fR.NOT_LOADED})),QT=pv(qT,((t,n)=>{if(!t.cardMetadataMap.hasOwnProperty(n))return null;const{plugin:e,tag:a,sample:o}=t.cardMetadataMap[n],r=AT(t.timeSeriesData,e,a,o);return r?r.runToSeries:null})),KT=pv(qT,(t=>t.cardMetadataMap)),$T=pv(KT,((t,n)=>t.hasOwnProperty(n)?t[n]:null)),tD=pv(qT,(t=>t.visibleCards)),nD=pv(tD,(t=>t)),eD=pv(XT,KT,((t,n)=>t.filter((t=>n.hasOwnProperty(t))).map((t=>Object.assign({cardId:t},n[t]))))),aD=pv(qT,((t,n)=>t.cardStepIndex.hasOwnProperty(n)?t.cardStepIndex[n]:null)),oD=pv(qT,(t=>t.cardToPinnedCopy)),rD=pv(qT,(t=>t.pinnedCardToOriginal)),iD=pv(oD,KT,((t,n)=>[...t.values()].filter((t=>n.hasOwnProperty(t))).map((t=>Object.assign({cardId:t},n[t]))))),cD=pv(oD,rD,((t,n,e)=>t.has(e)||n.has(e))),sD=pv(qT,(t=>t.unresolvedImportedPinnedCards)),lD=pv(qT,(t=>FT(t))),mD=pv(qT,(t=>t.settings)),dD=pv(mD,(t=>t.tooltipSort)),gD=pv(mD,(t=>t.ignoreOutliers)),pD=pv(mD,(t=>t.xAxisType)),bD=pv(mD,(t=>t.histogramMode)),uD=pv(mD,(t=>t.scalarSmoothing)),fD=pv(mD,(t=>t.scalarPartitionNonMonotonicX)),hD=pv(mD,(t=>t.imageBrightnessInMilli)),_D=pv(mD,(t=>t.imageContrastInMilli)),CD=pv(mD,(t=>t.imageShowActualSize)),MD=pv(qT,(t=>t.tagFilter)),OD=pv(qT,((t,n)=>Boolean(t.tagGroupExpanded.get(n))));var PD;!(function(t){t[t.NONE=0]="NONE",t[t.WHATS_NEW=1]="WHATS_NEW"})(PD||(PD={}));const xD=uv("notification");var yD,kD,vD,wD;pv(xD,(t=>t.notifications)),pv(xD,(t=>{var n;return null!==(n=t.lastReadTimestampInMs)&&void 0!==n?n:-1})),(function(t){t.DATASET_UNKNOWN="DATASET_UNKNOWN",t.DATASET_TRAINING="DATASET_TRAINING",t.DATASET_VALIDATION="DATASET_VALIDATION"})(yD||(yD={})),(function(t){t.STATUS_UNKNOWN="STATUS_UNKNOWN",t.STATUS_SUCCESS="STATUS_SUCCESS",t.STATUS_FAILURE="STATUS_FAILURE",t.STATUS_RUNNING="STATUS_RUNNING"})(kD||(kD={})),(function(t){t.DATA_TYPE_UNSET="DATA_TYPE_UNSET",t.DATA_TYPE_STRING="DATA_TYPE_STRING",t.DATA_TYPE_BOOL="DATA_TYPE_BOOL",t.DATA_TYPE_FLOAT64="DATA_TYPE_FLOAT64"})(vD||(vD={})),(function(t){t[t.DISCRETE=0]="DISCRETE",t[t.INTERVAL=1]="INTERVAL"})(wD||(wD={}));class SD{}SD.ɵfac=function t(n){return new(n||SD)},SD.ɵprov=We({token:SD,factory:SD.ɵfac,providedIn:"root"});const ED="runs";function AD(t){return JSON.stringify(t.slice().sort())}const zD=uv(ED),RD=pv(zD,(t=>t.data)),TD=pv(RD,((t,n)=>{var e;return null!==(e=t.runIdToExpId[n.runId])&&void 0!==e?e:null})),DD=pv(RD,((t,n)=>{var e;return null!==(e=t.runMetadata[n.runId])&&void 0!==e?e:null})),ID=pv(RD,((t,n)=>(t.runIds[n.experimentId]||[]).filter((n=>Boolean(t.runMetadata[n]))).map((n=>t.runMetadata[n])))),ND=pv(RD,(t=>new Map(Object.entries(t.runMetadata)))),FD=pv(RD,((t,n)=>t.runsLoadState[n.experimentId]||{lastLoadedTimeInMs:null,state:fR.NOT_LOADED})),LD=pv(RD,(t=>t.hparamAndMetricSpec)),HD=pv(LD,((t,n)=>(function e(...t){const n=new Map,e=new Map,a=new Map,o=new Map,r=[];for(const i of t){for(const t of i.hparams)if(e.has(t.name)||e.set(t.name,new Set),e.get(t.name).add(t.displayName),n.has(t.name)){const e=n.get(t.name),a=t;if(e.type!==a.type&&r.push(`Hparam, ${a.name}, types have to match. Got: ${e.type} vs. ${a.type}`),e.domain.type===wD.INTERVAL&&a.domain.type===wD.INTERVAL)e.domain.minValue===a.domain.minValue&&e.domain.maxValue===a.domain.maxValue||r.push(`Hparam, ${a.name}, domains have to match. Got: ${e.domain} vs. ${a.domain}`);else if(e.domain.type===wD.DISCRETE&&a.domain.type===wD.DISCRETE){const t=new Set([...e.domain.values,...a.domain.values]);e.domain.values.length===a.domain.values.length&&e.domain.values.length===t.size||r.push(`Hparam, ${a.name}, domains have to match. Got: ${e.domain} vs. ${a.domain}`)}else r.push(`Hparam, ${a.name}, domains have to match. Got: ${e.domain} vs. ${a.domain}`)}else n.set(t.name,Object.assign({},t));for(const t of i.metrics)if(o.has(t.tag)||o.set(t.tag,new Set),o.get(t.tag).add(t.displayName),a.has(t.tag)){const n=a.get(t.tag),e=t;n.datasetType!==e.datasetType&&r.push(`Metric, ${e.tag}, datasetTypes have to match. Got: ${n.datasetType} vs. ${e.datasetType}`)}else a.set(t.tag,Object.assign({},t))}if(r.length)throw new Error(`Validation error:\n${r.join("\n")}`);return{hparams:[...n].map((([t,n])=>Object.assign(Object.assign({},n),{displayName:[...e.get(t)].join(" or ")}))),metrics:[...a].map((([t,n])=>Object.assign(Object.assign({},n),{displayName:[...o.get(t)].join(" or ")})))}})(...n.experimentIds.map((n=>t[n])).filter(Boolean)))),BD=pv(RD,((t,n)=>{const e=AD(n.experimentIds);return t.selectionState.get(e)||new Map})),VD=pv(zD,(t=>t.ui)),jD=pv(VD,(t=>t.paginationOption)),UD=pv(VD,(t=>t.regexFilter)),WD=pv(VD,(t=>t.sort)),GD=pv(VD,(t=>{const n=new Map([...t.defaultRunColor,...t.runColorOverride]),e={};return n.forEach(((t,n)=>{e[n]=t})),e})),YD=pv(VD,(t=>t.hparamDefaultFilters)),qD=pv(VD,(t=>t.hparamFilters)),ZD=pv(VD,(t=>t.metricDefaultFilters)),XD=pv(VD,(t=>t.metricFilters)),JD=pv(YD,qD,((t,n)=>new Map([...t,...n]))),QD=pv(ZD,XD,((t,n)=>new Map([...t,...n]))),KD=pv((t=>{const n=eR(t);return null===n?null:BD(t,{experimentIds:n})}),(t=>t)),$D=/[\\^$.*+?()[\]{}|]/g,tI="\\u0000-\\u0020\\u007f-\\u009f",nI=new RegExp("(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s"+tI+'"]{2,}[^\\s'+tI+"\"')}\\],:;.!?]","gu");function eI(t){return(function n(t,e){e.flags.includes("g")||(e=new RegExp(e,e.flags+"g"));const a=[];let o=0;for(const n of t.matchAll(e)){const e=n.index,r=n[0];e>o&&a.push({index:o,text:t.substring(o,e),matchesRegex:!1}),a.push({index:e,text:r,matchesRegex:!0}),o=e+r.length}return t.length>o&&a.push({index:o,text:t.substring(o,t.length),matchesRegex:!1}),a})(t,nI).map((({matchesRegex:t,text:n})=>({isURL:t,text:n})))}function aI(t,n){if(1&t&&(np(0),Jp(1),ep()),2&t){const t=gp().$implicit;ws(1),Kp(" ",t.text," ")}}function oI(t,n){if(1&t&&(Kg(0,"a",8),Jp(1),$g()),2&t){const t=gp().$implicit;_p("href",t.text,Xc),ws(1),Qp(t.text)}}function rI(t,n){if(1&t&&(np(0),Yg(1,aI,2,1,"ng-container",6),Yg(2,oI,2,2,"ng-template",null,7,Kf),ep()),2&t){const t=n.$implicit,e=qg(3);ws(1),Jg("ngIf",!t.isURL)("ngIfElse",e)}}function iI(t,n){if(1&t){const t=op();Kg(0,"button",9),cp("click",(function n(){return jr(t),gp().onActionButtonClicked()})),Jp(1),$g()}if(2&t){const t=gp();ws(1),Kp(" ",t.alert.followupAction.localizedLabel," ")}}class cI{constructor(t,n,e){this.snackBarRef=t,this.unknownData=n,this.store=e,this.splitByURL=eI,this.alert=n}onActionButtonClicked(){return CR(this,void 0,void 0,(function*(){this.snackBarRef.dismiss();const t=yield this.alert.followupAction.getFollowupAction(this.store);this.store.dispatch(t)}))}onCloseButtonClicked(){this.snackBarRef.dismiss()}}cI.ɵfac=function t(n){return new(n||cI)(Zg(Lz),Zg(Iz),Zg(cv))},cI.ɵcmp=_o({type:cI,selectors:[["alert-display-snackbar"]],decls:7,vars:2,consts:function(){return[[1,"message"],[4,"ngFor","ngForOf"],[1,"controls"],["mat-button","","class","followup-button",3,"click",4,"ngIf"],["mat-button","",1,"dismiss-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Dismiss"):$localize`:A button to close the snackbar message␟ea4d9fe61420a3fce81cf54c4c615e3c19c646a6␟1536087519743707362:Dismiss`],[4,"ngIf","ngIfElse"],["linkPiece",""],["rel","noreferrer noopener","target","_blank",3,"href"],["mat-button","",1,"followup-button",3,"click"]]},template:function t(n,e){1&n&&(Kg(0,"div",0),Yg(1,rI,4,2,"ng-container",1),$g(),Kg(2,"div",2),Yg(3,iI,2,1,"button",3),Kg(4,"button",4),lu(5,5),cp("click",(function t(){return e.onCloseButtonClicked()})),Jp(6," Dismiss "),$g(),$g()),2&n&&(ws(1),Jg("ngForOf",e.splitByURL(e.alert.localizedMessage)),ws(2),Jg("ngIf",e.alert.followupAction))},directives:[jM,WM,eA],styles:["[_nghost-%COMP%]{display:flex;flex-wrap:wrap}.message[_ngcontent-%COMP%]{font-size:14px;align-self:center;margin:5px 0;word-break:break-word}.message[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{color:inherit}.controls[_ngcontent-%COMP%]{white-space:nowrap;margin-left:auto}button[_ngcontent-%COMP%]{text-transform:uppercase}"],changeDetection:0});class sI{constructor(t,n){this.store=t,this.snackBar=n,this.ngUnsubscribe=new x}ngOnInit(){this.store.select(kw).pipe(de(this.ngUnsubscribe),Gt((t=>Boolean(t)))).subscribe((t=>{this.showAlert(t)}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}showAlert(t){this.snackBar.openFromComponent(cI,{duration:5e3,horizontalPosition:"start",verticalPosition:"bottom",data:t})}}sI.ɵfac=function t(n){return new(n||sI)(Zg(cv),Zg(Gz))},sI.ɵcmp=_o({type:sI,selectors:[["alert-snackbar"]],decls:0,vars:0,template:function t(n,e){},encapsulation:2,changeDetection:0});class lI{}lI.ɵmod=xo({type:lI}),lI.ɵinj=Ge({factory:function t(n){return new(n||lI)},imports:[[PO,oA,jz]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(lI,{declarations:[sI,cI],imports:[PO,oA,jz],exports:[sI]});class mI{}mI.ɵmod=xo({type:mI}),mI.ɵinj=Ge({factory:function t(n){return new(n||mI)},imports:[[Mw,lI,Iv.forFeature(yw,(function dI(t,n){return xw(t,n)})),fw.forFeature([Pw])]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(mI,{imports:[Mw,lI,Dv,uw]});const gI=Ok("[Core] Plugin Changed",{_as:"props",_p:void 0}),pI=Ok("[Core] Plugin Url Hash Changed",{_as:"props",_p:void 0}),bI=Ok("[Core] Loaded"),uI=Ok("[Core] User Triggered Reload"),fI=Ok("[Core] Auto Reload"),hI=Ok("[Core] PluginListing Fetch Requested"),_I=Ok("[Core] PluginListing Fetch Successful",{_as:"props",_p:void 0}),CI=Ok("[Core] PluginListing Fetch Failed",{_as:"props",_p:void 0}),MI=Ok("[Core] Environment Fetch Successful",{_as:"props",_p:void 0}),OI=Ok("[Core] Reload Enable Toggled"),PI=Ok("[Core] Reload Period Change",{_as:"props",_p:void 0}),xI=Ok("[Core] Page Size Change",{_as:"props",_p:void 0}),yI=Ok("[Core] Run Selection Changed",{_as:"props",_p:void 0}),kI=Ok("[Core] Run Fetch Successful",{_as:"props",_p:void 0}),vI=["*",[["mat-toolbar-row"]]],wI=eE(class{constructor(t){this._elementRef=t}});class SI{}SI.ɵfac=function t(n){return new(n||SI)},SI.ɵdir=vo({type:SI,selectors:[["mat-toolbar-row"]],hostAttrs:[1,"mat-toolbar-row"],exportAs:["matToolbarRow"]});class EI extends wI{constructor(t,n,e){super(t),this._platform=n,this._document=e}ngAfterViewInit(){this._platform.isBrowser&&(this._checkToolbarMixedModes(),this._toolbarRows.changes.subscribe((()=>this._checkToolbarMixedModes())))}_checkToolbarMixedModes(){this._toolbarRows.length&&("undefined"==typeof ngDevMode||ngDevMode)&&Array.from(this._elementRef.nativeElement.childNodes).filter((t=>!(t.classList&&t.classList.contains("mat-toolbar-row")))).filter((t=>t.nodeType!==(this._document?this._document.COMMENT_NODE:8))).some((t=>!(!t.textContent||!t.textContent.trim())))&&(function t(){throw Error("MatToolbar: Attempting to combine different toolbar modes. Either specify multiple `<mat-toolbar-row>` elements explicitly or just place content inside of a `<mat-toolbar>` for a single row.")}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)()}}EI.ɵfac=function t(n){return new(n||EI)(Zg(xu),Zg(Sw),Zg(zC))},EI.ɵcmp=_o({type:EI,selectors:[["mat-toolbar"]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,SI,!0),2&n&&Vf(o=Zf())&&(e._toolbarRows=o)},hostAttrs:[1,"mat-toolbar"],hostVars:4,hostBindings:function t(n,e){2&n&&Dp("mat-toolbar-multiple-rows",e._toolbarRows.length>0)("mat-toolbar-single-row",0===e._toolbarRows.length)},inputs:{color:"color"},exportAs:["matToolbar"],features:[hg],ngContentSelectors:["*","mat-toolbar-row"],decls:2,vars:0,template:function t(n,e){1&n&&(bp(vI),hp(0),hp(1,1))},styles:[".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}\n"],encapsulation:2,changeDetection:0}),EI.ctorParameters=()=>[{type:xu},{type:Sw},{type:void 0,decorators:[{type:Ie,args:[zC]}]}],EI.propDecorators={_toolbarRows:[{type:qd,args:[SI,{descendants:!0}]}]};class AI{}AI.ɵmod=xo({type:AI}),AI.ɵinj=Ge({factory:function t(n){return new(n||AI)},imports:[[tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(AI,{declarations:function(){return[EI,SI]},imports:function(){return[tE]},exports:function(){return[EI,SI,tE]}});const zI="core",RI={activePlugin:null,plugins:{},pluginsListLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null,failureCode:null},reloadPeriodInMs:3e4,reloadEnabled:!1,pageSize:12,environment:{data_location:"",window_title:""},polymerInteropRuns:[],polymerInteropRunSelection:new Set},TI=Uv(RI,jv(gI,pI,((t,{plugin:n})=>Object.assign(Object.assign({},t),{activePlugin:n}))),jv(hI,(t=>Object.assign(Object.assign({},t),{pluginsListLoaded:Object.assign(Object.assign({},t.pluginsListLoaded),{state:fR.LOADING})}))),jv(CI,((t,{failureCode:n})=>Object.assign(Object.assign({},t),{pluginsListLoaded:Object.assign(Object.assign({},t.pluginsListLoaded),{state:fR.FAILED,failureCode:n})}))),jv(_I,((t,{plugins:n})=>{const e=Object.keys(n).find((t=>n[t].enabled))||null,a=t.activePlugin||e;return Object.assign(Object.assign({},t),{activePlugin:a,plugins:n,pluginsListLoaded:{state:fR.LOADED,lastLoadedTimeInMs:Date.now(),failureCode:null}})})),jv(MI,((t,{environment:n})=>Object.assign(Object.assign({},t),{environment:n}))),jv(OI,(t=>Object.assign(Object.assign({},t),{reloadEnabled:!t.reloadEnabled}))),jv(PI,((t,{periodInMs:n})=>{const e=n>0?n:t.reloadPeriodInMs;return Object.assign(Object.assign({},t),{reloadPeriodInMs:e})})),jv(xI,((t,{size:n})=>{const e=n>0?n:t.pageSize;return Object.assign(Object.assign({},t),{pageSize:e})})),jv(kI,((t,{runs:n})=>Object.assign(Object.assign({},t),{polymerInteropRuns:n}))),jv(yI,((t,{nextSelection:n})=>Object.assign(Object.assign({},t),{polymerInteropRunSelection:new Set(n)})))),DI=uv(zI),II=pv(DI,(t=>t.pluginsListLoaded)),NI=pv(DI,(t=>t.activePlugin)),FI=pv(DI,(t=>t.plugins)),LI=pv(DI,(t=>t.environment)),HI=pv(DI,(t=>t.reloadEnabled)),BI=pv(DI,(t=>t.reloadPeriodInMs)),VI=pv(DI,(t=>t.pageSize));function jI(t,n){1&t&&hp(0)}const UI=["*"];function WI(t,n){}const GI=function(t){return{animationDuration:t}},YI=function(t,n){return{value:t,params:n}},qI=["tabBodyWrapper"],ZI=["tabHeader"];function XI(t,n){}function JI(t,n){1&t&&Yg(0,XI,0,0,"ng-template",9),2&t&&Jg("cdkPortalOutlet",gp().$implicit.templateLabel)}function QI(t,n){1&t&&Jp(0),2&t&&Qp(gp().$implicit.textLabel)}function KI(t,n){if(1&t){const t=op();Kg(0,"div",6),cp("click",(function e(){jr(t);const a=n.$implicit,o=n.index,r=gp(),i=qg(1);return r._handleClick(a,i,o)})),Kg(1,"div",7),Yg(2,JI,1,1,"ng-template",8),Yg(3,QI,1,1,"ng-template",8),$g(),$g()}if(2&t){const t=n.$implicit,e=n.index,a=gp();Dp("mat-tab-label-active",a.selectedIndex==e),Jg("id",a._getTabLabelId(e))("disabled",t.disabled)("matRippleDisabled",t.disabled||a.disableRipple),Ng("tabIndex",a._getTabIndex(t,e))("aria-posinset",e+1)("aria-setsize",a._tabs.length)("aria-controls",a._getTabContentId(e))("aria-selected",a.selectedIndex==e)("aria-label",t.ariaLabel||null)("aria-labelledby",!t.ariaLabel&&t.ariaLabelledby?t.ariaLabelledby:null),ws(2),Jg("ngIf",t.templateLabel),ws(1),Jg("ngIf",!t.templateLabel)}}function $I(t,n){if(1&t){const t=op();Kg(0,"mat-tab-body",10),cp("_onCentered",(function n(){return jr(t),gp()._removeTabBodyWrapperHeight()}))("_onCentering",(function n(e){return jr(t),gp()._setTabBodyWrapperHeight(e)})),$g()}if(2&t){const t=n.$implicit,e=n.index,a=gp();Dp("mat-tab-body-active",a.selectedIndex==e),Jg("id",a._getTabContentId(e))("content",t.content)("position",t.position)("origin",t.origin)("animationDuration",a.animationDuration),Ng("aria-labelledby",a._getTabLabelId(e))}}const tN=["tabListContainer"],nN=["tabList"],eN=["nextPaginator"],aN=["previousPaginator"],oN=new Fa("MatInkBarPositioner",{providedIn:"root",factory:function rN(){return t=>({left:t?(t.offsetLeft||0)+"px":"0",width:t?(t.offsetWidth||0)+"px":"0"})}});class iN{constructor(t,n,e,a){this._elementRef=t,this._ngZone=n,this._inkBarPositioner=e,this._animationMode=a}alignToElement(t){this.show(),"undefined"!=typeof requestAnimationFrame?this._ngZone.runOutsideAngular((()=>{requestAnimationFrame((()=>this._setStyles(t)))})):this._setStyles(t)}show(){this._elementRef.nativeElement.style.visibility="visible"}hide(){this._elementRef.nativeElement.style.visibility="hidden"}_setStyles(t){const n=this._inkBarPositioner(t),e=this._elementRef.nativeElement;e.style.left=n.left,e.style.width=n.width}}iN.ɵfac=function t(n){return new(n||iN)(Zg(xu),Zg(J_),Zg(oN),Zg(dk,8))},iN.ɵdir=vo({type:iN,selectors:[["mat-ink-bar"]],hostAttrs:[1,"mat-ink-bar"],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode)}}),iN.ctorParameters=()=>[{type:xu},{type:J_},{type:void 0,decorators:[{type:Ie,args:[oN]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const cN=new Fa("MatTabContent");class sN{constructor(t){this.template=t}}sN.ɵfac=function t(n){return new(n||sN)(Zg(Ju))},sN.ɵdir=vo({type:sN,selectors:[["","matTabContent",""]],features:[Mu([{provide:cN,useExisting:sN}])]}),sN.ctorParameters=()=>[{type:Ju}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const lN=new Fa("MatTabLabel");class mN extends DA{}mN.ɵfac=function t(n){return dN(n||mN)},mN.ɵdir=vo({type:mN,selectors:[["","mat-tab-label",""],["","matTabLabel",""]],features:[Mu([{provide:lN,useExisting:mN}]),hg]});const dN=tc(mN),gN=nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{}),pN=new Fa("MAT_TAB_GROUP");class bN extends gN{constructor(t,n){super(),this._viewContainerRef=t,this._closestTabGroup=n,this.textLabel="",this._contentPortal=null,this._stateChanges=new x,this.position=null,this.origin=null,this.isActive=!1}get templateLabel(){return this._templateLabel}set templateLabel(t){this._setTemplateLabelInput(t)}get content(){return this._contentPortal}ngOnChanges(t){(t.hasOwnProperty("textLabel")||t.hasOwnProperty("disabled"))&&this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}ngOnInit(){this._contentPortal=new AA(this._explicitContent||this._implicitContent,this._viewContainerRef)}_setTemplateLabelInput(t){t&&(this._templateLabel=t)}}bN.ɵfac=function t(n){return new(n||bN)(Zg($u),Zg(pN,8))},bN.ɵcmp=_o({type:bN,selectors:[["mat-tab"]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,lN,!0),Yf(a,cN,!0,Ju)),2&n&&(Vf(o=Zf())&&(e.templateLabel=o.first),Vf(o=Zf())&&(e._explicitContent=o.first))},viewQuery:function t(n,e){var a;1&n&&jf(Ju,!0),2&n&&Vf(a=Zf())&&(e._implicitContent=a.first)},inputs:{disabled:"disabled",textLabel:["label","textLabel"],ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"]},exportAs:["matTab"],features:[hg,pr],ngContentSelectors:UI,decls:1,vars:0,template:function t(n,e){1&n&&(bp(),Yg(0,jI,1,0,"ng-template"))},encapsulation:2}),bN.ctorParameters=()=>[{type:$u},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[pN]}]}],bN.propDecorators={templateLabel:[{type:Zd,args:[lN]}],_explicitContent:[{type:Zd,args:[cN,{read:Ju,static:!0}]}],_implicitContent:[{type:Xd,args:[Ju,{static:!0}]}],textLabel:[{type:f_,args:["label"]}],ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const uN={translateTab:SP("translateTab",[RP("center, void, left-origin-center, right-origin-center",zP({transform:"none"})),RP("left",zP({transform:"translate3d(-100%, 0, 0)",minHeight:"1px"})),RP("right",zP({transform:"translate3d(100%, 0, 0)",minHeight:"1px"})),DP("* => left, * => right, left => center, right => center",EP("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")),DP("void => left-origin-center",[zP({transform:"translate3d(-100%, 0, 0)"}),EP("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")]),DP("void => right-origin-center",[zP({transform:"translate3d(100%, 0, 0)"}),EP("{{animationDuration}} cubic-bezier(0.35, 0, 0.25, 1)")])])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class fN extends FA{constructor(t,n,e,a){super(t,n,a),this._host=e,this._centeringSub=s.EMPTY,this._leavingSub=s.EMPTY}ngOnInit(){super.ngOnInit(),this._centeringSub=this._host._beforeCentering.pipe(ce(this._host._isCenterPosition(this._host._position))).subscribe((t=>{t&&!this.hasAttached()&&this.attach(this._host._content)})),this._leavingSub=this._host._afterLeavingCenter.subscribe((()=>{this.detach()}))}ngOnDestroy(){super.ngOnDestroy(),this._centeringSub.unsubscribe(),this._leavingSub.unsubscribe()}}fN.ɵfac=function t(n){return new(n||fN)(Zg(Pu),Zg($u),Zg(aa((()=>_N))),Zg(zC))},fN.ɵdir=vo({type:fN,selectors:[["","matTabBodyHost",""]],features:[hg]}),fN.ctorParameters=()=>[{type:Pu},{type:$u},{type:_N,decorators:[{type:Ie,args:[aa((()=>_N))]}]},{type:void 0,decorators:[{type:Ie,args:[zC]}]}];class hN{constructor(t,n,e){this._elementRef=t,this._dir=n,this._dirChangeSubscription=s.EMPTY,this._translateTabComplete=new x,this._onCentering=new Ef,this._beforeCentering=new Ef,this._afterLeavingCenter=new Ef,this._onCentered=new Ef(!0),this.animationDuration="500ms",n&&(this._dirChangeSubscription=n.change.subscribe((t=>{this._computePositionAnimationState(t),e.markForCheck()}))),this._translateTabComplete.pipe(vn(((t,n)=>t.fromState===n.fromState&&t.toState===n.toState))).subscribe((t=>{this._isCenterPosition(t.toState)&&this._isCenterPosition(this._position)&&this._onCentered.emit(),this._isCenterPosition(t.fromState)&&!this._isCenterPosition(this._position)&&this._afterLeavingCenter.emit()}))}set position(t){this._positionIndex=t,this._computePositionAnimationState()}ngOnInit(){"center"==this._position&&null!=this.origin&&(this._position=this._computePositionFromOrigin(this.origin))}ngOnDestroy(){this._dirChangeSubscription.unsubscribe(),this._translateTabComplete.complete()}_onTranslateTabStarted(t){const n=this._isCenterPosition(t.toState);this._beforeCentering.emit(n),n&&this._onCentering.emit(this._elementRef.nativeElement.clientHeight)}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_isCenterPosition(t){return"center"==t||"left-origin-center"==t||"right-origin-center"==t}_computePositionAnimationState(t=this._getLayoutDirection()){this._position=this._positionIndex<0?"ltr"==t?"left":"right":this._positionIndex>0?"ltr"==t?"right":"left":"center"}_computePositionFromOrigin(t){const n=this._getLayoutDirection();return"ltr"==n&&t<=0||"rtl"==n&&t>0?"left-origin-center":"right-origin-center"}}hN.ɵfac=function t(n){return new(n||hN)(Zg(xu),Zg(US,8),Zg(Vm))},hN.ɵdir=vo({type:hN,inputs:{animationDuration:"animationDuration",position:"position",_content:["content","_content"],origin:"origin"},outputs:{_onCentering:"_onCentering",_beforeCentering:"_beforeCentering",_afterLeavingCenter:"_afterLeavingCenter",_onCentered:"_onCentered"}}),hN.ctorParameters=()=>[{type:xu},{type:US,decorators:[{type:Ne}]},{type:Vm}],hN.propDecorators={_onCentering:[{type:h_}],_beforeCentering:[{type:h_}],_afterLeavingCenter:[{type:h_}],_onCentered:[{type:h_}],_content:[{type:f_,args:["content"]}],origin:[{type:f_}],animationDuration:[{type:f_}],position:[{type:f_}]};class _N extends hN{constructor(t,n,e){super(t,n,e)}}_N.ɵfac=function t(n){return new(n||_N)(Zg(xu),Zg(US,8),Zg(Vm))},_N.ɵcmp=_o({type:_N,selectors:[["mat-tab-body"]],viewQuery:function t(n,e){var a;1&n&&Uf(LA,!0),2&n&&Vf(a=Zf())&&(e._portalHost=a.first)},hostAttrs:[1,"mat-tab-body"],features:[hg],decls:3,vars:6,consts:[[1,"mat-tab-body-content"],["content",""],["matTabBodyHost",""]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),cp("@translateTab.start",(function t(n){return e._onTranslateTabStarted(n)}))("@translateTab.done",(function t(n){return e._translateTabComplete.next(n)})),Yg(2,WI,0,0,"ng-template",2),$g()),2&n&&Jg("@translateTab",ff(3,YI,e._position,uf(1,GI,e.animationDuration)))},directives:[fN],styles:[".mat-tab-body-content{height:100%;overflow:auto}.mat-tab-group-dynamic-height .mat-tab-body-content{overflow:hidden}\n"],encapsulation:2,data:{animation:[uN.translateTab]}}),_N.ctorParameters=()=>[{type:xu},{type:US,decorators:[{type:Ne}]},{type:Vm}],_N.propDecorators={_portalHost:[{type:Xd,args:[LA]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const CN=new Fa("MAT_TABS_CONFIG");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let MN=0;class ON{}const PN=eE(aE(class{constructor(t){this._elementRef=t}}),"primary");class xN extends PN{constructor(t,n,e,a){super(t),this._changeDetectorRef=n,this._animationMode=a,this._tabs=new zf,this._indexToSelect=0,this._tabBodyWrapperHeight=0,this._tabsSubscription=s.EMPTY,this._tabLabelSubscription=s.EMPTY,this._dynamicHeight=!1,this._selectedIndex=null,this.headerPosition="above",this.selectedIndexChange=new Ef,this.focusChange=new Ef,this.animationDone=new Ef,this.selectedTabChange=new Ef(!0),this._groupId=MN++,this.animationDuration=e&&e.animationDuration?e.animationDuration:"500ms",this.disablePagination=!(!e||null==e.disablePagination)&&e.disablePagination}get dynamicHeight(){return this._dynamicHeight}set dynamicHeight(t){this._dynamicHeight=Gw(t)}get selectedIndex(){return this._selectedIndex}set selectedIndex(t){this._indexToSelect=Yw(t,null)}get animationDuration(){return this._animationDuration}set animationDuration(t){this._animationDuration=/^\d+$/.test(t)?t+"ms":t}get backgroundColor(){return this._backgroundColor}set backgroundColor(t){const n=this._elementRef.nativeElement;n.classList.remove(`mat-background-${this.backgroundColor}`),t&&n.classList.add(`mat-background-${t}`),this._backgroundColor=t}ngAfterContentChecked(){const t=this._indexToSelect=this._clampTabIndex(this._indexToSelect);if(this._selectedIndex!=t){const n=null==this._selectedIndex;n||this.selectedTabChange.emit(this._createChangeEvent(t)),Promise.resolve().then((()=>{this._tabs.forEach(((n,e)=>n.isActive=e===t)),n||this.selectedIndexChange.emit(t)}))}this._tabs.forEach(((n,e)=>{n.position=e-t,null==this._selectedIndex||0!=n.position||n.origin||(n.origin=t-this._selectedIndex)})),this._selectedIndex!==t&&(this._selectedIndex=t,this._changeDetectorRef.markForCheck())}ngAfterContentInit(){this._subscribeToAllTabChanges(),this._subscribeToTabLabels(),this._tabsSubscription=this._tabs.changes.subscribe((()=>{if(this._clampTabIndex(this._indexToSelect)===this._selectedIndex){const t=this._tabs.toArray();for(let n=0;n<t.length;n++)if(t[n].isActive){this._indexToSelect=this._selectedIndex=n;break}}this._changeDetectorRef.markForCheck()}))}_subscribeToAllTabChanges(){this._allTabs.changes.pipe(ce(this._allTabs)).subscribe((t=>{this._tabs.reset(t.filter((t=>!t._closestTabGroup||t._closestTabGroup===this))),this._tabs.notifyOnChanges()}))}ngOnDestroy(){this._tabs.destroy(),this._tabsSubscription.unsubscribe(),this._tabLabelSubscription.unsubscribe()}realignInkBar(){this._tabHeader&&this._tabHeader._alignInkBarToSelectedTab()}_focusChanged(t){this.focusChange.emit(this._createChangeEvent(t))}_createChangeEvent(t){const n=new ON;return n.index=t,this._tabs&&this._tabs.length&&(n.tab=this._tabs.toArray()[t]),n}_subscribeToTabLabels(){this._tabLabelSubscription&&this._tabLabelSubscription.unsubscribe(),this._tabLabelSubscription=Wt(...this._tabs.map((t=>t._stateChanges))).subscribe((()=>this._changeDetectorRef.markForCheck()))}_clampTabIndex(t){return Math.min(this._tabs.length-1,Math.max(t||0,0))}_getTabLabelId(t){return`mat-tab-label-${this._groupId}-${t}`}_getTabContentId(t){return`mat-tab-content-${this._groupId}-${t}`}_setTabBodyWrapperHeight(t){if(!this._dynamicHeight||!this._tabBodyWrapperHeight)return;const n=this._tabBodyWrapper.nativeElement;n.style.height=this._tabBodyWrapperHeight+"px",this._tabBodyWrapper.nativeElement.offsetHeight&&(n.style.height=t+"px")}_removeTabBodyWrapperHeight(){const t=this._tabBodyWrapper.nativeElement;this._tabBodyWrapperHeight=t.clientHeight,t.style.height="",this.animationDone.emit()}_handleClick(t,n,e){t.disabled||(this.selectedIndex=n.focusIndex=e)}_getTabIndex(t,n){return t.disabled?null:this.selectedIndex===n?0:-1}}xN.ɵfac=function t(n){return new(n||xN)(Zg(xu),Zg(Vm),Zg(CN,8),Zg(dk,8))},xN.ɵdir=vo({type:xN,inputs:{headerPosition:"headerPosition",animationDuration:"animationDuration",disablePagination:"disablePagination",dynamicHeight:"dynamicHeight",selectedIndex:"selectedIndex",backgroundColor:"backgroundColor"},outputs:{selectedIndexChange:"selectedIndexChange",focusChange:"focusChange",animationDone:"animationDone",selectedTabChange:"selectedTabChange"},features:[hg]}),xN.ctorParameters=()=>[{type:xu},{type:Vm},{type:void 0,decorators:[{type:Ie,args:[CN]},{type:Ne}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],xN.propDecorators={dynamicHeight:[{type:f_}],selectedIndex:[{type:f_}],headerPosition:[{type:f_}],animationDuration:[{type:f_}],disablePagination:[{type:f_}],backgroundColor:[{type:f_}],selectedIndexChange:[{type:h_}],focusChange:[{type:h_}],animationDone:[{type:h_}],selectedTabChange:[{type:h_}]};class yN extends xN{constructor(t,n,e,a){super(t,n,e,a)}}yN.ɵfac=function t(n){return new(n||yN)(Zg(xu),Zg(Vm),Zg(CN,8),Zg(dk,8))},yN.ɵcmp=_o({type:yN,selectors:[["mat-tab-group"]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,bN,!0),2&n&&Vf(o=Zf())&&(e._allTabs=o)},viewQuery:function t(n,e){var a;1&n&&(Uf(qI,!0),Uf(ZI,!0)),2&n&&(Vf(a=Zf())&&(e._tabBodyWrapper=a.first),Vf(a=Zf())&&(e._tabHeader=a.first))},hostAttrs:[1,"mat-tab-group"],hostVars:4,hostBindings:function t(n,e){2&n&&Dp("mat-tab-group-dynamic-height",e.dynamicHeight)("mat-tab-group-inverted-header","below"===e.headerPosition)},inputs:{color:"color",disableRipple:"disableRipple"},exportAs:["matTabGroup"],features:[Mu([{provide:pN,useExisting:yN}]),hg],decls:6,vars:7,consts:[[3,"selectedIndex","disableRipple","disablePagination","indexFocused","selectFocusedIndex"],["tabHeader",""],["class","mat-tab-label mat-focus-indicator","role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",3,"id","mat-tab-label-active","disabled","matRippleDisabled","click",4,"ngFor","ngForOf"],[1,"mat-tab-body-wrapper"],["tabBodyWrapper",""],["role","tabpanel",3,"id","mat-tab-body-active","content","position","origin","animationDuration","_onCentered","_onCentering",4,"ngFor","ngForOf"],["role","tab","matTabLabelWrapper","","mat-ripple","","cdkMonitorElementFocus","",1,"mat-tab-label","mat-focus-indicator",3,"id","disabled","matRippleDisabled","click"],[1,"mat-tab-label-content"],[3,"ngIf"],[3,"cdkPortalOutlet"],["role","tabpanel",3,"id","content","position","origin","animationDuration","_onCentered","_onCentering"]],template:function t(n,e){1&n&&(Kg(0,"mat-tab-header",0,1),cp("indexFocused",(function t(n){return e._focusChanged(n)}))("selectFocusedIndex",(function t(n){return e.selectedIndex=n})),Yg(2,KI,4,14,"div",2),$g(),Kg(3,"div",3,4),Yg(5,$I,1,8,"mat-tab-body",5),$g()),2&n&&(Jg("selectedIndex",e.selectedIndex||0)("disableRipple",e.disableRipple)("disablePagination",e.disablePagination),ws(2),Jg("ngForOf",e._tabs),ws(1),Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode),ws(2),Jg("ngForOf",e._tabs))},directives:function(){return[AN,jM,vN,zE,IS,WM,FA,_N]},styles:[".mat-tab-group{display:flex;flex-direction:column}.mat-tab-group.mat-tab-group-inverted-header{flex-direction:column-reverse}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.cdk-high-contrast-active .mat-tab-label:focus{outline:dotted 2px;outline-offset:-2px}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}@media(max-width: 599px){.mat-tab-label{padding:0 12px}}@media(max-width: 959px){.mat-tab-label{padding:0 12px}}.mat-tab-group[mat-stretch-tabs]>.mat-tab-header .mat-tab-label{flex-basis:0;flex-grow:1}.mat-tab-body-wrapper{position:relative;overflow:hidden;display:flex;transition:height 500ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable.mat-tab-body-wrapper{transition:none;animation:none}.mat-tab-body{top:0;left:0;right:0;bottom:0;position:absolute;display:block;overflow:hidden;flex-basis:100%}.mat-tab-body.mat-tab-body-active{position:relative;overflow-x:hidden;overflow-y:auto;z-index:1;flex-grow:1}.mat-tab-group.mat-tab-group-dynamic-height .mat-tab-body.mat-tab-body-active{overflow-y:hidden}\n"],encapsulation:2}),yN.ctorParameters=()=>[{type:xu},{type:Vm},{type:void 0,decorators:[{type:Ie,args:[CN]},{type:Ne}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],yN.propDecorators={_allTabs:[{type:qd,args:[bN,{descendants:!0}]}],_tabBodyWrapper:[{type:Xd,args:["tabBodyWrapper"]}],_tabHeader:[{type:Xd,args:["tabHeader"]}]};const kN=nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{});class vN extends kN{constructor(t){super(),this.elementRef=t}focus(){this.elementRef.nativeElement.focus()}getOffsetLeft(){return this.elementRef.nativeElement.offsetLeft}getOffsetWidth(){return this.elementRef.nativeElement.offsetWidth}}vN.ɵfac=function t(n){return new(n||vN)(Zg(xu))},vN.ɵdir=vo({type:vN,selectors:[["","matTabLabelWrapper",""]],hostVars:3,hostBindings:function t(n,e){2&n&&(Ng("aria-disabled",!!e.disabled),Dp("mat-tab-disabled",e.disabled))},inputs:{disabled:"disabled"},features:[hg]}),vN.ctorParameters=()=>[{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const wN=Nw({passive:!0});class SN{constructor(t,n,e,a,o,r,i){this._elementRef=t,this._changeDetectorRef=n,this._viewportRuler=e,this._dir=a,this._ngZone=o,this._platform=r,this._animationMode=i,this._scrollDistance=0,this._selectedIndexChanged=!1,this._destroyed=new x,this._showPaginationControls=!1,this._disableScrollAfter=!0,this._disableScrollBefore=!0,this._stopScrolling=new x,this.disablePagination=!1,this._selectedIndex=0,this.selectFocusedIndex=new Ef,this.indexFocused=new Ef,o.runOutsideAngular((()=>{Vt(t.nativeElement,"mouseleave").pipe(de(this._destroyed)).subscribe((()=>{this._stopInterval()}))}))}get selectedIndex(){return this._selectedIndex}set selectedIndex(t){t=Yw(t),this._selectedIndex!=t&&(this._selectedIndexChanged=!0,this._selectedIndex=t,this._keyManager&&this._keyManager.updateActiveItem(t))}ngAfterViewInit(){Vt(this._previousPaginator.nativeElement,"touchstart",wN).pipe(de(this._destroyed)).subscribe((()=>{this._handlePaginatorPress("before")})),Vt(this._nextPaginator.nativeElement,"touchstart",wN).pipe(de(this._destroyed)).subscribe((()=>{this._handlePaginatorPress("after")}))}ngAfterContentInit(){const t=this._dir?this._dir.change:Z(null),n=this._viewportRuler.change(150),e=()=>{this.updatePagination(),this._alignInkBarToSelectedTab()};this._keyManager=new mS(this._items).withHorizontalOrientation(this._getLayoutDirection()).withHomeAndEnd().withWrap(),this._keyManager.updateActiveItem(this._selectedIndex),"undefined"!=typeof requestAnimationFrame?requestAnimationFrame(e):e(),Wt(t,n,this._items.changes).pipe(de(this._destroyed)).subscribe((()=>{Promise.resolve().then(e),this._keyManager.withHorizontalOrientation(this._getLayoutDirection())})),this._keyManager.change.pipe(de(this._destroyed)).subscribe((t=>{this.indexFocused.emit(t),this._setTabFocus(t)}))}ngAfterContentChecked(){this._tabLabelCount!=this._items.length&&(this.updatePagination(),this._tabLabelCount=this._items.length,this._changeDetectorRef.markForCheck()),this._selectedIndexChanged&&(this._scrollToLabel(this._selectedIndex),this._checkScrollingControls(),this._alignInkBarToSelectedTab(),this._selectedIndexChanged=!1,this._changeDetectorRef.markForCheck()),this._scrollDistanceChanged&&(this._updateTabScrollPosition(),this._scrollDistanceChanged=!1,this._changeDetectorRef.markForCheck())}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete(),this._stopScrolling.complete()}_handleKeydown(t){if(!Ww(t))switch(t.keyCode){case Hw:case Vw:this.focusIndex!==this.selectedIndex&&(this.selectFocusedIndex.emit(this.focusIndex),this._itemSelected(t));break;default:this._keyManager.onKeydown(t)}}_onContentChanges(){const t=this._elementRef.nativeElement.textContent;t!==this._currentTextContent&&(this._currentTextContent=t||"",this._ngZone.run((()=>{this.updatePagination(),this._alignInkBarToSelectedTab(),this._changeDetectorRef.markForCheck()})))}updatePagination(){this._checkPaginationEnabled(),this._checkScrollingControls(),this._updateTabScrollPosition()}get focusIndex(){return this._keyManager?this._keyManager.activeItemIndex:0}set focusIndex(t){this._isValidIndex(t)&&this.focusIndex!==t&&this._keyManager&&this._keyManager.setActiveItem(t)}_isValidIndex(t){if(!this._items)return!0;const n=this._items?this._items.toArray()[t]:null;return!!n&&!n.disabled}_setTabFocus(t){if(this._showPaginationControls&&this._scrollToLabel(t),this._items&&this._items.length){this._items.toArray()[t].focus();const n=this._tabListContainer.nativeElement,e=this._getLayoutDirection();n.scrollLeft="ltr"==e?0:n.scrollWidth-n.offsetWidth}}_getLayoutDirection(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}_updateTabScrollPosition(){if(this.disablePagination)return;const t=this.scrollDistance,n=this._platform,e="ltr"===this._getLayoutDirection()?-t:t;this._tabList.nativeElement.style.transform=`translateX(${Math.round(e)}px)`,n&&(n.TRIDENT||n.EDGE)&&(this._tabListContainer.nativeElement.scrollLeft=0)}get scrollDistance(){return this._scrollDistance}set scrollDistance(t){this._scrollTo(t)}_scrollHeader(t){return this._scrollTo(this._scrollDistance+("before"==t?-1:1)*this._tabListContainer.nativeElement.offsetWidth/3)}_handlePaginatorClick(t){this._stopInterval(),this._scrollHeader(t)}_scrollToLabel(t){if(this.disablePagination)return;const n=this._items?this._items.toArray()[t]:null;if(!n)return;const e=this._tabListContainer.nativeElement.offsetWidth,{offsetLeft:a,offsetWidth:o}=n.elementRef.nativeElement;let r,i;"ltr"==this._getLayoutDirection()?(r=a,i=r+o):(i=this._tabList.nativeElement.offsetWidth-a,r=i-o);const c=this.scrollDistance,s=this.scrollDistance+e;r<c?this.scrollDistance-=c-r+60:i>s&&(this.scrollDistance+=i-s+60)}_checkPaginationEnabled(){if(this.disablePagination)this._showPaginationControls=!1;else{const t=this._tabList.nativeElement.scrollWidth>this._elementRef.nativeElement.offsetWidth;t||(this.scrollDistance=0),t!==this._showPaginationControls&&this._changeDetectorRef.markForCheck(),this._showPaginationControls=t}}_checkScrollingControls(){this.disablePagination?this._disableScrollAfter=this._disableScrollBefore=!0:(this._disableScrollBefore=0==this.scrollDistance,this._disableScrollAfter=this.scrollDistance==this._getMaxScrollDistance(),this._changeDetectorRef.markForCheck())}_getMaxScrollDistance(){return this._tabList.nativeElement.scrollWidth-this._tabListContainer.nativeElement.offsetWidth||0}_alignInkBarToSelectedTab(){const t=this._items&&this._items.length?this._items.toArray()[this.selectedIndex]:null,n=t?t.elementRef.nativeElement:null;n?this._inkBar.alignToElement(n):this._inkBar.hide()}_stopInterval(){this._stopScrolling.next()}_handlePaginatorPress(t,n){n&&null!=n.button&&0!==n.button||(this._stopInterval(),Zt(650,100).pipe(de(Wt(this._stopScrolling,this._destroyed))).subscribe((()=>{const{maxScrollDistance:n,distance:e}=this._scrollHeader(t);(0===e||e>=n)&&this._stopInterval()})))}_scrollTo(t){if(this.disablePagination)return{maxScrollDistance:0,distance:0};const n=this._getMaxScrollDistance();return this._scrollDistance=Math.max(0,Math.min(n,t)),this._scrollDistanceChanged=!0,this._checkScrollingControls(),{maxScrollDistance:n,distance:this._scrollDistance}}}SN.ɵfac=function t(n){return new(n||SN)(Zg(xu),Zg(Vm),Zg(MA),Zg(US,8),Zg(J_),Zg(Sw),Zg(dk,8))},SN.ɵdir=vo({type:SN,inputs:{disablePagination:"disablePagination"}}),SN.ctorParameters=()=>[{type:xu},{type:Vm},{type:MA},{type:US,decorators:[{type:Ne}]},{type:J_},{type:Sw},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],SN.propDecorators={disablePagination:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class EN extends SN{constructor(t,n,e,a,o,r,i){super(t,n,e,a,o,r,i),this._disableRipple=!1}get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Gw(t)}_itemSelected(t){t.preventDefault()}}EN.ɵfac=function t(n){return new(n||EN)(Zg(xu),Zg(Vm),Zg(MA),Zg(US,8),Zg(J_),Zg(Sw),Zg(dk,8))},EN.ɵdir=vo({type:EN,inputs:{disableRipple:"disableRipple"},features:[hg]}),EN.ctorParameters=()=>[{type:xu},{type:Vm},{type:MA},{type:US,decorators:[{type:Ne}]},{type:J_},{type:Sw},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],EN.propDecorators={disableRipple:[{type:f_}]};class AN extends EN{constructor(t,n,e,a,o,r,i){super(t,n,e,a,o,r,i)}}AN.ɵfac=function t(n){return new(n||AN)(Zg(xu),Zg(Vm),Zg(MA),Zg(US,8),Zg(J_),Zg(Sw),Zg(dk,8))},AN.ɵcmp=_o({type:AN,selectors:[["mat-tab-header"]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,vN,!1),2&n&&Vf(o=Zf())&&(e._items=o)},viewQuery:function t(n,e){var a;1&n&&(jf(iN,!0),jf(tN,!0),jf(nN,!0),Uf(eN,!0),Uf(aN,!0)),2&n&&(Vf(a=Zf())&&(e._inkBar=a.first),Vf(a=Zf())&&(e._tabListContainer=a.first),Vf(a=Zf())&&(e._tabList=a.first),Vf(a=Zf())&&(e._nextPaginator=a.first),Vf(a=Zf())&&(e._previousPaginator=a.first))},hostAttrs:[1,"mat-tab-header"],hostVars:4,hostBindings:function t(n,e){2&n&&Dp("mat-tab-header-pagination-controls-enabled",e._showPaginationControls)("mat-tab-header-rtl","rtl"==e._getLayoutDirection())},inputs:{selectedIndex:"selectedIndex"},outputs:{selectFocusedIndex:"selectFocusedIndex",indexFocused:"indexFocused"},features:[hg],ngContentSelectors:UI,decls:13,vars:8,consts:[["aria-hidden","true","mat-ripple","",1,"mat-tab-header-pagination","mat-tab-header-pagination-before","mat-elevation-z4",3,"matRippleDisabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-tab-header-pagination-chevron"],[1,"mat-tab-label-container",3,"keydown"],["tabListContainer",""],["role","tablist",1,"mat-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-tab-labels"],["aria-hidden","true","mat-ripple","",1,"mat-tab-header-pagination","mat-tab-header-pagination-after","mat-elevation-z4",3,"matRippleDisabled","mousedown","click","touchend"],["nextPaginator",""]],template:function t(n,e){1&n&&(bp(),Kg(0,"div",0,1),cp("click",(function t(){return e._handlePaginatorClick("before")}))("mousedown",(function t(n){return e._handlePaginatorPress("before",n)}))("touchend",(function t(){return e._stopInterval()})),tp(2,"div",2),$g(),Kg(3,"div",3,4),cp("keydown",(function t(n){return e._handleKeydown(n)})),Kg(5,"div",5,6),cp("cdkObserveContent",(function t(){return e._onContentChanges()})),Kg(7,"div",7),hp(8),$g(),tp(9,"mat-ink-bar"),$g(),$g(),Kg(10,"div",8,9),cp("mousedown",(function t(n){return e._handlePaginatorPress("after",n)}))("click",(function t(){return e._handlePaginatorClick("after")}))("touchend",(function t(){return e._stopInterval()})),tp(12,"div",2),$g()),2&n&&(Dp("mat-tab-header-pagination-disabled",e._disableScrollBefore),Jg("matRippleDisabled",e._disableScrollBefore||e.disableRipple),ws(5),Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode),ws(5),Dp("mat-tab-header-pagination-disabled",e._disableScrollAfter),Jg("matRippleDisabled",e._disableScrollAfter||e.disableRipple))},directives:[zE,$w,iN],styles:['.mat-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-tab-header-pagination{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:transparent;touch-action:none}.mat-tab-header-pagination-controls-enabled .mat-tab-header-pagination{display:flex}.mat-tab-header-pagination-before,.mat-tab-header-rtl .mat-tab-header-pagination-after{padding-left:4px}.mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-rtl .mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-tab-header-rtl .mat-tab-header-pagination-before,.mat-tab-header-pagination-after{padding-right:4px}.mat-tab-header-rtl .mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;content:"";height:8px;width:8px}.mat-tab-header-pagination-disabled{box-shadow:none;cursor:default}.mat-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-ink-bar{position:absolute;bottom:0;height:2px;transition:500ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable.mat-ink-bar{transition:none;animation:none}.mat-tab-group-inverted-header .mat-ink-bar{bottom:auto;top:0}.cdk-high-contrast-active .mat-ink-bar{outline:solid 2px;height:0}.mat-tab-labels{display:flex}[mat-align-tabs=center]>.mat-tab-header .mat-tab-labels{justify-content:center}[mat-align-tabs=end]>.mat-tab-header .mat-tab-labels{justify-content:flex-end}.mat-tab-label-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}._mat-animation-noopable.mat-tab-list{transition:none;animation:none}.mat-tab-label{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;position:relative}.mat-tab-label:focus{outline:none}.mat-tab-label:focus:not(.mat-tab-disabled){opacity:1}.cdk-high-contrast-active .mat-tab-label:focus{outline:dotted 2px;outline-offset:-2px}.mat-tab-label.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-label.mat-tab-disabled{opacity:.5}.mat-tab-label .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-label{opacity:1}@media(max-width: 599px){.mat-tab-label{min-width:72px}}\n'],encapsulation:2}),AN.ctorParameters=()=>[{type:xu},{type:Vm},{type:MA},{type:US,decorators:[{type:Ne}]},{type:J_},{type:Sw},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],AN.propDecorators={_items:[{type:qd,args:[vN,{descendants:!1}]}],_inkBar:[{type:Xd,args:[iN,{static:!0}]}],_tabListContainer:[{type:Xd,args:["tabListContainer",{static:!0}]}],_tabList:[{type:Xd,args:["tabList",{static:!0}]}],_nextPaginator:[{type:Xd,args:["nextPaginator"]}],_previousPaginator:[{type:Xd,args:["previousPaginator"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class zN extends SN{constructor(t,n,e,a,o,r,i){super(t,a,o,n,e,r,i),this._disableRipple=!1,this.color="primary"}get backgroundColor(){return this._backgroundColor}set backgroundColor(t){const n=this._elementRef.nativeElement.classList;n.remove(`mat-background-${this.backgroundColor}`),t&&n.add(`mat-background-${t}`),this._backgroundColor=t}get disableRipple(){return this._disableRipple}set disableRipple(t){this._disableRipple=Gw(t)}_itemSelected(){}ngAfterContentInit(){this._items.changes.pipe(ce(null),de(this._destroyed)).subscribe((()=>{this.updateActiveLink()})),super.ngAfterContentInit()}updateActiveLink(t){if(!this._items)return;const n=this._items.toArray();for(let t=0;t<n.length;t++)if(n[t].active)return this.selectedIndex=t,void this._changeDetectorRef.markForCheck();this.selectedIndex=-1,this._inkBar.hide()}}zN.ɵfac=function t(n){return new(n||zN)(Zg(xu),Zg(US,8),Zg(J_),Zg(Vm),Zg(MA),Zg(Sw),Zg(dk,8))},zN.ɵdir=vo({type:zN,inputs:{color:"color",backgroundColor:"backgroundColor",disableRipple:"disableRipple"},features:[hg]}),zN.ctorParameters=()=>[{type:xu},{type:US,decorators:[{type:Ne}]},{type:J_},{type:Vm},{type:MA},{type:Sw},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],zN.propDecorators={backgroundColor:[{type:f_}],disableRipple:[{type:f_}],color:[{type:f_}]};class RN extends zN{constructor(t,n,e,a,o,r,i){super(t,n,e,a,o,r,i)}}RN.ɵfac=function t(n){return new(n||RN)(Zg(xu),Zg(US,8),Zg(J_),Zg(Vm),Zg(MA),Zg(Sw),Zg(dk,8))},RN.ɵcmp=_o({type:RN,selectors:[["","mat-tab-nav-bar",""]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,IN,!0),2&n&&Vf(o=Zf())&&(e._items=o)},viewQuery:function t(n,e){var a;1&n&&(jf(iN,!0),jf(tN,!0),jf(nN,!0),Uf(eN,!0),Uf(aN,!0)),2&n&&(Vf(a=Zf())&&(e._inkBar=a.first),Vf(a=Zf())&&(e._tabListContainer=a.first),Vf(a=Zf())&&(e._tabList=a.first),Vf(a=Zf())&&(e._nextPaginator=a.first),Vf(a=Zf())&&(e._previousPaginator=a.first))},hostAttrs:[1,"mat-tab-nav-bar","mat-tab-header"],hostVars:10,hostBindings:function t(n,e){2&n&&Dp("mat-tab-header-pagination-controls-enabled",e._showPaginationControls)("mat-tab-header-rtl","rtl"==e._getLayoutDirection())("mat-primary","warn"!==e.color&&"accent"!==e.color)("mat-accent","accent"===e.color)("mat-warn","warn"===e.color)},inputs:{color:"color"},exportAs:["matTabNavBar","matTabNav"],features:[hg],attrs:["mat-tab-nav-bar",""],ngContentSelectors:UI,decls:13,vars:8,consts:[["aria-hidden","true","mat-ripple","",1,"mat-tab-header-pagination","mat-tab-header-pagination-before","mat-elevation-z4",3,"matRippleDisabled","click","mousedown","touchend"],["previousPaginator",""],[1,"mat-tab-header-pagination-chevron"],[1,"mat-tab-link-container",3,"keydown"],["tabListContainer",""],[1,"mat-tab-list",3,"cdkObserveContent"],["tabList",""],[1,"mat-tab-links"],["aria-hidden","true","mat-ripple","",1,"mat-tab-header-pagination","mat-tab-header-pagination-after","mat-elevation-z4",3,"matRippleDisabled","mousedown","click","touchend"],["nextPaginator",""]],template:function t(n,e){1&n&&(bp(),Kg(0,"div",0,1),cp("click",(function t(){return e._handlePaginatorClick("before")}))("mousedown",(function t(n){return e._handlePaginatorPress("before",n)}))("touchend",(function t(){return e._stopInterval()})),tp(2,"div",2),$g(),Kg(3,"div",3,4),cp("keydown",(function t(n){return e._handleKeydown(n)})),Kg(5,"div",5,6),cp("cdkObserveContent",(function t(){return e._onContentChanges()})),Kg(7,"div",7),hp(8),$g(),tp(9,"mat-ink-bar"),$g(),$g(),Kg(10,"div",8,9),cp("mousedown",(function t(n){return e._handlePaginatorPress("after",n)}))("click",(function t(){return e._handlePaginatorClick("after")}))("touchend",(function t(){return e._stopInterval()})),tp(12,"div",2),$g()),2&n&&(Dp("mat-tab-header-pagination-disabled",e._disableScrollBefore),Jg("matRippleDisabled",e._disableScrollBefore||e.disableRipple),ws(5),Dp("_mat-animation-noopable","NoopAnimations"===e._animationMode),ws(5),Dp("mat-tab-header-pagination-disabled",e._disableScrollAfter),Jg("matRippleDisabled",e._disableScrollAfter||e.disableRipple))},directives:[zE,$w,iN],styles:['.mat-tab-header{display:flex;overflow:hidden;position:relative;flex-shrink:0}.mat-tab-header-pagination{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;position:relative;display:none;justify-content:center;align-items:center;min-width:32px;cursor:pointer;z-index:2;-webkit-tap-highlight-color:transparent;touch-action:none}.mat-tab-header-pagination-controls-enabled .mat-tab-header-pagination{display:flex}.mat-tab-header-pagination-before,.mat-tab-header-rtl .mat-tab-header-pagination-after{padding-left:4px}.mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-rtl .mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(-135deg)}.mat-tab-header-rtl .mat-tab-header-pagination-before,.mat-tab-header-pagination-after{padding-right:4px}.mat-tab-header-rtl .mat-tab-header-pagination-before .mat-tab-header-pagination-chevron,.mat-tab-header-pagination-after .mat-tab-header-pagination-chevron{transform:rotate(45deg)}.mat-tab-header-pagination-chevron{border-style:solid;border-width:2px 2px 0 0;content:"";height:8px;width:8px}.mat-tab-header-pagination-disabled{box-shadow:none;cursor:default}.mat-tab-list{flex-grow:1;position:relative;transition:transform 500ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-tab-links{display:flex}[mat-align-tabs=center]>.mat-tab-link-container .mat-tab-links{justify-content:center}[mat-align-tabs=end]>.mat-tab-link-container .mat-tab-links{justify-content:flex-end}.mat-ink-bar{position:absolute;bottom:0;height:2px;transition:500ms cubic-bezier(0.35, 0, 0.25, 1)}._mat-animation-noopable.mat-ink-bar{transition:none;animation:none}.mat-tab-group-inverted-header .mat-ink-bar{bottom:auto;top:0}.cdk-high-contrast-active .mat-ink-bar{outline:solid 2px;height:0}.mat-tab-link-container{display:flex;flex-grow:1;overflow:hidden;z-index:1}.mat-tab-link{height:48px;padding:0 24px;cursor:pointer;box-sizing:border-box;opacity:.6;min-width:160px;text-align:center;display:inline-flex;justify-content:center;align-items:center;white-space:nowrap;vertical-align:top;text-decoration:none;position:relative;overflow:hidden;-webkit-tap-highlight-color:transparent}.mat-tab-link:focus{outline:none}.mat-tab-link:focus:not(.mat-tab-disabled){opacity:1}.cdk-high-contrast-active .mat-tab-link:focus{outline:dotted 2px;outline-offset:-2px}.mat-tab-link.mat-tab-disabled{cursor:default}.cdk-high-contrast-active .mat-tab-link.mat-tab-disabled{opacity:.5}.mat-tab-link .mat-tab-label-content{display:inline-flex;justify-content:center;align-items:center;white-space:nowrap}.cdk-high-contrast-active .mat-tab-link{opacity:1}[mat-stretch-tabs] .mat-tab-link{flex-basis:0;flex-grow:1}.mat-tab-link.mat-tab-disabled{pointer-events:none}@media(max-width: 599px){.mat-tab-link{min-width:72px}}\n'],encapsulation:2}),RN.ctorParameters=()=>[{type:xu},{type:US,decorators:[{type:Ne}]},{type:J_},{type:Vm},{type:MA},{type:Sw},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],RN.propDecorators={_items:[{type:qd,args:[aa((()=>IN)),{descendants:!0}]}],_inkBar:[{type:Xd,args:[iN,{static:!0}]}],_tabListContainer:[{type:Xd,args:["tabListContainer",{static:!0}]}],_tabList:[{type:Xd,args:["tabList",{static:!0}]}],_nextPaginator:[{type:Xd,args:["nextPaginator"]}],_previousPaginator:[{type:Xd,args:["previousPaginator"]}]};const TN=oE(aE(nE(class{})));class DN extends TN{constructor(t,n,e,a,o,r){super(),this._tabNavBar=t,this.elementRef=n,this._focusMonitor=o,this._isActive=!1,this.rippleConfig=e||{},this.tabIndex=parseInt(a)||0,"NoopAnimations"===r&&(this.rippleConfig.animation={enterDuration:0,exitDuration:0})}get active(){return this._isActive}set active(t){Gw(t)!==this._isActive&&(this._isActive=t,this._tabNavBar.updateActiveLink(this.elementRef))}get rippleDisabled(){return this.disabled||this.disableRipple||this._tabNavBar.disableRipple||!!this.rippleConfig.disabled}focus(){this.elementRef.nativeElement.focus()}ngAfterViewInit(){this._focusMonitor.monitor(this.elementRef)}ngOnDestroy(){this._focusMonitor.stopMonitoring(this.elementRef)}}DN.ɵfac=function t(n){return new(n||DN)(Zg(zN),Zg(xu),Zg(AE,8),Xg("tabindex"),Zg(TS),Zg(dk,8))},DN.ɵdir=vo({type:DN,inputs:{active:"active"},features:[hg]}),DN.ctorParameters=()=>[{type:zN},{type:xu},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[AE]}]},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:TS},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],DN.propDecorators={active:[{type:f_}]};class IN extends DN{constructor(t,n,e,a,o,r,i,c){super(t,n,o,r,i,c),this._tabLinkRipple=new EE(this,e,n,a),this._tabLinkRipple.setupTriggerEvents(n.nativeElement)}ngOnDestroy(){super.ngOnDestroy(),this._tabLinkRipple._removeTriggerEvents()}}IN.ɵfac=function t(n){return new(n||IN)(Zg(RN),Zg(xu),Zg(J_),Zg(Sw),Zg(AE,8),Xg("tabindex"),Zg(TS),Zg(dk,8))},IN.ɵdir=vo({type:IN,selectors:[["","mat-tab-link",""],["","matTabLink",""]],hostAttrs:[1,"mat-tab-link","mat-focus-indicator"],hostVars:7,hostBindings:function t(n,e){2&n&&(Ng("aria-current",e.active?"page":null)("aria-disabled",e.disabled)("tabIndex",e.tabIndex),Dp("mat-tab-disabled",e.disabled)("mat-tab-label-active",e.active))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex"},exportAs:["matTabLink"],features:[hg]}),IN.ctorParameters=()=>[{type:RN},{type:xu},{type:J_},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[AE]}]},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:TS},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class NN{}NN.ɵmod=xo({type:NN}),NN.ɵinj=Ge({factory:function t(n){return new(n||NN)},imports:[[PO,tE,BA,RE,tS,BS],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(NN,{declarations:function(){return[yN,mN,bN,iN,vN,RN,IN,_N,fN,AN,sN]},imports:function(){return[PO,tE,BA,RE,tS,BS]},exports:function(){return[tE,yN,mN,bN,RN,IN,sN]}});const FN=["underline"],LN=["connectionContainer"],HN=["inputContainer"],BN=["label"];function VN(t,n){1&t&&(np(0),Kg(1,"div",14),tp(2,"div",15),tp(3,"div",16),tp(4,"div",17),$g(),Kg(5,"div",18),tp(6,"div",15),tp(7,"div",16),tp(8,"div",17),$g(),ep())}function jN(t,n){1&t&&(Kg(0,"div",19),hp(1,1),$g())}function UN(t,n){if(1&t&&(np(0),hp(1,2),Kg(2,"span"),Jp(3),$g(),ep()),2&t){const t=gp(2);ws(3),Qp(t._control.placeholder)}}function WN(t,n){1&t&&hp(0,3,["*ngSwitchCase","true"])}function GN(t,n){1&t&&(Kg(0,"span",23),Jp(1," *"),$g())}function YN(t,n){if(1&t){const t=op();Kg(0,"label",20,21),cp("cdkObserveContent",(function n(){return jr(t),gp().updateOutlineGap()})),Yg(2,UN,4,1,"ng-container",12),Yg(3,WN,1,0,"ng-content",12),Yg(4,GN,2,0,"span",22),$g()}if(2&t){const t=gp();Dp("mat-empty",t._control.empty&&!t._shouldAlwaysFloat())("mat-form-field-empty",t._control.empty&&!t._shouldAlwaysFloat())("mat-accent","accent"==t.color)("mat-warn","warn"==t.color),Jg("cdkObserveContentDisabled","outline"!=t.appearance)("id",t._labelId)("ngSwitch",t._hasLabel()),Ng("for",t._control.id)("aria-owns",t._control.id),ws(2),Jg("ngSwitchCase",!1),ws(1),Jg("ngSwitchCase",!0),ws(1),Jg("ngIf",!t.hideRequiredMarker&&t._control.required&&!t._control.disabled)}}function qN(t,n){1&t&&(Kg(0,"div",24),hp(1,4),$g())}function ZN(t,n){if(1&t&&(Kg(0,"div",25,26),tp(2,"span",27),$g()),2&t){const t=gp();ws(2),Dp("mat-accent","accent"==t.color)("mat-warn","warn"==t.color)}}function XN(t,n){1&t&&(Kg(0,"div"),hp(1,5),$g()),2&t&&Jg("@transitionMessages",gp()._subscriptAnimationState)}function JN(t,n){if(1&t&&(Kg(0,"div",31),Jp(1),$g()),2&t){const t=gp(2);Jg("id",t._hintLabelId),ws(1),Qp(t.hintLabel)}}function QN(t,n){if(1&t&&(Kg(0,"div",28),Yg(1,JN,2,2,"div",29),hp(2,6),tp(3,"div",30),hp(4,7),$g()),2&t){const t=gp();Jg("@transitionMessages",t._subscriptAnimationState),ws(1),Jg("ngIf",t.hintLabel)}}const KN=["*",[["","matPrefix",""]],[["mat-placeholder"]],[["mat-label"]],[["","matSuffix",""]],[["mat-error"]],[["mat-hint",3,"align","end"]],[["mat-hint","align","end"]]];let $N=0;const tF=new Fa("MatError");class nF{constructor(){this.id="mat-error-"+$N++}}nF.ɵfac=function t(n){return new(n||nF)},nF.ɵdir=vo({type:nF,selectors:[["mat-error"]],hostAttrs:["role","alert",1,"mat-error"],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("id",e.id)},inputs:{id:"id"},features:[Mu([{provide:tF,useExisting:nF}])]}),nF.propDecorators={id:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const eF={transitionMessages:SP("transitionMessages",[RP("enter",zP({opacity:1,transform:"translateY(0%)"})),DP("void => enter",[zP({opacity:0,transform:"translateY(-100%)"}),EP("300ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class aF{}function oF(t){return Error(`A hint was already declared for 'align="${t}"'.`)}aF.ɵfac=function t(n){return new(n||aF)},aF.ɵdir=vo({type:aF});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let rF=0;const iF=new Fa("MatHint");class cF{constructor(){this.align="start",this.id="mat-hint-"+rF++}}cF.ɵfac=function t(n){return new(n||cF)},cF.ɵdir=vo({type:cF,selectors:[["mat-hint"]],hostAttrs:[1,"mat-hint"],hostVars:4,hostBindings:function t(n,e){2&n&&(Ng("id",e.id)("align",null),Dp("mat-form-field-hint-end","end"===e.align))},inputs:{align:"align",id:"id"},features:[Mu([{provide:iF,useExisting:cF}])]}),cF.propDecorators={align:[{type:f_}],id:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class sF{}sF.ɵfac=function t(n){return new(n||sF)},sF.ɵdir=vo({type:sF,selectors:[["mat-label"]]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class lF{}lF.ɵfac=function t(n){return new(n||lF)},lF.ɵdir=vo({type:lF,selectors:[["mat-placeholder"]]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const mF=new Fa("MatPrefix");class dF{}dF.ɵfac=function t(n){return new(n||dF)},dF.ɵdir=vo({type:dF,selectors:[["","matPrefix",""]],features:[Mu([{provide:mF,useExisting:dF}])]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const gF=new Fa("MatSuffix");class pF{}pF.ɵfac=function t(n){return new(n||pF)},pF.ɵdir=vo({type:pF,selectors:[["","matSuffix",""]],features:[Mu([{provide:gF,useExisting:pF}])]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let bF=0;const uF=eE(class{constructor(t){this._elementRef=t}},"primary"),fF=new Fa("MAT_FORM_FIELD_DEFAULT_OPTIONS"),hF=new Fa("MatFormField");class _F extends uF{constructor(t,n,e,a,o,r,i,c){super(t),this._elementRef=t,this._changeDetectorRef=n,this._dir=a,this._defaults=o,this._platform=r,this._ngZone=i,this._outlineGapCalculationNeededImmediately=!1,this._outlineGapCalculationNeededOnStable=!1,this._destroyed=new x,this._showAlwaysAnimate=!1,this._subscriptAnimationState="",this._hintLabel="",this._hintLabelId="mat-hint-"+bF++,this._labelId="mat-form-field-label-"+bF++,this._labelOptions=e||{},this.floatLabel=this._getDefaultFloatLabelState(),this._animationsEnabled="NoopAnimations"!==c,this.appearance=o&&o.appearance?o.appearance:"legacy",this._hideRequiredMarker=!(!o||null==o.hideRequiredMarker)&&o.hideRequiredMarker}get appearance(){return this._appearance}set appearance(t){const n=this._appearance;this._appearance=t||this._defaults&&this._defaults.appearance||"legacy","outline"===this._appearance&&n!==t&&(this._outlineGapCalculationNeededOnStable=!0)}get hideRequiredMarker(){return this._hideRequiredMarker}set hideRequiredMarker(t){this._hideRequiredMarker=Gw(t)}_shouldAlwaysFloat(){return"always"===this.floatLabel&&!this._showAlwaysAnimate}_canLabelFloat(){return"never"!==this.floatLabel}get hintLabel(){return this._hintLabel}set hintLabel(t){this._hintLabel=t,this._processHints()}get floatLabel(){return"legacy"!==this.appearance&&"never"===this._floatLabel?"auto":this._floatLabel}set floatLabel(t){t!==this._floatLabel&&(this._floatLabel=t||this._getDefaultFloatLabelState(),this._changeDetectorRef.markForCheck())}get _control(){return this._explicitFormFieldControl||this._controlNonStatic||this._controlStatic}set _control(t){this._explicitFormFieldControl=t}getLabelId(){return this._hasFloatingLabel()?this._labelId:null}getConnectedOverlayOrigin(){return this._connectionContainerRef||this._elementRef}ngAfterContentInit(){this._validateControlChild();const t=this._control;t.controlType&&this._elementRef.nativeElement.classList.add(`mat-form-field-type-${t.controlType}`),t.stateChanges.pipe(ce(null)).subscribe((()=>{this._validatePlaceholders(),this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()})),t.ngControl&&t.ngControl.valueChanges&&t.ngControl.valueChanges.pipe(de(this._destroyed)).subscribe((()=>this._changeDetectorRef.markForCheck())),this._ngZone.runOutsideAngular((()=>{this._ngZone.onStable.pipe(de(this._destroyed)).subscribe((()=>{this._outlineGapCalculationNeededOnStable&&this.updateOutlineGap()}))})),Wt(this._prefixChildren.changes,this._suffixChildren.changes).subscribe((()=>{this._outlineGapCalculationNeededOnStable=!0,this._changeDetectorRef.markForCheck()})),this._hintChildren.changes.pipe(ce(null)).subscribe((()=>{this._processHints(),this._changeDetectorRef.markForCheck()})),this._errorChildren.changes.pipe(ce(null)).subscribe((()=>{this._syncDescribedByIds(),this._changeDetectorRef.markForCheck()})),this._dir&&this._dir.change.pipe(de(this._destroyed)).subscribe((()=>{"function"==typeof requestAnimationFrame?this._ngZone.runOutsideAngular((()=>{requestAnimationFrame((()=>this.updateOutlineGap()))})):this.updateOutlineGap()}))}ngAfterContentChecked(){this._validateControlChild(),this._outlineGapCalculationNeededImmediately&&this.updateOutlineGap()}ngAfterViewInit(){this._subscriptAnimationState="enter",this._changeDetectorRef.detectChanges()}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}_shouldForward(t){const n=this._control?this._control.ngControl:null;return n&&n[t]}_hasPlaceholder(){return!!(this._control&&this._control.placeholder||this._placeholderChild)}_hasLabel(){return!(!this._labelChildNonStatic&&!this._labelChildStatic)}_shouldLabelFloat(){return this._canLabelFloat()&&(this._control&&this._control.shouldLabelFloat||this._shouldAlwaysFloat())}_hideControlPlaceholder(){return"legacy"===this.appearance&&!this._hasLabel()||this._hasLabel()&&!this._shouldLabelFloat()}_hasFloatingLabel(){return this._hasLabel()||"legacy"===this.appearance&&this._hasPlaceholder()}_getDisplayedMessages(){return this._errorChildren&&this._errorChildren.length>0&&this._control.errorState?"error":"hint"}_animateAndLockLabel(){this._hasFloatingLabel()&&this._canLabelFloat()&&(this._animationsEnabled&&this._label&&(this._showAlwaysAnimate=!0,Vt(this._label.nativeElement,"transitionend").pipe(Tn(1)).subscribe((()=>{this._showAlwaysAnimate=!1}))),this.floatLabel="always",this._changeDetectorRef.markForCheck())}_validatePlaceholders(){if(this._control.placeholder&&this._placeholderChild&&("undefined"==typeof ngDevMode||ngDevMode))
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
throw(function t(){return Error("Placeholder attribute and child element were both specified.")})()}_processHints(){this._validateHints(),this._syncDescribedByIds()}_validateHints(){if(this._hintChildren&&("undefined"==typeof ngDevMode||ngDevMode)){let t,n;this._hintChildren.forEach((e=>{if("start"===e.align){if(t||this.hintLabel)throw oF("start");t=e}else if("end"===e.align){if(n)throw oF("end");n=e}}))}}_getDefaultFloatLabelState(){return this._defaults&&this._defaults.floatLabel||this._labelOptions.float||"auto"}_syncDescribedByIds(){if(this._control){let t=[];if(this._control.userAriaDescribedBy&&"string"==typeof this._control.userAriaDescribedBy&&t.push(...this._control.userAriaDescribedBy.split(" ")),"hint"===this._getDisplayedMessages()){const n=this._hintChildren?this._hintChildren.find((t=>"start"===t.align)):null,e=this._hintChildren?this._hintChildren.find((t=>"end"===t.align)):null;n?t.push(n.id):this._hintLabel&&t.push(this._hintLabelId),e&&t.push(e.id)}else this._errorChildren&&t.push(...this._errorChildren.map((t=>t.id)));this._control.setDescribedByIds(t)}}_validateControlChild(){if(!this._control&&("undefined"==typeof ngDevMode||ngDevMode))throw(function t(){return Error("mat-form-field must contain a MatFormFieldControl.")})()}updateOutlineGap(){const t=this._label?this._label.nativeElement:null;if("outline"!==this.appearance||!t||!t.children.length||!t.textContent.trim())return;if(!this._platform.isBrowser)return;if(!this._isAttachedToDOM())return void(this._outlineGapCalculationNeededImmediately=!0);let n=0,e=0;const a=this._connectionContainerRef.nativeElement,o=a.querySelectorAll(".mat-form-field-outline-start"),r=a.querySelectorAll(".mat-form-field-outline-gap");if(this._label&&this._label.nativeElement.children.length){const o=a.getBoundingClientRect();if(0===o.width&&0===o.height)return this._outlineGapCalculationNeededOnStable=!0,void(this._outlineGapCalculationNeededImmediately=!1);const r=this._getStartEnd(o),i=t.children,c=this._getStartEnd(i[0].getBoundingClientRect());let s=0;for(let t=0;t<i.length;t++)s+=i[t].offsetWidth;n=Math.abs(c-r)-5,e=s>0?.75*s+10:0}for(let t=0;t<o.length;t++)o[t].style.width=`${n}px`;for(let t=0;t<r.length;t++)r[t].style.width=`${e}px`;this._outlineGapCalculationNeededOnStable=this._outlineGapCalculationNeededImmediately=!1}_getStartEnd(t){return this._dir&&"rtl"===this._dir.value?t.right:t.left}_isAttachedToDOM(){const t=this._elementRef.nativeElement;if(t.getRootNode){const n=t.getRootNode();return n&&n!==t}return document.documentElement.contains(t)}}_F.ɵfac=function t(n){return new(n||_F)(Zg(xu),Zg(Vm),Zg(JE,8),Zg(US,8),Zg(fF,8),Zg(Sw),Zg(J_),Zg(dk,8))},_F.ɵcmp=_o({type:_F,selectors:[["mat-form-field"]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,aF,!0),Yf(a,aF,!0),Gf(a,sF,!0),Yf(a,sF,!0),Gf(a,lF,!0),Gf(a,tF,!0),Gf(a,iF,!0),Gf(a,mF,!0),Gf(a,gF,!0)),2&n&&(Vf(o=Zf())&&(e._controlNonStatic=o.first),Vf(o=Zf())&&(e._controlStatic=o.first),Vf(o=Zf())&&(e._labelChildNonStatic=o.first),Vf(o=Zf())&&(e._labelChildStatic=o.first),Vf(o=Zf())&&(e._placeholderChild=o.first),Vf(o=Zf())&&(e._errorChildren=o),Vf(o=Zf())&&(e._hintChildren=o),Vf(o=Zf())&&(e._prefixChildren=o),Vf(o=Zf())&&(e._suffixChildren=o))},viewQuery:function t(n,e){var a;1&n&&(Uf(FN,!0),jf(LN,!0),Uf(HN,!0),Uf(BN,!0)),2&n&&(Vf(a=Zf())&&(e.underlineRef=a.first),Vf(a=Zf())&&(e._connectionContainerRef=a.first),Vf(a=Zf())&&(e._inputContainerRef=a.first),Vf(a=Zf())&&(e._label=a.first))},hostAttrs:[1,"mat-form-field"],hostVars:44,hostBindings:function t(n,e){2&n&&Dp("mat-form-field-appearance-standard","standard"==e.appearance)("mat-form-field-appearance-fill","fill"==e.appearance)("mat-form-field-appearance-outline","outline"==e.appearance)("mat-form-field-appearance-legacy","legacy"==e.appearance)("mat-form-field-invalid",e._control.errorState)("mat-form-field-can-float",e._canLabelFloat())("mat-form-field-should-float",e._shouldLabelFloat())("mat-form-field-has-label",e._hasFloatingLabel())("mat-form-field-hide-placeholder",e._hideControlPlaceholder())("mat-form-field-disabled",e._control.disabled)("mat-form-field-autofilled",e._control.autofilled)("mat-focused",e._control.focused)("mat-accent","accent"==e.color)("mat-warn","warn"==e.color)("ng-untouched",e._shouldForward("untouched"))("ng-touched",e._shouldForward("touched"))("ng-pristine",e._shouldForward("pristine"))("ng-dirty",e._shouldForward("dirty"))("ng-valid",e._shouldForward("valid"))("ng-invalid",e._shouldForward("invalid"))("ng-pending",e._shouldForward("pending"))("_mat-animation-noopable",!e._animationsEnabled)},inputs:{color:"color",floatLabel:"floatLabel",appearance:"appearance",hideRequiredMarker:"hideRequiredMarker",hintLabel:"hintLabel"},exportAs:["matFormField"],features:[Mu([{provide:hF,useExisting:_F}]),hg],ngContentSelectors:["*","[matPrefix]","mat-placeholder","mat-label","[matSuffix]","mat-error","mat-hint:not([align='end'])","mat-hint[align='end']"],decls:15,vars:8,consts:[[1,"mat-form-field-wrapper"],[1,"mat-form-field-flex",3,"click"],["connectionContainer",""],[4,"ngIf"],["class","mat-form-field-prefix",4,"ngIf"],[1,"mat-form-field-infix"],["inputContainer",""],[1,"mat-form-field-label-wrapper"],["class","mat-form-field-label",3,"cdkObserveContentDisabled","id","mat-empty","mat-form-field-empty","mat-accent","mat-warn","ngSwitch","cdkObserveContent",4,"ngIf"],["class","mat-form-field-suffix",4,"ngIf"],["class","mat-form-field-underline",4,"ngIf"],[1,"mat-form-field-subscript-wrapper",3,"ngSwitch"],[4,"ngSwitchCase"],["class","mat-form-field-hint-wrapper",4,"ngSwitchCase"],[1,"mat-form-field-outline"],[1,"mat-form-field-outline-start"],[1,"mat-form-field-outline-gap"],[1,"mat-form-field-outline-end"],[1,"mat-form-field-outline","mat-form-field-outline-thick"],[1,"mat-form-field-prefix"],[1,"mat-form-field-label",3,"cdkObserveContentDisabled","id","ngSwitch","cdkObserveContent"],["label",""],["class","mat-placeholder-required mat-form-field-required-marker","aria-hidden","true",4,"ngIf"],["aria-hidden","true",1,"mat-placeholder-required","mat-form-field-required-marker"],[1,"mat-form-field-suffix"],[1,"mat-form-field-underline"],["underline",""],[1,"mat-form-field-ripple"],[1,"mat-form-field-hint-wrapper"],["class","mat-hint",3,"id",4,"ngIf"],[1,"mat-form-field-hint-spacer"],[1,"mat-hint",3,"id"]],template:function t(n,e){1&n&&(bp(KN),Kg(0,"div",0),Kg(1,"div",1,2),cp("click",(function t(n){return e._control.onContainerClick&&e._control.onContainerClick(n)})),Yg(3,VN,9,0,"ng-container",3),Yg(4,jN,2,0,"div",4),Kg(5,"div",5,6),hp(7),Kg(8,"span",7),Yg(9,YN,5,16,"label",8),$g(),$g(),Yg(10,qN,2,0,"div",9),$g(),Yg(11,ZN,3,4,"div",10),Kg(12,"div",11),Yg(13,XN,2,1,"div",12),Yg(14,QN,5,2,"div",13),$g(),$g()),2&n&&(ws(3),Jg("ngIf","outline"==e.appearance),ws(1),Jg("ngIf",e._prefixChildren.length),ws(5),Jg("ngIf",e._hasFloatingLabel()),ws(1),Jg("ngIf",e._suffixChildren.length),ws(1),Jg("ngIf","outline"!=e.appearance),ws(1),Jg("ngSwitch",e._getDisplayedMessages()),ws(1),Jg("ngSwitchCase","error"),ws(1),Jg("ngSwitchCase","hint"))},directives:[WM,ZM,XM,$w],styles:[".mat-form-field{display:inline-block;position:relative;text-align:left}[dir=rtl] .mat-form-field{text-align:right}.mat-form-field-wrapper{position:relative}.mat-form-field-flex{display:inline-flex;align-items:baseline;box-sizing:border-box;width:100%}.mat-form-field-prefix,.mat-form-field-suffix{white-space:nowrap;flex:none;position:relative}.mat-form-field-infix{display:block;position:relative;flex:auto;min-width:0;width:180px}.cdk-high-contrast-active .mat-form-field-infix{border-image:linear-gradient(transparent, transparent)}.mat-form-field-label-wrapper{position:absolute;left:0;box-sizing:content-box;width:100%;height:100%;overflow:hidden;pointer-events:none}[dir=rtl] .mat-form-field-label-wrapper{left:auto;right:0}.mat-form-field-label{position:absolute;left:0;font:inherit;pointer-events:none;width:100%;white-space:nowrap;text-overflow:ellipsis;overflow:hidden;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),width 400ms cubic-bezier(0.25, 0.8, 0.25, 1);display:none}[dir=rtl] .mat-form-field-label{transform-origin:100% 0;left:auto;right:0}.mat-form-field-empty.mat-form-field-label,.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label{display:block}.mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{display:block;transition:none}.mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:none}.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label,.mat-form-field-can-float .mat-input-server[placeholder]:not(:placeholder-shown)+.mat-form-field-label-wrapper .mat-form-field-label{display:block}.mat-form-field-label:not(.mat-form-field-empty){transition:none}.mat-form-field-underline{position:absolute;width:100%;pointer-events:none;transform:scale3d(1, 1.0001, 1)}.mat-form-field-ripple{position:absolute;left:0;width:100%;transform-origin:50%;transform:scaleX(0.5);opacity:0;transition:background-color 300ms cubic-bezier(0.55, 0, 0.55, 0.2)}.mat-form-field.mat-focused .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple{opacity:1;transform:scaleX(1);transition:transform 300ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 300ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-subscript-wrapper{position:absolute;box-sizing:border-box;width:100%;overflow:hidden}.mat-form-field-subscript-wrapper .mat-icon,.mat-form-field-label-wrapper .mat-icon{width:1em;height:1em;font-size:inherit;vertical-align:baseline}.mat-form-field-hint-wrapper{display:flex}.mat-form-field-hint-spacer{flex:1 0 1em}.mat-error{display:block}.mat-form-field-control-wrapper{position:relative}.mat-form-field-hint-end{order:1}.mat-form-field._mat-animation-noopable .mat-form-field-label,.mat-form-field._mat-animation-noopable .mat-form-field-ripple{transition:none}\n",'.mat-form-field-appearance-fill .mat-form-field-flex{border-radius:4px 4px 0 0;padding:.75em .75em 0 .75em}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-flex{outline:solid 1px}.mat-form-field-appearance-fill .mat-form-field-underline::before{content:"";display:block;position:absolute;bottom:0;height:1px;width:100%}.mat-form-field-appearance-fill .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-fill .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-fill:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-fill._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}.mat-form-field-appearance-fill .mat-form-field-subscript-wrapper{padding:0 1em}\n','.mat-input-element{font:inherit;background:transparent;color:currentColor;border:none;outline:none;padding:0;margin:0;width:100%;max-width:100%;vertical-align:bottom;text-align:inherit}.mat-input-element:-moz-ui-invalid{box-shadow:none}.mat-input-element::-ms-clear,.mat-input-element::-ms-reveal{display:none}.mat-input-element,.mat-input-element::-webkit-search-cancel-button,.mat-input-element::-webkit-search-decoration,.mat-input-element::-webkit-search-results-button,.mat-input-element::-webkit-search-results-decoration{-webkit-appearance:none}.mat-input-element::-webkit-contacts-auto-fill-button,.mat-input-element::-webkit-caps-lock-indicator,.mat-input-element::-webkit-credentials-auto-fill-button{visibility:hidden}.mat-input-element[type=date],.mat-input-element[type=datetime],.mat-input-element[type=datetime-local],.mat-input-element[type=month],.mat-input-element[type=week],.mat-input-element[type=time]{line-height:1}.mat-input-element[type=date]::after,.mat-input-element[type=datetime]::after,.mat-input-element[type=datetime-local]::after,.mat-input-element[type=month]::after,.mat-input-element[type=week]::after,.mat-input-element[type=time]::after{content:" ";white-space:pre;width:1px}.mat-input-element::-webkit-inner-spin-button,.mat-input-element::-webkit-calendar-picker-indicator,.mat-input-element::-webkit-clear-button{font-size:.75em}.mat-input-element::placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-moz-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-moz-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element::-webkit-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element::-webkit-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-input-element:-ms-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-input-element:-ms-input-placeholder:-ms-input-placeholder{-ms-user-select:text}.mat-form-field-hide-placeholder .mat-input-element::placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-moz-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element::-webkit-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}.mat-form-field-hide-placeholder .mat-input-element:-ms-input-placeholder{color:transparent !important;-webkit-text-fill-color:transparent;transition:none}textarea.mat-input-element{resize:vertical;overflow:auto}textarea.mat-input-element.cdk-textarea-autosize{resize:none}textarea.mat-input-element{padding:2px 0;margin:-2px 0}select.mat-input-element{-moz-appearance:none;-webkit-appearance:none;position:relative;background-color:transparent;display:inline-flex;box-sizing:border-box;padding-top:1em;top:-1em;margin-bottom:-1em}select.mat-input-element::-ms-expand{display:none}select.mat-input-element::-moz-focus-inner{border:0}select.mat-input-element:not(:disabled){cursor:pointer}select.mat-input-element::-ms-value{color:inherit;background:none}.mat-focused .cdk-high-contrast-active select.mat-input-element::-ms-value{color:inherit}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{content:"";width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;position:absolute;top:50%;right:0;margin-top:-2.5px;pointer-events:none}[dir=rtl] .mat-form-field-type-mat-native-select .mat-form-field-infix::after{right:auto;left:0}.mat-form-field-type-mat-native-select .mat-input-element{padding-right:15px}[dir=rtl] .mat-form-field-type-mat-native-select .mat-input-element{padding-right:0;padding-left:15px}.mat-form-field-type-mat-native-select .mat-form-field-label-wrapper{max-width:calc(100% - 10px)}.mat-form-field-type-mat-native-select.mat-form-field-appearance-outline .mat-form-field-infix::after{margin-top:-5px}.mat-form-field-type-mat-native-select.mat-form-field-appearance-fill .mat-form-field-infix::after{margin-top:-10px}\n',".mat-form-field-appearance-legacy .mat-form-field-label{transform:perspective(100px);-ms-transform:none}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon{width:1em}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button{font:inherit;vertical-align:baseline}.mat-form-field-appearance-legacy .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-icon-button .mat-icon{font-size:inherit}.mat-form-field-appearance-legacy .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-legacy .mat-form-field-ripple{top:0;height:2px;overflow:hidden}.cdk-high-contrast-active .mat-form-field-appearance-legacy .mat-form-field-ripple{height:0;border-top:solid 2px}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-legacy.mat-form-field-invalid:not(.mat-focused) .mat-form-field-ripple{height:1px}\n",".mat-form-field-appearance-outline .mat-form-field-wrapper{margin:.25em 0}.mat-form-field-appearance-outline .mat-form-field-flex{padding:0 .75em 0 .75em;margin-top:-0.25em;position:relative}.mat-form-field-appearance-outline .mat-form-field-prefix,.mat-form-field-appearance-outline .mat-form-field-suffix{top:.25em}.mat-form-field-appearance-outline .mat-form-field-outline{display:flex;position:absolute;top:.25em;left:0;right:0;bottom:0;pointer-events:none}.mat-form-field-appearance-outline .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-end{border:1px solid currentColor;min-width:5px}.mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:5px 0 0 5px;border-right-style:none}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-start{border-right-style:solid;border-left-style:none;border-radius:0 5px 5px 0}.mat-form-field-appearance-outline .mat-form-field-outline-end{border-radius:0 5px 5px 0;border-left-style:none;flex-grow:1}[dir=rtl] .mat-form-field-appearance-outline .mat-form-field-outline-end{border-left-style:solid;border-right-style:none;border-radius:5px 0 0 5px}.mat-form-field-appearance-outline .mat-form-field-outline-gap{border-radius:.000001px;border:1px solid currentColor;border-left-style:none;border-right-style:none}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-outline-gap{border-top-color:transparent}.mat-form-field-appearance-outline .mat-form-field-outline-thick{opacity:0}.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-start,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-end,.mat-form-field-appearance-outline .mat-form-field-outline-thick .mat-form-field-outline-gap{border-width:2px}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline{opacity:0;transition:opacity 100ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,.mat-form-field-appearance-outline.mat-form-field-invalid .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline{opacity:0;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-outline:not(.mat-form-field-disabled) .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}.mat-form-field-appearance-outline .mat-form-field-subscript-wrapper{padding:0 1em}.mat-form-field-appearance-outline._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-start,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-end,.mat-form-field-appearance-outline._mat-animation-noopable .mat-form-field-outline-gap{transition:none}\n",".mat-form-field-appearance-standard .mat-form-field-flex{padding-top:.75em}.mat-form-field-appearance-standard .mat-form-field-underline{height:1px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-underline{height:0;border-top:solid 1px}.mat-form-field-appearance-standard .mat-form-field-ripple{bottom:0;height:2px}.cdk-high-contrast-active .mat-form-field-appearance-standard .mat-form-field-ripple{height:0;border-top:2px}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-position:0;background-color:transparent}.cdk-high-contrast-active .mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{border-top-style:dotted;border-top-width:2px}.mat-form-field-appearance-standard:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{opacity:1;transform:none;transition:opacity 600ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-form-field-appearance-standard._mat-animation-noopable:not(.mat-form-field-disabled) .mat-form-field-flex:hover~.mat-form-field-underline .mat-form-field-ripple{transition:none}\n"],encapsulation:2,data:{animation:[eF.transitionMessages]},changeDetection:0}),_F.ctorParameters=()=>[{type:xu},{type:Vm},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[JE]}]},{type:US,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[fF]}]},{type:Sw},{type:J_},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],_F.propDecorators={appearance:[{type:f_}],hideRequiredMarker:[{type:f_}],hintLabel:[{type:f_}],floatLabel:[{type:f_}],underlineRef:[{type:Xd,args:["underline"]}],_connectionContainerRef:[{type:Xd,args:["connectionContainer",{static:!0}]}],_inputContainerRef:[{type:Xd,args:["inputContainer"]}],_label:[{type:Xd,args:["label"]}],_controlNonStatic:[{type:Zd,args:[aF]}],_controlStatic:[{type:Zd,args:[aF,{static:!0}]}],_labelChildNonStatic:[{type:Zd,args:[sF]}],_labelChildStatic:[{type:Zd,args:[sF,{static:!0}]}],_placeholderChild:[{type:Zd,args:[lF]}],_errorChildren:[{type:qd,args:[tF,{descendants:!0}]}],_hintChildren:[{type:qd,args:[iF,{descendants:!0}]}],_prefixChildren:[{type:qd,args:[mF,{descendants:!0}]}],_suffixChildren:[{type:qd,args:[gF,{descendants:!0}]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class CF{}CF.ɵmod=xo({type:CF}),CF.ɵinj=Ge({factory:function t(n){return new(n||CF)},imports:[[PO,tE,tS],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(CF,{declarations:function(){return[nF,_F,cF,sF,lF,dF,pF]},imports:function(){return[PO,tE,tS]},exports:function(){return[tE,nF,_F,cF,sF,lF,dF,pF]}});
/**
     * @license Angular v10.2.4
     * (c) 2010-2020 Google LLC. https://angular.io/
     * License: MIT
     */
const MF=new Fa("NgValueAccessor"),OF={provide:MF,useExisting:aa((()=>PF)),multi:!0};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class PF{constructor(t,n){this._renderer=t,this._elementRef=n,this.onChange=t=>{},this.onTouched=()=>{}}writeValue(t){this._renderer.setProperty(this._elementRef.nativeElement,"checked",t)}registerOnChange(t){this.onChange=t}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}}PF.ɵfac=function t(n){return new(n||PF)(Zg(Su),Zg(xu))},PF.ɵdir=vo({type:PF,selectors:[["input","type","checkbox","formControlName",""],["input","type","checkbox","formControl",""],["input","type","checkbox","ngModel",""]],hostBindings:function t(n,e){1&n&&cp("change",(function t(n){return e.onChange(n.target.checked)}))("blur",(function t(){return e.onTouched()}))},features:[Mu([OF])]}),PF.ctorParameters=()=>[{type:Su},{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const xF={provide:MF,useExisting:aa((()=>kF)),multi:!0},yF=new Fa("CompositionEventMode");class kF{constructor(t,n,e){this._renderer=t,this._elementRef=n,this._compositionMode=e,this.onChange=t=>{},this.onTouched=()=>{},this._composing=!1,null==this._compositionMode&&(this._compositionMode=!(function a(){const t=AC()?AC().getUserAgent():"";return/android (\d+)/.test(t.toLowerCase())})())}writeValue(t){this._renderer.setProperty(this._elementRef.nativeElement,"value",null==t?"":t)}registerOnChange(t){this.onChange=t}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}_handleInput(t){(!this._compositionMode||this._compositionMode&&!this._composing)&&this.onChange(t)}_compositionStart(){this._composing=!0}_compositionEnd(t){this._composing=!1,this._compositionMode&&this.onChange(t)}}kF.ɵfac=function t(n){return new(n||kF)(Zg(Su),Zg(xu),Zg(yF,8))},kF.ɵdir=vo({type:kF,selectors:[["input","formControlName","",3,"type","checkbox"],["textarea","formControlName",""],["input","formControl","",3,"type","checkbox"],["textarea","formControl",""],["input","ngModel","",3,"type","checkbox"],["textarea","ngModel",""],["","ngDefaultControl",""]],hostBindings:function t(n,e){1&n&&cp("input",(function t(n){return e._handleInput(n.target.value)}))("blur",(function t(){return e.onTouched()}))("compositionstart",(function t(){return e._compositionStart()}))("compositionend",(function t(n){return e._compositionEnd(n.target.value)}))},features:[Mu([xF])]}),kF.ctorParameters=()=>[{type:Su},{type:xu},{type:Boolean,decorators:[{type:Ne},{type:Ie,args:[yF]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class vF{get value(){return this.control?this.control.value:null}get valid(){return this.control?this.control.valid:null}get invalid(){return this.control?this.control.invalid:null}get pending(){return this.control?this.control.pending:null}get disabled(){return this.control?this.control.disabled:null}get enabled(){return this.control?this.control.enabled:null}get errors(){return this.control?this.control.errors:null}get pristine(){return this.control?this.control.pristine:null}get dirty(){return this.control?this.control.dirty:null}get touched(){return this.control?this.control.touched:null}get status(){return this.control?this.control.status:null}get untouched(){return this.control?this.control.untouched:null}get statusChanges(){return this.control?this.control.statusChanges:null}get valueChanges(){return this.control?this.control.valueChanges:null}get path(){return null}reset(t){this.control&&this.control.reset(t)}hasError(t,n){return!!this.control&&this.control.hasError(t,n)}getError(t,n){return this.control?this.control.getError(t,n):null}}vF.ɵfac=function t(n){return new(n||vF)},vF.ɵdir=vo({type:vF});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class wF extends vF{get formDirective(){return null}get path(){return null}}wF.ɵfac=function t(n){return SF(n||wF)},wF.ɵdir=vo({type:wF,features:[hg]});const SF=tc(wF);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function EF(){if("undefined"==typeof ngDevMode||ngDevMode)throw new Error("unimplemented")}class AF extends vF{constructor(){super(...arguments),this._parent=null,this.name=null,this.valueAccessor=null,this._rawValidators=[],this._rawAsyncValidators=[]}get validator(){return EF()}get asyncValidator(){return EF()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class zF{constructor(t){this._cd=t}get ngClassUntouched(){return!!this._cd.control&&this._cd.control.untouched}get ngClassTouched(){return!!this._cd.control&&this._cd.control.touched}get ngClassPristine(){return!!this._cd.control&&this._cd.control.pristine}get ngClassDirty(){return!!this._cd.control&&this._cd.control.dirty}get ngClassValid(){return!!this._cd.control&&this._cd.control.valid}get ngClassInvalid(){return!!this._cd.control&&this._cd.control.invalid}get ngClassPending(){return!!this._cd.control&&this._cd.control.pending}}class RF extends zF{constructor(t){super(t)}}RF.ɵfac=function t(n){return new(n||RF)(Zg(AF,2))},RF.ɵdir=vo({type:RF,selectors:[["","formControlName",""],["","ngModel",""],["","formControl",""]],hostVars:14,hostBindings:function t(n,e){2&n&&Dp("ng-untouched",e.ngClassUntouched)("ng-touched",e.ngClassTouched)("ng-pristine",e.ngClassPristine)("ng-dirty",e.ngClassDirty)("ng-valid",e.ngClassValid)("ng-invalid",e.ngClassInvalid)("ng-pending",e.ngClassPending)},features:[hg]}),RF.ctorParameters=()=>[{type:AF,decorators:[{type:Fe}]}];class TF extends zF{constructor(t){super(t)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function DF(t){return null==t||0===t.length}function IF(t){return null!=t&&"number"==typeof t.length}TF.ɵfac=function t(n){return new(n||TF)(Zg(wF,2))},TF.ɵdir=vo({type:TF,selectors:[["","formGroupName",""],["","formArrayName",""],["","ngModelGroup",""],["","formGroup",""],["form",3,"ngNoForm",""],["","ngForm",""]],hostVars:14,hostBindings:function t(n,e){2&n&&Dp("ng-untouched",e.ngClassUntouched)("ng-touched",e.ngClassTouched)("ng-pristine",e.ngClassPristine)("ng-dirty",e.ngClassDirty)("ng-valid",e.ngClassValid)("ng-invalid",e.ngClassInvalid)("ng-pending",e.ngClassPending)},features:[hg]}),TF.ctorParameters=()=>[{type:wF,decorators:[{type:Fe}]}];const NF=new Fa("NgValidators"),FF=new Fa("NgAsyncValidators"),LF=/^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;class HF{static min(t){return n=>{if(DF(n.value)||DF(t))return null;const e=parseFloat(n.value);return!isNaN(e)&&e<t?{min:{min:t,actual:n.value}}:null}}static max(t){return n=>{if(DF(n.value)||DF(t))return null;const e=parseFloat(n.value);return!isNaN(e)&&e>t?{max:{max:t,actual:n.value}}:null}}static required(t){return DF(t.value)?{required:!0}:null}static requiredTrue(t){return!0===t.value?null:{required:!0}}static email(t){return DF(t.value)||LF.test(t.value)?null:{email:!0}}static minLength(t){return n=>DF(n.value)||!IF(n.value)?null:n.value.length<t?{minlength:{requiredLength:t,actualLength:n.value.length}}:null}static maxLength(t){return n=>IF(n.value)&&n.value.length>t?{maxlength:{requiredLength:t,actualLength:n.value.length}}:null}static pattern(t){if(!t)return HF.nullValidator;let n,e;return"string"==typeof t?(e="","^"!==t.charAt(0)&&(e+="^"),e+=t,"$"!==t.charAt(t.length-1)&&(e+="$"),n=new RegExp(e)):(e=t.toString(),n=t),t=>{if(DF(t.value))return null;const a=t.value;return n.test(a)?null:{pattern:{requiredPattern:e,actualValue:a}}}}static nullValidator(t){return null}static compose(t){if(!t)return null;const n=t.filter(BF);return 0==n.length?null:function(t){return jF(UF(t,n))}}static composeAsync(t){if(!t)return null;const n=t.filter(BF);return 0==n.length?null:function(t){return Ht(UF(t,n).map(VF)).pipe(ft(jF))}}}function BF(t){return null!=t}function VF(t){const n=rp(t)?Rt(t):t;if(!ip(n)&&("undefined"==typeof ngDevMode||ngDevMode))throw new Error("Expected validator to return Promise or Observable.");return n}function jF(t){let n={};return t.forEach((t=>{n=null!=t?Object.assign(Object.assign({},n),t):n})),0===Object.keys(n).length?null:n}function UF(t,n){return n.map((n=>n(t)))}function WF(t){return t.map((t=>(function n(t){return!t.validate})(t)?t:n=>t.validate(n)))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const GF={provide:MF,useExisting:aa((()=>YF)),multi:!0};class YF{constructor(t,n){this._renderer=t,this._elementRef=n,this.onChange=t=>{},this.onTouched=()=>{}}writeValue(t){this._renderer.setProperty(this._elementRef.nativeElement,"value",null==t?"":t)}registerOnChange(t){this.onChange=n=>{t(""==n?null:parseFloat(n))}}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}}YF.ɵfac=function t(n){return new(n||YF)(Zg(Su),Zg(xu))},YF.ɵdir=vo({type:YF,selectors:[["input","type","number","formControlName",""],["input","type","number","formControl",""],["input","type","number","ngModel",""]],hostBindings:function t(n,e){1&n&&cp("input",(function t(n){return e.onChange(n.target.value)}))("blur",(function t(){return e.onTouched()}))},features:[Mu([GF])]}),YF.ctorParameters=()=>[{type:Su},{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const qF={provide:MF,useExisting:aa((()=>XF)),multi:!0};class ZF{constructor(){this._accessors=[]}add(t,n){this._accessors.push([t,n])}remove(t){for(let n=this._accessors.length-1;n>=0;--n)if(this._accessors[n][1]===t)return void this._accessors.splice(n,1)}select(t){this._accessors.forEach((n=>{this._isSameGroup(n,t)&&n[1]!==t&&n[1].fireUncheck(t.value)}))}_isSameGroup(t,n){return!!t[0].control&&t[0]._parent===n._control._parent&&t[1].name===n.name}}ZF.ɵfac=function t(n){return new(n||ZF)},ZF.ɵprov=We({token:ZF,factory:ZF.ɵfac});class XF{constructor(t,n,e,a){this._renderer=t,this._elementRef=n,this._registry=e,this._injector=a,this.onChange=()=>{},this.onTouched=()=>{}}ngOnInit(){this._control=this._injector.get(AF),this._checkName(),this._registry.add(this._control,this)}ngOnDestroy(){this._registry.remove(this)}writeValue(t){this._state=t===this.value,this._renderer.setProperty(this._elementRef.nativeElement,"checked",this._state)}registerOnChange(t){this._fn=t,this.onChange=()=>{t(this.value),this._registry.select(this)}}fireUncheck(t){this.writeValue(t)}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}_checkName(){this.name&&this.formControlName&&this.name!==this.formControlName&&("undefined"==typeof ngDevMode||ngDevMode)&&(function t(){throw new Error('\n      If you define both a name and a formControlName attribute on your radio button, their values\n      must match. Ex: <input type="radio" formControlName="food" name="food">\n    ')})(),!this.name&&this.formControlName&&(this.name=this.formControlName)}}XF.ɵfac=function t(n){return new(n||XF)(Zg(Su),Zg(xu),Zg(ZF),Zg(yd))},XF.ɵdir=vo({type:XF,selectors:[["input","type","radio","formControlName",""],["input","type","radio","formControl",""],["input","type","radio","ngModel",""]],hostBindings:function t(n,e){1&n&&cp("change",(function t(){return e.onChange()}))("blur",(function t(){return e.onTouched()}))},inputs:{name:"name",formControlName:"formControlName",value:"value"},features:[Mu([qF])]}),XF.ctorParameters=()=>[{type:Su},{type:xu},{type:ZF},{type:yd}],XF.propDecorators={name:[{type:f_}],formControlName:[{type:f_}],value:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const JF={provide:MF,useExisting:aa((()=>QF)),multi:!0};class QF{constructor(t,n){this._renderer=t,this._elementRef=n,this.onChange=t=>{},this.onTouched=()=>{}}writeValue(t){this._renderer.setProperty(this._elementRef.nativeElement,"value",parseFloat(t))}registerOnChange(t){this.onChange=n=>{t(""==n?null:parseFloat(n))}}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}}QF.ɵfac=function t(n){return new(n||QF)(Zg(Su),Zg(xu))},QF.ɵdir=vo({type:QF,selectors:[["input","type","range","formControlName",""],["input","type","range","formControl",""],["input","type","range","ngModel",""]],hostBindings:function t(n,e){1&n&&cp("change",(function t(n){return e.onChange(n.target.value)}))("input",(function t(n){return e.onChange(n.target.value)}))("blur",(function t(){return e.onTouched()}))},features:[Mu([JF])]}),QF.ctorParameters=()=>[{type:Su},{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const KF='\n    <div [formGroup]="myGroup">\n      <input formControlName="firstName">\n    </div>\n\n    In your class:\n\n    this.myGroup = new FormGroup({\n       firstName: new FormControl()\n    });',$F='\n    <div [formGroup]="myGroup">\n       <div formGroupName="person">\n          <input formControlName="firstName">\n       </div>\n    </div>\n\n    In your class:\n\n    this.myGroup = new FormGroup({\n       person: new FormGroup({ firstName: new FormControl() })\n    });',tL='\n    <form>\n       <div ngModelGroup="person">\n          <input [(ngModel)]="person.name" name="firstName">\n       </div>\n    </form>';
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class nL{static controlParentException(){throw new Error(`formControlName must be used with a parent formGroup directive.  You'll want to add a formGroup\n       directive and pass it an existing FormGroup instance (you can create one in your class).\n\n      Example:\n\n      ${KF}`)}static ngModelGroupException(){throw new Error(`formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents\n       that also have a "form" prefix: formGroupName, formArrayName, or formGroup.\n\n       Option 1:  Update the parent to be formGroupName (reactive form strategy)\n\n        ${$F}\n\n        Option 2: Use ngModel instead of formControlName (template-driven strategy)\n\n        ${tL}`)}static missingFormException(){throw new Error(`formGroup expects a FormGroup instance. Please pass one in.\n\n       Example:\n\n       ${KF}`)}static groupParentException(){throw new Error(`formGroupName must be used with a parent formGroup directive.  You'll want to add a formGroup\n      directive and pass it an existing FormGroup instance (you can create one in your class).\n\n      Example:\n\n      ${$F}`)}static arrayParentException(){throw new Error('formArrayName must be used with a parent formGroup directive.  You\'ll want to add a formGroup\n       directive and pass it an existing FormGroup instance (you can create one in your class).\n\n        Example:\n\n        \n    <div [formGroup]="myGroup">\n      <div formArrayName="cities">\n        <div *ngFor="let city of cityArray.controls; index as i">\n          <input [formControlName]="i">\n        </div>\n      </div>\n    </div>\n\n    In your class:\n\n    this.cityArray = new FormArray([new FormControl(\'SF\')]);\n    this.myGroup = new FormGroup({\n      cities: this.cityArray\n    });')}static disabledAttrWarning(){console.warn("\n      It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true\n      when you set up this control in your component class, the disabled attribute will actually be set in the DOM for\n      you. We recommend using this approach to avoid 'changed after checked' errors.\n\n      Example:\n      form = new FormGroup({\n        first: new FormControl({value: 'Nancy', disabled: true}, Validators.required),\n        last: new FormControl('Drew', Validators.required)\n      });\n    ")}static ngModelWarning(t){console.warn(`\n    It looks like you're using ngModel on the same form field as ${t}.\n    Support for using the ngModel input property and ngModelChange event with\n    reactive form directives has been deprecated in Angular v6 and will be removed\n    in a future version of Angular.\n\n    For more information on this, see our API docs here:\n    https://angular.io/api/forms/${"formControl"===t?"FormControlDirective":"FormControlName"}#use-with-ngmodel\n    `)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const eL={provide:MF,useExisting:aa((()=>oL)),multi:!0};function aL(t,n){return null==t?`${n}`:(n&&"object"==typeof n&&(n="Object"),`${t}: ${n}`.slice(0,50))}class oL{constructor(t,n){this._renderer=t,this._elementRef=n,this._optionMap=new Map,this._idCounter=0,this.onChange=t=>{},this.onTouched=()=>{},this._compareWith=Object.is}set compareWith(t){if("function"!=typeof t&&("undefined"==typeof ngDevMode||ngDevMode))throw new Error(`compareWith must be a function, but received ${JSON.stringify(t)}`);this._compareWith=t}writeValue(t){this.value=t;const n=this._getOptionId(t);null==n&&this._renderer.setProperty(this._elementRef.nativeElement,"selectedIndex",-1);const e=aL(n,t);this._renderer.setProperty(this._elementRef.nativeElement,"value",e)}registerOnChange(t){this.onChange=n=>{this.value=this._getOptionValue(n),t(this.value)}}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}_registerOption(){return(this._idCounter++).toString()}_getOptionId(t){for(const n of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(n),t))return n;return null}_getOptionValue(t){const n=(function e(t){return t.split(":")[0]})(t);return this._optionMap.has(n)?this._optionMap.get(n):t}}oL.ɵfac=function t(n){return new(n||oL)(Zg(Su),Zg(xu))},oL.ɵdir=vo({type:oL,selectors:[["select","formControlName","",3,"multiple",""],["select","formControl","",3,"multiple",""],["select","ngModel","",3,"multiple",""]],hostBindings:function t(n,e){1&n&&cp("change",(function t(n){return e.onChange(n.target.value)}))("blur",(function t(){return e.onTouched()}))},inputs:{compareWith:"compareWith"},features:[Mu([eL])]}),oL.ctorParameters=()=>[{type:Su},{type:xu}],oL.propDecorators={compareWith:[{type:f_}]};class rL{constructor(t,n,e){this._element=t,this._renderer=n,this._select=e,this._select&&(this.id=this._select._registerOption())}set ngValue(t){null!=this._select&&(this._select._optionMap.set(this.id,t),this._setElementValue(aL(this.id,t)),this._select.writeValue(this._select.value))}set value(t){this._setElementValue(t),this._select&&this._select.writeValue(this._select.value)}_setElementValue(t){this._renderer.setProperty(this._element.nativeElement,"value",t)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}rL.ɵfac=function t(n){return new(n||rL)(Zg(xu),Zg(Su),Zg(oL,9))},rL.ɵdir=vo({type:rL,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),rL.ctorParameters=()=>[{type:xu},{type:Su},{type:oL,decorators:[{type:Ne},{type:He}]}],rL.propDecorators={ngValue:[{type:f_,args:["ngValue"]}],value:[{type:f_,args:["value"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const iL={provide:MF,useExisting:aa((()=>sL)),multi:!0};function cL(t,n){return null==t?`${n}`:("string"==typeof n&&(n=`'${n}'`),n&&"object"==typeof n&&(n="Object"),`${t}: ${n}`.slice(0,50))}class sL{constructor(t,n){this._renderer=t,this._elementRef=n,this._optionMap=new Map,this._idCounter=0,this.onChange=t=>{},this.onTouched=()=>{},this._compareWith=Object.is}set compareWith(t){if("function"!=typeof t&&("undefined"==typeof ngDevMode||ngDevMode))throw new Error(`compareWith must be a function, but received ${JSON.stringify(t)}`);this._compareWith=t}writeValue(t){let n;if(this.value=t,Array.isArray(t)){const e=t.map((t=>this._getOptionId(t)));n=(t,n)=>{t._setSelected(e.indexOf(n.toString())>-1)}}else n=(t,n)=>{t._setSelected(!1)};this._optionMap.forEach(n)}registerOnChange(t){this.onChange=n=>{const e=[];if(void 0!==n.selectedOptions){const t=n.selectedOptions;for(let n=0;n<t.length;n++){const a=t.item(n),o=this._getOptionValue(a.value);e.push(o)}}else{const t=n.options;for(let n=0;n<t.length;n++){const a=t.item(n);if(a.selected){const t=this._getOptionValue(a.value);e.push(t)}}}this.value=e,t(e)}}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this._renderer.setProperty(this._elementRef.nativeElement,"disabled",t)}_registerOption(t){const n=(this._idCounter++).toString();return this._optionMap.set(n,t),n}_getOptionId(t){for(const n of Array.from(this._optionMap.keys()))if(this._compareWith(this._optionMap.get(n)._value,t))return n;return null}_getOptionValue(t){const n=(function e(t){return t.split(":")[0]})(t);return this._optionMap.has(n)?this._optionMap.get(n)._value:t}}sL.ɵfac=function t(n){return new(n||sL)(Zg(Su),Zg(xu))},sL.ɵdir=vo({type:sL,selectors:[["select","multiple","","formControlName",""],["select","multiple","","formControl",""],["select","multiple","","ngModel",""]],hostBindings:function t(n,e){1&n&&cp("change",(function t(n){return e.onChange(n.target)}))("blur",(function t(){return e.onTouched()}))},inputs:{compareWith:"compareWith"},features:[Mu([iL])]}),sL.ctorParameters=()=>[{type:Su},{type:xu}],sL.propDecorators={compareWith:[{type:f_}]};class lL{constructor(t,n,e){this._element=t,this._renderer=n,this._select=e,this._select&&(this.id=this._select._registerOption(this))}set ngValue(t){null!=this._select&&(this._value=t,this._setElementValue(cL(this.id,t)),this._select.writeValue(this._select.value))}set value(t){this._select?(this._value=t,this._setElementValue(cL(this.id,t)),this._select.writeValue(this._select.value)):this._setElementValue(t)}_setElementValue(t){this._renderer.setProperty(this._element.nativeElement,"value",t)}_setSelected(t){this._renderer.setProperty(this._element.nativeElement,"selected",t)}ngOnDestroy(){this._select&&(this._select._optionMap.delete(this.id),this._select.writeValue(this._select.value))}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function mL(t,n){return[...n.path,t]}function dL(t,n){("undefined"==typeof ngDevMode||ngDevMode)&&(t||bL(n,"Cannot find control with"),n.valueAccessor||bL(n,"No value accessor for form control with")),t.validator=HF.compose([t.validator,n.validator]),t.asyncValidator=HF.composeAsync([t.asyncValidator,n.asyncValidator]),n.valueAccessor.writeValue(t.value),(function e(t,n){n.valueAccessor.registerOnChange((e=>{t._pendingValue=e,t._pendingChange=!0,t._pendingDirty=!0,"change"===t.updateOn&&gL(t,n)}))})(t,n),(function a(t,n){t.registerOnChange(((t,e)=>{n.valueAccessor.writeValue(t),e&&n.viewToModelUpdate(t)}))})(t,n),(function o(t,n){n.valueAccessor.registerOnTouched((()=>{t._pendingTouched=!0,"blur"===t.updateOn&&t._pendingChange&&gL(t,n),"submit"!==t.updateOn&&t.markAsTouched()}))})(t,n),n.valueAccessor.setDisabledState&&t.registerOnDisabledChange((t=>{n.valueAccessor.setDisabledState(t)})),n._rawValidators.forEach((n=>{n.registerOnValidatorChange&&n.registerOnValidatorChange((()=>t.updateValueAndValidity()))})),n._rawAsyncValidators.forEach((n=>{n.registerOnValidatorChange&&n.registerOnValidatorChange((()=>t.updateValueAndValidity()))}))}function gL(t,n){t._pendingDirty&&t.markAsDirty(),t.setValue(t._pendingValue,{emitModelToViewChange:!1}),n.viewToModelUpdate(t._pendingValue),t._pendingChange=!1}function pL(t,n){null!=t||"undefined"!=typeof ngDevMode&&!ngDevMode||bL(n,"Cannot find control with"),t.validator=HF.compose([t.validator,n.validator]),t.asyncValidator=HF.composeAsync([t.asyncValidator,n.asyncValidator])}function bL(t,n){let e;throw e=t.path.length>1?`path: '${t.path.join(" -> ")}'`:t.path[0]?`name: '${t.path}'`:"unspecified name attribute",new Error(`${n} ${e}`)}function uL(t){return null!=t?HF.compose(WF(t)):null}function fL(t){return null!=t?HF.composeAsync(WF(t)):null}function hL(t,n){if(!t.hasOwnProperty("model"))return!1;const e=t.model;return!!e.isFirstChange()||!Object.is(n,e.currentValue)}lL.ɵfac=function t(n){return new(n||lL)(Zg(xu),Zg(Su),Zg(sL,9))},lL.ɵdir=vo({type:lL,selectors:[["option"]],inputs:{ngValue:"ngValue",value:"value"}}),lL.ctorParameters=()=>[{type:xu},{type:Su},{type:sL,decorators:[{type:Ne},{type:He}]}],lL.propDecorators={ngValue:[{type:f_,args:["ngValue"]}],value:[{type:f_,args:["value"]}]};const _L=[PF,QF,YF,oL,sL,XF];function CL(t,n){t._syncPendingControls(),n.forEach((t=>{const n=t.control;"submit"===n.updateOn&&n._pendingChange&&(t.viewToModelUpdate(n._pendingValue),n._pendingChange=!1)}))}function ML(t,n){if(!n)return null;let e,a,o;return Array.isArray(n)||"undefined"!=typeof ngDevMode&&!ngDevMode||bL(t,"Value accessor was not provided as an array for form control with"),n.forEach((n=>{n.constructor===kF?e=n:(function r(t){return _L.some((n=>t.constructor===n))})(n)?(a&&("undefined"==typeof ngDevMode||ngDevMode)&&bL(t,"More than one built-in value accessor matches form control with"),a=n):(o&&("undefined"==typeof ngDevMode||ngDevMode)&&bL(t,"More than one custom value accessor matches form control with"),o=n)})),o||a||e||(("undefined"==typeof ngDevMode||ngDevMode)&&bL(t,"No valid value accessor for form control with"),null)}function OL(t,n){const e=t.indexOf(n);e>-1&&t.splice(e,1)}function PL(t,n,e,a){_c()&&"never"!==a&&((null!==a&&"once"!==a||n._ngModelWarningSentOnce)&&("always"!==a||e._ngModelWarningSent)||(("undefined"==typeof ngDevMode||ngDevMode)&&nL.ngModelWarning(t),n._ngModelWarningSentOnce=!0,e._ngModelWarningSent=!0))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const xL="VALID",yL="INVALID",kL="PENDING",vL="DISABLED";function wL(t){return(zL(t)?t.validators:t)||null}function SL(t){return Array.isArray(t)?uL(t):t||null}function EL(t,n){return(zL(n)?n.asyncValidators:t)||null}function AL(t){return Array.isArray(t)?fL(t):t||null}function zL(t){return null!=t&&!Array.isArray(t)&&"object"==typeof t}class RL{constructor(t,n){this._hasOwnPendingAsyncValidator=!1,this._onCollectionChange=()=>{},this.pristine=!0,this.touched=!1,this._onDisabledChange=[],this._rawValidators=t,this._rawAsyncValidators=n,this._composedValidatorFn=SL(this._rawValidators),this._composedAsyncValidatorFn=AL(this._rawAsyncValidators)}get validator(){return this._composedValidatorFn}set validator(t){this._rawValidators=this._composedValidatorFn=t}get asyncValidator(){return this._composedAsyncValidatorFn}set asyncValidator(t){this._rawAsyncValidators=this._composedAsyncValidatorFn=t}get parent(){return this._parent}get valid(){return this.status===xL}get invalid(){return this.status===yL}get pending(){return this.status==kL}get disabled(){return this.status===vL}get enabled(){return this.status!==vL}get dirty(){return!this.pristine}get untouched(){return!this.touched}get updateOn(){return this._updateOn?this._updateOn:this.parent?this.parent.updateOn:"change"}setValidators(t){this._rawValidators=t,this._composedValidatorFn=SL(t)}setAsyncValidators(t){this._rawAsyncValidators=t,this._composedAsyncValidatorFn=AL(t)}clearValidators(){this.validator=null}clearAsyncValidators(){this.asyncValidator=null}markAsTouched(t={}){this.touched=!0,this._parent&&!t.onlySelf&&this._parent.markAsTouched(t)}markAllAsTouched(){this.markAsTouched({onlySelf:!0}),this._forEachChild((t=>t.markAllAsTouched()))}markAsUntouched(t={}){this.touched=!1,this._pendingTouched=!1,this._forEachChild((t=>{t.markAsUntouched({onlySelf:!0})})),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}markAsDirty(t={}){this.pristine=!1,this._parent&&!t.onlySelf&&this._parent.markAsDirty(t)}markAsPristine(t={}){this.pristine=!0,this._pendingDirty=!1,this._forEachChild((t=>{t.markAsPristine({onlySelf:!0})})),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}markAsPending(t={}){this.status=kL,!1!==t.emitEvent&&this.statusChanges.emit(this.status),this._parent&&!t.onlySelf&&this._parent.markAsPending(t)}disable(t={}){const n=this._parentMarkedDirty(t.onlySelf);this.status=vL,this.errors=null,this._forEachChild((n=>{n.disable(Object.assign(Object.assign({},t),{onlySelf:!0}))})),this._updateValue(),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._updateAncestors(Object.assign(Object.assign({},t),{skipPristineCheck:n})),this._onDisabledChange.forEach((t=>t(!0)))}enable(t={}){const n=this._parentMarkedDirty(t.onlySelf);this.status=xL,this._forEachChild((n=>{n.enable(Object.assign(Object.assign({},t),{onlySelf:!0}))})),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent}),this._updateAncestors(Object.assign(Object.assign({},t),{skipPristineCheck:n})),this._onDisabledChange.forEach((t=>t(!1)))}_updateAncestors(t){this._parent&&!t.onlySelf&&(this._parent.updateValueAndValidity(t),t.skipPristineCheck||this._parent._updatePristine(),this._parent._updateTouched())}setParent(t){this._parent=t}updateValueAndValidity(t={}){this._setInitialStatus(),this._updateValue(),this.enabled&&(this._cancelExistingSubscription(),this.errors=this._runValidator(),this.status=this._calculateStatus(),this.status!==xL&&this.status!==kL||this._runAsyncValidator(t.emitEvent)),!1!==t.emitEvent&&(this.valueChanges.emit(this.value),this.statusChanges.emit(this.status)),this._parent&&!t.onlySelf&&this._parent.updateValueAndValidity(t)}_updateTreeValidity(t={emitEvent:!0}){this._forEachChild((n=>n._updateTreeValidity(t))),this.updateValueAndValidity({onlySelf:!0,emitEvent:t.emitEvent})}_setInitialStatus(){this.status=this._allControlsDisabled()?vL:xL}_runValidator(){return this.validator?this.validator(this):null}_runAsyncValidator(t){if(this.asyncValidator){this.status=kL,this._hasOwnPendingAsyncValidator=!0;const n=VF(this.asyncValidator(this));this._asyncValidationSubscription=n.subscribe((n=>{this._hasOwnPendingAsyncValidator=!1,this.setErrors(n,{emitEvent:t})}))}}_cancelExistingSubscription(){this._asyncValidationSubscription&&(this._asyncValidationSubscription.unsubscribe(),this._hasOwnPendingAsyncValidator=!1)}setErrors(t,n={}){this.errors=t,this._updateControlsErrors(!1!==n.emitEvent)}get(t){return(function n(t,e,a){if(null==e)return null;if(Array.isArray(e)||(e=e.split(a)),Array.isArray(e)&&0===e.length)return null;let o=t;return e.forEach((t=>{o=o instanceof DL?o.controls.hasOwnProperty(t)?o.controls[t]:null:o instanceof IL&&o.at(t)||null})),o})(this,t,".")}getError(t,n){const e=n?this.get(n):this;return e&&e.errors?e.errors[t]:null}hasError(t,n){return!!this.getError(t,n)}get root(){let t=this;for(;t._parent;)t=t._parent;return t}_updateControlsErrors(t){this.status=this._calculateStatus(),t&&this.statusChanges.emit(this.status),this._parent&&this._parent._updateControlsErrors(t)}_initObservables(){this.valueChanges=new Ef,this.statusChanges=new Ef}_calculateStatus(){return this._allControlsDisabled()?vL:this.errors?yL:this._hasOwnPendingAsyncValidator||this._anyControlsHaveStatus(kL)?kL:this._anyControlsHaveStatus(yL)?yL:xL}_anyControlsHaveStatus(t){return this._anyControls((n=>n.status===t))}_anyControlsDirty(){return this._anyControls((t=>t.dirty))}_anyControlsTouched(){return this._anyControls((t=>t.touched))}_updatePristine(t={}){this.pristine=!this._anyControlsDirty(),this._parent&&!t.onlySelf&&this._parent._updatePristine(t)}_updateTouched(t={}){this.touched=this._anyControlsTouched(),this._parent&&!t.onlySelf&&this._parent._updateTouched(t)}_isBoxedValue(t){return"object"==typeof t&&null!==t&&2===Object.keys(t).length&&"value"in t&&"disabled"in t}_registerOnCollectionChange(t){this._onCollectionChange=t}_setUpdateStrategy(t){zL(t)&&null!=t.updateOn&&(this._updateOn=t.updateOn)}_parentMarkedDirty(t){return!t&&this._parent&&this._parent.dirty&&!this._parent._anyControlsDirty()}}class TL extends RL{constructor(t=null,n,e){super(wL(n),EL(e,n)),this._onChange=[],this._applyFormState(t),this._setUpdateStrategy(n),this.updateValueAndValidity({onlySelf:!0,emitEvent:!1}),this._initObservables()}setValue(t,n={}){this.value=this._pendingValue=t,this._onChange.length&&!1!==n.emitModelToViewChange&&this._onChange.forEach((t=>t(this.value,!1!==n.emitViewToModelChange))),this.updateValueAndValidity(n)}patchValue(t,n={}){this.setValue(t,n)}reset(t=null,n={}){this._applyFormState(t),this.markAsPristine(n),this.markAsUntouched(n),this.setValue(this.value,n),this._pendingChange=!1}_updateValue(){}_anyControls(t){return!1}_allControlsDisabled(){return this.disabled}registerOnChange(t){this._onChange.push(t)}_clearChangeFns(){this._onChange=[],this._onDisabledChange=[],this._onCollectionChange=()=>{}}registerOnDisabledChange(t){this._onDisabledChange.push(t)}_forEachChild(t){}_syncPendingControls(){return!("submit"!==this.updateOn||(this._pendingDirty&&this.markAsDirty(),this._pendingTouched&&this.markAsTouched(),!this._pendingChange)||(this.setValue(this._pendingValue,{onlySelf:!0,emitModelToViewChange:!1}),0))}_applyFormState(t){this._isBoxedValue(t)?(this.value=this._pendingValue=t.value,t.disabled?this.disable({onlySelf:!0,emitEvent:!1}):this.enable({onlySelf:!0,emitEvent:!1})):this.value=this._pendingValue=t}}class DL extends RL{constructor(t,n,e){super(wL(n),EL(e,n)),this.controls=t,this._initObservables(),this._setUpdateStrategy(n),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!1})}registerControl(t,n){return this.controls[t]?this.controls[t]:(this.controls[t]=n,n.setParent(this),n._registerOnCollectionChange(this._onCollectionChange),n)}addControl(t,n){this.registerControl(t,n),this.updateValueAndValidity(),this._onCollectionChange()}removeControl(t){this.controls[t]&&this.controls[t]._registerOnCollectionChange((()=>{})),delete this.controls[t],this.updateValueAndValidity(),this._onCollectionChange()}setControl(t,n){this.controls[t]&&this.controls[t]._registerOnCollectionChange((()=>{})),delete this.controls[t],n&&this.registerControl(t,n),this.updateValueAndValidity(),this._onCollectionChange()}contains(t){return this.controls.hasOwnProperty(t)&&this.controls[t].enabled}setValue(t,n={}){this._checkAllValuesPresent(t),Object.keys(t).forEach((e=>{this._throwIfControlMissing(e),this.controls[e].setValue(t[e],{onlySelf:!0,emitEvent:n.emitEvent})})),this.updateValueAndValidity(n)}patchValue(t,n={}){Object.keys(t).forEach((e=>{this.controls[e]&&this.controls[e].patchValue(t[e],{onlySelf:!0,emitEvent:n.emitEvent})})),this.updateValueAndValidity(n)}reset(t={},n={}){this._forEachChild(((e,a)=>{e.reset(t[a],{onlySelf:!0,emitEvent:n.emitEvent})})),this._updatePristine(n),this._updateTouched(n),this.updateValueAndValidity(n)}getRawValue(){return this._reduceChildren({},((t,n,e)=>(t[e]=n instanceof TL?n.value:n.getRawValue(),t)))}_syncPendingControls(){let t=this._reduceChildren(!1,((t,n)=>!!n._syncPendingControls()||t));return t&&this.updateValueAndValidity({onlySelf:!0}),t}_throwIfControlMissing(t){if(!Object.keys(this.controls).length)throw new Error("\n        There are no form controls registered with this group yet. If you're using ngModel,\n        you may want to check next tick (e.g. use setTimeout).\n      ");if(!this.controls[t])throw new Error(`Cannot find form control with name: ${t}.`)}_forEachChild(t){Object.keys(this.controls).forEach((n=>t(this.controls[n],n)))}_setUpControls(){this._forEachChild((t=>{t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)}))}_updateValue(){this.value=this._reduceValue()}_anyControls(t){for(const n of Object.keys(this.controls)){const e=this.controls[n];if(this.contains(n)&&t(e))return!0}return!1}_reduceValue(){return this._reduceChildren({},((t,n,e)=>((n.enabled||this.disabled)&&(t[e]=n.value),t)))}_reduceChildren(t,n){let e=t;return this._forEachChild(((t,a)=>{e=n(e,t,a)})),e}_allControlsDisabled(){for(const t of Object.keys(this.controls))if(this.controls[t].enabled)return!1;return Object.keys(this.controls).length>0||this.disabled}_checkAllValuesPresent(t){this._forEachChild(((n,e)=>{if(void 0===t[e])throw new Error(`Must supply a value for form control with name: '${e}'.`)}))}}class IL extends RL{constructor(t,n,e){super(wL(n),EL(e,n)),this.controls=t,this._initObservables(),this._setUpdateStrategy(n),this._setUpControls(),this.updateValueAndValidity({onlySelf:!0,emitEvent:!1})}at(t){return this.controls[t]}push(t){this.controls.push(t),this._registerControl(t),this.updateValueAndValidity(),this._onCollectionChange()}insert(t,n){this.controls.splice(t,0,n),this._registerControl(n),this.updateValueAndValidity()}removeAt(t){this.controls[t]&&this.controls[t]._registerOnCollectionChange((()=>{})),this.controls.splice(t,1),this.updateValueAndValidity()}setControl(t,n){this.controls[t]&&this.controls[t]._registerOnCollectionChange((()=>{})),this.controls.splice(t,1),n&&(this.controls.splice(t,0,n),this._registerControl(n)),this.updateValueAndValidity(),this._onCollectionChange()}get length(){return this.controls.length}setValue(t,n={}){this._checkAllValuesPresent(t),t.forEach(((t,e)=>{this._throwIfControlMissing(e),this.at(e).setValue(t,{onlySelf:!0,emitEvent:n.emitEvent})})),this.updateValueAndValidity(n)}patchValue(t,n={}){t.forEach(((t,e)=>{this.at(e)&&this.at(e).patchValue(t,{onlySelf:!0,emitEvent:n.emitEvent})})),this.updateValueAndValidity(n)}reset(t=[],n={}){this._forEachChild(((e,a)=>{e.reset(t[a],{onlySelf:!0,emitEvent:n.emitEvent})})),this._updatePristine(n),this._updateTouched(n),this.updateValueAndValidity(n)}getRawValue(){return this.controls.map((t=>t instanceof TL?t.value:t.getRawValue()))}clear(){this.controls.length<1||(this._forEachChild((t=>t._registerOnCollectionChange((()=>{})))),this.controls.splice(0),this.updateValueAndValidity())}_syncPendingControls(){let t=this.controls.reduce(((t,n)=>!!n._syncPendingControls()||t),!1);return t&&this.updateValueAndValidity({onlySelf:!0}),t}_throwIfControlMissing(t){if(!this.controls.length)throw new Error("\n        There are no form controls registered with this array yet. If you're using ngModel,\n        you may want to check next tick (e.g. use setTimeout).\n      ");if(!this.at(t))throw new Error(`Cannot find form control at index ${t}`)}_forEachChild(t){this.controls.forEach(((n,e)=>{t(n,e)}))}_updateValue(){this.value=this.controls.filter((t=>t.enabled||this.disabled)).map((t=>t.value))}_anyControls(t){return this.controls.some((n=>n.enabled&&t(n)))}_setUpControls(){this._forEachChild((t=>this._registerControl(t)))}_checkAllValuesPresent(t){this._forEachChild(((n,e)=>{if(void 0===t[e])throw new Error(`Must supply a value for form control at index: ${e}.`)}))}_allControlsDisabled(){for(const t of this.controls)if(t.enabled)return!1;return this.controls.length>0||this.disabled}_registerControl(t){t.setParent(this),t._registerOnCollectionChange(this._onCollectionChange)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const NL={provide:wF,useExisting:aa((()=>LL))},FL=Promise.resolve(null);class LL extends wF{constructor(t,n){super(),this.submitted=!1,this._directives=[],this.ngSubmit=new Ef,this.form=new DL({},uL(t),fL(n))}ngAfterViewInit(){this._setUpdateStrategy()}get formDirective(){return this}get control(){return this.form}get path(){return[]}get controls(){return this.form.controls}addControl(t){FL.then((()=>{const n=this._findContainer(t.path);t.control=n.registerControl(t.name,t.control),dL(t.control,t),t.control.updateValueAndValidity({emitEvent:!1}),this._directives.push(t)}))}getControl(t){return this.form.get(t.path)}removeControl(t){FL.then((()=>{const n=this._findContainer(t.path);n&&n.removeControl(t.name),OL(this._directives,t)}))}addFormGroup(t){FL.then((()=>{const n=this._findContainer(t.path),e=new DL({});pL(e,t),n.registerControl(t.name,e),e.updateValueAndValidity({emitEvent:!1})}))}removeFormGroup(t){FL.then((()=>{const n=this._findContainer(t.path);n&&n.removeControl(t.name)}))}getFormGroup(t){return this.form.get(t.path)}updateModel(t,n){FL.then((()=>{this.form.get(t.path).setValue(n)}))}setValue(t){this.control.setValue(t)}onSubmit(t){return this.submitted=!0,CL(this.form,this._directives),this.ngSubmit.emit(t),!1}onReset(){this.resetForm()}resetForm(t){this.form.reset(t),this.submitted=!1}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.form._updateOn=this.options.updateOn)}_findContainer(t){return t.pop(),t.length?this.form.get(t):this.form}}LL.ɵfac=function t(n){return new(n||LL)(Zg(NF,10),Zg(FF,10))},LL.ɵdir=vo({type:LL,selectors:[["form",3,"ngNoForm","",3,"formGroup",""],["ng-form"],["","ngForm",""]],hostBindings:function t(n,e){1&n&&cp("submit",(function t(n){return e.onSubmit(n)}))("reset",(function t(){return e.onReset()}))},inputs:{options:["ngFormOptions","options"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Mu([NL]),hg]}),LL.ctorParameters=()=>[{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]}],LL.propDecorators={options:[{type:f_,args:["ngFormOptions"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class HL extends wF{ngOnInit(){this._checkParentType(),this.formDirective.addFormGroup(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormGroup(this)}get control(){return this.formDirective.getFormGroup(this)}get path(){return mL(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}get validator(){return uL(this._validators)}get asyncValidator(){return fL(this._asyncValidators)}_checkParentType(){}}HL.ɵfac=function t(n){return BL(n||HL)},HL.ɵdir=vo({type:HL,features:[hg]});const BL=tc(HL);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class VL{static modelParentException(){throw new Error(`\n      ngModel cannot be used to register form controls with a parent formGroup directive.  Try using\n      formGroup's partner directive "formControlName" instead.  Example:\n\n      ${KF}\n\n      Or, if you'd like to avoid registering this form control, indicate that it's standalone in ngModelOptions:\n\n      Example:\n\n      \n    <div [formGroup]="myGroup">\n       <input formControlName="firstName">\n       <input [(ngModel)]="showMoreControls" [ngModelOptions]="{standalone: true}">\n    </div>\n  `)}static formGroupNameException(){throw new Error(`\n      ngModel cannot be used to register form controls with a parent formGroupName or formArrayName directive.\n\n      Option 1: Use formControlName instead of ngModel (reactive strategy):\n\n      ${$F}\n\n      Option 2:  Update ngModel's parent be ngModelGroup (template-driven strategy):\n\n      ${tL}`)}static missingNameException(){throw new Error('If ngModel is used within a form tag, either the name attribute must be set or the form\n      control must be defined as \'standalone\' in ngModelOptions.\n\n      Example 1: <input [(ngModel)]="person.firstName" name="first">\n      Example 2: <input [(ngModel)]="person.firstName" [ngModelOptions]="{standalone: true}">')}static modelGroupParentException(){throw new Error(`\n      ngModelGroup cannot be used with a parent formGroup directive.\n\n      Option 1: Use formGroupName instead of ngModelGroup (reactive strategy):\n\n      ${$F}\n\n      Option 2:  Use a regular form tag instead of the formGroup directive (template-driven strategy):\n\n      ${tL}`)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const jL={provide:wF,useExisting:aa((()=>UL))};class UL extends HL{constructor(t,n,e){super(),this._parent=t,this._validators=n,this._asyncValidators=e}_checkParentType(){this._parent instanceof UL||this._parent instanceof LL||"undefined"!=typeof ngDevMode&&!ngDevMode||VL.modelGroupParentException()}}UL.ɵfac=function t(n){return new(n||UL)(Zg(wF,5),Zg(NF,10),Zg(FF,10))},UL.ɵdir=vo({type:UL,selectors:[["","ngModelGroup",""]],inputs:{name:["ngModelGroup","name"]},exportAs:["ngModelGroup"],features:[Mu([jL]),hg]}),UL.ctorParameters=()=>[{type:wF,decorators:[{type:He},{type:Le}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]}],UL.propDecorators={name:[{type:f_,args:["ngModelGroup"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const WL={provide:AF,useExisting:aa((()=>YL))},GL=Promise.resolve(null);class YL extends AF{constructor(t,n,e,a){super(),this.control=new TL,this._registered=!1,this.update=new Ef,this._parent=t,this._rawValidators=n||[],this._rawAsyncValidators=e||[],this.valueAccessor=ML(this,a)}ngOnChanges(t){this._checkForErrors(),this._registered||this._setUpControl(),"isDisabled"in t&&this._updateDisabled(t),hL(t,this.viewModel)&&(this._updateValue(this.model),this.viewModel=this.model)}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}get path(){return this._parent?mL(this.name,this._parent):[this.name]}get formDirective(){return this._parent?this._parent.formDirective:null}get validator(){return uL(this._rawValidators)}get asyncValidator(){return fL(this._rawAsyncValidators)}viewToModelUpdate(t){this.viewModel=t,this.update.emit(t)}_setUpControl(){this._setUpdateStrategy(),this._isStandalone()?this._setUpStandalone():this.formDirective.addControl(this),this._registered=!0}_setUpdateStrategy(){this.options&&null!=this.options.updateOn&&(this.control._updateOn=this.options.updateOn)}_isStandalone(){return!this._parent||!(!this.options||!this.options.standalone)}_setUpStandalone(){dL(this.control,this),this.control.updateValueAndValidity({emitEvent:!1})}_checkForErrors(){this._isStandalone()||this._checkParentType(),this._checkName()}_checkParentType(){("undefined"==typeof ngDevMode||ngDevMode)&&(!(this._parent instanceof UL)&&this._parent instanceof HL?VL.formGroupNameException():this._parent instanceof UL||this._parent instanceof LL||VL.modelParentException())}_checkName(){this.options&&this.options.name&&(this.name=this.options.name),this._isStandalone()||this.name||"undefined"!=typeof ngDevMode&&!ngDevMode||VL.missingNameException()}_updateValue(t){GL.then((()=>{this.control.setValue(t,{emitViewToModelChange:!1})}))}_updateDisabled(t){const n=t.isDisabled.currentValue,e=""===n||n&&"false"!==n;GL.then((()=>{e&&!this.control.disabled?this.control.disable():!e&&this.control.disabled&&this.control.enable()}))}}YL.ɵfac=function t(n){return new(n||YL)(Zg(wF,9),Zg(NF,10),Zg(FF,10),Zg(MF,10))},YL.ɵdir=vo({type:YL,selectors:[["","ngModel","",3,"formControlName","",3,"formControl",""]],inputs:{name:"name",isDisabled:["disabled","isDisabled"],model:["ngModel","model"],options:["ngModelOptions","options"]},outputs:{update:"ngModelChange"},exportAs:["ngModel"],features:[Mu([WL]),hg,pr]}),YL.ctorParameters=()=>[{type:wF,decorators:[{type:Ne},{type:He}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[MF]}]}],YL.propDecorators={name:[{type:f_}],isDisabled:[{type:f_,args:["disabled"]}],model:[{type:f_,args:["ngModel"]}],options:[{type:f_,args:["ngModelOptions"]}],update:[{type:h_,args:["ngModelChange"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class qL{}qL.ɵfac=function t(n){return new(n||qL)},qL.ɵdir=vo({type:qL,selectors:[["form",3,"ngNoForm","",3,"ngNativeValidate",""]],hostAttrs:["novalidate",""]});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const ZL=new Fa("NgModelWithFormControlWarning"),XL={provide:AF,useExisting:aa((()=>JL))};class JL extends AF{constructor(t,n,e,a){super(),this._ngModelWarningConfig=a,this.update=new Ef,this._ngModelWarningSent=!1,this._rawValidators=t||[],this._rawAsyncValidators=n||[],this.valueAccessor=ML(this,e)}set isDisabled(t){("undefined"==typeof ngDevMode||ngDevMode)&&nL.disabledAttrWarning()}ngOnChanges(t){this._isControlChanged(t)&&(dL(this.form,this),this.control.disabled&&this.valueAccessor.setDisabledState&&this.valueAccessor.setDisabledState(!0),this.form.updateValueAndValidity({emitEvent:!1})),hL(t,this.viewModel)&&(PL("formControl",JL,this,this._ngModelWarningConfig),this.form.setValue(this.model),this.viewModel=this.model)}get path(){return[]}get validator(){return uL(this._rawValidators)}get asyncValidator(){return fL(this._rawAsyncValidators)}get control(){return this.form}viewToModelUpdate(t){this.viewModel=t,this.update.emit(t)}_isControlChanged(t){return t.hasOwnProperty("form")}}JL.ɵfac=function t(n){return new(n||JL)(Zg(NF,10),Zg(FF,10),Zg(MF,10),Zg(ZL,8))},JL.ɵdir=vo({type:JL,selectors:[["","formControl",""]],inputs:{isDisabled:["disabled","isDisabled"],form:["formControl","form"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},exportAs:["ngForm"],features:[Mu([XL]),hg,pr]}),JL._ngModelWarningSentOnce=!1,JL.ctorParameters=()=>[{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[MF]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[ZL]}]}],JL.propDecorators={form:[{type:f_,args:["formControl"]}],isDisabled:[{type:f_,args:["disabled"]}],model:[{type:f_,args:["ngModel"]}],update:[{type:h_,args:["ngModelChange"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const QL={provide:wF,useExisting:aa((()=>KL))};class KL extends wF{constructor(t,n){super(),this._validators=t,this._asyncValidators=n,this.submitted=!1,this.directives=[],this.form=null,this.ngSubmit=new Ef}ngOnChanges(t){this._checkFormPresent(),t.hasOwnProperty("form")&&(this._updateValidators(),this._updateDomValue(),this._updateRegistrations())}get formDirective(){return this}get control(){return this.form}get path(){return[]}addControl(t){const n=this.form.get(t.path);return dL(n,t),n.updateValueAndValidity({emitEvent:!1}),this.directives.push(t),n}getControl(t){return this.form.get(t.path)}removeControl(t){OL(this.directives,t)}addFormGroup(t){const n=this.form.get(t.path);pL(n,t),n.updateValueAndValidity({emitEvent:!1})}removeFormGroup(t){}getFormGroup(t){return this.form.get(t.path)}addFormArray(t){const n=this.form.get(t.path);pL(n,t),n.updateValueAndValidity({emitEvent:!1})}removeFormArray(t){}getFormArray(t){return this.form.get(t.path)}updateModel(t,n){this.form.get(t.path).setValue(n)}onSubmit(t){return this.submitted=!0,CL(this.form,this.directives),this.ngSubmit.emit(t),!1}onReset(){this.resetForm()}resetForm(t){this.form.reset(t),this.submitted=!1}_updateDomValue(){this.directives.forEach((t=>{const n=this.form.get(t.path);t.control!==n&&((function e(t,n){const e=()=>{("undefined"==typeof ngDevMode||ngDevMode)&&(function t(n){bL(n,"There is no FormControl instance attached to form control element with")})(n)};n.valueAccessor.registerOnChange(e),n.valueAccessor.registerOnTouched(e),n._rawValidators.forEach((t=>{t.registerOnValidatorChange&&t.registerOnValidatorChange(null)})),n._rawAsyncValidators.forEach((t=>{t.registerOnValidatorChange&&t.registerOnValidatorChange(null)})),t&&t._clearChangeFns()})(t.control,t),n&&dL(n,t),t.control=n)})),this.form._updateTreeValidity({emitEvent:!1})}_updateRegistrations(){this.form._registerOnCollectionChange((()=>this._updateDomValue())),this._oldForm&&this._oldForm._registerOnCollectionChange((()=>{})),this._oldForm=this.form}_updateValidators(){const t=uL(this._validators);this.form.validator=HF.compose([this.form.validator,t]);const n=fL(this._asyncValidators);this.form.asyncValidator=HF.composeAsync([this.form.asyncValidator,n])}_checkFormPresent(){this.form||"undefined"!=typeof ngDevMode&&!ngDevMode||nL.missingFormException()}}KL.ɵfac=function t(n){return new(n||KL)(Zg(NF,10),Zg(FF,10))},KL.ɵdir=vo({type:KL,selectors:[["","formGroup",""]],hostBindings:function t(n,e){1&n&&cp("submit",(function t(n){return e.onSubmit(n)}))("reset",(function t(){return e.onReset()}))},inputs:{form:["formGroup","form"]},outputs:{ngSubmit:"ngSubmit"},exportAs:["ngForm"],features:[Mu([QL]),hg,pr]}),KL.ctorParameters=()=>[{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]}],KL.propDecorators={form:[{type:f_,args:["formGroup"]}],ngSubmit:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const $L={provide:wF,useExisting:aa((()=>tH))};class tH extends HL{constructor(t,n,e){super(),this._parent=t,this._validators=n,this._asyncValidators=e}_checkParentType(){aH(this._parent)&&("undefined"==typeof ngDevMode||ngDevMode)&&nL.groupParentException()}}tH.ɵfac=function t(n){return new(n||tH)(Zg(wF,13),Zg(NF,10),Zg(FF,10))},tH.ɵdir=vo({type:tH,selectors:[["","formGroupName",""]],inputs:{name:["formGroupName","name"]},features:[Mu([$L]),hg]}),tH.ctorParameters=()=>[{type:wF,decorators:[{type:Ne},{type:He},{type:Le}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]}],tH.propDecorators={name:[{type:f_,args:["formGroupName"]}]};const nH={provide:wF,useExisting:aa((()=>eH))};class eH extends wF{constructor(t,n,e){super(),this._parent=t,this._validators=n,this._asyncValidators=e}ngOnInit(){this._checkParentType(),this.formDirective.addFormArray(this)}ngOnDestroy(){this.formDirective&&this.formDirective.removeFormArray(this)}get control(){return this.formDirective.getFormArray(this)}get formDirective(){return this._parent?this._parent.formDirective:null}get path(){return mL(null==this.name?this.name:this.name.toString(),this._parent)}get validator(){return uL(this._validators)}get asyncValidator(){return fL(this._asyncValidators)}_checkParentType(){aH(this._parent)&&("undefined"==typeof ngDevMode||ngDevMode)&&nL.arrayParentException()}}function aH(t){return!(t instanceof tH||t instanceof KL||t instanceof eH)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */eH.ɵfac=function t(n){return new(n||eH)(Zg(wF,13),Zg(NF,10),Zg(FF,10))},eH.ɵdir=vo({type:eH,selectors:[["","formArrayName",""]],inputs:{name:["formArrayName","name"]},features:[Mu([nH]),hg]}),eH.ctorParameters=()=>[{type:wF,decorators:[{type:Ne},{type:He},{type:Le}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]}],eH.propDecorators={name:[{type:f_,args:["formArrayName"]}]};const oH={provide:AF,useExisting:aa((()=>rH))};class rH extends AF{constructor(t,n,e,a,o){super(),this._ngModelWarningConfig=o,this._added=!1,this.update=new Ef,this._ngModelWarningSent=!1,this._parent=t,this._rawValidators=n||[],this._rawAsyncValidators=e||[],this.valueAccessor=ML(this,a)}set isDisabled(t){("undefined"==typeof ngDevMode||ngDevMode)&&nL.disabledAttrWarning()}ngOnChanges(t){this._added||this._setUpControl(),hL(t,this.viewModel)&&(PL("formControlName",rH,this,this._ngModelWarningConfig),this.viewModel=this.model,this.formDirective.updateModel(this,this.model))}ngOnDestroy(){this.formDirective&&this.formDirective.removeControl(this)}viewToModelUpdate(t){this.viewModel=t,this.update.emit(t)}get path(){return mL(null==this.name?this.name:this.name.toString(),this._parent)}get formDirective(){return this._parent?this._parent.formDirective:null}get validator(){return uL(this._rawValidators)}get asyncValidator(){return fL(this._rawAsyncValidators)}_checkParentType(){("undefined"==typeof ngDevMode||ngDevMode)&&(!(this._parent instanceof tH)&&this._parent instanceof HL?nL.ngModelGroupException():this._parent instanceof tH||this._parent instanceof KL||this._parent instanceof eH||nL.controlParentException())}_setUpControl(){this._checkParentType(),this.control=this.formDirective.addControl(this),this.control.disabled&&this.valueAccessor.setDisabledState&&this.valueAccessor.setDisabledState(!0),this._added=!0}}rH.ɵfac=function t(n){return new(n||rH)(Zg(wF,13),Zg(NF,10),Zg(FF,10),Zg(MF,10),Zg(ZL,8))},rH.ɵdir=vo({type:rH,selectors:[["","formControlName",""]],inputs:{isDisabled:["disabled","isDisabled"],name:["formControlName","name"],model:["ngModel","model"]},outputs:{update:"ngModelChange"},features:[Mu([oH]),hg,pr]}),rH._ngModelWarningSentOnce=!1,rH.ctorParameters=()=>[{type:wF,decorators:[{type:Ne},{type:He},{type:Le}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[NF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[FF]}]},{type:Array,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[MF]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[ZL]}]}],rH.propDecorators={name:[{type:f_,args:["formControlName"]}],isDisabled:[{type:f_,args:["disabled"]}],model:[{type:f_,args:["ngModel"]}],update:[{type:h_,args:["ngModelChange"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const iH={provide:NF,useExisting:aa((()=>sH)),multi:!0},cH={provide:NF,useExisting:aa((()=>lH)),multi:!0};class sH{constructor(){this._required=!1}get required(){return this._required}set required(t){this._required=null!=t&&!1!==t&&"false"!=`${t}`,this._onChange&&this._onChange()}validate(t){return this.required?HF.required(t):null}registerOnValidatorChange(t){this._onChange=t}}sH.ɵfac=function t(n){return new(n||sH)},sH.ɵdir=vo({type:sH,selectors:[["","required","","formControlName","",3,"type","checkbox"],["","required","","formControl","",3,"type","checkbox"],["","required","","ngModel","",3,"type","checkbox"]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("required",e.required?"":null)},inputs:{required:"required"},features:[Mu([iH])]}),sH.propDecorators={required:[{type:f_}]};class lH extends sH{validate(t){return this.required?HF.requiredTrue(t):null}}lH.ɵfac=function t(n){return mH(n||lH)},lH.ɵdir=vo({type:lH,selectors:[["input","type","checkbox","required","","formControlName",""],["input","type","checkbox","required","","formControl",""],["input","type","checkbox","required","","ngModel",""]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("required",e.required?"":null)},features:[Mu([cH]),hg]});const mH=tc(lH),dH={provide:NF,useExisting:aa((()=>gH)),multi:!0};class gH{constructor(){this._enabled=!1}set email(t){this._enabled=""===t||!0===t||"true"===t,this._onChange&&this._onChange()}validate(t){return this._enabled?HF.email(t):null}registerOnValidatorChange(t){this._onChange=t}}gH.ɵfac=function t(n){return new(n||gH)},gH.ɵdir=vo({type:gH,selectors:[["","email","","formControlName",""],["","email","","formControl",""],["","email","","ngModel",""]],inputs:{email:"email"},features:[Mu([dH])]}),gH.propDecorators={email:[{type:f_}]};const pH={provide:NF,useExisting:aa((()=>bH)),multi:!0};class bH{constructor(){this._validator=HF.nullValidator}ngOnChanges(t){"minlength"in t&&(this._createValidator(),this._onChange&&this._onChange())}validate(t){return null==this.minlength?null:this._validator(t)}registerOnValidatorChange(t){this._onChange=t}_createValidator(){this._validator=HF.minLength("number"==typeof this.minlength?this.minlength:parseInt(this.minlength,10))}}bH.ɵfac=function t(n){return new(n||bH)},bH.ɵdir=vo({type:bH,selectors:[["","minlength","","formControlName",""],["","minlength","","formControl",""],["","minlength","","ngModel",""]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("minlength",e.minlength?e.minlength:null)},inputs:{minlength:"minlength"},features:[Mu([pH]),pr]}),bH.propDecorators={minlength:[{type:f_}]};const uH={provide:NF,useExisting:aa((()=>fH)),multi:!0};class fH{constructor(){this._validator=HF.nullValidator}ngOnChanges(t){"maxlength"in t&&(this._createValidator(),this._onChange&&this._onChange())}validate(t){return null!=this.maxlength?this._validator(t):null}registerOnValidatorChange(t){this._onChange=t}_createValidator(){this._validator=HF.maxLength("number"==typeof this.maxlength?this.maxlength:parseInt(this.maxlength,10))}}fH.ɵfac=function t(n){return new(n||fH)},fH.ɵdir=vo({type:fH,selectors:[["","maxlength","","formControlName",""],["","maxlength","","formControl",""],["","maxlength","","ngModel",""]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("maxlength",e.maxlength?e.maxlength:null)},inputs:{maxlength:"maxlength"},features:[Mu([uH]),pr]}),fH.propDecorators={maxlength:[{type:f_}]};const hH={provide:NF,useExisting:aa((()=>_H)),multi:!0};class _H{constructor(){this._validator=HF.nullValidator}ngOnChanges(t){"pattern"in t&&(this._createValidator(),this._onChange&&this._onChange())}validate(t){return this._validator(t)}registerOnValidatorChange(t){this._onChange=t}_createValidator(){this._validator=HF.pattern(this.pattern)}}_H.ɵfac=function t(n){return new(n||_H)},_H.ɵdir=vo({type:_H,selectors:[["","pattern","","formControlName",""],["","pattern","","formControl",""],["","pattern","","ngModel",""]],hostVars:1,hostBindings:function t(n,e){2&n&&Ng("pattern",e.pattern?e.pattern:null)},inputs:{pattern:"pattern"},features:[Mu([hH]),pr]}),_H.propDecorators={pattern:[{type:f_}]};class CH{}CH.ɵmod=xo({type:CH}),CH.ɵinj=Ge({factory:function t(n){return new(n||CH)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(CH,{declarations:[qL,rL,lL,kF,YF,QF,PF,oL,sL,XF,RF,TF,sH,bH,fH,_H,lH,gH],exports:[qL,rL,lL,kF,YF,QF,PF,oL,sL,XF,RF,TF,sH,bH,fH,_H,lH,gH]});class MH{group(t,n=null){const e=this._reduceControls(t);let a,o=null,r=null;return null!=n&&((
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
function i(t){return void 0!==t.asyncValidators||void 0!==t.validators||void 0!==t.updateOn})(n)?(o=null!=n.validators?n.validators:null,r=null!=n.asyncValidators?n.asyncValidators:null,a=null!=n.updateOn?n.updateOn:void 0):(o=null!=n.validator?n.validator:null,r=null!=n.asyncValidator?n.asyncValidator:null)),new DL(e,{asyncValidators:r,updateOn:a,validators:o})}control(t,n,e){return new TL(t,n,e)}array(t,n,e){const a=t.map((t=>this._createControl(t)));return new IL(a,n,e)}_reduceControls(t){const n={};return Object.keys(t).forEach((e=>{n[e]=this._createControl(t[e])})),n}_createControl(t){return t instanceof TL||t instanceof DL||t instanceof IL?t:Array.isArray(t)?this.control(t[0],t.length>1?t[1]:null,t.length>2?t[2]:null):this.control(t)}}MH.ɵfac=function t(n){return new(n||MH)},MH.ɵprov=We({token:MH,factory:MH.ɵfac}),
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
new Ru("10.2.4");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class OH{}OH.ɵmod=xo({type:OH}),OH.ɵinj=Ge({factory:function t(n){return new(n||OH)},providers:[ZF],imports:[CH]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(OH,{declarations:[YL,UL,LL],exports:[CH,YL,UL,LL]});class PH{static withConfig(t){return{ngModule:PH,providers:[{provide:ZL,useValue:t.warnOnNgModelWithFormControl}]}}}PH.ɵmod=xo({type:PH}),PH.ɵinj=Ge({factory:function t(n){return new(n||PH)},providers:[MH,ZF],imports:[CH]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(PH,{declarations:[JL,KL,rH,tH,eH],exports:[CH,JL,KL,rH,tH,eH]});const xH=["trigger"],yH=["panel"];function kH(t,n){if(1&t&&(Kg(0,"span",8),Jp(1),$g()),2&t){const t=gp();ws(1),Qp(t.placeholder||" ")}}function vH(t,n){if(1&t&&(Kg(0,"span"),Jp(1),$g()),2&t){const t=gp(2);ws(1),Qp(t.triggerValue||" ")}}function wH(t,n){1&t&&hp(0,0,["*ngSwitchCase","true"])}function SH(t,n){1&t&&(Kg(0,"span",9),Yg(1,vH,2,1,"span",10),Yg(2,wH,1,0,"ng-content",11),$g()),2&t&&(Jg("ngSwitch",!!gp().customTrigger),ws(2),Jg("ngSwitchCase",!0))}function EH(t,n){if(1&t){const t=op();Kg(0,"div",12),Kg(1,"div",13,14),cp("@transformPanel.done",(function n(e){return jr(t),gp()._panelDoneAnimatingStream.next(e.toState)}))("keydown",(function n(e){return jr(t),gp()._handleKeydown(e)})),hp(3,1),$g(),$g()}if(2&t){const t=gp();Jg("@transformPanelWrap",void 0),ws(1),nb("mat-select-panel ",t._getPanelTheme(),""),Tp("transform-origin",t._transformOrigin)("font-size",t._triggerFontSize,"px"),Jg("ngClass",t.panelClass)("@transformPanel",t.multiple?"showing-multiple":"showing"),Ng("id",t.id+"-panel")("aria-multiselectable",t.multiple)("aria-label",t.ariaLabel||null)("aria-labelledby",t._getPanelAriaLabelledby())}}const AH=[[["mat-select-trigger"]],"*"],zH={transformPanelWrap:SP("transformPanelWrap",[DP("* => void",NP("@transformPanel",[IP()],{optional:!0}))]),transformPanel:SP("transformPanel",[RP("void",zP({transform:"scaleY(0.8)",minWidth:"100%",opacity:0})),RP("showing",zP({opacity:1,minWidth:"calc(100% + 32px)",transform:"scaleY(1)"})),RP("showing-multiple",zP({opacity:1,minWidth:"calc(100% + 64px)",transform:"scaleY(1)"})),DP("void => *",EP("120ms cubic-bezier(0, 0, 0.2, 1)")),DP("* => void",EP("100ms 25ms linear",zP({opacity:0})))])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let RH=0;const TH=256,DH=new Fa("mat-select-scroll-strategy"),IH=new Fa("MAT_SELECT_CONFIG"),NH={provide:DH,deps:[hz],useFactory:function FH(t){return()=>t.scrollStrategies.reposition()}};class LH{constructor(t,n){this.source=t,this.value=n}}const HH=aE(oE(nE(rE(class{constructor(t,n,e,a,o){this._elementRef=t,this._defaultErrorStateMatcher=n,this._parentForm=e,this._parentFormGroup=a,this.ngControl=o}})))),BH=new Fa("MatSelectTrigger");class VH{}VH.ɵfac=function t(n){return new(n||VH)},VH.ɵdir=vo({type:VH,selectors:[["mat-select-trigger"]],features:[Mu([{provide:BH,useExisting:VH}])]});class jH extends HH{constructor(t,n,e,a,o,r,i,c,s,l,m,d,g,p){super(o,a,i,c,l),this._viewportRuler=t,this._changeDetectorRef=n,this._ngZone=e,this._dir=r,this._parentFormField=s,this.ngControl=l,this._liveAnnouncer=g,this._panelOpen=!1,this._required=!1,this._scrollTop=0,this._multiple=!1,this._compareWith=(t,n)=>t===n,this._uid="mat-select-"+RH++,this._triggerAriaLabelledBy=null,this._destroy=new x,this._triggerFontSize=0,this._onChange=()=>{},this._onTouched=()=>{},this._valueId="mat-select-value-"+RH++,this._transformOrigin="top",this._panelDoneAnimatingStream=new x,this._offsetY=0,this._positions=[{originX:"start",originY:"top",overlayX:"start",overlayY:"top"},{originX:"start",originY:"bottom",overlayX:"start",overlayY:"bottom"}],this._disableOptionCentering=!1,this._focused=!1,this.controlType="mat-select",this.ariaLabel="",this.optionSelectionChanges=Lt((()=>{const t=this.options;return t?t.changes.pipe(ce(t),se((()=>Wt(...t.map((t=>t.onSelectionChange)))))):this._ngZone.onStable.pipe(Tn(1),se((()=>this.optionSelectionChanges)))})),this.openedChange=new Ef,this._openedStream=this.openedChange.pipe(Gt((t=>t)),ft((()=>{}))),this._closedStream=this.openedChange.pipe(Gt((t=>!t)),ft((()=>{}))),this.selectionChange=new Ef,this.valueChange=new Ef,this.ngControl&&(this.ngControl.valueAccessor=this),this._scrollStrategyFactory=d,this._scrollStrategy=this._scrollStrategyFactory(),this.tabIndex=parseInt(m)||0,this.id=this.id,p&&(null!=p.disableOptionCentering&&(this.disableOptionCentering=p.disableOptionCentering),null!=p.typeaheadDebounceInterval&&(this.typeaheadDebounceInterval=p.typeaheadDebounceInterval))}get focused(){return this._focused||this._panelOpen}get placeholder(){return this._placeholder}set placeholder(t){this._placeholder=t,this.stateChanges.next()}get required(){return this._required}set required(t){this._required=Gw(t),this.stateChanges.next()}get multiple(){return this._multiple}set multiple(t){if(this._selectionModel&&("undefined"==typeof ngDevMode||ngDevMode))
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
throw(function n(){return Error("Cannot change `multiple` mode of select after initialization.")})();this._multiple=Gw(t)}get disableOptionCentering(){return this._disableOptionCentering}set disableOptionCentering(t){this._disableOptionCentering=Gw(t)}get compareWith(){return this._compareWith}set compareWith(t){if("function"!=typeof t&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("`compareWith` must be a function.")})();this._compareWith=t,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(t){t!==this._value&&(this.options&&this._setSelectionByValue(t),this._value=t)}get typeaheadDebounceInterval(){return this._typeaheadDebounceInterval}set typeaheadDebounceInterval(t){this._typeaheadDebounceInterval=Yw(t)}get id(){return this._id}set id(t){this._id=t||this._uid,this.stateChanges.next()}ngOnInit(){this._selectionModel=new mA(this.multiple),this.stateChanges.next(),this._panelDoneAnimatingStream.pipe(vn(),de(this._destroy)).subscribe((()=>{this.panelOpen?(this._scrollTop=0,this.openedChange.emit(!0)):(this.openedChange.emit(!1),this.overlayDir.offsetX=0,this._changeDetectorRef.markForCheck())})),this._viewportRuler.change().pipe(de(this._destroy)).subscribe((()=>{this._panelOpen&&(this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._changeDetectorRef.markForCheck())}))}ngAfterContentInit(){this._initKeyManager(),this._selectionModel.changed.pipe(de(this._destroy)).subscribe((t=>{t.added.forEach((t=>t.select())),t.removed.forEach((t=>t.deselect()))})),this.options.changes.pipe(ce(null),de(this._destroy)).subscribe((()=>{this._resetOptions(),this._initializeSelection()}))}ngDoCheck(){const t=this._getTriggerAriaLabelledby();if(t!==this._triggerAriaLabelledBy){const n=this._elementRef.nativeElement;this._triggerAriaLabelledBy=t,t?n.setAttribute("aria-labelledby",t):n.removeAttribute("aria-labelledby")}this.ngControl&&this.updateErrorState()}ngOnChanges(t){t.disabled&&this.stateChanges.next(),t.typeaheadDebounceInterval&&this._keyManager&&this._keyManager.withTypeAhead(this._typeaheadDebounceInterval)}ngOnDestroy(){this._destroy.next(),this._destroy.complete(),this.stateChanges.complete()}toggle(){this.panelOpen?this.close():this.open()}open(){!this.disabled&&this.options&&this.options.length&&!this._panelOpen&&(this._triggerRect=this.trigger.nativeElement.getBoundingClientRect(),this._triggerFontSize=parseInt(getComputedStyle(this.trigger.nativeElement).fontSize||"0"),this._panelOpen=!0,this._keyManager.withHorizontalOrientation(null),this._calculateOverlayPosition(),this._highlightCorrectOption(),this._changeDetectorRef.markForCheck(),this._ngZone.onStable.pipe(Tn(1)).subscribe((()=>{this._triggerFontSize&&this.overlayDir.overlayRef&&this.overlayDir.overlayRef.overlayElement&&(this.overlayDir.overlayRef.overlayElement.style.fontSize=`${this._triggerFontSize}px`)})))}close(){this._panelOpen&&(this._panelOpen=!1,this._keyManager.withHorizontalOrientation(this._isRtl()?"rtl":"ltr"),this._changeDetectorRef.markForCheck(),this._onTouched())}writeValue(t){this.value=t}registerOnChange(t){this._onChange=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this.disabled=t,this._changeDetectorRef.markForCheck(),this.stateChanges.next()}get panelOpen(){return this._panelOpen}get selected(){return this.multiple?this._selectionModel.selected:this._selectionModel.selected[0]}get triggerValue(){if(this.empty)return"";if(this._multiple){const t=this._selectionModel.selected.map((t=>t.viewValue));return this._isRtl()&&t.reverse(),t.join(", ")}return this._selectionModel.selected[0].viewValue}_isRtl(){return!!this._dir&&"rtl"===this._dir.value}_handleKeydown(t){this.disabled||(this.panelOpen?this._handleOpenKeydown(t):this._handleClosedKeydown(t))}_handleClosedKeydown(t){const n=t.keyCode,e=n===Uw||n===jw||37===n||39===n,a=n===Hw||n===Vw,o=this._keyManager;if(!o.isTyping()&&a&&!Ww(t)||(this.multiple||t.altKey)&&e)t.preventDefault(),this.open();else if(!this.multiple){const n=this.selected;o.onKeydown(t);const e=this.selected;e&&n!==e&&this._liveAnnouncer.announce(e.viewValue,1e4)}}_handleOpenKeydown(t){const n=this._keyManager,e=t.keyCode,a=e===Uw||e===jw,o=n.isTyping();if(a&&t.altKey)t.preventDefault(),this.close();else if(o||e!==Hw&&e!==Vw||!n.activeItem||Ww(t))if(!o&&this._multiple&&65===e&&t.ctrlKey){t.preventDefault();const n=this.options.some((t=>!t.disabled&&!t.selected));this.options.forEach((t=>{t.disabled||(n?t.select():t.deselect())}))}else{const e=n.activeItemIndex;n.onKeydown(t),this._multiple&&a&&t.shiftKey&&n.activeItem&&n.activeItemIndex!==e&&n.activeItem._selectViaInteraction()}else t.preventDefault(),n.activeItem._selectViaInteraction()}_onFocus(){this.disabled||(this._focused=!0,this.stateChanges.next())}_onBlur(){this._focused=!1,this.disabled||this.panelOpen||(this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next())}_onAttached(){this.overlayDir.positionChange.pipe(Tn(1)).subscribe((()=>{this._changeDetectorRef.detectChanges(),this._calculateOverlayOffsetX(),this.panel.nativeElement.scrollTop=this._scrollTop}))}_getPanelTheme(){return this._parentFormField?`mat-${this._parentFormField.color}`:""}get empty(){return!this._selectionModel||this._selectionModel.isEmpty()}_initializeSelection(){Promise.resolve().then((()=>{this._setSelectionByValue(this.ngControl?this.ngControl.value:this._value),this.stateChanges.next()}))}_setSelectionByValue(t){if(this.multiple&&t){if(!Array.isArray(t)&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("Value must be an array in multiple-selection mode.")})();this._selectionModel.clear(),t.forEach((t=>this._selectValue(t))),this._sortValues()}else{this._selectionModel.clear();const n=this._selectValue(t);n?this._keyManager.updateActiveItem(n):this.panelOpen||this._keyManager.updateActiveItem(-1)}this._changeDetectorRef.markForCheck()}_selectValue(t){const n=this.options.find((n=>{try{return null!=n.value&&this._compareWith(n.value,t)}catch(t){return("undefined"==typeof ngDevMode||ngDevMode)&&console.warn(t),!1}}));return n&&this._selectionModel.select(n),n}_initKeyManager(){this._keyManager=new lS(this.options).withTypeAhead(this._typeaheadDebounceInterval).withVerticalOrientation().withHorizontalOrientation(this._isRtl()?"rtl":"ltr").withHomeAndEnd().withAllowedModifierKeys(["shiftKey"]),this._keyManager.tabOut.pipe(de(this._destroy)).subscribe((()=>{this.panelOpen&&(!this.multiple&&this._keyManager.activeItem&&this._keyManager.activeItem._selectViaInteraction(),this.focus(),this.close())})),this._keyManager.change.pipe(de(this._destroy)).subscribe((()=>{this._panelOpen&&this.panel?this._scrollActiveOptionIntoView():this._panelOpen||this.multiple||!this._keyManager.activeItem||this._keyManager.activeItem._selectViaInteraction()}))}_resetOptions(){const t=Wt(this.options.changes,this._destroy);this.optionSelectionChanges.pipe(de(t)).subscribe((t=>{this._onSelect(t.source,t.isUserInput),t.isUserInput&&!this.multiple&&this._panelOpen&&(this.close(),this.focus())})),Wt(...this.options.map((t=>t._stateChanges))).pipe(de(t)).subscribe((()=>{this._changeDetectorRef.markForCheck(),this.stateChanges.next()}))}_onSelect(t,n){const e=this._selectionModel.isSelected(t);null!=t.value||this._multiple?(e!==t.selected&&(t.selected?this._selectionModel.select(t):this._selectionModel.deselect(t)),n&&this._keyManager.setActiveItem(t),this.multiple&&(this._sortValues(),n&&this.focus())):(t.deselect(),this._selectionModel.clear(),null!=this.value&&this._propagateChanges(t.value)),e!==this._selectionModel.isSelected(t)&&this._propagateChanges(),this.stateChanges.next()}_sortValues(){if(this.multiple){const t=this.options.toArray();this._selectionModel.sort(((n,e)=>this.sortComparator?this.sortComparator(n,e,t):t.indexOf(n)-t.indexOf(e))),this.stateChanges.next()}}_propagateChanges(t){let n=null;n=this.multiple?this.selected.map((t=>t.value)):this.selected?this.selected.value:t,this._value=n,this.valueChange.emit(n),this._onChange(n),this.selectionChange.emit(new LH(this,n)),this._changeDetectorRef.markForCheck()}_highlightCorrectOption(){this._keyManager&&(this.empty?this._keyManager.setFirstItemActive():this._keyManager.setActiveItem(this._selectionModel.selected[0]))}_scrollActiveOptionIntoView(){const t=this._keyManager.activeItemIndex||0,n=qE(t,this.options,this.optionGroups),e=this._getItemHeight();this.panel.nativeElement.scrollTop=ZE((t+n)*e,e,this.panel.nativeElement.scrollTop,TH)}focus(t){this._elementRef.nativeElement.focus(t)}_getOptionIndex(t){return this.options.reduce(((n,e,a)=>void 0!==n?n:t===e?a:void 0),void 0)}_calculateOverlayPosition(){const t=this._getItemHeight(),n=this._getItemCount(),e=Math.min(n*t,TH),a=n*t-e;let o=this.empty?0:this._getOptionIndex(this._selectionModel.selected[0]);o+=qE(o,this.options,this.optionGroups);const r=e/2;this._scrollTop=this._calculateOverlayScroll(o,r,a),this._offsetY=this._calculateOverlayOffsetY(o,r,a),this._checkOverlayWithinViewport(a)}_calculateOverlayScroll(t,n,e){const a=this._getItemHeight();return Math.min(Math.max(0,a*t-n+a/2),e)}_getPanelAriaLabelledby(){if(this.ariaLabel)return null;const t=this._getLabelId();return this.ariaLabelledby?t+" "+this.ariaLabelledby:t}_getAriaActiveDescendant(){return this.panelOpen&&this._keyManager&&this._keyManager.activeItem?this._keyManager.activeItem.id:null}_getLabelId(){var t;return(null===(t=this._parentFormField)||void 0===t?void 0:t.getLabelId())||""}_calculateOverlayOffsetX(){const t=this.overlayDir.overlayRef.overlayElement.getBoundingClientRect(),n=this._viewportRuler.getViewportSize(),e=this._isRtl(),a=this.multiple?56:32;let o;if(this.multiple)o=40;else{let t=this._selectionModel.selected[0]||this.options.first;o=t&&t.group?32:16}e||(o*=-1);const r=0-(t.left+o-(e?a:0)),i=t.right+o-n.width+(e?0:a);r>0?o+=r+8:i>0&&(o-=i+8),this.overlayDir.offsetX=Math.round(o),this.overlayDir.overlayRef.updatePosition()}_calculateOverlayOffsetY(t,n,e){const a=this._getItemHeight(),o=(a-this._triggerRect.height)/2,r=Math.floor(TH/a);let i;return this._disableOptionCentering?0:(i=0===this._scrollTop?t*a:this._scrollTop===e?(t-(this._getItemCount()-r))*a+(a-(this._getItemCount()*a-TH)%a):n-a/2,Math.round(-1*i-o))}_checkOverlayWithinViewport(t){const n=this._getItemHeight(),e=this._viewportRuler.getViewportSize(),a=this._triggerRect.top-8,o=e.height-this._triggerRect.bottom-8,r=Math.abs(this._offsetY),i=Math.min(this._getItemCount()*n,TH)-r-this._triggerRect.height;i>o?this._adjustPanelUp(i,o):r>a?this._adjustPanelDown(r,a,t):this._transformOrigin=this._getOriginBasedOnOption()}_adjustPanelUp(t,n){const e=Math.round(t-n);this._scrollTop-=e,this._offsetY-=e,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop<=0&&(this._scrollTop=0,this._offsetY=0,this._transformOrigin="50% bottom 0px")}_adjustPanelDown(t,n,e){const a=Math.round(t-n);if(this._scrollTop+=a,this._offsetY+=a,this._transformOrigin=this._getOriginBasedOnOption(),this._scrollTop>=e)return this._scrollTop=e,this._offsetY=0,void(this._transformOrigin="50% top 0px")}_getOriginBasedOnOption(){const t=this._getItemHeight(),n=(t-this._triggerRect.height)/2;return`50% ${Math.abs(this._offsetY)-n+t/2}px 0px`}_getItemCount(){return this.options.length+this.optionGroups.length}_getItemHeight(){return 3*this._triggerFontSize}_getTriggerAriaLabelledby(){if(this.ariaLabel)return null;let t=this._getLabelId()+" "+this._valueId;return this.ariaLabelledby&&(t+=" "+this.ariaLabelledby),t}setDescribedByIds(t){this._ariaDescribedby=t.join(" ")}onContainerClick(){this.focus(),this.open()}get shouldLabelFloat(){return this._panelOpen||!this.empty}}jH.ɵfac=function t(n){return new(n||jH)(Zg(MA),Zg(Vm),Zg(J_),Zg(OE),Zg(xu),Zg(US,8),Zg(LL,8),Zg(KL,8),Zg(hF,8),Zg(AF,10),Xg("tabindex"),Zg(DH),Zg(SS),Zg(IH,8))},jH.ɵcmp=_o({type:jH,selectors:[["mat-select"]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,BH,!0),Gf(a,YE,!0),Gf(a,HE,!0)),2&n&&(Vf(o=Zf())&&(e.customTrigger=o.first),Vf(o=Zf())&&(e.options=o),Vf(o=Zf())&&(e.optionGroups=o))},viewQuery:function t(n,e){var a;1&n&&(Uf(xH,!0),Uf(yH,!0),Uf(Oz,!0)),2&n&&(Vf(a=Zf())&&(e.trigger=a.first),Vf(a=Zf())&&(e.panel=a.first),Vf(a=Zf())&&(e.overlayDir=a.first))},hostAttrs:["role","combobox","aria-autocomplete","none","aria-haspopup","true",1,"mat-select"],hostVars:20,hostBindings:function t(n,e){1&n&&cp("keydown",(function t(n){return e._handleKeydown(n)}))("focus",(function t(){return e._onFocus()}))("blur",(function t(){return e._onBlur()})),2&n&&(Ng("id",e.id)("tabindex",e.tabIndex)("aria-controls",e.panelOpen?e.id+"-panel":null)("aria-expanded",e.panelOpen)("aria-label",e.ariaLabel||null)("aria-required",e.required.toString())("aria-disabled",e.disabled.toString())("aria-invalid",e.errorState)("aria-describedby",e._ariaDescribedby||null)("aria-activedescendant",e._getAriaActiveDescendant()),Dp("mat-select-disabled",e.disabled)("mat-select-invalid",e.errorState)("mat-select-required",e.required)("mat-select-empty",e.empty)("mat-select-multiple",e.multiple))},inputs:{disabled:"disabled",disableRipple:"disableRipple",tabIndex:"tabIndex",ariaLabel:["aria-label","ariaLabel"],id:"id",disableOptionCentering:"disableOptionCentering",typeaheadDebounceInterval:"typeaheadDebounceInterval",placeholder:"placeholder",required:"required",multiple:"multiple",compareWith:"compareWith",value:"value",panelClass:"panelClass",ariaLabelledby:["aria-labelledby","ariaLabelledby"],errorStateMatcher:"errorStateMatcher",sortComparator:"sortComparator"},outputs:{openedChange:"openedChange",_openedStream:"opened",_closedStream:"closed",selectionChange:"selectionChange",valueChange:"valueChange"},exportAs:["matSelect"],features:[Mu([{provide:aF,useExisting:jH},{provide:WE,useExisting:jH}]),hg,pr],ngContentSelectors:["mat-select-trigger","*"],decls:9,vars:10,consts:[["cdk-overlay-origin","",1,"mat-select-trigger",3,"click"],["origin","cdkOverlayOrigin","trigger",""],[1,"mat-select-value",3,"ngSwitch"],["class","mat-select-placeholder",4,"ngSwitchCase"],["class","mat-select-value-text",3,"ngSwitch",4,"ngSwitchCase"],[1,"mat-select-arrow-wrapper"],[1,"mat-select-arrow"],["cdk-connected-overlay","","cdkConnectedOverlayLockPosition","","cdkConnectedOverlayHasBackdrop","","cdkConnectedOverlayBackdropClass","cdk-overlay-transparent-backdrop",3,"cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayMinWidth","cdkConnectedOverlayOffsetY","backdropClick","attach","detach"],[1,"mat-select-placeholder"],[1,"mat-select-value-text",3,"ngSwitch"],[4,"ngSwitchDefault"],[4,"ngSwitchCase"],[1,"mat-select-panel-wrap"],["role","listbox","tabindex","-1",3,"ngClass","keydown"],["panel",""]],template:function t(n,e){if(1&n&&(bp(AH),Kg(0,"div",0,1),cp("click",(function t(){return e.toggle()})),Kg(3,"div",2),Yg(4,kH,2,1,"span",3),Yg(5,SH,3,2,"span",4),$g(),Kg(6,"div",5),tp(7,"div",6),$g(),$g(),Yg(8,EH,4,14,"ng-template",7),cp("backdropClick",(function t(){return e.close()}))("attach",(function t(){return e._onAttached()}))("detach",(function t(){return e.close()}))),2&n){const t=qg(1);ws(3),Jg("ngSwitch",e.empty),Ng("id",e._valueId),ws(1),Jg("ngSwitchCase",!0),ws(1),Jg("ngSwitchCase",!1),ws(3),Jg("cdkConnectedOverlayScrollStrategy",e._scrollStrategy)("cdkConnectedOverlayOrigin",t)("cdkConnectedOverlayOpen",e.panelOpen)("cdkConnectedOverlayPositions",e._positions)("cdkConnectedOverlayMinWidth",null==e._triggerRect?null:e._triggerRect.width)("cdkConnectedOverlayOffsetY",e._offsetY)}},directives:[Mz,ZM,XM,Oz,JM,HM],styles:[".mat-select{display:inline-block;width:100%;outline:none}.mat-select-trigger{display:inline-table;cursor:pointer;position:relative;box-sizing:border-box}.mat-select-disabled .mat-select-trigger{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.mat-select-value{display:table-cell;max-width:0;width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mat-select-value-text{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-select-arrow-wrapper{display:table-cell;vertical-align:middle}.mat-form-field-appearance-fill .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-outline .mat-select-arrow-wrapper{transform:translateY(-25%)}.mat-form-field-appearance-standard.mat-form-field-has-label .mat-select:not(.mat-select-empty) .mat-select-arrow-wrapper{transform:translateY(-50%)}.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable.mat-form-field-appearance-standard .mat-select.mat-select-empty .mat-select-arrow-wrapper{transition:none}.mat-select-arrow{width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid;margin:0 4px}.mat-select-panel-wrap{flex-basis:100%}.mat-select-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;padding-top:0;padding-bottom:0;max-height:256px;min-width:100%;border-radius:4px}.cdk-high-contrast-active .mat-select-panel{outline:solid 1px}.mat-select-panel .mat-optgroup-label,.mat-select-panel .mat-option{font-size:inherit;line-height:3em;height:3em}.mat-form-field-type-mat-select:not(.mat-form-field-disabled) .mat-form-field-flex{cursor:pointer}.mat-form-field-type-mat-select .mat-form-field-label{width:calc(100% - 18px)}.mat-select-placeholder{transition:color 400ms 133.3333333333ms cubic-bezier(0.25, 0.8, 0.25, 1)}._mat-animation-noopable .mat-select-placeholder{transition:none}.mat-form-field-hide-placeholder .mat-select-placeholder{color:transparent;-webkit-text-fill-color:transparent;transition:none;display:block}\n"],encapsulation:2,data:{animation:[zH.transformPanelWrap,zH.transformPanel]},changeDetection:0}),jH.ctorParameters=()=>[{type:MA},{type:Vm},{type:J_},{type:OE},{type:xu},{type:US,decorators:[{type:Ne}]},{type:LL,decorators:[{type:Ne}]},{type:KL,decorators:[{type:Ne}]},{type:_F,decorators:[{type:Ne},{type:Ie,args:[hF]}]},{type:AF,decorators:[{type:Fe},{type:Ne}]},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:void 0,decorators:[{type:Ie,args:[DH]}]},{type:SS},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[IH]}]}],jH.propDecorators={trigger:[{type:Xd,args:["trigger"]}],panel:[{type:Xd,args:["panel"]}],overlayDir:[{type:Xd,args:[Oz]}],options:[{type:qd,args:[YE,{descendants:!0}]}],optionGroups:[{type:qd,args:[HE,{descendants:!0}]}],panelClass:[{type:f_}],customTrigger:[{type:Zd,args:[BH]}],placeholder:[{type:f_}],required:[{type:f_}],multiple:[{type:f_}],disableOptionCentering:[{type:f_}],compareWith:[{type:f_}],value:[{type:f_}],ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}],errorStateMatcher:[{type:f_}],typeaheadDebounceInterval:[{type:f_}],sortComparator:[{type:f_}],id:[{type:f_}],openedChange:[{type:h_}],_openedStream:[{type:h_,args:["opened"]}],_closedStream:[{type:h_,args:["closed"]}],selectionChange:[{type:h_}],valueChange:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class UH{}function WH(t,n){if(1&t){const t=op();Kg(0,"span",5),cp("click",(function n(e){jr(t);const a=gp().$implicit;return gp().onActivePluginSelection(e,a.id)})),Jp(1),$g()}if(2&t){const t=gp().$implicit;Ng("data-plugin-id",t.id),ws(1),Kp(" ",t.tab_name," ")}}function GH(t,n){1&t&&(Kg(0,"mat-tab",3),Yg(1,WH,2,2,"ng-template",4),$g()),2&t&&Jg("disabled",!n.$implicit.enabled)}function YH(t,n){if(1&t&&(Kg(0,"mat-option",9),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t.id),Ng("data-plugin-id",t.id),ws(1),Kp(" ",t.tab_name," ")}}function qH(t,n){if(1&t){const t=op();Kg(0,"mat-form-field",6),Kg(1,"mat-label"),Jp(2,"Inactive"),$g(),Kg(3,"mat-select",7),cp("selectionChange",(function n(e){return jr(t),gp().onDisabledPluginSelectionChanged(e)})),Yg(4,YH,2,3,"mat-option",8),$g(),$g()}if(2&t){const t=gp();ws(3),Jg("value",t.selectedPlugin),ws(1),Jg("ngForOf",t.disabledPlugins)}}UH.ɵmod=xo({type:UH}),UH.ɵinj=Ge({factory:function t(n){return new(n||UH)},providers:[NH],imports:[[PO,yz,XE,tE],kA,CF,XE,tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(UH,{declarations:function(){return[jH,VH]},imports:function(){return[PO,yz,XE,tE]},exports:function(){return[kA,CF,jH,VH,XE,tE]}});class ZH{constructor(){this.onPluginSelectionChanged=new Ef}getActivePluginIndex(){return this.activePlugins.findIndex((({id:t})=>t===this.selectedPlugin))}onActivePluginSelection(t,n){t.stopPropagation(),this.onPluginSelectionChanged.emit(n)}onDisabledPluginSelectionChanged(t){this.onPluginSelectionChanged.emit(t.value)}}ZH.ɵfac=function t(n){return new(n||ZH)},ZH.ɵcmp=_o({type:ZH,selectors:[["plugin-selector-component"]],inputs:{activePlugins:"activePlugins",disabledPlugins:"disabledPlugins",selectedPlugin:"selectedPlugin"},outputs:{onPluginSelectionChanged:"onPluginSelectionChanged"},decls:3,vars:3,consts:[["animationDuration","100ms",1,"active-plugin-list",3,"selectedIndex"],[3,"disabled",4,"ngFor","ngForOf"],["floatLabel","never",4,"ngIf"],[3,"disabled"],["mat-tab-label",""],[1,"plugin-name",3,"click"],["floatLabel","never"],[3,"value","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"]],template:function t(n,e){1&n&&(Kg(0,"mat-tab-group",0),Yg(1,GH,2,1,"mat-tab",1),$g(),Yg(2,qH,5,2,"mat-form-field",2)),2&n&&(Jg("selectedIndex",e.getActivePluginIndex()),ws(1),Jg("ngForOf",e.activePlugins),ws(1),Jg("ngIf",e.disabledPlugins.length>0))},directives:[yN,jM,WM,bN,mN,_F,sF,jH,YE],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex:1 1 auto;font-size:14px;height:100%;overflow:hidden}mat-form-field[_ngcontent-%COMP%]{flex:0 0;margin-top:5px;width:130px}mat-label[_ngcontent-%COMP%], mat-select[_ngcontent-%COMP%], mat-option[_ngcontent-%COMP%]{font-weight:500;text-transform:uppercase}.active-plugin-list[_ngcontent-%COMP%]{align-self:stretch;flex:1 1 auto;overflow:hidden}.plugin-name[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:100%;justify-content:center;padding:0 12px;width:100%}[_nghost-%COMP%]     .active-plugin-list.mat-primary .mat-ink-bar{background-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link{color:inherit;opacity:.7}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label.mat-tab-label-active, [_nghost-%COMP%]     .active-plugin-list .mat-tab-link.mat-tab-label-active{opacity:1}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-chevron{border-color:currentColor}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header-pagination-disabled{visibility:hidden}[_nghost-%COMP%]     .active-plugin-list .mat-tab-disabled{display:none}[_nghost-%COMP%]     .active-plugin-list .mat-tab-header, [_nghost-%COMP%]     .active-plugin-list .mat-tab-labels, [_nghost-%COMP%]     .active-plugin-list .mat-tab-label{height:100%}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label{min-width:48px;padding:0;text-transform:uppercase}[_nghost-%COMP%]     .active-plugin-list .mat-tab-label-content{height:100%}[_nghost-%COMP%]     .active-plugin-list mat-tab-header:not(.mat-tab-header-pagination-controls-enabled){padding:0 36px}"]});const XH=pv(FI,(t=>Object.keys(t).map((n=>Object.assign({},{id:n},t[n]))))),JH=pv(XH,(t=>t.filter((t=>!t.enabled))));class QH{constructor(t){this.store=t,this.activePlugin$=this.store.pipe(lv(NI)),this.plugins$=this.store.pipe(lv(XH)),this.disabledPlugins$=this.store.pipe(lv(JH))}onPluginSelectionChange(t){this.store.dispatch(gI({plugin:t}))}}function KH(t,n){}QH.ɵfac=function t(n){return new(n||QH)(Zg(cv))},QH.ɵcmp=_o({type:QH,selectors:[["plugin-selector"]],decls:4,vars:9,consts:[[3,"activePlugins","disabledPlugins","selectedPlugin","onPluginSelectionChanged"]],template:function t(n,e){1&n&&(Kg(0,"plugin-selector-component",0),cp("onPluginSelectionChanged",(function t(n){return e.onPluginSelectionChange(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("activePlugins",kf(1,3,e.plugins$))("disabledPlugins",kf(2,5,e.disabledPlugins$))("selectedPlugin",kf(3,7,e.activePlugin$))},directives:[ZH],pipes:[oO],encapsulation:2});class $H{constructor(){this.role="dialog",this.panelClass="",this.hasBackdrop=!0,this.backdropClass="",this.disableClose=!1,this.width="",this.height="",this.maxWidth="80vw",this.data=null,this.ariaDescribedBy=null,this.ariaLabelledBy=null,this.ariaLabel=null,this.autoFocus=!0,this.restoreFocus=!0,this.closeOnNavigation=!0}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const tB={dialogContainer:SP("dialogContainer",[RP("void, exit",zP({opacity:0,transform:"scale(0.7)"})),RP("enter",zP({transform:"none"})),DP("* => enter",EP("150ms cubic-bezier(0, 0, 0.2, 1)",zP({transform:"none",opacity:1}))),DP("* => void, * => exit",EP("75ms cubic-bezier(0.4, 0.0, 0.2, 1)",zP({opacity:0})))])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function nB(){throw Error("Attempting to attach dialog content after content is already attached")}class eB extends RA{constructor(t,n,e,a,o,r){super(),this._elementRef=t,this._focusTrapFactory=n,this._changeDetectorRef=e,this._config=o,this._focusMonitor=r,this._animationStateChanged=new Ef,this._elementFocusedBeforeDialogWasOpened=null,this._closeInteractionType=null,this.attachDomPortal=t=>(this._portalOutlet.hasAttached()&&("undefined"==typeof ngDevMode||ngDevMode)&&nB(),this._portalOutlet.attachDomPortal(t)),this._ariaLabelledBy=o.ariaLabelledBy||null,this._document=a}_initializeWithAttachedContent(){this._setupFocusTrap(),this._capturePreviouslyFocusedElement(),this._focusDialogContainer()}attachComponentPortal(t){return this._portalOutlet.hasAttached()&&("undefined"==typeof ngDevMode||ngDevMode)&&nB(),this._portalOutlet.attachComponentPortal(t)}attachTemplatePortal(t){return this._portalOutlet.hasAttached()&&("undefined"==typeof ngDevMode||ngDevMode)&&nB(),this._portalOutlet.attachTemplatePortal(t)}_recaptureFocus(){this._containsFocus()||(!this._config.autoFocus||!this._focusTrap.focusInitialElement())&&this._elementRef.nativeElement.focus()}_trapFocus(){this._config.autoFocus?this._focusTrap.focusInitialElementWhenReady():this._containsFocus()||this._elementRef.nativeElement.focus()}_restoreFocus(){const t=this._elementFocusedBeforeDialogWasOpened;if(this._config.restoreFocus&&t&&"function"==typeof t.focus){const n=this._document.activeElement,e=this._elementRef.nativeElement;n&&n!==this._document.body&&n!==e&&!e.contains(n)||(this._focusMonitor?(this._focusMonitor.focusVia(t,this._closeInteractionType),this._closeInteractionType=null):t.focus())}this._focusTrap&&this._focusTrap.destroy()}_setupFocusTrap(){this._focusTrap=this._focusTrapFactory.create(this._elementRef.nativeElement)}_capturePreviouslyFocusedElement(){this._document&&(this._elementFocusedBeforeDialogWasOpened=this._document.activeElement)}_focusDialogContainer(){this._elementRef.nativeElement.focus&&this._elementRef.nativeElement.focus()}_containsFocus(){const t=this._elementRef.nativeElement,n=this._document.activeElement;return t===n||t.contains(n)}}eB.ɵfac=function t(n){return new(n||eB)(Zg(xu),Zg(uS),Zg(Vm),Zg(zC,8),Zg($H),Zg(TS))},eB.ɵdir=vo({type:eB,viewQuery:function t(n,e){var a;1&n&&jf(FA,!0),2&n&&Vf(a=Zf())&&(e._portalOutlet=a.first)},features:[hg]}),eB.ctorParameters=()=>[{type:xu},{type:uS},{type:Vm},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:$H},{type:TS}],eB.propDecorators={_portalOutlet:[{type:Xd,args:[FA,{static:!0}]}]};class aB extends eB{constructor(){super(...arguments),this._state="enter"}_onAnimationDone({toState:t,totalTime:n}){"enter"===t?(this._trapFocus(),this._animationStateChanged.next({state:"opened",totalTime:n})):"exit"===t&&(this._restoreFocus(),this._animationStateChanged.next({state:"closed",totalTime:n}))}_onAnimationStart({toState:t,totalTime:n}){"enter"===t?this._animationStateChanged.next({state:"opening",totalTime:n}):"exit"!==t&&"void"!==t||this._animationStateChanged.next({state:"closing",totalTime:n})}_startExitAnimation(){this._state="exit",this._changeDetectorRef.markForCheck()}}aB.ɵfac=function t(n){return oB(n||aB)},aB.ɵcmp=_o({type:aB,selectors:[["mat-dialog-container"]],hostAttrs:["tabindex","-1","aria-modal","true",1,"mat-dialog-container"],hostVars:6,hostBindings:function t(n,e){1&n&&sp("@dialogContainer.start",(function t(n){return e._onAnimationStart(n)}))("@dialogContainer.done",(function t(n){return e._onAnimationDone(n)})),2&n&&(eb("id",e._id),Ng("role",e._config.role)("aria-labelledby",e._config.ariaLabel?null:e._ariaLabelledBy)("aria-label",e._config.ariaLabel)("aria-describedby",e._config.ariaDescribedBy||null),ab("@dialogContainer",e._state))},features:[hg],decls:1,vars:0,consts:[["cdkPortalOutlet",""]],template:function t(n,e){1&n&&Yg(0,KH,0,0,"ng-template",0)},directives:[FA],styles:[".mat-dialog-container{display:block;padding:24px;border-radius:4px;box-sizing:border-box;overflow:auto;outline:0;width:100%;height:100%;min-height:inherit;max-height:inherit}.cdk-high-contrast-active .mat-dialog-container{outline:solid 1px}.mat-dialog-content{display:block;margin:0 -24px;padding:0 24px;max-height:65vh;overflow:auto;-webkit-overflow-scrolling:touch}.mat-dialog-title{margin:0 0 20px;display:block}.mat-dialog-actions{padding:8px 0;display:flex;flex-wrap:wrap;min-height:52px;align-items:center;margin-bottom:-24px}.mat-dialog-actions[align=end]{justify-content:flex-end}.mat-dialog-actions[align=center]{justify-content:center}.mat-dialog-actions .mat-button-base+.mat-button-base,.mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:8px}[dir=rtl] .mat-dialog-actions .mat-button-base+.mat-button-base,[dir=rtl] .mat-dialog-actions .mat-mdc-button-base+.mat-mdc-button-base{margin-left:0;margin-right:8px}\n"],encapsulation:2,data:{animation:[tB.dialogContainer]}});const oB=tc(aB);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let rB=0;class iB{constructor(t,n,e="mat-dialog-"+rB++){this._overlayRef=t,this._containerInstance=n,this.id=e,this.disableClose=this._containerInstance._config.disableClose,this._afterOpened=new x,this._afterClosed=new x,this._beforeClosed=new x,this._state=0,n._id=e,n._animationStateChanged.pipe(Gt((t=>"opened"===t.state)),Tn(1)).subscribe((()=>{this._afterOpened.next(),this._afterOpened.complete()})),n._animationStateChanged.pipe(Gt((t=>"closed"===t.state)),Tn(1)).subscribe((()=>{clearTimeout(this._closeFallbackTimeout),this._finishDialogClose()})),t.detachments().subscribe((()=>{this._beforeClosed.next(this._result),this._beforeClosed.complete(),this._afterClosed.next(this._result),this._afterClosed.complete(),this.componentInstance=null,this._overlayRef.dispose()})),t.keydownEvents().pipe(Gt((t=>t.keyCode===Bw&&!this.disableClose&&!Ww(t)))).subscribe((t=>{t.preventDefault(),cB(this,"keyboard")})),t.backdropClick().subscribe((()=>{this.disableClose?this._containerInstance._recaptureFocus():cB(this,"mouse")}))}close(t){this._result=t,this._containerInstance._animationStateChanged.pipe(Gt((t=>"closing"===t.state)),Tn(1)).subscribe((n=>{this._beforeClosed.next(t),this._beforeClosed.complete(),this._overlayRef.detachBackdrop(),this._closeFallbackTimeout=setTimeout((()=>this._finishDialogClose()),n.totalTime+100)})),this._state=1,this._containerInstance._startExitAnimation()}afterOpened(){return this._afterOpened}afterClosed(){return this._afterClosed}beforeClosed(){return this._beforeClosed}backdropClick(){return this._overlayRef.backdropClick()}keydownEvents(){return this._overlayRef.keydownEvents()}updatePosition(t){let n=this._getPositionStrategy();return t&&(t.left||t.right)?t.left?n.left(t.left):n.right(t.right):n.centerHorizontally(),t&&(t.top||t.bottom)?t.top?n.top(t.top):n.bottom(t.bottom):n.centerVertically(),this._overlayRef.updatePosition(),this}updateSize(t="",n=""){return this._getPositionStrategy().width(t).height(n),this._overlayRef.updatePosition(),this}addPanelClass(t){return this._overlayRef.addPanelClass(t),this}removePanelClass(t){return this._overlayRef.removePanelClass(t),this}getState(){return this._state}_finishDialogClose(){this._state=2,this._overlayRef.dispose()}_getPositionStrategy(){return this._overlayRef.getConfig().positionStrategy}}function cB(t,n,e){return void 0!==t._containerInstance&&(t._containerInstance._closeInteractionType=n),t.close(e)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const sB=new Fa("MatDialogData"),lB=new Fa("mat-dialog-default-options"),mB=new Fa("mat-dialog-scroll-strategy"),dB={provide:mB,deps:[hz],useFactory:function gB(t){return()=>t.scrollStrategies.block()}};class pB{constructor(t,n,e,a,o,r,i,c,s){this._overlay=t,this._injector=n,this._defaultOptions=e,this._parentDialog=a,this._overlayContainer=o,this._dialogRefConstructor=i,this._dialogContainerType=c,this._dialogDataToken=s,this._openDialogsAtThisLevel=[],this._afterAllClosedAtThisLevel=new x,this._afterOpenedAtThisLevel=new x,this._ariaHiddenElements=new Map,this.afterAllClosed=Lt((()=>this.openDialogs.length?this._getAfterAllClosed():this._getAfterAllClosed().pipe(ce(void 0)))),this._scrollStrategy=r}get openDialogs(){return this._parentDialog?this._parentDialog.openDialogs:this._openDialogsAtThisLevel}get afterOpened(){return this._parentDialog?this._parentDialog.afterOpened:this._afterOpenedAtThisLevel}_getAfterAllClosed(){const t=this._parentDialog;return t?t._getAfterAllClosed():this._afterAllClosedAtThisLevel}open(t,n){if((n=(function e(t,n){return Object.assign(Object.assign({},n),t)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(n,this._defaultOptions||new $H)).id&&this.getDialogById(n.id)&&("undefined"==typeof ngDevMode||ngDevMode))throw Error(`Dialog with id "${n.id}" exists already. The dialog id must be unique.`);const a=this._createOverlay(n),o=this._attachDialogContainer(a,n),r=this._attachDialogContent(t,o,a,n);return this.openDialogs.length||this._hideNonDialogContentFromAssistiveTechnology(),this.openDialogs.push(r),r.afterClosed().subscribe((()=>this._removeOpenDialog(r))),this.afterOpened.next(r),o._initializeWithAttachedContent(),r}closeAll(){this._closeDialogs(this.openDialogs)}getDialogById(t){return this.openDialogs.find((n=>n.id===t))}ngOnDestroy(){this._closeDialogs(this._openDialogsAtThisLevel),this._afterAllClosedAtThisLevel.complete(),this._afterOpenedAtThisLevel.complete()}_createOverlay(t){const n=this._getOverlayConfig(t);return this._overlay.create(n)}_getOverlayConfig(t){const n=new XA({positionStrategy:this._overlay.position().global(),scrollStrategy:t.scrollStrategy||this._scrollStrategy(),panelClass:t.panelClass,hasBackdrop:t.hasBackdrop,direction:t.direction,minWidth:t.minWidth,minHeight:t.minHeight,maxWidth:t.maxWidth,maxHeight:t.maxHeight,disposeOnNavigation:t.closeOnNavigation});return t.backdropClass&&(n.backdropClass=t.backdropClass),n}_attachDialogContainer(t,n){const e=yd.create({parent:n&&n.viewContainerRef&&n.viewContainerRef.injector||this._injector,providers:[{provide:$H,useValue:n}]}),a=new EA(this._dialogContainerType,n.viewContainerRef,e,n.componentFactoryResolver);return t.attach(a).instance}_attachDialogContent(t,n,e,a){const o=new this._dialogRefConstructor(e,n,a.id);if(t instanceof Ju)n.attachTemplatePortal(new AA(t,null,{$implicit:a.data,dialogRef:o}));else{const e=this._createInjector(a,o,n),r=n.attachComponentPortal(new EA(t,a.viewContainerRef,e));o.componentInstance=r.instance}return o.updateSize(a.width,a.height).updatePosition(a.position),o}_createInjector(t,n,e){const a=t&&t.viewContainerRef&&t.viewContainerRef.injector,o=[{provide:this._dialogContainerType,useValue:e},{provide:this._dialogDataToken,useValue:t.data},{provide:this._dialogRefConstructor,useValue:n}];return!t.direction||a&&a.get(US,null)||o.push({provide:US,useValue:{value:t.direction,change:Z()}}),yd.create({parent:a||this._injector,providers:o})}_removeOpenDialog(t){const n=this.openDialogs.indexOf(t);n>-1&&(this.openDialogs.splice(n,1),this.openDialogs.length||(this._ariaHiddenElements.forEach(((t,n)=>{t?n.setAttribute("aria-hidden",t):n.removeAttribute("aria-hidden")})),this._ariaHiddenElements.clear(),this._getAfterAllClosed().next()))}_hideNonDialogContentFromAssistiveTechnology(){const t=this._overlayContainer.getContainerElement();if(t.parentElement){const n=t.parentElement.children;for(let e=n.length-1;e>-1;e--){let a=n[e];a===t||"SCRIPT"===a.nodeName||"STYLE"===a.nodeName||a.hasAttribute("aria-live")||(this._ariaHiddenElements.set(a,a.getAttribute("aria-hidden")),a.setAttribute("aria-hidden","true"))}}}_closeDialogs(t){let n=t.length;for(;n--;)t[n].close()}}pB.ɵfac=function t(n){return new(n||pB)(Zg(hz),Zg(yd),Zg(void 0),Zg(void 0),Zg(rz),Zg(void 0),Zg(Um),Zg(Um),Zg(Fa))},pB.ɵdir=vo({type:pB}),pB.ctorParameters=()=>[{type:hz},{type:yd},{type:void 0},{type:void 0},{type:rz},{type:void 0},{type:Um},{type:Um},{type:Fa}];class bB extends pB{constructor(t,n,e,a,o,r,i){super(t,n,a,r,i,o,iB,aB,sB)}}bB.ɵfac=function t(n){return new(n||bB)(Za(hz),Za(yd),Za(GC,8),Za(lB,8),Za(mB),Za(bB,12),Za(rz))},bB.ɵprov=We({token:bB,factory:bB.ɵfac}),bB.ctorParameters=()=>[{type:hz},{type:yd},{type:GC,decorators:[{type:Ne}]},{type:$H,decorators:[{type:Ne},{type:Ie,args:[lB]}]},{type:void 0,decorators:[{type:Ie,args:[mB]}]},{type:bB,decorators:[{type:Ne},{type:Le}]},{type:rz}];let uB=0;class fB{constructor(t,n,e){this.dialogRef=t,this._elementRef=n,this._dialog=e,this.type="button"}ngOnInit(){this.dialogRef||(this.dialogRef=MB(this._elementRef,this._dialog.openDialogs))}ngOnChanges(t){const n=t._matDialogClose||t._matDialogCloseResult;n&&(this.dialogResult=n.currentValue)}_onButtonClick(t){cB(this.dialogRef,0===t.screenX&&0===t.screenY?"keyboard":"mouse",this.dialogResult)}}fB.ɵfac=function t(n){return new(n||fB)(Zg(iB,8),Zg(xu),Zg(bB))},fB.ɵdir=vo({type:fB,selectors:[["","mat-dialog-close",""],["","matDialogClose",""]],hostVars:2,hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e._onButtonClick(n)})),2&n&&Ng("aria-label",e.ariaLabel||null)("type",e.type)},inputs:{type:"type",dialogResult:["mat-dialog-close","dialogResult"],ariaLabel:["aria-label","ariaLabel"],_matDialogClose:["matDialogClose","_matDialogClose"]},exportAs:["matDialogClose"],features:[pr]}),fB.ctorParameters=()=>[{type:iB,decorators:[{type:Ne}]},{type:xu},{type:bB}],fB.propDecorators={ariaLabel:[{type:f_,args:["aria-label"]}],type:[{type:f_}],dialogResult:[{type:f_,args:["mat-dialog-close"]}],_matDialogClose:[{type:f_,args:["matDialogClose"]}]};class hB{constructor(t,n,e){this._dialogRef=t,this._elementRef=n,this._dialog=e,this.id="mat-dialog-title-"+uB++}ngOnInit(){this._dialogRef||(this._dialogRef=MB(this._elementRef,this._dialog.openDialogs)),this._dialogRef&&Promise.resolve().then((()=>{const t=this._dialogRef._containerInstance;t&&!t._ariaLabelledBy&&(t._ariaLabelledBy=this.id)}))}}hB.ɵfac=function t(n){return new(n||hB)(Zg(iB,8),Zg(xu),Zg(bB))},hB.ɵdir=vo({type:hB,selectors:[["","mat-dialog-title",""],["","matDialogTitle",""]],hostAttrs:[1,"mat-dialog-title"],hostVars:1,hostBindings:function t(n,e){2&n&&eb("id",e.id)},inputs:{id:"id"},exportAs:["matDialogTitle"]}),hB.ctorParameters=()=>[{type:iB,decorators:[{type:Ne}]},{type:xu},{type:bB}],hB.propDecorators={id:[{type:f_}]};class _B{}_B.ɵfac=function t(n){return new(n||_B)},_B.ɵdir=vo({type:_B,selectors:[["","mat-dialog-content",""],["mat-dialog-content"],["","matDialogContent",""]],hostAttrs:[1,"mat-dialog-content"]});class CB{}function MB(t,n){let e=t.nativeElement.parentElement;for(;e&&!e.classList.contains("mat-dialog-container");)e=e.parentElement;return e?n.find((t=>t.id===e.id)):null}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */CB.ɵfac=function t(n){return new(n||CB)},CB.ɵdir=vo({type:CB,selectors:[["","mat-dialog-actions",""],["mat-dialog-actions"],["","matDialogActions",""]],hostAttrs:[1,"mat-dialog-actions"]});class OB{}OB.ɵmod=xo({type:OB}),OB.ɵinj=Ge({factory:function t(n){return new(n||OB)},providers:[bB,dB],imports:[[yz,BA,tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(OB,{declarations:function(){return[aB,fB,hB,CB,_B]},imports:function(){return[yz,BA,tE]},exports:function(){return[aB,fB,hB,_B,CB,tE]}});class PB{constructor(t,n){this._document=n;const e=this._textarea=this._document.createElement("textarea"),a=e.style;a.position="fixed",a.top=a.opacity="0",a.left="-999em",e.setAttribute("aria-hidden","true"),e.value=t,this._document.body.appendChild(e)}copy(){const t=this._textarea;let n=!1;try{if(t){const e=this._document.activeElement;t.select(),t.setSelectionRange(0,t.value.length),n=this._document.execCommand("copy"),e&&e.focus()}}catch(t){}return n}destroy(){const t=this._textarea;t&&(t.parentNode&&t.parentNode.removeChild(t),this._textarea=void 0)}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class xB{constructor(t){this._document=t}copy(t){const n=this.beginCopy(t),e=n.copy();return n.destroy(),e}beginCopy(t){return new PB(t,this._document)}}xB.ɵfac=function t(n){return new(n||xB)(Za(zC))},xB.ɵprov=We({factory:function t(){return new xB(Za(zC))},token:xB,providedIn:"root"}),xB.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[zC]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const yB=new Fa("CKD_COPY_TO_CLIPBOARD_CONFIG");class kB{constructor(t,n,e){this._clipboard=t,this._ngZone=n,this.text="",this.attempts=1,this.copied=new Ef,this._pending=new Set,e&&null!=e.attempts&&(this.attempts=e.attempts)}copy(t=this.attempts){if(t>1){let n=t;const e=this._clipboard.beginCopy(this.text);this._pending.add(e);const a=()=>{const t=e.copy();t||!--n||this._destroyed?(this._currentTimeout=null,this._pending.delete(e),e.destroy(),this.copied.emit(t)):this._currentTimeout=this._ngZone.runOutsideAngular((()=>setTimeout(a,1)))};a()}else this.copied.emit(this._clipboard.copy(this.text))}ngOnDestroy(){this._currentTimeout&&clearTimeout(this._currentTimeout),this._pending.forEach((t=>t.destroy())),this._pending.clear(),this._destroyed=!0}}kB.ɵfac=function t(n){return new(n||kB)(Zg(xB),Zg(J_),Zg(yB,8))},kB.ɵdir=vo({type:kB,selectors:[["","cdkCopyToClipboard",""]],hostBindings:function t(n,e){1&n&&cp("click",(function t(){return e.copy()}))},inputs:{text:["cdkCopyToClipboard","text"],attempts:["cdkCopyToClipboardAttempts","attempts"]},outputs:{copied:"cdkCopyToClipboardCopied"}}),kB.ctorParameters=()=>[{type:xB},{type:J_},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[yB]}]}],kB.propDecorators={text:[{type:f_,args:["cdkCopyToClipboard"]}],attempts:[{type:f_,args:["cdkCopyToClipboardAttempts"]}],copied:[{type:h_,args:["cdkCopyToClipboardCopied"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class vB{}function wB(t){return Error(`Unable to find icon with the name "${t}"`)}function SB(t){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${t}".`)}function EB(t){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${t}".`)}vB.ɵmod=xo({type:vB}),vB.ɵinj=Ge({factory:function t(n){return new(n||vB)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(vB,{declarations:[kB],exports:[kB]});class AB{constructor(t,n,e){this.url=t,this.svgText=n,this.options=e}}class zB{constructor(t,n,e,a){this._httpClient=t,this._sanitizer=n,this._errorHandler=a,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._defaultFontSetClass="material-icons",this._document=e}addSvgIcon(t,n,e){return this.addSvgIconInNamespace("",t,n,e)}addSvgIconLiteral(t,n,e){return this.addSvgIconLiteralInNamespace("",t,n,e)}addSvgIconInNamespace(t,n,e,a){return this._addSvgIconConfig(t,n,new AB(e,null,a))}addSvgIconLiteralInNamespace(t,n,e,a){const o=this._sanitizer.sanitize(Zc.HTML,e);if(!o)throw EB(e);return this._addSvgIconConfig(t,n,new AB("",o,a))}addSvgIconSet(t,n){return this.addSvgIconSetInNamespace("",t,n)}addSvgIconSetLiteral(t,n){return this.addSvgIconSetLiteralInNamespace("",t,n)}addSvgIconSetInNamespace(t,n,e){return this._addSvgIconSetConfig(t,new AB(n,null,e))}addSvgIconSetLiteralInNamespace(t,n,e){const a=this._sanitizer.sanitize(Zc.HTML,n);if(!a)throw EB(n);return this._addSvgIconSetConfig(t,new AB("",a,e))}registerFontClassAlias(t,n=t){return this._fontCssClassesByAlias.set(t,n),this}classNameForFontAlias(t){return this._fontCssClassesByAlias.get(t)||t}setDefaultFontSetClass(t){return this._defaultFontSetClass=t,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(t){const n=this._sanitizer.sanitize(Zc.RESOURCE_URL,t);if(!n)throw SB(t);const e=this._cachedIconsByUrl.get(n);return e?Z(RB(e)):this._loadSvgIconFromConfig(new AB(t,null)).pipe(he((t=>this._cachedIconsByUrl.set(n,t))),ft((t=>RB(t))))}getNamedSvgIcon(t,n=""){const e=TB(n,t),a=this._svgIconConfigs.get(e);if(a)return this._getSvgFromConfig(a);const o=this._iconSetConfigs.get(n);return o?this._getSvgFromIconSetConfigs(t,o):X(wB(e))}ngOnDestroy(){this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(t){return t.svgText?Z(RB(this._svgElementFromConfig(t))):this._loadSvgIconFromConfig(t).pipe(ft((t=>RB(t))))}_getSvgFromIconSetConfigs(t,n){const e=this._extractIconWithNameFromAnySet(t,n);return e?Z(e):Ht(n.filter((t=>!t.svgText)).map((t=>this._loadSvgIconSetFromConfig(t).pipe(on((n=>{const e=this._sanitizer.sanitize(Zc.RESOURCE_URL,t.url);return this._errorHandler.handleError(new Error(`Loading icon set URL: ${e} failed: ${n.message}`)),Z(null)})))))).pipe(ft((()=>{const e=this._extractIconWithNameFromAnySet(t,n);if(!e)throw wB(t);return e})))}_extractIconWithNameFromAnySet(t,n){for(let e=n.length-1;e>=0;e--){const a=n[e];if(a.svgText&&a.svgText.indexOf(t)>-1){const n=this._svgElementFromConfig(a),e=this._extractSvgIconFromSet(n,t,a.options);if(e)return e}}return null}_loadSvgIconFromConfig(t){return this._fetchIcon(t).pipe(he((n=>t.svgText=n)),ft((()=>this._svgElementFromConfig(t))))}_loadSvgIconSetFromConfig(t){return t.svgText?Z(null):this._fetchIcon(t).pipe(he((n=>t.svgText=n)))}_extractSvgIconFromSet(t,n,e){const a=t.querySelector(`[id="${n}"]`);if(!a)return null;const o=a.cloneNode(!0);if(o.removeAttribute("id"),"svg"===o.nodeName.toLowerCase())return this._setSvgAttributes(o,e);if("symbol"===o.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(o),e);const r=this._svgElementFromString("<svg></svg>");return r.appendChild(o),this._setSvgAttributes(r,e)}_svgElementFromString(t){const n=this._document.createElement("DIV");n.innerHTML=t;const e=n.querySelector("svg");if(!e)throw Error("<svg> tag not found");return e}_toSvgElement(t){const n=this._svgElementFromString("<svg></svg>"),e=t.attributes;for(let t=0;t<e.length;t++){const{name:a,value:o}=e[t];"id"!==a&&n.setAttribute(a,o)}for(let e=0;e<t.childNodes.length;e++)t.childNodes[e].nodeType===this._document.ELEMENT_NODE&&n.appendChild(t.childNodes[e].cloneNode(!0));return n}_setSvgAttributes(t,n){return t.setAttribute("fit",""),t.setAttribute("height","100%"),t.setAttribute("width","100%"),t.setAttribute("preserveAspectRatio","xMidYMid meet"),t.setAttribute("focusable","false"),n&&n.viewBox&&t.setAttribute("viewBox",n.viewBox),t}_fetchIcon(t){var n;const{url:e,options:a}=t,o=null!==(n=null==a?void 0:a.withCredentials)&&void 0!==n&&n;if(!this._httpClient)throw(function r(){return Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.")})();if(null==e)throw Error(`Cannot fetch icon from URL "${e}".`);const i=this._sanitizer.sanitize(Zc.RESOURCE_URL,e);if(!i)throw SB(e);const c=this._inProgressUrlFetches.get(i);if(c)return c;const s=this._httpClient.get(i,{responseType:"text",withCredentials:o}).pipe((function l(t){return n=>n.lift(new Hn(t))})((()=>this._inProgressUrlFetches.delete(i))),ee());return this._inProgressUrlFetches.set(i,s),s}_addSvgIconConfig(t,n,e){return this._svgIconConfigs.set(TB(t,n),e),this}_addSvgIconSetConfig(t,n){const e=this._iconSetConfigs.get(t);return e?e.push(n):this._iconSetConfigs.set(t,[n]),this}_svgElementFromConfig(t){if(!t.svgElement){const n=this._svgElementFromString(t.svgText);this._setSvgAttributes(n,t.options),t.svgElement=n}return t.svgElement}}function RB(t){return t.cloneNode(!0)}function TB(t,n){return t+":"+n}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */zB.ɵfac=function t(n){return new(n||zB)(Za(IR,8),Za(sP),Za(zC,8),Za(oc))},zB.ɵprov=We({factory:function t(){return new zB(Za(IR,8),Za(sP),Za(zC,8),Za(oc))},token:zB,providedIn:"root"}),zB.ctorParameters=()=>[{type:IR,decorators:[{type:Ne}]},{type:sP},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:oc}],new Ne,new Le,new Ne,new Ne;const DB=eE(class{constructor(t){this._elementRef=t}}),IB=new Fa("mat-icon-location",{providedIn:"root",factory:function NB(){const t=Ja(zC),n=t?t.location:null;return{getPathname:()=>n?n.pathname+n.search:""}}}),FB=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],LB=FB.map((t=>`[${t}]`)).join(", "),HB=/^url\(['"]?#(.*?)['"]?\)$/;class BB extends DB{constructor(t,n,e,a,o){super(t),this._iconRegistry=n,this._location=a,this._errorHandler=o,this._inline=!1,this._currentIconFetch=s.EMPTY,e||t.nativeElement.setAttribute("aria-hidden","true")}get inline(){return this._inline}set inline(t){this._inline=Gw(t)}get svgIcon(){return this._svgIcon}set svgIcon(t){t!==this._svgIcon&&(t?this._updateSvgIcon(t):this._svgIcon&&this._clearSvgElement(),this._svgIcon=t)}get fontSet(){return this._fontSet}set fontSet(t){const n=this._cleanupFontValue(t);n!==this._fontSet&&(this._fontSet=n,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(t){const n=this._cleanupFontValue(t);n!==this._fontIcon&&(this._fontIcon=n,this._updateFontIconClasses())}_splitIconName(t){if(!t)return["",""];const n=t.split(":");switch(n.length){case 1:return["",n[0]];case 2:return n;default:throw Error(`Invalid icon name: "${t}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){const t=this._elementsWithExternalReferences;if(t&&t.size){const t=this._location.getPathname();t!==this._previousPath&&(this._previousPath=t,this._prependPathToReferences(t))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(t){this._clearSvgElement();const n=t.querySelectorAll("style");for(let t=0;t<n.length;t++)n[t].textContent+=" ";const e=this._location.getPathname();this._previousPath=e,this._cacheChildrenWithExternalReferences(t),this._prependPathToReferences(e),this._elementRef.nativeElement.appendChild(t)}_clearSvgElement(){const t=this._elementRef.nativeElement;let n=t.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();n--;){const e=t.childNodes[n];1===e.nodeType&&"svg"!==e.nodeName.toLowerCase()||t.removeChild(e)}}_updateFontIconClasses(){if(!this._usingFontIcon())return;const t=this._elementRef.nativeElement,n=this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet):this._iconRegistry.getDefaultFontSetClass();n!=this._previousFontSetClass&&(this._previousFontSetClass&&t.classList.remove(this._previousFontSetClass),n&&t.classList.add(n),this._previousFontSetClass=n),this.fontIcon!=this._previousFontIconClass&&(this._previousFontIconClass&&t.classList.remove(this._previousFontIconClass),this.fontIcon&&t.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(t){return"string"==typeof t?t.trim().split(" ")[0]:t}_prependPathToReferences(t){const n=this._elementsWithExternalReferences;n&&n.forEach(((n,e)=>{n.forEach((n=>{e.setAttribute(n.name,`url('${t}#${n.value}')`)}))}))}_cacheChildrenWithExternalReferences(t){const n=t.querySelectorAll(LB),e=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let t=0;t<n.length;t++)FB.forEach((a=>{const o=n[t],r=o.getAttribute(a),i=r?r.match(HB):null;if(i){let t=e.get(o);t||(t=[],e.set(o,t)),t.push({name:a,value:i[1]})}}))}_updateSvgIcon(t){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),t){const[n,e]=this._splitIconName(t);n&&(this._svgNamespace=n),e&&(this._svgName=e),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(e,n).pipe(Tn(1)).subscribe((t=>this._setSvgElement(t)),(t=>{this._errorHandler.handleError(new Error(`Error retrieving icon ${n}:${e}! ${t.message}`))}))}}}BB.ɵfac=function t(n){return new(n||BB)(Zg(xu),Zg(zB),Xg("aria-hidden"),Zg(IB),Zg(oc))},BB.ɵcmp=_o({type:BB,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:7,hostBindings:function t(n,e){2&n&&(Ng("data-mat-icon-type",e._usingFontIcon()?"font":"svg")("data-mat-icon-name",e._svgName||e.fontIcon)("data-mat-icon-namespace",e._svgNamespace||e.fontSet),Dp("mat-icon-inline",e.inline)("mat-icon-no-color","primary"!==e.color&&"accent"!==e.color&&"warn"!==e.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[hg],ngContentSelectors:["*"],decls:1,vars:0,template:function t(n,e){1&n&&(bp(),hp(0))},styles:[".mat-icon{background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}\n"],encapsulation:2,changeDetection:0}),BB.ctorParameters=()=>[{type:xu},{type:zB},{type:String,decorators:[{type:Be,args:["aria-hidden"]}]},{type:void 0,decorators:[{type:Ie,args:[IB]}]},{type:oc}],BB.propDecorators={inline:[{type:f_}],svgIcon:[{type:f_}],fontSet:[{type:f_}],fontIcon:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class VB{}VB.ɵmod=xo({type:VB}),VB.ɵinj=Ge({factory:function t(n){return new(n||VB)},imports:[[tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(VB,{declarations:function(){return[BB]},imports:function(){return[tE]},exports:function(){return[BB,tE]}});class jB{constructor(t){this.dialogRef=t,this.tensorboardDotDevUrl="https://tensorboard.dev/?utm_source=tensorboard"}onClose(){this.dialogRef.close()}getCommandText(){return this.logdir?"tensorboard dev upload --logdir \\\n    '"+this.logdir.replace(/'/g,"'\\''")+"'":"tensorboard dev upload --logdir {logdir}"}}jB.ɵfac=function t(n){return new(n||jB)(Zg(iB))},jB.ɵcmp=_o({type:jB,selectors:[["tbdev-upload-dialog-component"]],inputs:{logdir:"logdir"},decls:21,vars:4,consts:[["target","_blank","rel","noreferrer noopener",1,"anchor-text",3,"href"],[1,"command"],["mat-icon-button","","title","Click to copy the command",1,"command-copy",3,"cdkCopyToClipboard"],["svgIcon","content_copy_24px"],[1,"bottom-buttons"],["mat-flat-button","",1,"close-button",3,"click"],["mat-flat-button","","target","_blank","rel","noreferrer noopener",1,"learn-more-button",3,"href"]],template:function t(n,e){1&n&&(Kg(0,"h3"),Jp(1,"Upload to TensorBoard.dev"),$g(),Kg(2,"p"),Kg(3,"a",0),Jp(4," TensorBoard.dev"),$g(),Jp(5," enables you to easily host, track, and share your ML experiments with everyone. You can share a link to the uploaded TensorBoard in papers, blog posts, and social media. This can showcase the results more effectively and helps reproducibility.\n"),$g(),Kg(6,"p"),Jp(7,"To upload a logdir to TensorBoard.dev, run the command:"),$g(),Kg(8,"div",1),Kg(9,"pre"),Kg(10,"code"),Jp(11),$g(),$g(),Kg(12,"button",2),tp(13,"mat-icon",3),$g(),$g(),Kg(14,"p"),Jp(15," Only certain plugins are currently supported. Uploaded TensorBoards are public and visible to everyone; do not upload sensitive data.\n"),$g(),Kg(16,"div",4),Kg(17,"button",5),cp("click",(function t(){return e.onClose()})),Jp(18," Close "),$g(),Kg(19,"a",6),Jp(20," Learn more "),$g(),$g()),2&n&&(ws(3),_p("href",e.tensorboardDotDevUrl,Xc),ws(8),Qp(e.getCommandText()),ws(1),Jg("cdkCopyToClipboard",e.getCommandText()),ws(7),_p("href",e.tensorboardDotDevUrl,Xc))},directives:[eA,kB,BB,aA],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}div[_ngcontent-%COMP%], p[_ngcontent-%COMP%]{margin:16px 0}[_nghost-%COMP%] > [_ngcontent-%COMP%]:first-child{margin-top:0}[_nghost-%COMP%] > [_ngcontent-%COMP%]:last-child{margin-bottom:0}h3[_ngcontent-%COMP%]{font-size:14px;font-weight:500;line-height:1.5}p[_ngcontent-%COMP%]{color:#212121;font-size:12px;line-height:1.5}.anchor-text[_ngcontent-%COMP%]{color:#1976d2;text-decoration:none}.command[_ngcontent-%COMP%]{align-items:center;background:#f5f6f7;border-radius:4px;display:flex;justify-content:space-between;padding:2px 12px}pre[_ngcontent-%COMP%]{overflow-x:auto}code[_ngcontent-%COMP%]{font-size:14px;line-height:1.5}.bottom-buttons[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:flex-end}.close-button[_ngcontent-%COMP%]{color:#616161;text-transform:uppercase;margin-right:8px}.learn-more-button[_ngcontent-%COMP%]{color:#1976d2;text-transform:uppercase}']});const UB=pv(LI,(t=>t.data_location));class WB{constructor(t){this.store=t,this.logdir$=this.store.pipe(lv(UB))}}function GB(t,n){if(1&t){const t=op();Kg(0,"button",1),cp("click",(function n(){return jr(t),gp().openDialog()})),Kg(1,"span",2),tp(2,"mat-icon",3),Jp(3," Upload "),$g(),$g()}}WB.ɵfac=function t(n){return new(n||WB)(Zg(cv))},WB.ɵcmp=_o({type:WB,selectors:[["tbdev-upload-dialog"]],decls:2,vars:3,consts:[[3,"logdir"]],template:function t(n,e){1&n&&(tp(0,"tbdev-upload-dialog-component",0),yf(1,"async")),2&n&&Jg("logdir",kf(1,1,e.logdir$))},directives:[jB],pipes:[oO],encapsulation:2});const YB=["localhost","127.0.0.1"];class qB{constructor(t,n){this.window=t,this.dialog=n,this.shown=YB.includes(t.location.hostname)}openDialog(){this.dialog.open(WB,{width:"560px"})}}qB.ɵfac=function t(n){return new(n||qB)(Zg("window"),Zg(bB))},qB.ɵcmp=_o({type:qB,selectors:[["tbdev-upload-button"]],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("shown",e.shown)},decls:1,vars:1,consts:[["mat-stroked-button","",3,"click",4,"ngIf"],["mat-stroked-button","",3,"click"],[1,"button-contents"],["svgIcon","info_outline_24px"]],template:function t(n,e){1&n&&Yg(0,GB,4,0,"button",0),2&n&&Jg("ngIf",e.shown)},directives:[WM,eA,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]   button.mat-stroked-button[_ngcontent-%COMP%]{background-color:#ff9800;border:1px solid #ebebeb}.button-contents[_ngcontent-%COMP%]{align-items:center;display:flex;text-transform:uppercase}mat-icon[_ngcontent-%COMP%]{margin-right:6px}']});const ZB=pv(FI,NI,((t,n)=>!(!n||!t[n])&&t[n].disable_reload));class XB{constructor(t){this.store=t,this.reloadDisabled$=this.store.select(ZB),this.isReloading$=this.store.select(II).pipe(ye(this.reloadDisabled$),ft((([t,n])=>!n&&t.state===fR.LOADING))),this.lastLoadedTimeInMs$=this.store.select(II).pipe(ft((t=>t.lastLoadedTimeInMs)))}triggerReload(){this.store.dispatch(uI())}getReloadTitle(t){return t?`Last Updated: ${t}`:"Loading..."}}XB.ɵfac=function t(n){return new(n||XB)(Zg(cv))},XB.ɵcmp=_o({type:XB,selectors:[["app-header-reload"]],decls:6,vars:13,consts:[["mat-icon-button","",1,"reload-button",3,"title","disabled","click"],["svgIcon","refresh_24px",1,"refresh-icon"]],template:function t(n,e){1&n&&(Kg(0,"button",0),cp("click",(function t(){return e.triggerReload()})),yf(1,"async"),yf(2,"date"),yf(3,"async"),yf(4,"async"),tp(5,"mat-icon",1),$g()),2&n&&(Dp("loading",kf(1,4,e.isReloading$)),Jg("title",e.getReloadTitle(vf(2,6,kf(3,9,e.lastLoadedTimeInMs$),"medium")))("disabled",kf(4,11,e.reloadDisabled$)))},directives:[eA,BB],pipes:[oO,lO],styles:[".reload-button[_ngcontent-%COMP%], .refresh-icon[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        justify-content: center;\n      }\n\n      .reload-button.loading[_ngcontent-%COMP%] {\n        animation: rotate 2s linear infinite;\n      }\n\n      @keyframes rotate {\n        0% {\n          transform: rotate(0deg);\n        }\n        50% {\n          transform: rotate(180deg);\n        }\n        100% {\n          transform: rotate(360deg);\n        }\n      }"]});const JB=["input"],QB=function(){return{enterDuration:150}},KB=new Fa("mat-checkbox-default-options",{providedIn:"root",factory:function $B(){return{color:"accent",clickAction:"check-indeterminate"}}}),tV=new Fa("mat-checkbox-click-action");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let nV=0;const eV={provide:MF,useExisting:aa((()=>rV)),multi:!0};class aV{}const oV=oE(eE(aE(nE(class{constructor(t){this._elementRef=t}}))));class rV extends oV{constructor(t,n,e,a,o,r,i,c){super(t),this._changeDetectorRef=n,this._focusMonitor=e,this._ngZone=a,this._clickAction=r,this._animationMode=i,this._options=c,this.ariaLabel="",this.ariaLabelledby=null,this._uniqueId="mat-checkbox-"+ ++nV,this.id=this._uniqueId,this.labelPosition="after",this.name=null,this.change=new Ef,this.indeterminateChange=new Ef,this._onTouched=()=>{},this._currentAnimationClass="",this._currentCheckState=0,this._controlValueAccessorChangeFn=()=>{},this._checked=!1,this._disabled=!1,this._indeterminate=!1,this._options=this._options||{},this._options.color&&(this.color=this.defaultColor=this._options.color),this.tabIndex=parseInt(o)||0,this._clickAction=this._clickAction||this._options.clickAction}get inputId(){return`${this.id||this._uniqueId}-input`}get required(){return this._required}set required(t){this._required=Gw(t)}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe((t=>{t||Promise.resolve().then((()=>{this._onTouched(),this._changeDetectorRef.markForCheck()}))})),this._syncIndeterminate(this._indeterminate)}ngAfterViewChecked(){}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}get checked(){return this._checked}set checked(t){t!=this.checked&&(this._checked=t,this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled}set disabled(t){const n=Gw(t);n!==this.disabled&&(this._disabled=n,this._changeDetectorRef.markForCheck())}get indeterminate(){return this._indeterminate}set indeterminate(t){const n=t!=this._indeterminate;this._indeterminate=Gw(t),n&&(this._transitionCheckState(this._indeterminate?3:this.checked?1:2),this.indeterminateChange.emit(this._indeterminate)),this._syncIndeterminate(this._indeterminate)}_isRippleDisabled(){return this.disableRipple||this.disabled}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}writeValue(t){this.checked=!!t}registerOnChange(t){this._controlValueAccessorChangeFn=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this.disabled=t}_getAriaChecked(){return this.checked?"true":this.indeterminate?"mixed":"false"}_transitionCheckState(t){let n=this._currentCheckState,e=this._elementRef.nativeElement;if(n!==t&&(this._currentAnimationClass.length>0&&e.classList.remove(this._currentAnimationClass),this._currentAnimationClass=this._getAnimationClassForCheckStateTransition(n,t),this._currentCheckState=t,this._currentAnimationClass.length>0)){e.classList.add(this._currentAnimationClass);const t=this._currentAnimationClass;this._ngZone.runOutsideAngular((()=>{setTimeout((()=>{e.classList.remove(t)}),1e3)}))}}_emitChangeEvent(){const t=new aV;t.source=this,t.checked=this.checked,this._controlValueAccessorChangeFn(this.checked),this.change.emit(t)}toggle(){this.checked=!this.checked}_onInputClick(t){t.stopPropagation(),this.disabled||"noop"===this._clickAction?this.disabled||"noop"!==this._clickAction||(this._inputElement.nativeElement.checked=this.checked,this._inputElement.nativeElement.indeterminate=this.indeterminate):(this.indeterminate&&"check"!==this._clickAction&&Promise.resolve().then((()=>{this._indeterminate=!1,this.indeterminateChange.emit(this._indeterminate)})),this.toggle(),this._transitionCheckState(this._checked?1:2),this._emitChangeEvent())}focus(t="keyboard",n){this._focusMonitor.focusVia(this._inputElement,t,n)}_onInteractionEvent(t){t.stopPropagation()}_getAnimationClassForCheckStateTransition(t,n){if("NoopAnimations"===this._animationMode)return"";let e="";switch(t){case 0:if(1===n)e="unchecked-checked";else{if(3!=n)return"";e="unchecked-indeterminate"}break;case 2:e=1===n?"unchecked-checked":"unchecked-indeterminate";break;case 1:e=2===n?"checked-unchecked":"checked-indeterminate";break;case 3:e=1===n?"indeterminate-checked":"indeterminate-unchecked"}return`mat-checkbox-anim-${e}`}_syncIndeterminate(t){const n=this._inputElement;n&&(n.nativeElement.indeterminate=t)}}rV.ɵfac=function t(n){return new(n||rV)(Zg(xu),Zg(Vm),Zg(TS),Zg(J_),Xg("tabindex"),Zg(tV,8),Zg(dk,8),Zg(KB,8))},rV.ɵcmp=_o({type:rV,selectors:[["mat-checkbox"]],viewQuery:function t(n,e){var a;1&n&&(Uf(JB,!0),Uf(zE,!0)),2&n&&(Vf(a=Zf())&&(e._inputElement=a.first),Vf(a=Zf())&&(e.ripple=a.first))},hostAttrs:[1,"mat-checkbox"],hostVars:12,hostBindings:function t(n,e){2&n&&(eb("id",e.id),Ng("tabindex",null),Dp("mat-checkbox-indeterminate",e.indeterminate)("mat-checkbox-checked",e.checked)("mat-checkbox-disabled",e.disabled)("mat-checkbox-label-before","before"==e.labelPosition)("_mat-animation-noopable","NoopAnimations"===e._animationMode))},inputs:{disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],id:"id",labelPosition:"labelPosition",name:"name",required:"required",checked:"checked",disabled:"disabled",indeterminate:"indeterminate",ariaDescribedby:["aria-describedby","ariaDescribedby"],value:"value"},outputs:{change:"change",indeterminateChange:"indeterminateChange"},exportAs:["matCheckbox"],features:[Mu([eV]),hg],ngContentSelectors:["*"],decls:17,vars:20,consts:[[1,"mat-checkbox-layout"],["label",""],[1,"mat-checkbox-inner-container"],["type","checkbox",1,"mat-checkbox-input","cdk-visually-hidden",3,"id","required","checked","disabled","tabIndex","change","click"],["input",""],["matRipple","",1,"mat-checkbox-ripple","mat-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleRadius","matRippleCentered","matRippleAnimation"],[1,"mat-ripple-element","mat-checkbox-persistent-ripple"],[1,"mat-checkbox-frame"],[1,"mat-checkbox-background"],["version","1.1","focusable","false","viewBox","0 0 24 24",0,"xml","space","preserve",1,"mat-checkbox-checkmark"],["fill","none","stroke","white","d","M4.1,12.7 9,17.6 20.3,6.3",1,"mat-checkbox-checkmark-path"],[1,"mat-checkbox-mixedmark"],[1,"mat-checkbox-label",3,"cdkObserveContent"],["checkboxLabel",""],[2,"display","none"]],template:function t(n,e){if(1&n&&(bp(),Kg(0,"label",0,1),Kg(2,"div",2),Kg(3,"input",3,4),cp("change",(function t(n){return e._onInteractionEvent(n)}))("click",(function t(n){return e._onInputClick(n)})),$g(),Kg(5,"div",5),tp(6,"div",6),$g(),tp(7,"div",7),Kg(8,"div",8),ui(),Kg(9,"svg",9),tp(10,"path",10),$g(),fi(),tp(11,"div",11),$g(),$g(),Kg(12,"span",12,13),cp("cdkObserveContent",(function t(){return e._onLabelTextChange()})),Kg(14,"span",14),Jp(15," "),$g(),hp(16),$g(),$g()),2&n){const t=qg(1),n=qg(13);Ng("for",e.inputId),ws(2),Dp("mat-checkbox-inner-container-no-side-margin",!n.textContent||!n.textContent.trim()),ws(1),Jg("id",e.inputId)("required",e.required)("checked",e.checked)("disabled",e.disabled)("tabIndex",e.tabIndex),Ng("value",e.value)("name",e.name)("aria-label",e.ariaLabel||null)("aria-labelledby",e.ariaLabelledby)("aria-checked",e._getAriaChecked())("aria-describedby",e.ariaDescribedby),ws(2),Jg("matRippleTrigger",t)("matRippleDisabled",e._isRippleDisabled())("matRippleRadius",20)("matRippleCentered",!0)("matRippleAnimation",bf(19,QB))}},directives:[zE,$w],styles:["@keyframes mat-checkbox-fade-in-background{0%{opacity:0}50%{opacity:1}}@keyframes mat-checkbox-fade-out-background{0%,50%{opacity:1}100%{opacity:0}}@keyframes mat-checkbox-unchecked-checked-checkmark-path{0%,50%{stroke-dashoffset:22.910259}50%{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1)}100%{stroke-dashoffset:0}}@keyframes mat-checkbox-unchecked-indeterminate-mixedmark{0%,68.2%{transform:scaleX(0)}68.2%{animation-timing-function:cubic-bezier(0, 0, 0, 1)}100%{transform:scaleX(1)}}@keyframes mat-checkbox-checked-unchecked-checkmark-path{from{animation-timing-function:cubic-bezier(0.4, 0, 1, 1);stroke-dashoffset:0}to{stroke-dashoffset:-22.910259}}@keyframes mat-checkbox-checked-indeterminate-checkmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(45deg)}}@keyframes mat-checkbox-indeterminate-checked-checkmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:0;transform:rotate(45deg)}to{opacity:1;transform:rotate(360deg)}}@keyframes mat-checkbox-checked-indeterminate-mixedmark{from{animation-timing-function:cubic-bezier(0, 0, 0.2, 0.1);opacity:0;transform:rotate(-45deg)}to{opacity:1;transform:rotate(0deg)}}@keyframes mat-checkbox-indeterminate-checked-mixedmark{from{animation-timing-function:cubic-bezier(0.14, 0, 0, 1);opacity:1;transform:rotate(0deg)}to{opacity:0;transform:rotate(315deg)}}@keyframes mat-checkbox-indeterminate-unchecked-mixedmark{0%{animation-timing-function:linear;opacity:1;transform:scaleX(1)}32.8%,100%{opacity:0;transform:scaleX(0)}}.mat-checkbox-background,.mat-checkbox-frame{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:2px;box-sizing:border-box;pointer-events:none}.mat-checkbox{transition:background 400ms cubic-bezier(0.25, 0.8, 0.25, 1),box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);cursor:pointer;-webkit-tap-highlight-color:transparent}._mat-animation-noopable.mat-checkbox{transition:none;animation:none}.mat-checkbox .mat-ripple-element:not(.mat-checkbox-persistent-ripple){opacity:.16}.mat-checkbox-layout{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:inherit;align-items:baseline;vertical-align:middle;display:inline-flex;white-space:nowrap}.mat-checkbox-label{-webkit-user-select:auto;-moz-user-select:auto;-ms-user-select:auto;user-select:auto}.mat-checkbox-inner-container{display:inline-block;height:16px;line-height:0;margin:auto;margin-right:8px;order:0;position:relative;vertical-align:middle;white-space:nowrap;width:16px;flex-shrink:0}[dir=rtl] .mat-checkbox-inner-container{margin-left:8px;margin-right:auto}.mat-checkbox-inner-container-no-side-margin{margin-left:0;margin-right:0}.mat-checkbox-frame{background-color:transparent;transition:border-color 90ms cubic-bezier(0, 0, 0.2, 0.1);border-width:2px;border-style:solid}._mat-animation-noopable .mat-checkbox-frame{transition:none}.cdk-high-contrast-active .mat-checkbox.cdk-keyboard-focused .mat-checkbox-frame{border-style:dotted}.mat-checkbox-background{align-items:center;display:inline-flex;justify-content:center;transition:background-color 90ms cubic-bezier(0, 0, 0.2, 0.1),opacity 90ms cubic-bezier(0, 0, 0.2, 0.1)}._mat-animation-noopable .mat-checkbox-background{transition:none}.cdk-high-contrast-active .mat-checkbox .mat-checkbox-background{background:none}.mat-checkbox-persistent-ripple{width:100%;height:100%;transform:none}.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:.04}.mat-checkbox.cdk-keyboard-focused .mat-checkbox-persistent-ripple{opacity:.12}.mat-checkbox-persistent-ripple,.mat-checkbox.mat-checkbox-disabled .mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{opacity:0}@media(hover: none){.mat-checkbox-inner-container:hover .mat-checkbox-persistent-ripple{display:none}}.mat-checkbox-checkmark{top:0;left:0;right:0;bottom:0;position:absolute;width:100%}.mat-checkbox-checkmark-path{stroke-dashoffset:22.910259;stroke-dasharray:22.910259;stroke-width:2.1333333333px}.cdk-high-contrast-black-on-white .mat-checkbox-checkmark-path{stroke:#000 !important}.mat-checkbox-mixedmark{width:calc(100% - 6px);height:2px;opacity:0;transform:scaleX(0) rotate(0deg);border-radius:2px}.cdk-high-contrast-active .mat-checkbox-mixedmark{height:0;border-top:solid 2px;margin-top:2px}.mat-checkbox-label-before .mat-checkbox-inner-container{order:1;margin-left:8px;margin-right:auto}[dir=rtl] .mat-checkbox-label-before .mat-checkbox-inner-container{margin-left:auto;margin-right:8px}.mat-checkbox-checked .mat-checkbox-checkmark{opacity:1}.mat-checkbox-checked .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-checked .mat-checkbox-mixedmark{transform:scaleX(1) rotate(-45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark{opacity:0;transform:rotate(45deg)}.mat-checkbox-indeterminate .mat-checkbox-checkmark-path{stroke-dashoffset:0}.mat-checkbox-indeterminate .mat-checkbox-mixedmark{opacity:1;transform:scaleX(1) rotate(0deg)}.mat-checkbox-unchecked .mat-checkbox-background{background-color:transparent}.mat-checkbox-disabled{cursor:default}.cdk-high-contrast-active .mat-checkbox-disabled{opacity:.5}.mat-checkbox-anim-unchecked-checked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-checked .mat-checkbox-checkmark-path{animation:180ms linear 0ms mat-checkbox-unchecked-checked-checkmark-path}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-in-background}.mat-checkbox-anim-unchecked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-unchecked-indeterminate-mixedmark}.mat-checkbox-anim-checked-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-checked-unchecked .mat-checkbox-checkmark-path{animation:90ms linear 0ms mat-checkbox-checked-unchecked-checkmark-path}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-checkmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-checkmark}.mat-checkbox-anim-checked-indeterminate .mat-checkbox-mixedmark{animation:90ms linear 0ms mat-checkbox-checked-indeterminate-mixedmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-checkmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-checkmark}.mat-checkbox-anim-indeterminate-checked .mat-checkbox-mixedmark{animation:500ms linear 0ms mat-checkbox-indeterminate-checked-mixedmark}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-background{animation:180ms linear 0ms mat-checkbox-fade-out-background}.mat-checkbox-anim-indeterminate-unchecked .mat-checkbox-mixedmark{animation:300ms linear 0ms mat-checkbox-indeterminate-unchecked-mixedmark}.mat-checkbox-input{bottom:0;left:50%}.mat-checkbox .mat-checkbox-ripple{position:absolute;left:calc(50% - 20px);top:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}\n"],encapsulation:2,changeDetection:0}),rV.ctorParameters=()=>[{type:xu},{type:Vm},{type:TS},{type:J_},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[tV]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[KB]}]}],rV.propDecorators={ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}],ariaDescribedby:[{type:f_,args:["aria-describedby"]}],id:[{type:f_}],required:[{type:f_}],labelPosition:[{type:f_}],name:[{type:f_}],change:[{type:h_}],indeterminateChange:[{type:h_}],value:[{type:f_}],_inputElement:[{type:Xd,args:["input"]}],ripple:[{type:Xd,args:[zE]}],checked:[{type:f_}],disabled:[{type:f_}],indeterminate:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const iV={provide:NF,useExisting:aa((()=>cV)),multi:!0};class cV extends lH{}cV.ɵfac=function t(n){return sV(n||cV)},cV.ɵdir=vo({type:cV,selectors:[["mat-checkbox","required","","formControlName",""],["mat-checkbox","required","","formControl",""],["mat-checkbox","required","","ngModel",""]],features:[Mu([iV]),hg]});const sV=tc(cV);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class lV{}lV.ɵmod=xo({type:lV}),lV.ɵinj=Ge({factory:function t(n){return new(n||lV)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(lV,{declarations:[cV],exports:[cV]});class mV{}mV.ɵmod=xo({type:mV}),mV.ɵinj=Ge({factory:function t(n){return new(n||mV)},imports:[[RE,tE,tS,lV],tE,lV]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(mV,{declarations:function(){return[rV]},imports:function(){return[RE,tE,tS,lV]},exports:function(){return[rV,tE,lV]}});const dV=Nw({passive:!0});class gV{constructor(t,n){this._platform=t,this._ngZone=n,this._monitoredElements=new Map}monitor(t){if(!this._platform.isBrowser)return U;const n=Jw(t),e=this._monitoredElements.get(n);if(e)return e.subject;const a=new x,o="cdk-text-field-autofilled",r=t=>{"cdk-text-field-autofill-start"!==t.animationName||n.classList.contains(o)?"cdk-text-field-autofill-end"===t.animationName&&n.classList.contains(o)&&(n.classList.remove(o),this._ngZone.run((()=>a.next({target:t.target,isAutofilled:!1})))):(n.classList.add(o),this._ngZone.run((()=>a.next({target:t.target,isAutofilled:!0}))))};return this._ngZone.runOutsideAngular((()=>{n.addEventListener("animationstart",r,dV),n.classList.add("cdk-text-field-autofill-monitored")})),this._monitoredElements.set(n,{subject:a,unlisten:()=>{n.removeEventListener("animationstart",r,dV)}}),a}stopMonitoring(t){const n=Jw(t),e=this._monitoredElements.get(n);e&&(e.unlisten(),e.subject.complete(),n.classList.remove("cdk-text-field-autofill-monitored"),n.classList.remove("cdk-text-field-autofilled"),this._monitoredElements.delete(n))}ngOnDestroy(){this._monitoredElements.forEach(((t,n)=>this.stopMonitoring(n)))}}gV.ɵfac=function t(n){return new(n||gV)(Za(Sw),Za(J_))},gV.ɵprov=We({factory:function t(){return new gV(Za(Sw),Za(J_))},token:gV,providedIn:"root"}),gV.ctorParameters=()=>[{type:Sw},{type:J_}];class pV{constructor(t,n){this._elementRef=t,this._autofillMonitor=n,this.cdkAutofill=new Ef}ngOnInit(){this._autofillMonitor.monitor(this._elementRef).subscribe((t=>this.cdkAutofill.emit(t)))}ngOnDestroy(){this._autofillMonitor.stopMonitoring(this._elementRef)}}pV.ɵfac=function t(n){return new(n||pV)(Zg(xu),Zg(gV))},pV.ɵdir=vo({type:pV,selectors:[["","cdkAutofill",""]],outputs:{cdkAutofill:"cdkAutofill"}}),pV.ctorParameters=()=>[{type:xu},{type:gV}],pV.propDecorators={cdkAutofill:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class bV{constructor(t,n,e,a){this._elementRef=t,this._platform=n,this._ngZone=e,this._destroyed=new x,this._enabled=!0,this._previousMinRows=-1,this._document=a,this._textareaElement=this._elementRef.nativeElement,this._measuringClass=n.FIREFOX?"cdk-textarea-autosize-measuring-firefox":"cdk-textarea-autosize-measuring"}get minRows(){return this._minRows}set minRows(t){this._minRows=Yw(t),this._setMinHeight()}get maxRows(){return this._maxRows}set maxRows(t){this._maxRows=Yw(t),this._setMaxHeight()}get enabled(){return this._enabled}set enabled(t){t=Gw(t),this._enabled!==t&&((this._enabled=t)?this.resizeToFitContent(!0):this.reset())}_setMinHeight(){const t=this.minRows&&this._cachedLineHeight?this.minRows*this._cachedLineHeight+"px":null;t&&(this._textareaElement.style.minHeight=t)}_setMaxHeight(){const t=this.maxRows&&this._cachedLineHeight?this.maxRows*this._cachedLineHeight+"px":null;t&&(this._textareaElement.style.maxHeight=t)}ngAfterViewInit(){this._platform.isBrowser&&(this._initialHeight=this._textareaElement.style.height,this.resizeToFitContent(),this._ngZone.runOutsideAngular((()=>{Vt(this._getWindow(),"resize").pipe(an(16),de(this._destroyed)).subscribe((()=>this.resizeToFitContent(!0)))})))}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}_cacheTextareaLineHeight(){if(this._cachedLineHeight)return;let t=this._textareaElement.cloneNode(!1);t.rows=1,t.style.position="absolute",t.style.visibility="hidden",t.style.border="none",t.style.padding="0",t.style.height="",t.style.minHeight="",t.style.maxHeight="",t.style.overflow="hidden",this._textareaElement.parentNode.appendChild(t),this._cachedLineHeight=t.clientHeight,this._textareaElement.parentNode.removeChild(t),this._setMinHeight(),this._setMaxHeight()}ngDoCheck(){this._platform.isBrowser&&this.resizeToFitContent()}resizeToFitContent(t=!1){if(!this._enabled)return;if(this._cacheTextareaLineHeight(),!this._cachedLineHeight)return;const n=this._elementRef.nativeElement,e=n.value;if(!t&&this._minRows===this._previousMinRows&&e===this._previousValue)return;const a=n.placeholder;n.classList.add(this._measuringClass),n.placeholder="",n.style.height=n.scrollHeight-4+"px",n.classList.remove(this._measuringClass),n.placeholder=a,this._ngZone.runOutsideAngular((()=>{"undefined"!=typeof requestAnimationFrame?requestAnimationFrame((()=>this._scrollToCaretPosition(n))):setTimeout((()=>this._scrollToCaretPosition(n)))})),this._previousValue=e,this._previousMinRows=this._minRows}reset(){void 0!==this._initialHeight&&(this._textareaElement.style.height=this._initialHeight)}_noopInputHandler(){}_getDocument(){return this._document||document}_getWindow(){return this._getDocument().defaultView||window}_scrollToCaretPosition(t){const{selectionStart:n,selectionEnd:e}=t,a=this._getDocument();this._destroyed.isStopped||a.activeElement!==t||t.setSelectionRange(n,e)}}bV.ɵfac=function t(n){return new(n||bV)(Zg(xu),Zg(Sw),Zg(J_),Zg(zC,8))},bV.ɵdir=vo({type:bV,selectors:[["textarea","cdkTextareaAutosize",""]],hostAttrs:["rows","1",1,"cdk-textarea-autosize"],hostBindings:function t(n,e){1&n&&cp("input",(function t(){return e._noopInputHandler()}))},inputs:{minRows:["cdkAutosizeMinRows","minRows"],maxRows:["cdkAutosizeMaxRows","maxRows"],enabled:["cdkTextareaAutosize","enabled"]},exportAs:["cdkTextareaAutosize"]}),bV.ctorParameters=()=>[{type:xu},{type:Sw},{type:J_},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]}],bV.propDecorators={minRows:[{type:f_,args:["cdkAutosizeMinRows"]}],maxRows:[{type:f_,args:["cdkAutosizeMaxRows"]}],enabled:[{type:f_,args:["cdkTextareaAutosize"]}],_noopInputHandler:[{type:__,args:["input"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class uV{}uV.ɵmod=xo({type:uV}),uV.ɵinj=Ge({factory:function t(n){return new(n||uV)},imports:[[Ew]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(uV,{declarations:function(){return[pV,bV]},imports:function(){return[Ew]},exports:function(){return[pV,bV]}});class fV extends bV{get matAutosizeMinRows(){return this.minRows}set matAutosizeMinRows(t){this.minRows=t}get matAutosizeMaxRows(){return this.maxRows}set matAutosizeMaxRows(t){this.maxRows=t}get matAutosize(){return this.enabled}set matAutosize(t){this.enabled=t}get matTextareaAutosize(){return this.enabled}set matTextareaAutosize(t){this.enabled=t}}fV.ɵfac=function t(n){return hV(n||fV)},fV.ɵdir=vo({type:fV,selectors:[["textarea","mat-autosize",""],["textarea","matTextareaAutosize",""]],hostAttrs:["rows","1",1,"cdk-textarea-autosize","mat-autosize"],inputs:{cdkAutosizeMinRows:"cdkAutosizeMinRows",cdkAutosizeMaxRows:"cdkAutosizeMaxRows",matAutosizeMinRows:"matAutosizeMinRows",matAutosizeMaxRows:"matAutosizeMaxRows",matAutosize:["mat-autosize","matAutosize"],matTextareaAutosize:"matTextareaAutosize"},exportAs:["matTextareaAutosize"],features:[hg]}),fV.propDecorators={matAutosizeMinRows:[{type:f_}],matAutosizeMaxRows:[{type:f_}],matAutosize:[{type:f_,args:["mat-autosize"]}],matTextareaAutosize:[{type:f_}]};const hV=tc(fV),_V=new Fa("MAT_INPUT_VALUE_ACCESSOR"),CV=["button","checkbox","file","hidden","image","radio","range","reset","submit"];
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */let MV=0;const OV=rE(class{constructor(t,n,e,a){this._defaultErrorStateMatcher=t,this._parentForm=n,this._parentFormGroup=e,this.ngControl=a}});class PV extends OV{constructor(t,n,e,a,o,r,i,c,s,l){super(r,a,o,e),this._elementRef=t,this._platform=n,this.ngControl=e,this._autofillMonitor=c,this._formField=l,this._uid="mat-input-"+MV++,this.focused=!1,this.stateChanges=new x,this.controlType="mat-input",this.autofilled=!1,this._disabled=!1,this._required=!1,this._type="text",this._readonly=!1,this._neverEmptyInputTypes=["date","datetime","datetime-local","month","time","week"].filter((t=>zw().has(t)));const m=this._elementRef.nativeElement,d=m.nodeName.toLowerCase();this._inputValueAccessor=i||m,this._previousNativeValue=this.value,this.id=this.id,n.IOS&&s.runOutsideAngular((()=>{t.nativeElement.addEventListener("keyup",(t=>{let n=t.target;n.value||n.selectionStart||n.selectionEnd||(n.setSelectionRange(1,1),n.setSelectionRange(0,0))}))})),this._isServer=!this._platform.isBrowser,this._isNativeSelect="select"===d,this._isTextarea="textarea"===d,this._isNativeSelect&&(this.controlType=m.multiple?"mat-native-select-multiple":"mat-native-select")}get disabled(){return this.ngControl&&null!==this.ngControl.disabled?this.ngControl.disabled:this._disabled}set disabled(t){this._disabled=Gw(t),this.focused&&(this.focused=!1,this.stateChanges.next())}get id(){return this._id}set id(t){this._id=t||this._uid}get required(){return this._required}set required(t){this._required=Gw(t)}get type(){return this._type}set type(t){this._type=t||"text",this._validateType(),!this._isTextarea&&zw().has(this._type)&&(this._elementRef.nativeElement.type=this._type)}get value(){return this._inputValueAccessor.value}set value(t){t!==this.value&&(this._inputValueAccessor.value=t,this.stateChanges.next())}get readonly(){return this._readonly}set readonly(t){this._readonly=Gw(t)}ngAfterViewInit(){this._platform.isBrowser&&this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe((t=>{this.autofilled=t.isAutofilled,this.stateChanges.next()}))}ngOnChanges(){this.stateChanges.next()}ngOnDestroy(){this.stateChanges.complete(),this._platform.isBrowser&&this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement)}ngDoCheck(){this.ngControl&&this.updateErrorState(),this._dirtyCheckNativeValue(),this._dirtyCheckPlaceholder()}focus(t){this._elementRef.nativeElement.focus(t)}_focusChanged(t){t===this.focused||this.readonly&&t||(this.focused=t,this.stateChanges.next())}_onInput(){}_dirtyCheckPlaceholder(){var t,n;const e=(null===(n=null===(t=this._formField)||void 0===t?void 0:t._hideControlPlaceholder)||void 0===n?void 0:n.call(t))?null:this.placeholder;if(e!==this._previousPlaceholder){const t=this._elementRef.nativeElement;this._previousPlaceholder=e,e?t.setAttribute("placeholder",e):t.removeAttribute("placeholder")}}_dirtyCheckNativeValue(){const t=this._elementRef.nativeElement.value;this._previousNativeValue!==t&&(this._previousNativeValue=t,this.stateChanges.next())}_validateType(){if(CV.indexOf(this._type)>-1&&("undefined"==typeof ngDevMode||ngDevMode))throw(function t(n){return Error(`Input type "${n}" isn't supported by matInput.`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(this._type)}_isNeverEmpty(){return this._neverEmptyInputTypes.indexOf(this._type)>-1}_isBadInput(){let t=this._elementRef.nativeElement.validity;return t&&t.badInput}get empty(){return!(this._isNeverEmpty()||this._elementRef.nativeElement.value||this._isBadInput()||this.autofilled)}get shouldLabelFloat(){if(this._isNativeSelect){const t=this._elementRef.nativeElement,n=t.options[0];return this.focused||t.multiple||!this.empty||!!(t.selectedIndex>-1&&n&&n.label)}return this.focused||!this.empty}setDescribedByIds(t){t.length?this._elementRef.nativeElement.setAttribute("aria-describedby",t.join(" ")):this._elementRef.nativeElement.removeAttribute("aria-describedby")}onContainerClick(){this.focused||this.focus()}}PV.ɵfac=function t(n){return new(n||PV)(Zg(xu),Zg(Sw),Zg(AF,10),Zg(LL,8),Zg(KL,8),Zg(OE),Zg(_V,10),Zg(gV),Zg(J_),Zg(hF,8))},PV.ɵdir=vo({type:PV,selectors:[["input","matInput",""],["textarea","matInput",""],["select","matNativeControl",""],["input","matNativeControl",""],["textarea","matNativeControl",""]],hostAttrs:[1,"mat-input-element","mat-form-field-autofill-control"],hostVars:9,hostBindings:function t(n,e){1&n&&cp("focus",(function t(){return e._focusChanged(!0)}))("blur",(function t(){return e._focusChanged(!1)}))("input",(function t(){return e._onInput()})),2&n&&(eb("disabled",e.disabled)("required",e.required),Ng("id",e.id)("data-placeholder",e.placeholder)("readonly",e.readonly&&!e._isNativeSelect||null)("aria-invalid",e.errorState)("aria-required",e.required.toString()),Dp("mat-input-server",e._isServer))},inputs:{id:"id",disabled:"disabled",required:"required",type:"type",value:"value",readonly:"readonly",placeholder:"placeholder",errorStateMatcher:"errorStateMatcher",userAriaDescribedBy:["aria-describedby","userAriaDescribedBy"]},exportAs:["matInput"],features:[Mu([{provide:aF,useExisting:PV}]),hg,pr]}),PV.ctorParameters=()=>[{type:xu},{type:Sw},{type:AF,decorators:[{type:Ne},{type:Fe}]},{type:LL,decorators:[{type:Ne}]},{type:KL,decorators:[{type:Ne}]},{type:OE},{type:void 0,decorators:[{type:Ne},{type:Fe},{type:Ie,args:[_V]}]},{type:gV},{type:J_},{type:_F,decorators:[{type:Ne},{type:Ie,args:[hF]}]}],PV.propDecorators={disabled:[{type:f_}],id:[{type:f_}],placeholder:[{type:f_}],required:[{type:f_}],type:[{type:f_}],errorStateMatcher:[{type:f_}],userAriaDescribedBy:[{type:f_,args:["aria-describedby"]}],value:[{type:f_}],readonly:[{type:f_}],_focusChanged:[{type:__,args:["focus",["true"]]},{type:__,args:["blur",["false"]]}],_onInput:[{type:__,args:["input"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class xV{}function yV(t,n){1&t&&(Kg(0,"mat-error"),Jp(1," Reload period has to be minimum of 15 seconds. "),$g())}function kV(t,n){1&t&&(Kg(0,"mat-error"),Jp(1," Page size has to be a positive integer. "),$g())}xV.ɵmod=xo({type:xV}),xV.ɵinj=Ge({factory:function t(n){return new(n||xV)},providers:[OE],imports:[[uV,CF],uV,CF]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(xV,{declarations:function(){return[PV,fV]},imports:function(){return[uV,CF]},exports:function(){return[uV,CF,PV,fV]}});const vV=pv(BI,(t=>Math.round(t/1e3)));class wV{constructor(t){this.store=t,this.reloadEnabled$=this.store.pipe(lv(HI)),this.pageSize$=this.store.pipe(lv(VI)),this.reloadPeriodInSec$=this.store.pipe(lv(vV)),this.reloadPeriodControl=new TL(15,[HF.required,HF.min(15)]),this.paginationControl=new TL(1,[HF.required,HF.min(1),t=>{const n=Number(t.value);return Math.round(n)===t.value?null:{integer:{value:t.value}}}]),this.ngUnsubscribe=new x}ngOnInit(){this.reloadPeriodInSec$.pipe(de(this.ngUnsubscribe),Gt((t=>t!==this.reloadPeriodControl.value))).subscribe((t=>{this.reloadPeriodControl.setValue(t)})),this.reloadEnabled$.pipe(de(this.ngUnsubscribe)).subscribe((t=>{t?this.reloadPeriodControl.enable():this.reloadPeriodControl.disable()})),this.reloadPeriodControl.valueChanges.pipe(de(this.ngUnsubscribe),ln(500),Gt((()=>this.reloadPeriodControl.valid))).subscribe((()=>{this.reloadPeriodControl.valid&&this.store.dispatch(PI({periodInMs:1e3*this.reloadPeriodControl.value}))})),this.pageSize$.pipe(de(this.ngUnsubscribe),Gt((t=>t!==this.paginationControl.value))).subscribe((t=>{this.paginationControl.setValue(t)})),this.paginationControl.valueChanges.pipe(de(this.ngUnsubscribe),ln(500),Gt((()=>this.paginationControl.valid))).subscribe((()=>{this.store.dispatch(xI({size:this.paginationControl.value}))}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}onReloadToggle(){this.store.dispatch(OI())}}wV.ɵfac=function t(n){return new(n||wV)(Zg(cv))},wV.ɵcmp=_o({type:wV,selectors:[["settings-dialog"]],decls:15,vars:7,consts:[[1,"reload-toggle"],[3,"checked","change"],["matInput","","type","number","placeholder","Reload Period",1,"reload-period",3,"formControl"],[4,"ngIf"],["matInput","","type","number","placeholder","Pagination Limit",1,"page-size",3,"formControl"]],template:function t(n,e){1&n&&(Kg(0,"h3"),Jp(1,"Settings"),$g(),Kg(2,"div"),Kg(3,"div",0),Kg(4,"mat-checkbox",1),cp("change",(function t(){return e.onReloadToggle()})),yf(5,"async"),Jp(6,"Reload data"),$g(),$g(),Kg(7,"div"),Kg(8,"mat-form-field"),tp(9,"input",2),$g(),Yg(10,yV,2,0,"mat-error",3),$g(),$g(),Kg(11,"div"),Kg(12,"mat-form-field"),tp(13,"input",4),$g(),Yg(14,kV,2,0,"mat-error",3),$g()),2&n&&(ws(4),Jg("checked",kf(5,5,e.reloadEnabled$)),ws(5),Jg("formControl",e.reloadPeriodControl),ws(1),Jg("ngIf",e.reloadPeriodControl.hasError("min")||e.reloadPeriodControl.hasError("required")),ws(3),Jg("formControl",e.paginationControl),ws(1),Jg("ngIf",e.paginationControl.invalid))},directives:[rV,_F,PV,YF,kF,RF,JL,WM,nF],pipes:[oO],styles:["[_nghost-%COMP%] {\n  font-size: 15px;\n}\n\n[_nghost-%COMP%]    > div[_ngcontent-%COMP%] {\n  margin: 10px 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:first-child {\n  margin-top: 0;\n}\n\n[_nghost-%COMP%]    > [_ngcontent-%COMP%]:last-child {\n  margin-bottom: 0;\n}\n\nh3[_ngcontent-%COMP%] {\n  font-size: 20px;\n}\n\n.reload-toggle[_ngcontent-%COMP%] {\n  margin-bottom: 10px;\n}"]});class SV{constructor(t){this.dialog=t}openDialog(){this.dialog.open(wV,{width:"400px"})}}SV.ɵfac=function t(n){return new(n||SV)(Zg(bB))},SV.ɵcmp=_o({type:SV,selectors:[["settings-button"]],decls:2,vars:0,consts:[["mat-icon-button","",3,"click"],["svgIcon","settings_24px"]],template:function t(n,e){1&n&&(Kg(0,"button",0),cp("click",(function t(){return e.openDialog()})),tp(1,"mat-icon",1),$g())},directives:[eA,BB],encapsulation:2});class EV{}function AV(t){return TV(t).map((t=>{const n=t.startsWith(":");return n?{pathPart:t,isParam:!0,paramName:t.slice(1)}:{pathPart:t,isParam:n}}))}EV.ɵfac=function t(n){return new(n||EV)},EV.ɵcmp=_o({type:EV,selectors:[["app-header"]],decls:9,vars:0,consts:[["color","primary"],[1,"brand"],[1,"plugins"],["mat-icon-button","","href","https://github.com/tensorflow/tensorboard/blob/master/README.md","rel","noopener noreferrer","target","_blank","aria-label","Help",1,"readme"],["svgIcon","help_outline_24px"]],template:function t(n,e){1&n&&(Kg(0,"mat-toolbar",0),Kg(1,"span",1),Jp(2,"TensorBoard"),$g(),tp(3,"plugin-selector",2),tp(4,"tbdev-upload-button"),tp(5,"app-header-reload"),tp(6,"settings-button"),Kg(7,"a",3),tp(8,"mat-icon",4),$g(),$g())},directives:[EI,QH,qB,XB,SV,aA,BB],styles:["mat-toolbar[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        height: 64px;\n        overflow: hidden;\n        width: 100%;\n      }\n\n      tbdev-upload-button.shown[_ngcontent-%COMP%] {\n        margin: 0 8px 0 16px;\n      }\n\n      .brand[_ngcontent-%COMP%], .readme[_ngcontent-%COMP%], app-header-reload[_ngcontent-%COMP%], settings-button[_ngcontent-%COMP%] {\n        flex: 0 0 auto;\n      }\n\n      .brand[_ngcontent-%COMP%] {\n        letter-spacing: -0.025em;\n        margin-left: 10px;\n        text-rendering: optimizeLegibility;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        align-items: center;\n        display: flex;\n        flex: 1 1 auto;\n        font-size: 14px;\n        height: 100%;\n        overflow: hidden;\n      }"]});class zV{constructor(t){this.config=t,this.validateConfig(t),this.pathFragments=AV(t.path),this.pathMatchers=this.getPathMatchers(this.pathFragments),this.redirectionFragments=null===t.routeKind?AV(t.redirectionPath):null}validateConfig({path:t}){if(!t.startsWith("/"))throw new RangeError(`config.path should start with '/'. ${t}`);let n=0;for(;(n=t.indexOf(":",n+1))>=0;){if("/"!==t[n-1])throw new RangeError(`config.path parameter should come after '/'. ${t}`);if(void 0===t[n+1]||"/"===t[n+1])throw new RangeError(`config.path parameter should have non-empty name. ${t}`)}}getPathMatchers(t){return t.map((t=>{const{pathPart:n}=t;return t.isParam?n=>({isParamPathPart:!0,partMatched:!0,paramName:t.paramName,paramValue:n}):t=>({isParamPathPart:!1,partMatched:t===n})}))}match(t){let n={};if(this.pathMatchers.length!==t.length)return{result:!1};let e=0;for(const a of this.pathMatchers){const o=a(t[e++]);if(!o.partMatched)return{result:!1};o.isParamPathPart&&(n=Object.assign(Object.assign({},n),{[o.paramName]:o.paramValue}))}return this.redirectionFragments?{result:!0,params:n,pathParts:this.reprojectPathByParams(this.redirectionFragments,n),isRedirection:!0}:{result:!0,params:n,pathParts:t,isRedirection:!1}}reprojectPathByParams(t,n){const e=[];for(const a of t)if(a.isParam){const{paramName:t}=a;if(!n.hasOwnProperty(t))throw new RangeError(`Failed to reproject parameter. "${t}" parameter should be present.`);e.push(n[t])}else e.push(a.pathPart);return e}matchByParams(t){return{result:!0,params:t,pathParts:this.reprojectPathByParams(this.pathFragments,t),isRedirection:!1}}}class RV{constructor(t,n=3){if(this.maxRedirection=n,n<0)throw new RangeError("maxRedirection has to be non-negative number");this.validateRouteConfigs(t),this.defaultRouteConfig=null,this.routeKindToConfigMatchers=new Map,this.configMatchers=[];for(const n of t){const t=new zV(n);this.configMatchers.push(t),null!==t.config.routeKind&&(this.routeKindToConfigMatchers.set(t.config.routeKind,t),t.config.defaultRoute&&(this.defaultRouteConfig=t))}}validateRouteConfigs(t){const n=t.filter((t=>Boolean(null!==t.routeKind&&t.defaultRoute)));if(n.length>1){const t=n.map((({path:t})=>t)).join(", ");throw new RangeError(`There are more than one defaultRoutes. ${t}`)}if(1===n.length){const{path:t}=n[0];if(Boolean(AV(t).find((({isParam:t})=>t))))throw new RangeError(`A defaultRoute cannot have any params. ${t}`)}const e=new Set;for(const{routeKind:n}of t)if(null!==n){if(e.has(n))throw new RangeError(`Multiple route configuration for kind: ${n}. Configurations should have unique routeKinds`);e.add(n)}}match(t){if(!t.pathname.startsWith("/"))throw new RangeError('Navigation has to made with pathname that starts with "/"');let n=TV(t.pathname),e=0;for(;;){let t=!1;for(const e of this.configMatchers){const a=e.match(n);if(a.result){const{params:o,pathParts:r,isRedirection:i}=a;if(i){n=r,t=!0;break}const c=e.config;return{routeKind:c.routeKind,params:o,pathname:DV(r),deepLinkProvider:c.deepLinkProvider||null}}}if(t&&e++,e>this.maxRedirection||!t)break}if(e>this.maxRedirection)throw new Error(`Potential redirection loop (redirecting more than ${this.maxRedirection} times. Please do not have cycles in the routes.`);if(this.defaultRouteConfig){const t=this.defaultRouteConfig.config;return{routeKind:t.routeKind,params:{},pathname:t.path,deepLinkProvider:t.deepLinkProvider||null}}return null}matchByRouteKind(t,n){const e=this.routeKindToConfigMatchers.get(t);if(!e||!e.config.routeKind)throw new RangeError(`Requires configuration for routeKind: ${t}`);const a=e.matchByParams(n),o=e.config;return{routeKind:t,params:n,pathname:DV(a.pathParts),deepLinkProvider:o.deepLinkProvider||null}}}function TV(t){return t.split("/").slice(1)}function DV(t){return"/"+t.join("/")}const IV=new Fa("[App Routing] Route Config");class NV{constructor(t){if(this.routeConfigs=null,this.routeKindToNgComponent=new Map,!t)return;const n=[];for(const e of t)for(const t of e)n.push(t);this.routeConfigs=new RV(n),n.forEach((t=>{t.routeKind&&this.routeKindToNgComponent.set(t.routeKind,t.ngComponent)}))}getRouteConfigs(){return this.routeConfigs}getNgComponentByRouteKind(t){return this.routeKindToNgComponent.get(t)||null}static registerRoutes(t){return{ngModule:NV,providers:[{provide:IV,multi:!0,useFactory:t}]}}}NV.ɵmod=xo({type:NV}),NV.ɵinj=Ge({factory:function t(n){return new(n||NV)(Za(IV,8))}});const FV=["routeContainer"];class LV{constructor(t){this.componentFactoryResolver=t}ngOnChanges(t){const n=t.activeNgComponent;if(n&&(this.routeContainer.clear(),n.currentValue)){const t=this.componentFactoryResolver.resolveComponentFactory(n.currentValue);this.routeContainer.createComponent(t)}}}LV.ɵfac=function t(n){return new(n||LV)(Zg(Pu))},LV.ɵcmp=_o({type:LV,selectors:[["router-outlet-component"]],viewQuery:function t(n,e){var a;1&n&&jf(FV,!0,$u),2&n&&Vf(a=Zf())&&(e.routeContainer=a.first)},inputs:{activeNgComponent:"activeNgComponent"},features:[pr],decls:2,vars:0,consts:[["routeContainer",""]],template:function t(n,e){1&n&&ap(0,null,0)},encapsulation:2,changeDetection:0});class HV{constructor(t,n){this.store=t,this.registry=n,this.activeNgComponent$=Et([this.store.select(Kz),this.store.select($z)]).pipe(ft((([t,n])=>t?null!==n&&Xz(n.routeKind,n.params)!==Xz(t.routeKind,t.params)?null:this.registry.getNgComponentByRouteKind(t.routeKind):null)))}}HV.ɵfac=function t(n){return new(n||HV)(Zg(cv),Zg(NV))},HV.ɵcmp=_o({type:HV,selectors:[["router-outlet"]],decls:2,vars:3,consts:[[3,"activeNgComponent"]],template:function t(n,e){1&n&&(tp(0,"router-outlet-component",0),yf(1,"async")),2&n&&Jg("activeNgComponent",kf(1,1,e.activeNgComponent$))},directives:[LV],pipes:[oO],encapsulation:2,changeDetection:0});const BV="__tab__";class VV{constructor(){this.tfStorage=document.createElement("tf-storage"),document.createElement("tf-globals").tf_globals.setUseHash(!0),this.tfStorage.tf_storage.migrateLegacyURLScheme()}getString(t){return this.tfStorage.tf_storage.getString(t)}setString(t,n,e){this.tfStorage.tf_storage.setString(t,n,e)}getPluginId(){return this.getString(BV)}setPluginId(t,n){this.setString(BV,t,n)}}var jV;VV.ɵfac=function t(n){return new(n||VV)},VV.ɵprov=We({token:VV,factory:VV.ɵfac}),(function(t){t[t.ACTIVE_PLUGIN=0]="ACTIVE_PLUGIN"})(jV||(jV={}));class UV{constructor(t){this.deepLinker=t,this.onHashChange=this.onHashChangedImpl.bind(this),this.onValueChange=new Ef}onHashChangedImpl(){const t=this.deepLinker.getPluginId();t!==this.activePluginId&&this.onValueChange.emit({prop:jV.ACTIVE_PLUGIN,value:t})}ngOnInit(){window.addEventListener("hashchange",this.onHashChange)}ngOnDestroy(){window.removeEventListener("hashchange",this.onHashChange)}ngOnChanges(t){if(t.activePluginId){const n=t.activePluginId;this.deepLinker.setPluginId(null===n.currentValue?"":n.currentValue,{defaultValue:"",useLocationReplace:null===n.previousValue||n.firstChange})}}}UV.ɵfac=function t(n){return new(n||UV)(Zg(VV))},UV.ɵcmp=_o({type:UV,selectors:[["hash-storage-component"]],inputs:{activePluginId:"activePluginId"},outputs:{onValueChange:"onValueChange"},features:[pr],decls:0,vars:0,template:function t(n,e){},encapsulation:2,changeDetection:0});class WV{constructor(t){this.store=t,this.activePluginId$=this.store.pipe(lv(NI))}onValueChanged(t){switch(t.prop){case jV.ACTIVE_PLUGIN:this.store.dispatch(pI({plugin:t.value}))}}}WV.ɵfac=function t(n){return new(n||WV)(Zg(cv))},WV.ɵcmp=_o({type:WV,selectors:[["hash-storage"]],decls:2,vars:3,consts:[[3,"activePluginId","onValueChange"]],template:function t(n,e){1&n&&(Kg(0,"hash-storage-component",0),cp("onValueChange",(function t(n){return e.onValueChanged(n)})),yf(1,"async"),$g()),2&n&&Jg("activePluginId",kf(1,1,e.activePluginId$))},directives:[UV],pipes:[oO],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0});class GV{ngOnChanges(t){t.title&&(document.title=t.title.currentValue)}}GV.ɵfac=function t(n){return new(n||GV)},GV.ɵcmp=_o({type:GV,selectors:[["page-title-component"]],inputs:{title:"title"},features:[pr],decls:0,vars:0,template:function t(n,e){},encapsulation:2,changeDetection:0});class YV{constructor(t){this.store=t,this.title$=this.store.pipe(lv(LI),ft((t=>t.window_title||"TensorBoard")),vn())}}YV.ɵfac=function t(n){return new(n||YV)(Zg(cv))},YV.ɵcmp=_o({type:YV,selectors:[["page-title"]],decls:2,vars:3,consts:[[3,"title"]],template:function t(n,e){1&n&&(tp(0,"page-title-component",0),yf(1,"async")),2&n&&Jg("title",kf(1,1,e.title$))},directives:[GV],pipes:[oO],styles:["[_nghost-%COMP%] {\n        display: none;\n      }"],changeDetection:0});class qV{constructor(t){this.store=t,this.ngUnsubscribe=new x,this.getPageSize$=this.store.pipe(lv(VI)),this.paginatedViewStore=document.createElement("tf-paginated-view-store").tf_paginated_view}ngOnInit(){this.getPageSize$.pipe(de(this.ngUnsubscribe),vn()).subscribe((t=>{this.paginatedViewStore.setLimit(t)}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}qV.ɵfac=function t(n){return new(n||qV)(Zg(cv))},qV.ɵcmp=_o({type:qV,selectors:[["settings-polymer-interop"]],decls:0,vars:0,template:function t(n,e){},encapsulation:2,changeDetection:0});class ZV{constructor(t,n){this.store=t,this.vcRef=n,this.store.select(Kz).pipe(Gt((t=>Boolean(t))),Tn(1)).subscribe((()=>{this.store.dispatch(bI())}))}}ZV.ɵfac=function t(n){return new(n||ZV)(Zg(cv),Zg($u))},ZV.ɵcmp=_o({type:ZV,selectors:[["tb-webapp"]],decls:7,vars:0,template:function t(n,e){1&n&&(tp(0,"app-header"),Kg(1,"main"),tp(2,"router-outlet"),$g(),tp(3,"alert-snackbar"),tp(4,"hash-storage"),tp(5,"page-title"),tp(6,"settings-polymer-interop"))},directives:[EV,HV,sI,WV,YV,qV],styles:["html[_ngcontent-%COMP%], body[_ngcontent-%COMP%] {\n  font-family: Roboto, sans-serif;\n  height: 100%;\n  margin: 0;\n  padding: 0;\n}\n\n[_nghost-%COMP%] {\n  background: #f5f5f5;\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n}\n\napp-header[_ngcontent-%COMP%] {\n  box-shadow: 0 1px 3px 3px rgba(0, 0, 0, 0.25);\n  flex: 0 0;\n  z-index: 1; \n}\n\nmain[_ngcontent-%COMP%] {\n  flex-grow: 1;\n  overflow: auto;\n}"]});const XV=Ok("[App Routing] State Rehydrated From Url",{_as:"props",_p:void 0}),JV=Ok("[App Routing] In App Navigation Requested",{_as:"props",_p:void 0}),QV=Ok("[App Routing] In App Navigating",{_as:"props",_p:void 0}),KV=Ok("[App Routing] In App Navigated",{_as:"props",_p:void 0}),$V=new Fa("[App Routing] Programmatical Navigation Provider");class tj{constructor(t){this.providers=new Map;for(const n of t||[]){if(this.providers.has(n.actionCreator.type))throw new RangeError(`"${n.actionCreator.type}" is already registered for nav. Multiple navigations on same kick is not allowed.`);this.providers.set(n.actionCreator.type,n.lambda)}}getNavigation(t){const n=this.providers.get(t.type);return n?n(t):null}static registerProgrammaticalNavigation(t){return{ngModule:tj,providers:[{provide:$V,multi:!0,useFactory:t}]}}}tj.ɵmod=xo({type:tj}),tj.ɵinj=Ge({factory:function t(n){return new(n||tj)(Za($V,8))}});const nj=Ok("[App Routing] Effects Init");class ej{constructor(t,n,e,a,o,r){this.actions$=t,this.store=n,this.location=e,this.programmaticalNavModule=o,this.appRootProvider=r,this.onNavigationRequested$=this.actions$.pipe(tw(JV),ft((t=>{const n=t.pathname.startsWith("/")?this.appRootProvider.getAbsPathnameWithAppRoot(t.pathname):this.location.getResolvedPath(t.pathname);return Object.assign(Object.assign({},t),{pathname:n})}))),this.onInit$=this.actions$.pipe(tw(nj)).pipe(fn(0),ft((()=>({pathname:this.location.getPath(),queryParams:this.location.getSearch(),replaceState:!0,browserInitiated:!0})))),this.userInitNavRoute$=Wt(this.onNavigationRequested$,this.onInit$,this.location.onPopState().pipe(ft((t=>({pathname:t.pathname,replaceState:t.replaceState,browserInitiated:!0}))))).pipe(ft((t=>{if(!t.pathname.startsWith("/"))throw new Error(`[App routing] pathname must start with '/'. Got: ${t.pathname}`);return Object.assign(Object.assign({},t),{pathname:this.appRootProvider.getAppRootlessPathname(t.pathname)})})),ft((t=>({routeMatch:this.routeConfigs?this.routeConfigs.match(t):null,options:{replaceState:t.replaceState,browserInitiated:t.browserInitiated}})))),this.programmticalNavRoute$=this.actions$.pipe(ft((t=>this.programmaticalNavModule.getNavigation(t))),Gt((t=>null!==t)),ft((t=>{const{routeKind:n,routeParams:e}=t;return{routeMatch:this.routeConfigs?this.routeConfigs.matchByRouteKind(n,e):null,options:{replaceState:!1,browserInitiated:!1}}}))),this.validatedRoute$=Wt(this.userInitNavRoute$,this.programmticalNavRoute$).pipe(Gt((({routeMatch:t})=>Boolean(t))),ft((t=>({routeMatch:t.routeMatch,options:t.options})))),this.fireNavigatedIfValidRoute$=Yv((()=>this.validatedRoute$.pipe(he((({routeMatch:t,options:n})=>{if(n.browserInitiated&&t.deepLinkProvider){const n=t.deepLinkProvider.deserializeQueryParams(this.location.getSearch());this.store.dispatch(XV({routeKind:t.routeKind,partialState:n}))}})),se((({routeMatch:t,options:n})=>{var e;const a={replaceState:null!==(e=n.replaceState)&&void 0!==e&&e},o=Z({routeKind:t.routeKind,params:t.params,pathname:t.pathname,queryParams:[],navigationOptions:a});return null===t.deepLinkProvider?o:t.deepLinkProvider.serializeStateToQueryParams(this.store).pipe(ft(((n,e)=>({routeKind:t.routeKind,params:t.params,pathname:t.pathname,queryParams:n,navigationOptions:0===e?a:Object.assign(Object.assign({},a),{replaceState:!0})}))))})),he((t=>{this.store.dispatch(QV({after:t}))})),ln(0),ye(this.store.select(Kz)),ft((([t,n])=>KV({before:n,after:t})))))),this.changeBrowserUrl$=Yv((()=>this.actions$.pipe(tw(KV),ye(this.store.select(Kz)),Gt((([,t])=>Boolean(t))),ft((([t,n])=>{const e=t.before;return{preserveHash:null===e||Xz(e.routeKind,e.params)===Xz(n.routeKind,n.params),route:n}})),Gt((({route:t})=>!(function n(t,e){return t.pathname===e.pathname&&t.queryParams.length===e.queryParams.length&&t.queryParams.every(((t,n)=>{const a=e.queryParams[n];return t.key===a.key&&t.value===a.value}))})(t,{pathname:this.appRootProvider.getAppRootlessPathname(this.location.getPath()),queryParams:this.location.getSearch()}))),he((({preserveHash:t,route:n})=>{n.navigationOptions.replaceState?this.location.replaceState(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPathFromRouteOrNav(n,t))):this.location.pushState(this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPathFromRouteOrNav(n,t)))})))),{dispatch:!1}),this.routeConfigs=a.getRouteConfigs()}ngrxOnInitEffects(){return nj()}}ej.ɵfac=function t(n){return new(n||ej)(Za($v),Za(cv),Za(oT),Za(NV),Za(tj),Za(rT))},ej.ɵprov=We({token:ej,factory:ej.ɵfac});const aj=Uv({activeRoute:null,nextRoute:null},jv(QV,((t,{after:n})=>Object.assign(Object.assign({},t),{nextRoute:n}))),jv(KV,((t,{after:n})=>Object.assign(Object.assign({},t),{activeRoute:n,nextRoute:null}))));class oj{}oj.ɵmod=xo({type:oj}),oj.ɵinj=Ge({factory:function t(n){return new(n||oj)},providers:[tj],imports:[[Iv.forFeature(Jz,(function rj(t,n){return aj(t,n)})),fw.forFeature([ej]),wT,vT]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(oj,{imports:[Dv,uw,wT,vT]});class ij{constructor(t,n,e){this.store=t,this.location=n,this.appRootProvider=e,this.pathname=null}handleClick(t){!this.pathname||t.ctrlKey||t.metaKey||(t.preventDefault(),t.stopPropagation(),this.store.dispatch(JV({pathname:this.pathname})))}get href(){return this.pathname?this.appRootProvider.getAbsPathnameWithAppRoot(this.location.getFullPathFromRouteOrNav({pathname:this.pathname})):null}set routerLink(t){if("string"==typeof t&&(t=[t]),0===t.length)throw new RangeError("routeLink should have proper path. Got nothing.");const n=[...t].join("/");this.pathname=n.endsWith("/")?n:n+"/"}}ij.ɵfac=function t(n){return new(n||ij)(Zg(cv),Zg(oT),Zg(rT))},ij.ɵdir=vo({type:ij,selectors:[["a","routerLink",""]],hostVars:1,hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e.handleClick(n)})),2&n&&Ng("href",e.href,Xc)},inputs:{routerLink:"routerLink"}});class cj{}var sj;function lj(t){let n=sj.UNKNOWN;return t instanceof TR&&404===t.status&&(n=sj.NOT_FOUND),X(new mj(n))}cj.ɵmod=xo({type:cj}),cj.ɵinj=Ge({factory:function t(n){return new(n||cj)},imports:[[PO,wT,vT,NV]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(cj,{declarations:[HV,LV,ij],imports:[PO,wT,vT,NV],exports:[HV,ij]}),(function(t){t.UNKNOWN="UNKNOWN",t.NOT_FOUND="NOT_FOUND"})(sj||(sj={}));class mj{constructor(t){this.failureCode=t}}class dj{constructor(t){this.http=t,this.tfBackend=document.createElement("tf-backend").tf_backend}fetchPluginsListing(t){const n=(function e(t){if(!t.length)return null;const n=new URLSearchParams;for(const e of t)n.append("experimentalPlugin",e);return n})(t),a=n?`data/plugins_listing?${n.toString()}`:"data/plugins_listing";return this.http.get(a).pipe(on(lj))}fetchEnvironment(){return Ht([this.http.get("data/environment"),Rt(this.tfBackend.environmentStore.refresh())]).pipe(ft((([t])=>t)),on(lj))}}dj.ɵfac=function t(n){return new(n||dj)(Za(mT))},dj.ɵprov=We({token:dj,factory:dj.ɵfac});class gj{}gj.ɵmod=xo({type:gj}),gj.ɵinj=Ge({factory:function t(n){return new(n||gj)},providers:[dj],imports:[[ST]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(gj,{imports:[ST]});class pj{constructor(t,n,e){this.actions$=t,this.store=n,this.webappDataSource=e,this.tfBackend={ref:document.createElement("tf-backend").tf_backend},this.fetchWebAppData$=Yv((()=>this.actions$.pipe(tw(bI,fI,uI),ye(this.store.select(II),this.store.select(pR)),Gt((([,{state:t}])=>t!==fR.LOADING)),he((()=>this.store.dispatch(hI()))),Tt((([,,t])=>(function n(...t){let n;return"function"==typeof t[t.length-1]&&(n=t.pop()),q(t,void 0).lift(new Jt(n))})(this.webappDataSource.fetchPluginsListing(t),this.fetchEnvironment(),this.refreshPolymerRuns()).pipe(ft((([t])=>{this.store.dispatch(_I({plugins:t}))})),on((t=>(this.store.dispatch(CI(t instanceof mj?{failureCode:t.failureCode}:{failureCode:sj.UNKNOWN})),U)))))))),{dispatch:!1}),this.dispatchChangePlugin$=Yv((()=>this.actions$.pipe(tw(bI,_I),ye(this.store.select(NI)),ft((([,t])=>t)),vn(),Gt((t=>null!==t)),Tn(1),he((t=>{this.store.dispatch(gI({plugin:t}))})))),{dispatch:!1})}refreshPolymerRuns(){return Rt(this.tfBackend.ref.runsStore.refresh())}fetchEnvironment(){return this.webappDataSource.fetchEnvironment().pipe(he((t=>{this.store.dispatch(MI({environment:t}))})))}}pj.ɵfac=function t(n){return new(n||pj)(Za($v),Za(cv),Za(dj))},pj.ɵprov=We({token:pj,factory:pj.ɵfac});const bj=new Fa("Core Feature Config");class uj{}uj.ɵmod=xo({type:uj}),uj.ɵinj=Ge({factory:function t(n){return new(n||uj)},providers:[{provide:bj,deps:[VV],useFactory:function fj(t){return{initialState:Object.assign(Object.assign({},RI),{activePlugin:t.getPluginId()||null})}}}],imports:[[fw.forFeature([pj]),Iv.forFeature(zI,(function hj(t,n){return TI(t,n)}),bj),gj]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(uj,{imports:[uw,Dv,gj]});class _j{}_j.ɵmod=xo({type:_j}),_j.ɵinj=Ge({factory:function t(n){return new(n||_j)},providers:[VV]});class Cj{}Cj.ɵmod=xo({type:Cj}),Cj.ɵinj=Ge({factory:function t(n){return new(n||Cj)},imports:[[PO,_j]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Cj,{declarations:[WV,UV],imports:[PO,_j],exports:[WV]});class Mj{}Mj.ɵmod=xo({type:Mj}),Mj.ɵinj=Ge({factory:function t(n){return new(n||Mj)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Mj,{declarations:[YV,GV],imports:[PO],exports:[YV]});const Oj={id:qz,name:"Default experiment",start_time:0},Pj=Uv({experimentMap:{[Oj.id]:Oj}});class xj{}xj.ɵmod=xo({type:xj}),xj.ɵinj=Ge({factory:function t(n){return new(n||xj)},imports:[[Iv.forFeature(rR,(function yj(t,n){return qk({data:Pj})(t,n)}))]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(xj,{imports:[Dv]});class kj{}kj.ɵfac=function t(n){return new(n||kj)},kj.ɵprov=We({token:kj,factory:kj.ɵfac});const vj="experimentalPlugin",wj="fastChart",Sj="scalarsBatchSize",Ej=new URLSearchParams(window.location.search);class Aj extends kj{getFeatures(){const t=this.getParams(),n={};return t.has(vj)&&(n.enabledExperimentalPlugins=t.getAll(vj)),t.has("tensorboardColab")&&(n.inColab="true"===t.get("tensorboardColab")),t.has(wj)&&(n.enableGpuChart="true"===t.get(wj)),t.has(Sj)&&(n.scalarsBatchSize=Number(t.get(Sj))),n}getParams(){return Ej}}Aj.ɵfac=function t(n){return zj(n||Aj)},Aj.ɵprov=We({token:Aj,factory:Aj.ɵfac});const zj=tc(Aj);class Rj{}Rj.ɵmod=xo({type:Rj}),Rj.ɵinj=Ge({factory:function t(n){return new(n||Rj)},providers:[{provide:kj,useClass:Aj}]});const Tj={isFeatureFlagsLoaded:!1,defaultFlags:{enabledExperimentalPlugins:[],inColab:!1,enableGpuChart:!0,scalarsBatchSize:void 0},flagOverrides:{}},Dj=new Fa("[Feature Flag] Store Config"),Ij=Ok("[FEATURE FLAG] Partial Feature Flags Loaded",{_as:"props",_p:void 0}),Nj=Uv(Tj,jv(Ij,((t,{features:n})=>Object.assign(Object.assign({},t),{isFeatureFlagsLoaded:!0,flagOverrides:Object.assign(Object.assign({},t.flagOverrides),n)})))),Fj=Ok("[FEATURE FLAG] Effects Init");class Lj{constructor(t,n){this.actions$=t,this.dataSource=n,this.getFeatureFlags$=Yv((()=>this.actions$.pipe(tw(Fj),ft((()=>{const t=this.dataSource.getFeatures();return Ij({features:t})})))))}ngrxOnInitEffects(){return Fj()}}Lj.ɵfac=function t(n){return new(n||Lj)(Za($v),Za(kj))},Lj.ɵprov=We({token:Lj,factory:Lj.ɵfac});class Hj{}Hj.ɵmod=xo({type:Hj}),Hj.ɵinj=Ge({factory:function t(n){return new(n||Hj)},providers:[{provide:Dj,useFactory:function Bj(){return{initialState:Tj}}}],imports:[[Rj,Iv.forFeature(sR,(function Vj(t,n){return Nj(t,n)}),Dj),fw.forFeature([Lj])]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Hj,{imports:[Rj,Dv,uw]});class jj{}jj.ɵmod=xo({type:jj}),jj.ɵinj=Ge({factory:function t(n){return new(n||jj)},imports:[[PO,OH,PH,oA,mV,OB,VB,xV]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(jj,{declarations:[SV,wV,qV],imports:[PO,OH,PH,oA,mV,OB,VB,xV],exports:[SV,qV]});class Uj{}Uj.ɵmod=xo({type:Uj}),Uj.ɵinj=Ge({factory:function t(n){return new(n||Uj)},providers:[{provide:"window",useValue:window}],imports:[[vB,PO,oA,OB,VB]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Uj,{declarations:[qB,jB,WB],imports:[vB,PO,oA,OB,VB],exports:[qB]});class Wj{}Wj.ɵmod=xo({type:Wj}),Wj.ɵinj=Ge({factory:function t(n){return new(n||Wj)},providers:[],imports:[[oA,VB,NN,AI,UH,PO,uj,jj,Uj]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Wj,{declarations:[EV,ZH,QH,XB],imports:[oA,VB,NN,AI,UH,PO,uj,jj,Uj],exports:[EV,QH,XB]});class Gj{constructor(t,n){const e=t.bypassSecurityTrustResourceUrl("./icon_bundle.svg");n.addSvgIconSet(e)}}Gj.ɵmod=xo({type:Gj}),Gj.ɵinj=Ge({factory:function t(n){return new(n||Gj)(Za(sP),Za(zB))},imports:[[VB]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Gj,{imports:[VB]});class Yj{constructor(t){this.http=t,this.httpPathPrefix="data/plugin/debugger-v2"}fetchRuns(){return this.http.get(this.httpPathPrefix+"/runs")}fetchExecutionDigests(t,n,e){return this.http.get(this.httpPathPrefix+"/execution/digests",{params:{run:t,begin:String(n),end:String(e)}})}fetchExecutionData(t,n,e){return this.http.get(this.httpPathPrefix+"/execution/data",{params:{run:t,begin:String(n),end:String(e)}})}fetchGraphExecutionDigests(t,n,e,a){if(void 0!==a)throw new Error("trace_id is not implemented for fetchGraphExecutionDigests() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/digests",{params:{run:t,begin:String(n),end:String(e)}})}fetchGraphExecutionData(t,n,e,a){if(void 0!==a)throw new Error("trace_id is not implemented for fetchGraphExecutionData() yet");return this.http.get(this.httpPathPrefix+"/graph_execution/data",{params:{run:t,begin:String(n),end:String(e)}})}fetchGraphOpInfo(t,n,e){return this.http.get(this.httpPathPrefix+"/graphs/op_info",{params:{run:t,graph_id:n,op_name:e}})}fetchSourceFileList(t){return this.http.get(this.httpPathPrefix+"/source_files/list",{params:{run:t}})}fetchSourceFile(t,n){return this.http.get(this.httpPathPrefix+"/source_files/file",{params:{run:t,index:String(n)}})}fetchStackFrames(t,n){return this.http.get(this.httpPathPrefix+"/stack_frames/stack_frames",{params:{run:t,stack_frame_ids:n.join(",")}}).pipe(ft((t=>({stack_frames:t.stack_frames.map((t=>(function n(t){return{host_name:t[0],file_path:t[1],lineno:t[2],function_name:t[3]}})(t)))}))))}fetchAlerts(t,n,e,a){const o={run:t,begin:String(n),end:String(e)};return void 0!==a&&(o.alert_type=a),this.http.get(this.httpPathPrefix+"/alerts",{params:o})}}Yj.ɵfac=function t(n){return new(n||Yj)(Za(mT))},Yj.ɵprov=We({token:Yj,factory:Yj.ɵfac});class qj{}qj.ɵmod=xo({type:qj}),qj.ɵinj=Ge({factory:function t(n){return new(n||qj)},providers:[Yj],imports:[[ST]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(qj,{imports:[ST]});class Zj{}Zj.ɵfac=function t(n){return new(n||Zj)},Zj.ɵcmp=_o({type:Zj,selectors:[["inactive-component"]],decls:54,vars:0,consts:[[1,"container"],[1,"title"],[1,"code"],[1,"arg"],[1,"exhibits-container"],[1,"exhibit"],[1,"screenshot"],["src","data:image/png;base64,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"],[1,"description"],["src","data:image/png;base64,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"],["src","data:image/png;base64,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"],[1,"details-container"],[1,"details"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging/experimental/enable_dump_debug_info","target","blank","rel","noreferrer noopener"],["href","https://www.tensorflow.org/api_docs/python/tf/debugging","target","blank","rel","noreferrer noopener"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"div",1),Jp(2,"Debugger V2 is inactive because no data is available."),$g(),Kg(3,"div"),Jp(4,"To use the debugger,"),$g(),Kg(5,"div"),Kg(6,"ol"),Kg(7,"li"),Jp(8," Add the following line to the beginning of your program: "),Kg(9,"div",2),Kg(10,"span"),Jp(11,"tf.debugging.experimental.enable_dump_debug_info("),$g(),Kg(12,"span",3),Jp(13,"logdir"),$g(),Jp(14,", "),Kg(15,"span",3),Jp(16,'tensor_debug_mode="FULL_HEALTH"'),$g(),Jp(17,", "),Kg(18,"span",3),Jp(19,"circular_buffer_size=-1"),$g(),Kg(20,"span"),Jp(21,")"),$g(),$g(),$g(),Kg(22,"li"),Jp(23,"Re-run the program."),$g(),$g(),$g(),Kg(24,"div",4),Kg(25,"div",5),Kg(26,"div",6),tp(27,"img",7),$g(),Kg(28,"div",8),Jp(29,"Auto-alerts for problems found"),$g(),$g(),Kg(30,"div",5),Kg(31,"div",6),tp(32,"img",9),$g(),Kg(33,"div",8),Jp(34," Integrated debugging to trace problems to their causes "),$g(),$g(),Kg(35,"div",5),Kg(36,"div",6),tp(37,"img",10),$g(),Kg(38,"div",8),Jp(39,"Link log to code"),$g(),$g(),$g(),Kg(40,"div",11),Kg(41,"div",12),Jp(42," The log directory must contain TensorFlow Debugger (V2) data. tf.debugging.experimental.enable_dump_debug_info() will collect tensor data, graph structures, the associated stack traces, and source code to the specificed directory logdir as the instrumented TensorFlow program executes. "),$g(),Kg(43,"div",12),Kg(44,"div"),Jp(45," See "),Kg(46,"a",13),Jp(47," documentation "),$g(),Jp(48," of the Python API of Debugger V2. "),$g(),Kg(49,"div"),Jp(50," See "),Kg(51,"a",14),Jp(52," here "),$g(),Jp(53," for other TensorFlow debugging APIs. "),$g(),$g(),$g(),$g())},styles:[".arg[_ngcontent-%COMP%] {\n  color: lightblue;\n  font-style: italic;\n  margin: 2px;\n}\n\n.code[_ngcontent-%COMP%] {\n  font-family: 'Roboto Mono', monospace;\n  margin: 10px;\n}\n\n.container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  overflow-y: auto;\n  padding: 50px;\n}\n\n.details-container[_ngcontent-%COMP%] {\n  display: inline-flex;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.details[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 10px 60px;\n  width: 50%;\n}\n\n.exhibit-container[_ngcontent-%COMP%] {\n  white-space: nowrap;\n  width: 100%;\n}\n\n.exhibit[_ngcontent-%COMP%] {\n  align-content: center;\n  display: inline-block;\n  margin: 10px 60px;\n  vertical-align: top;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .description[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-align: center;\n  width: 310px;\n}\n\n.exhibit[_ngcontent-%COMP%]   .screenshot[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%] {\n  height: 200px;\n  width: 100%;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]});class Xj{constructor(t){this.store=t}}Xj.ɵfac=function t(n){return new(n||Xj)(Zg(cv))},Xj.ɵcmp=_o({type:Xj,selectors:[["tf-debugger-v2-inactive"]],decls:1,vars:0,template:function t(n,e){1&n&&tp(0,"inactive-component")},directives:[Zj],encapsulation:2});const Jj=Ok("[Debugger] Debugger Loaded"),Qj=Ok("[Debugger] Debugger Unloaded"),Kj=Ok("[Debugger] A New Debugger Data Polling Event Begins"),$j=Ok("[Debugger] Debugger Runs Requested"),tU=Ok("[Debugger] Debugger Runs Loaded",{_as:"props",_p:void 0}),nU=Ok("[Debugger] Debugger Runs Request Failed"),eU=Ok("[Debugger] Number and Breakdown of Alerts Requested"),aU=Ok("[Debugger] Number and Breakdown of Alerts Loaded",{_as:"props",_p:void 0}),oU=Ok("[Debugger] Alerts Data of an AlertType Is Loaded",{_as:"props",_p:void 0}),rU=Ok("[Debugger] Alert Type Focus Toggled",{_as:"props",_p:void 0}),iU=Ok("[Debugger] Number of Top-Level Executions Requested"),cU=Ok("[Debugger] Number of Top-Level Executions Loaded",{_as:"props",_p:void 0}),sU=Ok("[Debugger] ExecutionDigests Requested",{_as:"props",_p:void 0}),lU=Ok("[Debugger] ExecutionDigests Loaded",{_as:"props",_p:void 0}),mU=Ok("[Debugger] Scroll Leftward on the Execution Timeline"),dU=Ok("[Debugger] Scroll Rightward on the Execution Timeline"),gU=Ok("[Debugger] Scroll the Execution Timeline to Given Index",{_as:"props",_p:void 0}),pU=Ok("[Debugger] Execution Data Objects Being Focused On",{_as:"props",_p:void 0}),bU=Ok("[Debugger] Execution Data Objects Loaded",{_as:"props",_p:void 0}),uU=Ok("[Debugger] Number of Intra-Graph Executions Requested"),fU=Ok("[Debugger] Number of Intra-Graph Executions Loaded",{_as:"props",_p:void 0}),hU=Ok("[Debugger] Intra-Graph Execution Data Requested",{_as:"props",_p:void 0}),_U=Ok("[Debugger] Intra-Graph Execution Data Loaded",{_as:"props",_p:void 0}),CU=Ok("[Debugger] Scroll Intra-Graph Execution List to Given Index",{_as:"props",_p:void 0}),MU=Ok("[Debugger] Graph Execution is Focused On",{_as:"props",_p:void 0}),OU=Ok("[Debugger] Graph Op Is Focused On",{_as:"props",_p:void 0}),PU=Ok("[Debugger] Graph Op Info Requested",{_as:"props",_p:void 0}),xU=Ok("[Debugger] Graph Op Info Loaded",{_as:"props",_p:void 0}),yU=Ok("[Debugger] Source File List Requested."),kU=Ok("[Debugger] Source File List Loaded",{_as:"props",_p:void 0}),vU=Ok("[Debugger] Source File Line Is Focused on",{_as:"props",_p:void 0}),wU=Ok("[Debugger] Source File Requested",{_as:"props",_p:void 0}),SU=Ok("[Debugger] Source File Loaded",{_as:"props",_p:void 0}),EU=Ok("[Debugger] A Set of Stack Frames Have Been Loaded",{_as:"props",_p:void 0}),AU="debugger";var zU,RU,TU;function DU(t){if(null===t.codeLocationFocusType)return null;let n=[];if(t.codeLocationFocusType===TU.EXECUTION){const{focusIndex:e,executionData:a}=t.executions;if(null===e||void 0===a[e])return null;n=a[e].stack_frame_ids}else{if(null===t.graphs.focusedOp)return null;const{graphId:e,opName:a}=t.graphs.focusedOp;if(void 0===t.graphs.ops[e]||!t.graphs.ops[e].has(a))return null;n=t.graphs.ops[e].get(a).stack_frame_ids}const e=[];for(const a of n){if(null==t.stackFrames[a])return null;e.push(t.stackFrames[a])}return e}function IU(t,n){return t.findIndex((t=>t.host_name===n.host_name&&t.file_path===n.file_path))}function NU(t,n,e){if(n>=e)throw new Error(`Expected begin to be less than end, but got begin=${n}, end=${e}`);return t.findIndex((t=>t.begin===n&&t.end===e))}function FU(t){const n=t.sourceCode.focusLineSpec;if(!t.stickToBottommostFrameInFocusedFile)return n;const e=DU(t);if(null===e)return n;const a=(function o(t,n){if(null===n)return null;for(let e=t.length-1;e>=0;--e){const a=t[e],{host_name:o,file_path:r}=a;if(o===n.host_name&&r===n.file_path)return a}return null})(e,n);return null===a?n:a}!(function(t){t[t.UNSPECIFIED=0]="UNSPECIFIED",t[t.NO_TENSOR=1]="NO_TENSOR",t[t.CURT_HEALTH=2]="CURT_HEALTH",t[t.CONCISE_HEALTH=3]="CONCISE_HEALTH",t[t.FULL_HEALTH=4]="FULL_HEALTH",t[t.SHAPE=5]="SHAPE",t[t.FULL_NUMERICS=6]="FULL_NUMERICS",t[t.FULL_TENSOR=7]="FULL_TENSOR",t[t.REDUCE_INF_NAN_THREE_SLOTS=8]="REDUCE_INF_NAN_THREE_SLOTS"})(zU||(zU={})),(function(t){t.FUNCTION_RECOMPILE_ALERT="FunctionRecompilesAlert",t.INF_NAN_ALERT="InfNanAlert",t.TENSOR_SHAPE_ALERT="TensorShapeAlert"})(RU||(RU={})),(function(t){t[t.EXECUTION=0]="EXECUTION",t[t.GRAPH_OP_CREATION=1]="GRAPH_OP_CREATION"})(TU||(TU={}));const LU=Uv({runs:{},runsLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},activeRunId:null,lastDataPollOnsetTimeMs:-1,lastNonEmptyPollDataTimeMs:1,alerts:{alertsLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},numAlerts:0,alertsBreakdown:{},alerts:{},executionIndices:{},graphExecutionIndices:{},focusType:null},executions:(function HU(){return{numExecutionsLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:50,pageSize:100,scrollBeginIndex:0,focusIndex:null,executionDigests:{},executionData:{}}})(),graphExecutions:(function BU(){return{numExecutionsLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},executionDigestsLoaded:{loadingRanges:[],numExecutions:0,pageLoadedSizes:{}},displayCount:100,pageSize:200,scrollBeginIndex:0,focusIndex:null,graphExecutionDigests:{},graphExecutionDataLoadingPages:[],graphExecutionDataPageLoadedSizes:{},graphExecutionData:{}}})(),graphs:{ops:{},loadingOps:{},focusedOp:null},stackFrames:{},codeLocationFocusType:null,stickToBottommostFrameInFocusedFile:!1,sourceCode:{sourceFileListLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},sourceFileList:[],fileContents:[],focusLineSpec:null}},jv($j,(t=>Object.assign(Object.assign({},t),{runsLoaded:Object.assign(Object.assign({},t.runsLoaded),{state:fR.LOADING})}))),jv(nU,(t=>Object.assign(Object.assign({},t),{runsLoaded:Object.assign(Object.assign({},t.runsLoaded),{state:fR.FAILED})}))),jv(tU,((t,{runs:n})=>{const e=Object.keys(n),a=e.length>0&&null===t.activeRunId;return Object.assign(Object.assign({},t),{lastNonEmptyPollDataTimeMs:a?Date.now():t.lastNonEmptyPollDataTimeMs,runs:n,runsLoaded:{state:fR.LOADED,lastLoadedTimeInMs:Date.now()},activeRunId:e.length>0?e[0]:null})})),jv(Kj,(t=>Object.assign(Object.assign({},t),{lastDataPollOnsetTimeMs:Date.now()}))),jv(eU,(t=>null===t.activeRunId?t:Object.assign(Object.assign({},t),{alerts:Object.assign(Object.assign({},t.alerts),{alertsLoaded:Object.assign(Object.assign({},t.alerts.alertsLoaded),{state:fR.LOADING})})}))),jv(aU,((t,{numAlerts:n,alertsBreakdown:e})=>{if(null===t.activeRunId)return t;const a=n>t.alerts.numAlerts;return Object.assign(Object.assign({},t),{lastNonEmptyPollDataTimeMs:a?Date.now():t.lastNonEmptyPollDataTimeMs,alerts:Object.assign(Object.assign({},t.alerts),{alertsLoaded:Object.assign(Object.assign({},t.alerts.alertsLoaded),{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}),numAlerts:n,alertsBreakdown:e})})})),jv(oU,((t,{numAlerts:n,alertsBreakdown:e,alertType:a,begin:o,alerts:r})=>{if(null===t.activeRunId)return t;const i={},c=t.alerts.executionIndices[a]?t.alerts.executionIndices[a].slice():[],s=t.alerts.graphExecutionIndices[a]?t.alerts.graphExecutionIndices[a].slice():[];for(let t=0;t<r.length;++t){const n=o+t,e=r[t];if(i[n]=e,e.alert_type===RU.INF_NAN_ALERT){const t=e;c[n]=t.execution_index,null!==t.graph_execution_trace_index&&(s[n]=t.graph_execution_trace_index)}}void 0!==t.alerts.alerts[a]&&Object.assign(i,t.alerts.alerts[a]);let l=t.executions.scrollBeginIndex,m=t.graphExecutions.focusIndex;if(a===RU.INF_NAN_ALERT&&0===o){const n=r[0];l=Math.max(0,n.execution_index-Math.floor(t.executions.displayCount/2)),null!==n.graph_execution_trace_index&&(m=n.graph_execution_trace_index)}return Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{scrollBeginIndex:l}),graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{focusIndex:m}),alerts:Object.assign(Object.assign({},t.alerts),{alertsLoaded:Object.assign(Object.assign({},t.alerts.alertsLoaded),{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}),numAlerts:n,alertsBreakdown:e,alerts:Object.assign(Object.assign({},t.alerts.alerts),{[a]:i}),executionIndices:Object.assign(Object.assign({},t.alerts.executionIndices),{[a]:c}),graphExecutionIndices:Object.assign(Object.assign({},t.alerts.graphExecutionIndices),{[a]:s})})})})),jv(rU,((t,{alertType:n})=>{const e=Object.assign(Object.assign({},t),{alerts:Object.assign(Object.assign({},t.alerts),{focusType:t.alerts.focusType===n?null:n})}),a=e.alerts.focusType;if(null!==a){const t=e.alerts.executionIndices[a]||[];void 0!==t[0]&&(e.executions.scrollBeginIndex=Math.max(0,Number(t[0])-Math.floor(e.executions.displayCount/2)))}return e})),jv(iU,(t=>null===t.activeRunId?t:Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{numExecutionsLoaded:Object.assign(Object.assign({},t.executions.numExecutionsLoaded),{state:fR.LOADING})})}))),jv(cU,((t,{numExecutions:n})=>{if(null===t.activeRunId)return t;const e=n>t.executions.executionDigestsLoaded.numExecutions,a=Object.assign(Object.assign({},t),{lastNonEmptyPollDataTimeMs:e?Date.now():t.lastNonEmptyPollDataTimeMs,executions:Object.assign(Object.assign({},t.executions),{numExecutionsLoaded:Object.assign(Object.assign({},t.executions.numExecutionsLoaded),{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}),executionDigestsLoaded:Object.assign(Object.assign({},t.executions.executionDigestsLoaded),{numExecutions:n})})});return n>0&&null===t.executions.focusIndex&&(a.executions.focusIndex=0),a})),jv(sU,((t,n)=>{if(null===t.activeRunId)return t;const e=[...t.executions.executionDigestsLoaded.loadingRanges];return-1===NU(e,n.begin,n.end)&&e.push({begin:n.begin,end:n.end}),Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{executionDigestsLoaded:Object.assign(Object.assign({},t.executions.executionDigestsLoaded),{loadingRanges:e})})})})),jv(lU,((t,n)=>{if(null===t.activeRunId)return t;const e=[...t.executions.executionDigestsLoaded.loadingRanges],a=NU(e,n.begin,n.end);-1!==a&&e.splice(a,1);const o=Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{executionDigestsLoaded:Object.assign(Object.assign({},t.executions.executionDigestsLoaded),{numExecutions:n.num_digests,loadingRanges:e}),executionDigests:Object.assign({},t.executions.executionDigests)})});for(let t=n.begin;t<n.end;++t)o.executions.executionDigests[t]=n.execution_digests[t-n.begin];if(n.end>n.begin){const e=n.begin/t.executions.pageSize;o.executions.executionDigestsLoaded.pageLoadedSizes=Object.assign(Object.assign({},o.executions.executionDigestsLoaded.pageLoadedSizes),{[e]:n.end-n.begin})}return o})),jv(mU,(t=>{if(null===t.activeRunId)return t;let n=t.executions.scrollBeginIndex;return n>0&&n--,Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{scrollBeginIndex:n})})})),jv(dU,(t=>{if(null===t.activeRunId)return t;let n=t.executions.scrollBeginIndex;return n+t.executions.displayCount+1<=t.executions.executionDigestsLoaded.numExecutions&&n++,Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{scrollBeginIndex:n})})})),jv(gU,((t,n)=>{if(n.index<0||!Number.isInteger(n.index))throw new Error(`Attempt to scroll to negative or non-integer execution index (${n.index})`);const{displayCount:e}=t.executions,{numExecutions:a}=t.executions.executionDigestsLoaded;if(n.index>Math.max(0,a-e))throw new Error(`Attempt to scroll to execution index (${n.index}), which exceeds maximum allowed index (numExecutions=${a}; displayCount=${e})`);return Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{scrollBeginIndex:n.index})})})),jv(pU,((t,n)=>{const e=Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{focusIndex:t.executions.scrollBeginIndex+n.displayIndex}),codeLocationFocusType:TU.EXECUTION,sourceCode:Object.assign({},t.sourceCode)});return e.sourceCode.focusLineSpec=FU(e),e})),jv(bU,((t,n)=>{if(null===t.activeRunId)return t;const e=Object.assign(Object.assign({},t),{executions:Object.assign(Object.assign({},t.executions),{executionData:Object.assign({},t.executions.executionData)})});for(let t=n.begin;t<n.end;++t)e.executions.executionData[t]=n.executions[t-n.begin];return e})),jv(uU,(t=>null===t.activeRunId?t:Object.assign(Object.assign({},t),{graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{numExecutionsLoaded:Object.assign(Object.assign({},t.graphExecutions.numExecutionsLoaded),{state:fR.LOADING})})}))),jv(fU,((t,{numGraphExecutions:n})=>{if(null===t.activeRunId)return t;const e=n>t.graphExecutions.executionDigestsLoaded.numExecutions,a=Object.assign(Object.assign({},t),{lastNonEmptyPollDataTimeMs:e?Date.now():t.lastNonEmptyPollDataTimeMs,graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{numExecutionsLoaded:Object.assign(Object.assign({},t.graphExecutions.numExecutionsLoaded),{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}),executionDigestsLoaded:Object.assign(Object.assign({},t.graphExecutions.executionDigestsLoaded),{numExecutions:n})})});return n>0&&null===t.graphExecutions.focusIndex&&(a.graphExecutions.focusIndex=0),a})),jv(hU,((t,{pageIndex:n})=>{if(null===t.activeRunId)return t;const e=t.graphExecutions.graphExecutionDataLoadingPages.slice();return-1===e.indexOf(n)&&e.push(n),Object.assign(Object.assign({},t),{graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{graphExecutionDataLoadingPages:e})})})),jv(_U,((t,n)=>{if(null===t.activeRunId)return t;const{pageSize:e}=t.graphExecutions,a=t.graphExecutions.graphExecutionDataLoadingPages.slice(),o=Object.assign({},t.graphExecutions.graphExecutionDataPageLoadedSizes),r=Object.assign({},t.graphExecutions.graphExecutionData);for(let t=n.begin;t<n.end;++t){const i=Math.floor(t/e);-1!==a.indexOf(i)&&a.splice(a.indexOf(i),1),void 0===o[i]&&(o[i]=0),void 0===r[t]&&o[i]++,r[t]=n.graph_executions[t-n.begin]}return Object.assign(Object.assign({},t),{graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{graphExecutionDataLoadingPages:a,graphExecutionDataPageLoadedSizes:o,graphExecutionData:r})})})),jv(CU,((t,n)=>{if(n.index<0||!Number.isInteger(n.index))throw new Error(`Attempt to scroll to negative or non-integer graph-execution index (${n.index})`);return Object.assign(Object.assign({},t),{graphExecutions:Object.assign(Object.assign({},t.graphExecutions),{scrollBeginIndex:n.index})})})),jv(MU,((t,n)=>VU(t,n.graph_id,n.op_name,n.index))),jv(OU,((t,n)=>VU(t,n.graph_id,n.op_name))),jv(PU,((t,n)=>{const{graph_id:e,op_name:a}=n,o=Object.assign(Object.assign({},t),{graphs:Object.assign(Object.assign({},t.graphs),{loadingOps:Object.assign({},t.graphs.loadingOps)})});return void 0===o.graphs.loadingOps[e]&&(o.graphs.loadingOps[e]=new Map),o.graphs.loadingOps[e].has(a)||o.graphs.loadingOps[e].set(a,fR.LOADING),o})),jv(xU,((t,n)=>{const{graphOpInfoResponse:e}=n,{graph_ids:a}=e,o=a[a.length-1],r=Object.assign(Object.assign({},t),{graphs:Object.assign(Object.assign({},t.graphs),{ops:Object.assign(Object.assign({},t.graphs.ops),{[o]:new Map(t.graphs.ops[o])}),loadingOps:Object.assign(Object.assign({},t.graphs.loadingOps),{[o]:new Map(t.graphs.loadingOps[o])})})});for(const t of e.inputs)t.data&&r.graphs.ops[o].set(t.op_name,t.data);for(let t=0;t<e.consumers.length;++t)for(const n of e.consumers[t])n.data&&r.graphs.ops[o].set(n.op_name,n.data);return r.graphs.ops[o].set(e.op_name,Object.assign(Object.assign({},e),{inputs:e.inputs.map((t=>({op_name:t.op_name,output_slot:t.output_slot}))),consumers:e.consumers.map((t=>t.map((t=>({op_name:t.op_name,input_slot:t.input_slot})))))})),r.graphs.loadingOps[o].set(e.op_name,fR.LOADED),r})),jv(yU,(t=>Object.assign(Object.assign({},t),{sourceCode:Object.assign(Object.assign({},t.sourceCode),{sourceFileListLoaded:Object.assign(Object.assign({},t.sourceCode.sourceFileListLoaded),{state:fR.LOADING})})}))),jv(kU,((t,n)=>{const e=Object.assign(Object.assign({},t),{sourceCode:Object.assign(Object.assign({},t.sourceCode),{sourceFileListLoaded:Object.assign(Object.assign({},t.sourceCode.sourceFileListLoaded),{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}),sourceFileList:n.sourceFiles,fileContents:t.sourceCode.fileContents.slice()})}),a=n.sourceFiles.length,{fileContents:o}=e.sourceCode;for(let n=0;n<a;++n)o[n]=t.sourceCode.fileContents[n]||{loadState:fR.NOT_LOADED,lines:null};return e})),jv(vU,((t,n)=>{const e=DU(t),a=Object.assign(Object.assign({},t),{sourceCode:Object.assign(Object.assign({},t.sourceCode),{focusLineSpec:n.stackFrame})});return null!==e&&(a.stickToBottommostFrameInFocusedFile=(function o(t,n){let e=-1,a=-1;if(t.forEach((({file_path:t,lineno:o},r)=>{t===n.file_path&&(a=r,o===n.lineno&&(e=r))})),-1===e)throw new Error(`Stack frame ${JSON.stringify(n)} is not found.`);return e===a})(e,n.stackFrame)),a})),jv(wU,((t,n)=>{const e=Object.assign(Object.assign({},t),{sourceCode:Object.assign(Object.assign({},t.sourceCode),{fileContents:t.sourceCode.fileContents.slice()})}),a=IU(e.sourceCode.sourceFileList,n);if(!(a>=0))throw new Error(`Cannot find the following file in file list: host_name="${n.host_name}", file_path="${n.file_path}"`);return e.sourceCode.fileContents[a].loadState=fR.LOADING,e})),jv(SU,((t,n)=>{const e=Object.assign(Object.assign({},t),{sourceCode:Object.assign(Object.assign({},t.sourceCode),{fileContents:t.sourceCode.fileContents.slice()})}),a=IU(e.sourceCode.sourceFileList,n);if(!(a>=0))throw new Error(`Cannot find the following file in file list: host_name="${n.host_name}", file_path="${n.file_path}"`);return e.sourceCode.fileContents[a]={loadState:fR.LOADED,lines:n.lines},e})),jv(EU,((t,n)=>{if(null===t.activeRunId)return t;const e=Object.assign(Object.assign({},t),{stackFrames:Object.assign(Object.assign({},t.stackFrames),n.stackFrames),sourceCode:Object.assign({},t.sourceCode)});return e.sourceCode.focusLineSpec=FU(e),e})));function VU(t,n,e,a){const o=Object.assign(Object.assign({},t),{graphs:Object.assign(Object.assign({},t.graphs),{focusedOp:{graphId:n,opName:e}}),codeLocationFocusType:TU.GRAPH_OP_CREATION,sourceCode:Object.assign({},t.sourceCode)});return o.sourceCode.focusLineSpec=FU(o),void 0!==a&&(o.graphExecutions=Object.assign(Object.assign({},t.graphExecutions),{focusIndex:a})),o}const jU=uv(AU),UU=pv(jU,(t=>t.runs)),WU=pv(jU,(t=>t.runsLoaded)),GU=pv(jU,(t=>t.activeRunId)),YU=pv(jU,(t=>t.lastDataPollOnsetTimeMs-t.lastNonEmptyPollDataTimeMs)),qU=pv(jU,(t=>t.alerts)),ZU=pv(qU,(t=>t.alertsLoaded)),XU=pv(qU,(t=>t.numAlerts)),JU=pv(qU,(t=>t.focusType)),QU=pv(qU,(t=>null===t.focusType?0:t.alertsBreakdown[t.focusType]||0)),KU=pv(qU,(t=>null===t.focusType||void 0===t.alerts[t.focusType]?null:t.alerts[t.focusType])),$U=pv(qU,(t=>t.alertsBreakdown)),tW=pv(jU,(t=>t.executions)),nW=pv(tW,(t=>t.numExecutionsLoaded)),eW=pv(tW,(t=>t.executionDigestsLoaded)),aW=pv(tW,(t=>t.executionDigestsLoaded.numExecutions)),oW=pv(tW,(t=>t.scrollBeginIndex)),rW=pv(tW,(t=>t.pageSize)),iW=pv(tW,(t=>t.displayCount)),cW=pv(tW,(t=>{const n=[];for(let e=t.scrollBeginIndex;e<t.scrollBeginIndex+t.displayCount;++e)n.push(e in t.executionDigests?t.executionDigests[e]:null);return n})),sW=pv(jU,(t=>t.graphExecutions)),lW=pv(sW,(t=>t.numExecutionsLoaded)),mW=pv(jU,(t=>t.graphExecutions.executionDigestsLoaded.numExecutions)),dW=pv(sW,(t=>t.scrollBeginIndex)),gW=pv(sW,(t=>t.displayCount)),pW=pv(sW,(t=>t.pageSize)),bW=pv(sW,(t=>t.graphExecutionDataLoadingPages)),uW=pv(sW,(t=>t.graphExecutionDataPageLoadedSizes)),fW=pv(sW,(t=>t.graphExecutionData)),hW=pv(sW,(t=>t.focusIndex)),_W=pv(jU,(t=>t.graphs)),CW=pv(_W,(t=>{const{focusedOp:n,ops:e}=t;return null===n||void 0===e[n.graphId]?null:e[n.graphId].get(n.opName)||null})),MW=pv(_W,(t=>{const{focusedOp:n,ops:e}=t;if(null!==n&&void 0!==e[n.graphId]&&e[n.graphId].has(n.opName)){const t=e[n.graphId],{inputs:a}=t.get(n.opName);return a.map((n=>{const e=Object.assign({},n);return t.has(n.op_name)&&(e.data=t.get(n.op_name)),e}))}return null})),OW=pv(hW,fW,MW,((t,n,e)=>{if(null===t||null===e)return null;const a=e.map((t=>!1)),o=[];if(0===e.length)return o;const r=n[t].graph_id,i=Math.max(0,t-200);for(let c=t-1;c>=i;--c)if(void 0!==n[c])for(let t=0;t<e.length&&(a[t]||n[c].graph_id!==r||n[c].op_name!==e[t].op_name||n[c].output_slot!==e[t].output_slot||(o.push(c),a[t]=!0,o.length!==e.length));++t);return o})),PW=pv(_W,(t=>{const{focusedOp:n,ops:e}=t;if(null!==n&&void 0!==e[n.graphId]&&e[n.graphId].has(n.opName)){const t=e[n.graphId],{consumers:a}=t.get(n.opName);return a.map((n=>n.map((n=>{const e=Object.assign({},n);return t.has(n.op_name)&&(e.data=t.get(n.op_name)),e}))))}return null})),xW=pv(jU,(t=>{const n=t.executions.scrollBeginIndex,e=t.executions.scrollBeginIndex+t.executions.displayCount,a=new Array(e-n).fill(null),o=t.alerts.focusType;if(null===o)return a;const r=t.alerts.executionIndices[o];if(void 0===r)return a;for(let o=n;o<e;++o)r.includes(o)&&(a[o-n]=t.alerts.focusType);return a})),yW=pv(jU,(t=>t.executions)),kW=pv(yW,(t=>t.focusIndex)),vW=pv(yW,(t=>{if(null===t.focusIndex)return null;const{focusIndex:n,scrollBeginIndex:e,displayCount:a}=t;return n<e||n>=e+a?null:n-e})),wW=pv(yW,(t=>t.executionData)),SW=pv(jU,(t=>t.graphs.loadingOps)),EW=pv(jU,(t=>t.stackFrames)),AW=pv(yW,(t=>{const{focusIndex:n,executionData:e}=t;return null===n||void 0===e[n]?null:e[n]})),zW=pv(jU,kW,AW,CW,((t,n,e,a)=>{const{codeLocationFocusType:o}=t;return null===o?null:o===TU.EXECUTION?null===n||null===e?null:{codeLocationType:TU.EXECUTION,opType:e.op_type,executionIndex:n}:null===a?null:{codeLocationType:TU.GRAPH_OP_CREATION,opType:a.op_type,opName:a.op_name}})),RW=pv(jU,DU),TW=pv(jU,(t=>t.sourceCode)),DW=pv(TW,(t=>t.sourceFileListLoaded));pv(TW,(t=>t.sourceFileList));const IW=pv(TW,(t=>{const{sourceFileList:n,focusLineSpec:e}=t;return null===e?-1:IU(n,e)})),NW=pv(TW,IW,((t,n)=>-1===n?null:t.fileContents[n]||null)),FW=pv(jU,(t=>t.sourceCode.focusLineSpec)),LW=pv(jU,(t=>t.stickToBottommostFrameInFocusedFile)),HW=function(t){return[t]};function BW(t,n){if(1&t){const t=op();Kg(0,"div",7),cp("click",(function e(){jr(t);const a=n.$implicit;return gp().onToggleFocusType.emit(a.type)})),Kg(1,"div",8),Jp(2),$g(),Kg(3,"div",9),Jp(4),$g(),tp(5,"div"),$g()}if(2&t){const t=n.$implicit,e=gp();Jg("ngClass",uf(4,HW,t.type===e.focusType?"focus":"")),ws(2),Qp(t.displayName),ws(2),$p(" ",t.displaySymbol,": ",t.count," ")}}class VW{constructor(){this.numAlerts=0,this.alertsBreakdown=[],this.focusType=null,this.onToggleFocusType=new Ef}}VW.ɵfac=function t(n){return new(n||VW)},VW.ɵcmp=_o({type:VW,selectors:[["alerts-component"]],inputs:{numAlerts:"numAlerts",alertsBreakdown:"alertsBreakdown",focusType:"focusType"},outputs:{onToggleFocusType:"onToggleFocusType"},decls:10,vars:5,consts:[[1,"alerts-container"],[1,"debugging-title"],[1,"num-alerts-container"],[1,"num-alerts-label"],[1,"num-alerts-value",3,"ngClass"],[1,"alerts-breakdown-container"],["class","alerts-breakdown-type",3,"ngClass","click",4,"ngFor","ngForOf"],[1,"alerts-breakdown-type",3,"ngClass","click"],[1,"alert-type-name"],[1,"alert-type-count"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"div",1),Jp(2,"Debugging"),$g(),Kg(3,"div",2),Kg(4,"div",3),Jp(5,"Alerts"),$g(),Kg(6,"div",4),Jp(7),$g(),$g(),Kg(8,"div",5),Yg(9,BW,6,6,"div",6),$g(),$g()),2&n&&(ws(6),Jg("ngClass",uf(3,HW,e.numAlerts>0?"non-zero":"")),ws(1),Kp(" ",e.numAlerts," "),ws(2),Jg("ngForOf",e.alertsBreakdown))},directives:[HM,jM],styles:[".alerts-breakdown-container[_ngcontent-%COMP%] {\n  font-size: 13px;\n  padding: 10px 10px 10px;\n  position: relative;\n}\n\n.alerts-breakdown-type[_ngcontent-%COMP%] {\n  border-radius: 0 10px 10px 0;\n  cursor: pointer;\n  display: flex;\n  padding: 6px 0 6px 50px;\n  vertical-align: middle;\n}\n\n.alerts-breakdown-type.focus[_ngcontent-%COMP%] {\n  background-color: #ffeee0;\n}\n\n.alerts-container[_ngcontent-%COMP%] {\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n}\n\n.alert-type-count[_ngcontent-%COMP%] {\n  \n  background-color: #e52592;\n  border-radius: 3px;\n  color: #fff;\n  display: inline-block;\n  padding: 3px;\n  position: absolute;\n  right: 20px;\n  vertical-align: middle;\n}\n\n.alert-type-name[_ngcontent-%COMP%] {\n  display: inline-block;\n  padding: 3px;\n  vertical-align: middle;\n}\n\n.debugging-title[_ngcontent-%COMP%] {\n  font-size: 18px;\n}\n\n.num-alerts-container[_ngcontent-%COMP%] {\n  font-weight: bold;\n  padding: 10px 10px 10px 30px;\n  position: relative;\n}\n\n.num-alerts-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-size: 13px;\n}\n\n.num-alerts-value[_ngcontent-%COMP%] {\n  border-radius: 12px;\n  display: inline-block;\n  font-size: 13px;\n  font-weight: normal;\n  line-height: 24px;\n  position: absolute;\n  right: 20px;\n  text-align: center;\n  vertical-align: middle;\n  width: 24px;\n}\n\n.num-alerts-value.non-zero[_ngcontent-%COMP%] {\n  background-color: #ffb780;\n  font-weight: bold;\n}"]});const jW={[RU.FUNCTION_RECOMPILE_ALERT]:{displayName:"Function recompiles",displaySymbol:"C"},[RU.INF_NAN_ALERT]:{displayName:"NaN/∞",displaySymbol:"∞"},[RU.TENSOR_SHAPE_ALERT]:{displayName:"Tensor shape",displaySymbol:"■"}};class UW{constructor(t){this.store=t,this.numAlerts$=this.store.pipe(lv(XU)),this.alertsBreakdown$=this.store.pipe(lv(pv($U,(t=>{const n=Object.keys(t);return n.sort(),n.map((n=>Object.assign(Object.assign({type:n},jW[n]),{count:t[n]})))})))),this.focusType$=this.store.pipe(lv(JU))}onToggleFocusType(t){this.store.dispatch(rU({alertType:t}))}}UW.ɵfac=function t(n){return new(n||UW)(Zg(cv))},UW.ɵcmp=_o({type:UW,selectors:[["tf-debugger-v2-alerts"]],decls:4,vars:9,consts:[[3,"numAlerts","alertsBreakdown","focusType","onToggleFocusType"]],template:function t(n,e){1&n&&(Kg(0,"alerts-component",0),cp("onToggleFocusType",(function t(n){return e.onToggleFocusType(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("numAlerts",kf(1,3,e.numAlerts$))("alertsBreakdown",kf(2,5,e.alertsBreakdown$))("focusType",kf(3,7,e.focusType$))},directives:[VW],pipes:[oO],encapsulation:2,changeDetection:0});const WW=["sliderWrapper"],GW=Nw({passive:!1}),YW={provide:MF,useExisting:aa((()=>XW)),multi:!0};class qW{}const ZW=oE(eE(nE(class{constructor(t){this._elementRef=t}}),"accent"));class XW extends ZW{constructor(t,n,e,a,o,r,i,c){super(t),this._focusMonitor=n,this._changeDetectorRef=e,this._dir=a,this._ngZone=r,this._animationMode=c,this._invert=!1,this._max=100,this._min=0,this._step=1,this._thumbLabel=!1,this._tickInterval=0,this._value=null,this._vertical=!1,this.change=new Ef,this.input=new Ef,this.valueChange=new Ef,this.onTouched=()=>{},this._percent=0,this._isSliding=!1,this._isActive=!1,this._tickIntervalPercent=0,this._sliderDimensions=null,this._controlValueAccessorChangeFn=()=>{},this._dirChangeSubscription=s.EMPTY,this._pointerDown=t=>{this.disabled||this._isSliding||!JW(t)&&0!==t.button||this._ngZone.run((()=>{const n=this.value,e=QW(t);this._isSliding=!0,this._lastPointerEvent=t,t.preventDefault(),this._focusHostElement(),this._onMouseenter(),this._bindGlobalEvents(t),this._focusHostElement(),this._updateValueFromPosition(e),this._valueOnSlideStart=n,n!=this.value&&this._emitInputEvent()}))},this._pointerMove=t=>{if(this._isSliding){t.preventDefault();const n=this.value;this._lastPointerEvent=t,this._updateValueFromPosition(QW(t)),n!=this.value&&this._emitInputEvent()}},this._pointerUp=t=>{this._isSliding&&(t.preventDefault(),this._removeGlobalEvents(),this._isSliding=!1,this._valueOnSlideStart==this.value||this.disabled||this._emitChangeEvent(),this._valueOnSlideStart=this._lastPointerEvent=null)},this._windowBlur=()=>{this._lastPointerEvent&&this._pointerUp(this._lastPointerEvent)},this._document=i,this.tabIndex=parseInt(o)||0,r.runOutsideAngular((()=>{const n=t.nativeElement;n.addEventListener("mousedown",this._pointerDown,GW),n.addEventListener("touchstart",this._pointerDown,GW)}))}get invert(){return this._invert}set invert(t){this._invert=Gw(t)}get max(){return this._max}set max(t){this._max=Yw(t,this._max),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get min(){return this._min}set min(t){this._min=Yw(t,this._min),null===this._value&&(this.value=this._min),this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}get step(){return this._step}set step(t){this._step=Yw(t,this._step),this._step%1!=0&&(this._roundToDecimal=this._step.toString().split(".").pop().length),this._changeDetectorRef.markForCheck()}get thumbLabel(){return this._thumbLabel}set thumbLabel(t){this._thumbLabel=Gw(t)}get tickInterval(){return this._tickInterval}set tickInterval(t){this._tickInterval="auto"===t?"auto":"number"==typeof t||"string"==typeof t?Yw(t,this._tickInterval):0}get value(){return null===this._value&&(this.value=this._min),this._value}set value(t){if(t!==this._value){let n=Yw(t);this._roundToDecimal&&(n=parseFloat(n.toFixed(this._roundToDecimal))),this._value=n,this._percent=this._calculatePercentage(this._value),this._changeDetectorRef.markForCheck()}}get vertical(){return this._vertical}set vertical(t){this._vertical=Gw(t)}get displayValue(){return this.displayWith?this.displayWith(this.value):this._roundToDecimal&&this.value&&this.value%1!=0?this.value.toFixed(this._roundToDecimal):this.value||0}focus(t){this._focusHostElement(t)}blur(){this._blurHostElement()}get percent(){return this._clamp(this._percent)}_shouldInvertAxis(){return this.vertical?!this.invert:this.invert}_isMinValue(){return 0===this.percent}_getThumbGap(){return this.disabled?7:this._isMinValue()&&!this.thumbLabel?this._isActive?10:7:0}_getTrackBackgroundStyles(){const t=this.vertical?`1, ${1-this.percent}, 1`:1-this.percent+", 1, 1";return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"-":""}${this._getThumbGap()}px) scale3d(${t})`}}_getTrackFillStyles(){const t=this.percent,n=this.vertical?`1, ${t}, 1`:`${t}, 1, 1`;return{transform:`translate${this.vertical?"Y":"X"}(${this._shouldInvertMouseCoords()?"":"-"}${this._getThumbGap()}px) scale3d(${n})`,display:0===t?"none":""}}_getTicksContainerStyles(){return{transform:`translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"-":""}${this._tickIntervalPercent/2*100}%)`}}_getTicksStyles(){let t=100*this._tickIntervalPercent,n={backgroundSize:this.vertical?`2px ${t}%`:`${t}% 2px`,transform:`translateZ(0) translate${this.vertical?"Y":"X"}(${this.vertical||"rtl"!=this._getDirection()?"":"-"}${t/2}%)${this.vertical||"rtl"!=this._getDirection()?"":" rotate(180deg)"}`};if(this._isMinValue()&&this._getThumbGap()){const t=this._shouldInvertAxis();let e;e=this.vertical?t?"Bottom":"Top":t?"Right":"Left",n[`padding${e}`]=`${this._getThumbGap()}px`}return n}_getThumbContainerStyles(){const t=this._shouldInvertAxis();return{transform:`translate${this.vertical?"Y":"X"}(-${100*(("rtl"!=this._getDirection()||this.vertical?t:!t)?this.percent:1-this.percent)}%)`}}_shouldInvertMouseCoords(){const t=this._shouldInvertAxis();return"rtl"!=this._getDirection()||this.vertical?t:!t}_getDirection(){return this._dir&&"rtl"==this._dir.value?"rtl":"ltr"}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe((t=>{this._isActive=!!t&&"keyboard"!==t,this._changeDetectorRef.detectChanges()})),this._dir&&(this._dirChangeSubscription=this._dir.change.subscribe((()=>{this._changeDetectorRef.markForCheck()})))}ngOnDestroy(){const t=this._elementRef.nativeElement;t.removeEventListener("mousedown",this._pointerDown,GW),t.removeEventListener("touchstart",this._pointerDown,GW),this._lastPointerEvent=null,this._removeGlobalEvents(),this._focusMonitor.stopMonitoring(this._elementRef),this._dirChangeSubscription.unsubscribe()}_onMouseenter(){this.disabled||(this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent())}_onFocus(){this._sliderDimensions=this._getSliderDimensions(),this._updateTickIntervalPercent()}_onBlur(){this.onTouched()}_onKeydown(t){if(this.disabled||Ww(t))return;const n=this.value;switch(t.keyCode){case 33:this._increment(10);break;case 34:this._increment(-10);break;case 35:this.value=this.max;break;case 36:this.value=this.min;break;case 37:this._increment("rtl"==this._getDirection()?1:-1);break;case jw:this._increment(1);break;case 39:this._increment("rtl"==this._getDirection()?-1:1);break;case Uw:this._increment(-1);break;default:return}n!=this.value&&(this._emitInputEvent(),this._emitChangeEvent()),this._isSliding=!0,t.preventDefault()}_onKeyup(){this._isSliding=!1}_getWindow(){return this._document.defaultView||window}_bindGlobalEvents(t){const n=this._document,e=JW(t),a=e?"touchend":"mouseup";n.addEventListener(e?"touchmove":"mousemove",this._pointerMove,GW),n.addEventListener(a,this._pointerUp,GW),e&&n.addEventListener("touchcancel",this._pointerUp,GW);const o=this._getWindow();void 0!==o&&o&&o.addEventListener("blur",this._windowBlur)}_removeGlobalEvents(){const t=this._document;t.removeEventListener("mousemove",this._pointerMove,GW),t.removeEventListener("mouseup",this._pointerUp,GW),t.removeEventListener("touchmove",this._pointerMove,GW),t.removeEventListener("touchend",this._pointerUp,GW),t.removeEventListener("touchcancel",this._pointerUp,GW);const n=this._getWindow();void 0!==n&&n&&n.removeEventListener("blur",this._windowBlur)}_increment(t){this.value=this._clamp((this.value||0)+this.step*t,this.min,this.max)}_updateValueFromPosition(t){if(!this._sliderDimensions)return;let n=this._clamp(((this.vertical?t.y:t.x)-(this.vertical?this._sliderDimensions.top:this._sliderDimensions.left))/(this.vertical?this._sliderDimensions.height:this._sliderDimensions.width));if(this._shouldInvertMouseCoords()&&(n=1-n),0===n)this.value=this.min;else if(1===n)this.value=this.max;else{const t=this._calculateValue(n),e=Math.round((t-this.min)/this.step)*this.step+this.min;this.value=this._clamp(e,this.min,this.max)}}_emitChangeEvent(){this._controlValueAccessorChangeFn(this.value),this.valueChange.emit(this.value),this.change.emit(this._createChangeEvent())}_emitInputEvent(){this.input.emit(this._createChangeEvent())}_updateTickIntervalPercent(){if(this.tickInterval&&this._sliderDimensions)if("auto"==this.tickInterval){let t=this.vertical?this._sliderDimensions.height:this._sliderDimensions.width,n=Math.ceil(30/(t*this.step/(this.max-this.min)));this._tickIntervalPercent=n*this.step/t}else this._tickIntervalPercent=this.tickInterval*this.step/(this.max-this.min)}_createChangeEvent(t=this.value){let n=new qW;return n.source=this,n.value=t,n}_calculatePercentage(t){return((t||0)-this.min)/(this.max-this.min)}_calculateValue(t){return this.min+t*(this.max-this.min)}_clamp(t,n=0,e=1){return Math.max(n,Math.min(t,e))}_getSliderDimensions(){return this._sliderWrapper?this._sliderWrapper.nativeElement.getBoundingClientRect():null}_focusHostElement(t){this._elementRef.nativeElement.focus(t)}_blurHostElement(){this._elementRef.nativeElement.blur()}writeValue(t){this.value=t}registerOnChange(t){this._controlValueAccessorChangeFn=t}registerOnTouched(t){this.onTouched=t}setDisabledState(t){this.disabled=t}}function JW(t){return"t"===t.type[0]}function QW(t){const n=JW(t)?t.touches[0]||t.changedTouches[0]:t;return{x:n.clientX,y:n.clientY}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */XW.ɵfac=function t(n){return new(n||XW)(Zg(xu),Zg(TS),Zg(Vm),Zg(US,8),Xg("tabindex"),Zg(J_),Zg(zC),Zg(dk,8))},XW.ɵcmp=_o({type:XW,selectors:[["mat-slider"]],viewQuery:function t(n,e){var a;1&n&&Uf(WW,!0),2&n&&Vf(a=Zf())&&(e._sliderWrapper=a.first)},hostAttrs:["role","slider",1,"mat-slider","mat-focus-indicator"],hostVars:28,hostBindings:function t(n,e){1&n&&cp("focus",(function t(){return e._onFocus()}))("blur",(function t(){return e._onBlur()}))("keydown",(function t(n){return e._onKeydown(n)}))("keyup",(function t(){return e._onKeyup()}))("mouseenter",(function t(){return e._onMouseenter()}))("selectstart",(function t(n){return n.preventDefault()})),2&n&&(eb("tabIndex",e.tabIndex),Ng("aria-disabled",e.disabled)("aria-valuemax",e.max)("aria-valuemin",e.min)("aria-valuenow",e.value)("aria-orientation",e.vertical?"vertical":"horizontal"),Dp("mat-slider-disabled",e.disabled)("mat-slider-has-ticks",e.tickInterval)("mat-slider-horizontal",!e.vertical)("mat-slider-axis-inverted",e._shouldInvertAxis())("mat-slider-invert-mouse-coords",e._shouldInvertMouseCoords())("mat-slider-sliding",e._isSliding)("mat-slider-thumb-label-showing",e.thumbLabel)("mat-slider-vertical",e.vertical)("mat-slider-min-value",e._isMinValue())("mat-slider-hide-last-tick",e.disabled||e._isMinValue()&&e._getThumbGap()&&e._shouldInvertAxis())("_mat-animation-noopable","NoopAnimations"===e._animationMode))},inputs:{disabled:"disabled",color:"color",tabIndex:"tabIndex",invert:"invert",max:"max",min:"min",value:"value",step:"step",thumbLabel:"thumbLabel",tickInterval:"tickInterval",vertical:"vertical",displayWith:"displayWith"},outputs:{change:"change",input:"input",valueChange:"valueChange"},exportAs:["matSlider"],features:[Mu([YW]),hg],decls:13,vars:6,consts:[[1,"mat-slider-wrapper"],["sliderWrapper",""],[1,"mat-slider-track-wrapper"],[1,"mat-slider-track-background",3,"ngStyle"],[1,"mat-slider-track-fill",3,"ngStyle"],[1,"mat-slider-ticks-container",3,"ngStyle"],[1,"mat-slider-ticks",3,"ngStyle"],[1,"mat-slider-thumb-container",3,"ngStyle"],[1,"mat-slider-focus-ring"],[1,"mat-slider-thumb"],[1,"mat-slider-thumb-label"],[1,"mat-slider-thumb-label-text"]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),Kg(2,"div",2),tp(3,"div",3),tp(4,"div",4),$g(),Kg(5,"div",5),tp(6,"div",6),$g(),Kg(7,"div",7),tp(8,"div",8),tp(9,"div",9),Kg(10,"div",10),Kg(11,"span",11),Jp(12),$g(),$g(),$g(),$g()),2&n&&(ws(3),Jg("ngStyle",e._getTrackBackgroundStyles()),ws(1),Jg("ngStyle",e._getTrackFillStyles()),ws(1),Jg("ngStyle",e._getTicksContainerStyles()),ws(1),Jg("ngStyle",e._getTicksStyles()),ws(1),Jg("ngStyle",e._getThumbContainerStyles()),ws(5),Qp(e.displayValue))},directives:[$M],styles:['.mat-slider{display:inline-block;position:relative;box-sizing:border-box;padding:8px;outline:none;vertical-align:middle}.mat-slider:not(.mat-slider-disabled):active,.mat-slider.mat-slider-sliding:not(.mat-slider-disabled){cursor:-webkit-grabbing;cursor:grabbing}.mat-slider-wrapper{position:absolute}.mat-slider-track-wrapper{position:absolute;top:0;left:0;overflow:hidden}.mat-slider-track-fill{position:absolute;transform-origin:0 0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-track-background{position:absolute;transform-origin:100% 100%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-ticks-container{position:absolute;left:0;top:0;overflow:hidden}.mat-slider-ticks{background-repeat:repeat;background-clip:content-box;box-sizing:border-box;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-container{position:absolute;z-index:1;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-focus-ring{position:absolute;width:30px;height:30px;border-radius:50%;transform:scale(0);opacity:0;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider.cdk-keyboard-focused .mat-slider-focus-ring,.mat-slider.cdk-program-focused .mat-slider-focus-ring{transform:scale(1);opacity:1}.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb-label,.mat-slider:not(.mat-slider-disabled):not(.mat-slider-sliding) .mat-slider-thumb{cursor:-webkit-grab;cursor:grab}.mat-slider-thumb{position:absolute;right:-10px;bottom:-10px;box-sizing:border-box;width:20px;height:20px;border:3px solid transparent;border-radius:50%;transform:scale(0.7);transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-thumb-label{display:none;align-items:center;justify-content:center;position:absolute;width:28px;height:28px;border-radius:50%;transition:transform 400ms cubic-bezier(0.25, 0.8, 0.25, 1),border-radius 400ms cubic-bezier(0.25, 0.8, 0.25, 1),background-color 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.cdk-high-contrast-active .mat-slider-thumb-label{outline:solid 1px}.mat-slider-thumb-label-text{z-index:1;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-sliding .mat-slider-track-fill,.mat-slider-sliding .mat-slider-track-background,.mat-slider-sliding .mat-slider-thumb-container{transition-duration:0ms}.mat-slider-has-ticks .mat-slider-wrapper::after{content:"";position:absolute;border-width:0;border-style:solid;opacity:0;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after,.mat-slider-has-ticks:hover:not(.mat-slider-hide-last-tick) .mat-slider-wrapper::after{opacity:1}.mat-slider-has-ticks.cdk-focused:not(.mat-slider-disabled) .mat-slider-ticks,.mat-slider-has-ticks:hover:not(.mat-slider-disabled) .mat-slider-ticks{opacity:1}.mat-slider-thumb-label-showing .mat-slider-focus-ring{display:none}.mat-slider-thumb-label-showing .mat-slider-thumb-label{display:flex}.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:100% 100%}.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:0 0}.mat-slider:not(.mat-slider-disabled).cdk-focused.mat-slider-thumb-label-showing .mat-slider-thumb{transform:scale(0)}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label{border-radius:50% 50% 0}.mat-slider:not(.mat-slider-disabled).cdk-focused .mat-slider-thumb-label-text{opacity:1}.mat-slider:not(.mat-slider-disabled).cdk-mouse-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-touch-focused .mat-slider-thumb,.mat-slider:not(.mat-slider-disabled).cdk-program-focused .mat-slider-thumb{border-width:2px;transform:scale(1)}.mat-slider-disabled .mat-slider-focus-ring{transform:scale(0);opacity:0}.mat-slider-disabled .mat-slider-thumb{border-width:4px;transform:scale(0.5)}.mat-slider-disabled .mat-slider-thumb-label{display:none}.mat-slider-horizontal{height:48px;min-width:128px}.mat-slider-horizontal .mat-slider-wrapper{height:2px;top:23px;left:8px;right:8px}.mat-slider-horizontal .mat-slider-wrapper::after{height:2px;border-left-width:2px;right:0;top:0}.mat-slider-horizontal .mat-slider-track-wrapper{height:2px;width:100%}.mat-slider-horizontal .mat-slider-track-fill{height:2px;width:100%;transform:scaleX(0)}.mat-slider-horizontal .mat-slider-track-background{height:2px;width:100%;transform:scaleX(1)}.mat-slider-horizontal .mat-slider-ticks-container{height:2px;width:100%}.cdk-high-contrast-active .mat-slider-horizontal .mat-slider-ticks-container{height:0;outline:solid 2px;top:1px}.mat-slider-horizontal .mat-slider-ticks{height:2px;width:100%}.mat-slider-horizontal .mat-slider-thumb-container{width:100%;height:0;top:50%}.mat-slider-horizontal .mat-slider-focus-ring{top:-15px;right:-15px}.mat-slider-horizontal .mat-slider-thumb-label{right:-14px;top:-40px;transform:translateY(26px) scale(0.01) rotate(45deg)}.mat-slider-horizontal .mat-slider-thumb-label-text{transform:rotate(-45deg)}.mat-slider-horizontal.cdk-focused .mat-slider-thumb-label{transform:rotate(45deg)}.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label,.cdk-high-contrast-active .mat-slider-horizontal.cdk-focused .mat-slider-thumb-label-text{transform:none}.mat-slider-vertical{width:48px;min-height:128px}.mat-slider-vertical .mat-slider-wrapper{width:2px;top:8px;bottom:8px;left:23px}.mat-slider-vertical .mat-slider-wrapper::after{width:2px;border-top-width:2px;bottom:0;left:0}.mat-slider-vertical .mat-slider-track-wrapper{height:100%;width:2px}.mat-slider-vertical .mat-slider-track-fill{height:100%;width:2px;transform:scaleY(0)}.mat-slider-vertical .mat-slider-track-background{height:100%;width:2px;transform:scaleY(1)}.mat-slider-vertical .mat-slider-ticks-container{width:2px;height:100%}.cdk-high-contrast-active .mat-slider-vertical .mat-slider-ticks-container{width:0;outline:solid 2px;left:1px}.mat-slider-vertical .mat-slider-focus-ring{bottom:-15px;left:-15px}.mat-slider-vertical .mat-slider-ticks{width:2px;height:100%}.mat-slider-vertical .mat-slider-thumb-container{height:100%;width:0;left:50%}.mat-slider-vertical .mat-slider-thumb{-webkit-backface-visibility:hidden;backface-visibility:hidden}.mat-slider-vertical .mat-slider-thumb-label{bottom:-14px;left:-40px;transform:translateX(26px) scale(0.01) rotate(-45deg)}.mat-slider-vertical .mat-slider-thumb-label-text{transform:rotate(45deg)}.mat-slider-vertical.cdk-focused .mat-slider-thumb-label{transform:rotate(-45deg)}[dir=rtl] .mat-slider-wrapper::after{left:0;right:auto}[dir=rtl] .mat-slider-horizontal .mat-slider-track-fill{transform-origin:100% 100%}[dir=rtl] .mat-slider-horizontal .mat-slider-track-background{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-fill{transform-origin:0 0}[dir=rtl] .mat-slider-horizontal.mat-slider-axis-inverted .mat-slider-track-background{transform-origin:100% 100%}.mat-slider._mat-animation-noopable .mat-slider-track-fill,.mat-slider._mat-animation-noopable .mat-slider-track-background,.mat-slider._mat-animation-noopable .mat-slider-ticks,.mat-slider._mat-animation-noopable .mat-slider-thumb-container,.mat-slider._mat-animation-noopable .mat-slider-focus-ring,.mat-slider._mat-animation-noopable .mat-slider-thumb,.mat-slider._mat-animation-noopable .mat-slider-thumb-label,.mat-slider._mat-animation-noopable .mat-slider-thumb-label-text,.mat-slider._mat-animation-noopable .mat-slider-has-ticks .mat-slider-wrapper::after{transition:none}\n'],encapsulation:2,changeDetection:0}),XW.ctorParameters=()=>[{type:xu},{type:TS},{type:Vm},{type:US,decorators:[{type:Ne}]},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:J_},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],XW.propDecorators={invert:[{type:f_}],max:[{type:f_}],min:[{type:f_}],step:[{type:f_}],thumbLabel:[{type:f_}],tickInterval:[{type:f_}],value:[{type:f_}],displayWith:[{type:f_}],vertical:[{type:f_}],change:[{type:h_}],input:[{type:h_}],valueChange:[{type:h_}],_sliderWrapper:[{type:Xd,args:["sliderWrapper"]}]};class KW{}KW.ɵmod=xo({type:KW}),KW.ɵinj=Ge({factory:function t(n){return new(n||KW)},imports:[[PO,tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(KW,{declarations:function(){return[XW]},imports:function(){return[PO,tE]},exports:function(){return[XW,tE]}});const $W={19:"float16",1:"float32",2:"float64",3:"int32",4:"uint8",17:"uint16",22:"uint32",23:"uint64",5:"int16",6:"int8",7:"string",8:"complex64",18:"complex128",9:"int64",10:"bool",11:"qint8",12:"quint8",15:"qint16",16:"quint16",13:"qint32",14:"bfloat16",20:"resource",21:"variant",119:"float16_ref",101:"float32_ref",102:"float64_ref",103:"int32_ref",122:"uint32_ref",104:"uint8_ref",117:"uint16_ref",105:"int16_ref",106:"int8_ref",107:"string_ref",108:"complex64_ref",118:"complex128_ref",109:"int64_ref",123:"uint64_ref",110:"bool_ref",111:"qint8_ref",112:"quint8_ref",115:"qint16_ref",116:"quint16_ref",113:"qint32_ref",114:"bfloat16_ref",120:"resource_ref",121:"variant_ref"};function tG(t){const{tensorDebugMode:n,array:e}=t;switch(n){case zU.NO_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under NO_TENSOR mode");return{};case zU.CURT_HEALTH:if(null===e||2!==e.length)throw new Error(`Under CURT_HEALTH mode, expected debug-tensor-value array to have length 2, but got ${JSON.stringify(e)}`);return{hasInfOrNaN:Boolean(e[1])};case zU.CONCISE_HEALTH:{if(null===e||5!==e.length)throw new Error(`Under CONCISE_HEALTH mode, expected debug-tensor-value array to have length 5, but got ${JSON.stringify(e)}`);const t={size:e[1]};return e[2]>0&&(t.numNegativeInfs=e[2]),e[3]>0&&(t.numPositiveInfs=e[3]),e[4]>0&&(t.numNaNs=e[4]),t}case zU.SHAPE:{if(null===e||10!==e.length)throw new Error(`Under SHAPE mode, expected debug-tensor-value array to have length 10, but got ${JSON.stringify(e)}`);const t=e[2];let n=e.slice(4,Math.min(4+t,e.length));return n.length<t&&(n=new Array(t-n.length).concat(n)),{dtype:$W[e[1]],rank:t,size:e[3],shape:n}}case zU.FULL_HEALTH:{if(null===e||11!==e.length)throw new Error(`Under FULL_HEALTH mode, expected debug-tensor-value array to have length 11, but got ${JSON.stringify(e)}`);const t={dtype:$W[e[2]],rank:e[3],size:e[4]};return e[5]>0&&(t.numNegativeInfs=e[5]),e[6]>0&&(t.numPositiveInfs=e[6]),e[7]>0&&(t.numNaNs=e[7]),e[8]>0&&(t.numNegativeFinites=e[8]),e[9]>0&&(t.numZeros=e[9]),e[10]>0&&(t.numPositiveFinites=e[10]),t}case zU.FULL_TENSOR:if(null!==e)throw new Error("Unexpectedly received non-null debug-tensor-value array under FULL_TENSOR mode");return{};default:throw new Error(`Unrecognized tensorDebugMode: ${n}`)}}const nG="[_nghost-%COMP%] {\n    background-color: #e3e5e8;\n    border: 1px solid #c0c0c0;\n    border-radius: 4px;\n    font-family: 'Roboto Mono', monospace;\n    height: 14px;\n    line-height: 14px;\n    margin: 0 2px;\n    padding: 1px 3px;\n    width: max-content;\n  }";function eG(t,n){1&t&&tp(0,"div",4)}function aG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",8),Jp(2,"NaN"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numNaNs,"")}}function oG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",8),Jp(2,"-∞"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numNegativeInfs,"")}}function rG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",8),Jp(2,"+∞"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numPositiveInfs,"")}}function iG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",10),Jp(2,"-"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numNegativeFinites,"")}}function cG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",10),Jp(2,"0"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numZeros,"")}}function sG(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span",10),Jp(2,"+"),$g(),Kg(3,"span",9),Jp(4),$g(),$g()),2&t){const t=gp(2);ws(4),Kp("×",t.numPositiveFinites,"")}}function lG(t,n){if(1&t&&(Kg(0,"div",5),Yg(1,aG,5,1,"div",6),Yg(2,oG,5,1,"div",6),Yg(3,rG,5,1,"div",6),Yg(4,iG,5,1,"div",6),Yg(5,cG,5,1,"div",6),Yg(6,sG,5,1,"div",6),$g()),2&t){const t=gp();ws(1),Jg("ngIf",void 0!==t.numNaNs&&t.numNaNs>0),ws(1),Jg("ngIf",void 0!==t.numNegativeInfs&&t.numNegativeInfs>0),ws(1),Jg("ngIf",void 0!==t.numPositiveInfs&&t.numPositiveInfs>0),ws(1),Jg("ngIf",void 0!==t.numNegativeFinites&&t.numNegativeFinites>0),ws(1),Jg("ngIf",void 0!==t.numZeros&&t.numZeros>0),ws(1),Jg("ngIf",void 0!==t.numPositiveFinites&&t.numPositiveFinites>0)}}const mG=function(t){return["container",t]};function dG(t,n){1&t&&tp(0,"debug-tensor-dtype",5),2&t&&Jg("dtype",gp().debugTensorValue.dtype)}function gG(t,n){1&t&&tp(0,"debug-tensor-rank",6),2&t&&Jg("rank",gp().debugTensorValue.rank)}function pG(t,n){1&t&&tp(0,"debug-tensor-shape",7),2&t&&Jg("shape",gp().debugTensorValue.shape)}function bG(t,n){1&t&&tp(0,"debug-tensor-has-inf-or-nan",8),2&t&&Jg("hasInfOrNaN",gp().debugTensorValue.hasInfOrNaN)}function uG(t,n){if(1&t&&tp(0,"debug-tensor-numeric-breakdown",9),2&t){const t=gp();_p("size",t.debugTensorValue.size),Jg("numNegativeInfs",t.debugTensorValue.numNegativeInfs)("numPositiveInfs",t.debugTensorValue.numPositiveInfs)("numNaNs",t.debugTensorValue.numNaNs)("numNegativeFinites",t.debugTensorValue.numNegativeFinites)("numZeros",t.debugTensorValue.numZeros)("numPositiveFinites",t.debugTensorValue.numPositiveFinites)}}class fG{}fG.ɵfac=function t(n){return new(n||fG)},fG.ɵcmp=_o({type:fG,selectors:[["debug-tensor-dtype"]],inputs:{dtype:"dtype"},decls:1,vars:1,template:function t(n,e){1&n&&Jp(0),2&n&&Kp(" ",e.dtype," ")},styles:[nG]});class hG{}hG.ɵfac=function t(n){return new(n||hG)},hG.ɵcmp=_o({type:hG,selectors:[["debug-tensor-rank"]],inputs:{rank:"rank"},decls:1,vars:1,template:function t(n,e){1&n&&Jp(0),2&n&&Kp(" ",e.rank,"D ")},styles:[nG]});class _G{get shapeString(){return"["+this.shape.map((t=>void 0===t?"?":String(t))).join(",")+"]"}}_G.ɵfac=function t(n){return new(n||_G)},_G.ɵcmp=_o({type:_G,selectors:[["debug-tensor-shape"]],inputs:{shape:"shape"},decls:1,vars:1,template:function t(n,e){1&n&&Jp(0),2&n&&Kp(" shape:",e.shapeString," ")},styles:[nG]});class CG{get breakdownExists(){return void 0!==this.numNaNs||void 0!==this.numNegativeInfs||void 0!==this.numPositiveInfs||void 0!==this.numNegativeFinites||void 0!==this.numZeros||void 0!==this.numPositiveFinites}}CG.ɵfac=function t(n){return new(n||CG)},CG.ɵcmp=_o({type:CG,selectors:[["debug-tensor-numeric-breakdown"]],inputs:{size:"size",numNaNs:"numNaNs",numNegativeInfs:"numNegativeInfs",numPositiveInfs:"numPositiveInfs",numNegativeFinites:"numNegativeFinites",numZeros:"numZeros",numPositiveFinites:"numPositiveFinites"},decls:7,vars:3,consts:[[1,"size"],[1,"size-value"],["class","break",4,"ngIf"],["class","breakdown",4,"ngIf"],[1,"break"],[1,"breakdown"],["class","category",4,"ngIf"],[1,"category"],[1,"category-tag","infinite"],[1,"category-count"],[1,"category-tag","finite"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"span"),Jp(2,"size:"),$g(),Kg(3,"span",1),Jp(4),$g(),$g(),Yg(5,eG,1,0,"div",2),Yg(6,lG,7,6,"div",3)),2&n&&(ws(4),Qp(e.size),ws(1),Jg("ngIf",e.breakdownExists),ws(1),Jg("ngIf",e.breakdownExists))},directives:[WM],styles:["[_nghost-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        font-family: 'Roboto Mono', monospace;\n        font-size: 10px;\n        margin: 0 2px;\n        padding: 1px;\n      }\n      .break[_ngcontent-%COMP%] {\n        flex-basis: 100%;\n        width: 0;\n      }\n      .size[_ngcontent-%COMP%] {\n        display: block;\n        height: 11px;\n        line-height: 11px;\n        margin: 0 3px;\n        vertical-align: middle;\n      }\n      .breakdown[_ngcontent-%COMP%] {\n        border-top: 1px solid rgba(0, 0, 0, 0.12);\n        display: flex;\n        height: 11px;\n        line-height: 11px;\n        padding: 2px;\n        vertical-align: middle;\n      }\n      .category[_ngcontent-%COMP%] {\n        margin-bottom: 2px;\n        margin-left: 4px;\n        margin-top: 2px;\n        heigth: 100%;\n        width: max-content;\n      }\n      .category-tag[_ngcontent-%COMP%] {\n        border-radius: 2px;\n        padding: 0 2px;\n      }\n      .finite[_ngcontent-%COMP%] {\n        background-color: #aaa;\n        color: #fefefe;\n      }\n      .infinite[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]});class MG{get infoString(){return this.hasInfOrNaN?"Has ∞/NaN":"No ∞/NaN"}}MG.ɵfac=function t(n){return new(n||MG)},MG.ɵcmp=_o({type:MG,selectors:[["debug-tensor-has-inf-or-nan"]],inputs:{hasInfOrNaN:"hasInfOrNaN"},decls:2,vars:4,consts:[[3,"ngClass"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Jp(1),$g()),2&n&&(Jg("ngClass",uf(2,mG,e.hasInfOrNaN?"has-inf-or-nan":"")),ws(1),Kp(" ",e.infoString," "))},directives:[HM],styles:[".container[_ngcontent-%COMP%] {\n        background-color: #e3e5e8;\n        border: 1px solid #c0c0c0;\n        border-radius: 4px;\n        color: #666666;\n        font-family: 'Roboto Mono', monospace;\n        height: 14px;\n        line-height: 14px;\n        margin: 0 2px;\n        padding: 1px 3px;\n        width: max-content;\n      }\n      .has-inf-or-nan[_ngcontent-%COMP%] {\n        background-color: #e52592;\n        color: #fff;\n      }"]});class OG{}OG.ɵfac=function t(n){return new(n||OG)},OG.ɵcmp=_o({type:OG,selectors:[["debug-tensor-value"]],inputs:{debugTensorValue:"debugTensorValue"},decls:5,vars:5,consts:[[3,"dtype",4,"ngIf"],[3,"rank",4,"ngIf"],[3,"shape",4,"ngIf"],[3,"hasInfOrNaN",4,"ngIf"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites",4,"ngIf"],[3,"dtype"],[3,"rank"],[3,"shape"],[3,"hasInfOrNaN"],[3,"size","numNegativeInfs","numPositiveInfs","numNaNs","numNegativeFinites","numZeros","numPositiveFinites"]],template:function t(n,e){1&n&&(Yg(0,dG,1,1,"debug-tensor-dtype",0),Yg(1,gG,1,1,"debug-tensor-rank",1),Yg(2,pG,1,1,"debug-tensor-shape",2),Yg(3,bG,1,1,"debug-tensor-has-inf-or-nan",3),Yg(4,uG,1,7,"debug-tensor-numeric-breakdown",4)),2&n&&(Jg("ngIf",void 0!==e.debugTensorValue.dtype),ws(1),Jg("ngIf",void 0!==e.debugTensorValue.rank),ws(1),Jg("ngIf",void 0!==e.debugTensorValue.shape),ws(1),Jg("ngIf",void 0!==e.debugTensorValue.hasInfOrNaN),ws(1),Jg("ngIf",void 0!==e.debugTensorValue.size))},directives:[WM,fG,hG,_G,MG,CG],styles:["[_nghost-%COMP%] {\n        align-items: flex-start;\n        display: flex;\n        flex-wrap: nowrap;\n        overflow: hidden;\n        vertical-align: top;\n      }\n      debug-tensor-numeric-breakdown[_ngcontent-%COMP%] {\n        display: inline-block;\n      }"]});const PG=function(t,n){return{tensorDebugMode:t,array:n}};function xG(t,n){if(1&t&&(Kg(0,"div",12),Kg(1,"div",13),Jp(2),$g(),Kg(3,"div",14),tp(4,"debug-tensor-value",15),$g(),$g()),2&t){const t=n.$implicit,e=n.index,a=gp(3);ws(2),Kp("Output slot ",e,":"),ws(2),Jg("debugTensorValue",a.parseDebugTensorValue(ff(2,PG,a.tensorDebugMode,t)))}}function yG(t,n){if(1&t&&(Kg(0,"div",10),Yg(1,xG,5,5,"div",11),$g()),2&t){const t=gp(2);ws(1),Jg("ngForOf",t.debugTensorValues)}}function kG(t,n){if(1&t&&(Kg(0,"div"),Kg(1,"div"),Kg(2,"div",3),Kg(3,"span",4),Jp(4," Op: "),$g(),Kg(5,"span",5),Jp(6),$g(),$g(),Kg(7,"div",3),Kg(8,"span",4),Jp(9," # of input tensors: "),$g(),Kg(10,"span",6),Jp(11),$g(),$g(),Kg(12,"div",3),Kg(13,"span",4),Jp(14," # of output tensors: "),$g(),Kg(15,"span",7),Jp(16),$g(),Kg(17,"span",8),Jp(18),$g(),$g(),Yg(19,yG,2,1,"div",9),$g(),$g()),2&t){const t=gp();ws(6),Kp(" ",t.focusedExecutionData.op_type," "),ws(5),Kp(" ",null==t.focusedExecutionData.input_tensor_ids?0:t.focusedExecutionData.input_tensor_ids.length," "),ws(5),Kp(" ",null==t.focusedExecutionData.output_tensor_ids?0:t.focusedExecutionData.output_tensor_ids.length," "),ws(2),Kp(" (debug mode: ",t.TensorDebugMode[t.tensorDebugMode],") "),ws(1),Jg("ngIf",t.hasDebugTensorValues)}}function vG(t,n){}class wG{constructor(){this.tensorDebugMode=zU.UNSPECIFIED,this.hasDebugTensorValues=!1,this.debugTensorValues=null,this.debugTensorDtypes=null,this.TensorDebugMode=zU,this.parseDebugTensorValue=tG}}wG.ɵfac=function t(n){return new(n||wG)},wG.ɵcmp=_o({type:wG,selectors:[["execution-data-component"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionData:"focusedExecutionData",tensorDebugMode:"tensorDebugMode",hasDebugTensorValues:"hasDebugTensorValues",debugTensorValues:"debugTensorValues",debugTensorDtypes:"debugTensorDtypes"},decls:7,vars:3,consts:[[1,"focus-execution-container"],[4,"ngIf","ngIfElse"],["loading_section",""],[1,"execution-data-field"],[1,"execution-data-key"],[1,"execution-data-value","op-type"],[1,"execution-data-value","input-tensors"],[1,"execution-data-value","output-tensors"],[1,"execution-data-value"],["class","output-slots",4,"ngIf"],[1,"output-slots"],["class","output-slot-container",4,"ngFor","ngForOf"],[1,"output-slot-container"],[1,"output-slot-number"],[1,"output-slot-debug-tensor-value"],[3,"debugTensorValue"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Kg(1,"div"),Kg(2,"span"),Jp(3),$g(),$g(),Yg(4,kG,20,5,"div",1),Yg(5,vG,0,0,"ng-template",null,2,Kf),$g()),2&n){const t=qg(6);ws(3),Kp(" Python Execution #",e.focusedExecutionIndex," "),ws(1),Jg("ngIf",null!==e.focusedExecutionData)("ngIfElse",t)}},directives:[WM,jM,OG],styles:[".debug-tensor-values-table[_ngcontent-%COMP%] {\n  width: 100%;\n}\n\n.debug-tensor-values-table[_ngcontent-%COMP%]   td[_ngcontent-%COMP%] {\n  border-top: 1px solid #000;\n  text-align: left;\n}\n\n.debug-tensor-values-table[_ngcontent-%COMP%]   th[_ngcontent-%COMP%] {\n  text-align: left;\n}\n\n.execution-data-field[_ngcontent-%COMP%] {\n  white-space: nowrap;\n}\n\n.execution-data-key[_ngcontent-%COMP%] {\n  display: inline-block;\n  max-width: 120px;\n  text-align: right;\n  width: 120px;\n}\n\n.execution-data-value[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin-left: 10px;\n}\n\n.focus-execution-container[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border-radius: 4px;\n  font-size: 12px;\n  height: 120px;\n  padding: 5px;\n  width: 360px;\n}\n\n.output-slots[_ngcontent-%COMP%] {\n  height: 60px;\n  overflow-x: auto;\n  overflow-y: auto;\n}\n\n.output-slot-container[_ngcontent-%COMP%] {\n  border-top: 1px solid rgba(0, 0, 0, 0.12);\n  margin-top: 5px;\n  padding: 2px 0;\n  vertical-align: top;\n}\n\n.output-slot-number[_ngcontent-%COMP%] {\n  display: block;\n  font-family: 'Roboto Mono', monospace;\n}\n\n.output-slot-debug-tensor-value[_ngcontent-%COMP%] {\n  display: block;\n  margin: 3px 0 3px 30px;\n}\n\n.output-tensors[_ngcontent-%COMP%] {\n  margin-top: 5px;\n}"]});const SG="Unknown dtype";class EG{constructor(t){this.store=t,this.focusedExecutionData$=this.store.pipe(lv(AW)),this.tensorDebugMode$=this.store.pipe(lv(pv(AW,(t=>null===t?zU.UNSPECIFIED:t.tensor_debug_mode)))),this.hasDebugTensorValues$=this.store.pipe(lv(pv(AW,(t=>{if(null===t||null===t.debug_tensor_values)return!1;for(const n of t.debug_tensor_values)if(null!==n&&n.length>0)return!0;return!1})))),this.debugTensorValues$=this.store.pipe(lv(pv(AW,(t=>null===t?null:t.debug_tensor_values)))),this.debugTensorDtypes$=this.store.pipe(lv(pv(AW,(t=>{if(null===t||null===t.debug_tensor_values)return null;if(t.tensor_debug_mode!==zU.FULL_HEALTH&&t.tensor_debug_mode!==zU.SHAPE)return null;const n=[];for(const e of t.debug_tensor_values)if(null===e)n.push(SG);else{const a=String(t.tensor_debug_mode===zU.FULL_HEALTH?e[2]:e[1]);n.push($W[a]||SG)}return n}))))}}function AG(t,n){if(1&t){const t=op();Kg(0,"mat-slider",11),cp("input",(function n(e){return jr(t),gp(2).onSliderChange.emit(e.value)})),$g()}if(2&t){const t=gp(2);Jg("min",0)("max",t.scrollBeginIndexUpperLimit)("value",t.scrollBeginIndex)}}function zG(t,n){if(1&t){const t=op();Kg(0,"div",6),Kg(1,"button",7),cp("click",(function n(){return jr(t),gp().onNavigateLeft.emit()})),Jp(2," < "),$g(),Kg(3,"div",8),Jp(4),$g(),Kg(5,"button",9),cp("click",(function n(){return jr(t),gp().onNavigateRight.emit()})),Jp(6," > "),$g(),Yg(7,AG,1,3,"mat-slider",10),$g()}if(2&t){const t=gp();ws(4),tb(" ",t.scrollBeginIndex," ~ ",t.scrollBeginIndex+t.displayCount-1," of ",t.numExecutions," "),ws(3),Jg("ngIf",t.scrollBeginIndexUpperLimit>0)}}EG.ɵfac=function t(n){return new(n||EG)(Zg(cv))},EG.ɵcmp=_o({type:EG,selectors:[["tf-debugger-v2-execution-data"]],inputs:{focusedExecutionIndex:"focusedExecutionIndex"},decls:6,vars:16,consts:[[3,"focusedExecutionIndex","focusedExecutionData","tensorDebugMode","hasDebugTensorValues","debugTensorValues","debugTensorDtypes"]],template:function t(n,e){1&n&&(tp(0,"execution-data-component",0),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async")),2&n&&Jg("focusedExecutionIndex",e.focusedExecutionIndex)("focusedExecutionData",kf(1,6,e.focusedExecutionData$))("tensorDebugMode",kf(2,8,e.tensorDebugMode$))("hasDebugTensorValues",kf(3,10,e.hasDebugTensorValues$))("debugTensorValues",kf(4,12,e.debugTensorValues$))("debugTensorDtypes",kf(5,14,e.debugTensorDtypes$))},directives:[wG],pipes:[oO],encapsulation:2});const RG=function(t,n,e){return[t,n,e]};function TG(t,n){if(1&t){const t=op();Kg(0,"div",14),cp("click",(function e(){jr(t);const a=n.index;return gp(2).onExecutionDigestClicked.emit(a)})),Kg(1,"div",15),Jp(2),$g(),$g()}if(2&t){const t=n.$implicit,e=n.index,a=gp(2);ws(1),_p("title",t.op_type),Jg("ngClass",hf(3,RG,t.is_graph?"func-graph-execution":"",e===a.focusedExecutionDisplayIndex?"focused":"",a.displayFocusedAlertTypes[e]||"")),ws(1),Kp(" ",t.short_op_type," ")}}function DG(t,n){if(1&t&&(Kg(0,"div",12),Yg(1,TG,3,7,"div",13),$g()),2&t){const t=gp();ws(1),Jg("ngForOf",t.displayExecutionDigests)}}function IG(t,n){if(1&t&&(np(0),tp(1,"tf-debugger-v2-execution-data",16),ep()),2&t){const t=gp();ws(1),Jg("focusedExecutionIndex",t.focusedExecutionIndex)}}class NG{constructor(){this.activeRunId=null,this.loadingNumExecutions=!1,this.numExecutions=0,this.scrollBeginIndex=0,this.scrollBeginIndexUpperLimit=0,this.pageSize=0,this.displayCount=0,this.displayExecutionDigests=[],this.displayFocusedAlertTypes=[],this.focusedExecutionIndex=null,this.focusedExecutionDisplayIndex=null,this.focusedExecutionData=null,this.onNavigateLeft=new Ef,this.onNavigateRight=new Ef,this.onExecutionDigestClicked=new Ef,this.onSliderChange=new Ef}}NG.ɵfac=function t(n){return new(n||NG)},NG.ɵcmp=_o({type:NG,selectors:[["timeline-component"]],inputs:{activeRunId:"activeRunId",loadingNumExecutions:"loadingNumExecutions",numExecutions:"numExecutions",scrollBeginIndex:"scrollBeginIndex",scrollBeginIndexUpperLimit:"scrollBeginIndexUpperLimit",pageSize:"pageSize",displayCount:"displayCount",displayExecutionDigests:"displayExecutionDigests",displayFocusedAlertTypes:"displayFocusedAlertTypes",focusedExecutionIndex:"focusedExecutionIndex",focusedExecutionDisplayIndex:"focusedExecutionDisplayIndex",focusedExecutionData:"focusedExecutionData"},outputs:{onNavigateLeft:"onNavigateLeft",onNavigateRight:"onNavigateRight",onExecutionDigestClicked:"onExecutionDigestClicked",onSliderChange:"onSliderChange"},decls:9,vars:4,consts:[[1,"timeline-title"],[1,"execution-count"],[1,"top-level-executions"],["class","navigation-section",4,"ngIf"],["class","execution-timeline",4,"ngIf"],[4,"ngIf"],[1,"navigation-section"],["mat-button","",1,"navigation-button-left",3,"click"],[1,"navigation-position-info"],["mat-button","",1,"navigation-button-right",3,"click"],["class","timeline-slider","step","1",3,"min","max","value","input",4,"ngIf"],["step","1",1,"timeline-slider",3,"min","max","value","input"],[1,"execution-timeline"],[3,"click",4,"ngFor","ngForOf"],[3,"click"],[1,"execution-digest",3,"ngClass","title"],[3,"focusedExecutionIndex"]],template:function t(n,e){1&n&&(Kg(0,"div"),Kg(1,"div",0),Jp(2," Python Execution Timeline "),Kg(3,"span",1),Jp(4),$g(),$g(),Kg(5,"div",2),Yg(6,zG,8,4,"div",3),Yg(7,DG,2,1,"div",4),Yg(8,IG,2,1,"ng-container",5),$g(),$g()),2&n&&(ws(4),Kp(" (",e.numExecutions,") "),ws(2),Jg("ngIf",e.numExecutions),ws(1),Jg("ngIf",e.numExecutions),ws(1),Jg("ngIf",null!==e.activeRunId&&null!==e.focusedExecutionIndex))},directives:[WM,eA,XW,jM,HM,EG],styles:[".execution-digest[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  color: #425066;\n  display: inline-block;\n  font-size: 10px;\n  height: 15px;\n  padding: 1px;\n  text-align: center;\n  vertical-align: middle;\n  width: 12px;\n}\n\n.execution-digest.func-graph-execution[_ngcontent-%COMP%] {\n  background-color: #c7dbf5;\n  color: #4e5664;\n  text-decoration: underline;\n}\n\n.execution-digest.focused[_ngcontent-%COMP%] {\n  background-color: #ffd4b3;\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-digest.InfNanAlert[_ngcontent-%COMP%] {\n  background-color: #e52592;\n  color: #fff;\n}\n\n\n.execution-digest[_ngcontent-%COMP%]:hover {\n  border: 1px solid #000;\n  font-weight: bold;\n}\n\n.execution-timeline[_ngcontent-%COMP%] {\n  display: flex;\n  overflow-x: hidden;\n  white-space: nowrap;\n  width: 100%;\n  margin-top: 5px;\n  margin-bottom: 5px;\n}\n\n.timeline-slider[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 48px;\n  left: 340px; \n  padding: 0;\n  position: absolute;\n  right: 40px;\n}\n\n  .timeline-slider .mat-slider-thumb {\n  border-radius: 5px;\n  right: -40px;\n  width: 80px;\n}\n\n\n.navigation-position-info[_ngcontent-%COMP%] {\n  display: inline-flex;\n  font-size: 14px;\n  line-height: normal;\n  max-width: 200px;\n  padding-left: 10px;\n  padding-right: 10px;\n  text-align: center;\n  vertical-align: middle;\n}\n\n.navigation-section[_ngcontent-%COMP%] {\n  height: 48px;\n  line-height: 48px;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}"],changeDetection:0});const FG=["__forward_","__backward_","__inference_"];class LG{constructor(t){this.store=t,this.activeRunId$=this.store.pipe(lv(GU)),this.loadingNumExecutions$=this.store.pipe(lv(pv(nW,(t=>t.state==fR.LOADING)))),this.scrollBeginIndex$=this.store.pipe(lv(oW)),this.scrollBeginIndexUpperLimit$=this.store.pipe(lv(pv(aW,iW,((t,n)=>Math.max(0,t-n))))),this.pageSize$=this.store.pipe(lv(rW)),this.displayCount$=this.store.pipe(lv(iW)),this.displayExecutionDigests$=this.store.pipe(lv(pv(cW,(t=>t.map((t=>(function n(t,e=1){if(!t)return{op_type:"(N/A)",short_op_type:"..",is_graph:!1};const a=FG.filter((n=>t.op_type.startsWith(n)));if(a.length){const n=t.op_type.slice(a[0].length);return{op_type:t.op_type,short_op_type:n.slice(0,e),is_graph:!0}}return{op_type:t.op_type,short_op_type:t.op_type.slice(0,e),is_graph:!1}})(t))))))),this.displayFocusedAlertTypes$=this.store.pipe(lv(xW)),this.focusedExecutionIndex$=this.store.pipe(lv(kW)),this.focusedExecutionDisplayIndex$=this.store.pipe(lv(vW)),this.numExecutions$=this.store.pipe(lv(aW))}onNavigateLeft(){this.store.dispatch(mU())}onNavigateRight(){this.store.dispatch(dU())}onExecutionDigestClicked(t){this.store.dispatch(pU({displayIndex:t}))}onSliderChange(t){this.store.dispatch(gU({index:t}))}}function HG(t,n){1&t&&(Kg(0,"span"),Jp(1," Output "),$g())}function BG(t,n){1&t&&(Kg(0,"span"),Jp(1," Input "),$g())}function VG(t,n){if(1&t&&(Kg(0,"div",6),Kg(1,"span",7),Yg(2,HG,2,0,"span",8),Yg(3,BG,2,0,"span",8),$g(),Jp(4),$g()),2&t){const t=gp();ws(1),Jg("ngSwitch",t.kind),ws(1),Jg("ngSwitchCase","input"),ws(1),Jg("ngSwitchCase","consumer"),ws(1),Kp(" slot: ",t.slot," ")}}function jG(t,n){if(1&t&&(Kg(0,"div",9),Jp(1),$g()),2&t){const t=gp();ws(1),Kp(" ",t.opData.op_type," ")}}function UG(t,n){1&t&&(Kg(0,"span",10),Jp(1," (Op info unavailable.) "),$g())}LG.ɵfac=function t(n){return new(n||LG)(Zg(cv))},LG.ɵcmp=_o({type:LG,selectors:[["tf-debugger-v2-timeline"]],decls:12,vars:33,consts:[[3,"activeRunId","loadingNumExecutions","numExecutions","scrollBeginIndex","scrollBeginIndexUpperLimit","pageSize","displayCount","displayExecutionDigests","displayFocusedAlertTypes","focusedExecutionIndex","focusedExecutionDisplayIndex","onNavigateLeft","onNavigateRight","onExecutionDigestClicked","onSliderChange"]],template:function t(n,e){1&n&&(Kg(0,"timeline-component",0),cp("onNavigateLeft",(function t(){return e.onNavigateLeft()}))("onNavigateRight",(function t(){return e.onNavigateRight()}))("onExecutionDigestClicked",(function t(n){return e.onExecutionDigestClicked(n)}))("onSliderChange",(function t(n){return e.onSliderChange(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),yf(10,"async"),yf(11,"async"),$g()),2&n&&Jg("activeRunId",kf(1,11,e.activeRunId$))("loadingNumExecutions",kf(2,13,e.loadingNumExecutions$))("numExecutions",kf(3,15,e.numExecutions$))("scrollBeginIndex",kf(4,17,e.scrollBeginIndex$))("scrollBeginIndexUpperLimit",kf(5,19,e.scrollBeginIndexUpperLimit$))("pageSize",kf(6,21,e.pageSize$))("displayCount",kf(7,23,e.displayCount$))("displayExecutionDigests",kf(8,25,e.displayExecutionDigests$))("displayFocusedAlertTypes",kf(9,27,e.displayFocusedAlertTypes$))("focusedExecutionIndex",kf(10,29,e.focusedExecutionIndex$))("focusedExecutionDisplayIndex",kf(11,31,e.focusedExecutionDisplayIndex$))},directives:[NG],pipes:[oO],encapsulation:2,changeDetection:0});const WG=function(t){return[t]};class GG{constructor(){this.onOpNameClick=new Ef}}function YG(t,n){if(1&t){const t=op();Kg(0,"div",13),Kg(1,"div",14),Jp(2),$g(),Kg(3,"graph-op",15),cp("onOpNameClick",(function n(e){jr(t);const a=gp(3);return a.onGraphOpNavigate.emit({op_name:e.op_name,graph_id:a.graphId})})),$g(),$g()}if(2&t){const t=n.$implicit,e=n.index;ws(2),Kp("Input slot ",e,":"),ws(1),Jg("kind","input")("opName",t.op_name)("slot",t.output_slot)("opData",t.data)}}function qG(t,n){if(1&t&&(Kg(0,"div",11),Kg(1,"div"),Yg(2,YG,4,5,"div",12),$g(),$g()),2&t){const t=gp(2);ws(2),Jg("ngForOf",t.inputOps)}}function ZG(t,n){1&t&&(Kg(0,"div",16),Jp(1," (This op has no input tensor.) "),$g())}function XG(t,n){if(1&t){const t=op();Kg(0,"div",23),Kg(1,"graph-op",15),cp("onOpNameClick",(function n(e){jr(t);const a=gp(4);return a.onGraphOpNavigate.emit({op_name:e.op_name,graph_id:a.graphId})})),$g(),$g()}if(2&t){const t=n.$implicit;ws(1),Jg("kind","consumer")("opName",t.op_name)("slot",t.input_slot)("opData",t.data)}}function JG(t,n){if(1&t&&(Kg(0,"div",19),Kg(1,"div",20),Jp(2),Kg(3,"span"),su(4,21),$g(),Jp(5,") "),$g(),Yg(6,XG,2,4,"div",22),$g()),2&t){const t=n.$implicit,e=n.index;ws(2),$p(" Output slot ",e,": (",t.length," "),ws(2),mu(t.length),du(4),ws(2),Jg("ngForOf",t)}}function QG(t,n){if(1&t&&(Kg(0,"div",17),Kg(1,"div"),Yg(2,JG,7,4,"div",18),$g(),$g()),2&t){const t=gp(2);ws(2),Jg("ngForOf",t.consumerOps)}}function KG(t,n){if(1&t&&(Kg(0,"div",24),Jp(1),Kg(2,"span"),su(3,25),$g(),Jp(4," and no consumer.) "),$g()),2&t){const t=gp(2);ws(1),Kp(" (This op has ",t.opInfo.consumers.length," output "),ws(2),mu(t.opInfo.consumers.length),du(3)}}function $G(t,n){if(1&t){const t=op();Kg(0,"div"),Yg(1,qG,3,1,"div",4),Yg(2,ZG,2,0,"ng-template",null,5,Kf),Kg(4,"div",6),Kg(5,"div",7),Jp(6,"Op:"),$g(),Kg(7,"graph-op",8),cp("onOpNameClick",(function n(e){jr(t);const a=gp();return a.onGraphOpNavigate.emit({op_name:e.op_name,graph_id:a.graphId})})),$g(),$g(),Yg(8,QG,3,1,"div",9),Yg(9,KG,5,2,"ng-template",null,10,Kf),$g()}if(2&t){const t=qg(3),n=qg(10),e=gp();ws(1),Jg("ngIf",e.inputOps.length>0)("ngIfElse",t),ws(6),Jg("kind","self")("opName",e.opInfo.op_name)("opData",e.opInfo),ws(1),Jg("ngIf",e.totalNumConsumers>0)("ngIfElse",n)}}function tY(t,n){1&t&&(Kg(0,"span",26),Jp(1," (Op info unavailable.) "),$g())}function nY(t,n){1&t&&(Kg(0,"div",27),Jp(1," No graph op selected. Click a tensor name in the Graph Executions table to view the neighborhood of the tensor's op in its graph. "),$g())}GG.ɵfac=function t(n){return new(n||GG)},GG.ɵcmp=_o({type:GG,selectors:[["graph-op"]],inputs:{kind:"kind",opName:"opName",slot:"slot",opData:"opData"},outputs:{onOpNameClick:"onOpNameClick"},decls:9,vars:7,consts:[[1,"op-container"],[1,"input-tensor-name"],[1,"op-name",3,"ngClass","click"],["class","slot",4,"ngIf"],["class","op-type",4,"ngIf","ngIfElse"],["opInfoMissing",""],[1,"slot"],[3,"ngSwitch"],[4,"ngSwitchCase"],[1,"op-type"],[1,"op-info-missing"]],template:function t(n,e){if(1&n&&(Kg(0,"button",0),Kg(1,"div",1),Kg(2,"button",2),cp("click",(function t(){return e.onOpNameClick.emit({op_name:e.opName})})),Kg(3,"span"),Jp(4),$g(),$g(),Yg(5,VG,5,4,"div",3),$g(),Yg(6,jG,2,1,"div",4),Yg(7,UG,2,0,"ng-template",null,5,Kf),$g()),2&n){const t=qg(8);ws(2),Jg("ngClass",uf(5,WG,"self"===e.kind?"self-op-name":"")),ws(2),Qp(e.opName),ws(1),Jg("ngIf","self"!==e.kind),ws(1),Jg("ngIf",void 0!==e.opData)("ngIfElse",t)}},directives:[HM,WM,ZM,XM],styles:[".op-container[_ngcontent-%COMP%] {\n  background-color: transparent;\n  border: 2px solid #c6cad1;\n  border-radius: 4px;\n  box-shadow: 1px 3px #eee;\n  cursor: pointer;\n  margin: 0 5px 0 0;\n  padding: 2px 6px;\n  text-align: right;\n  width: 200px;\n}\n\n.op-container[_ngcontent-%COMP%]:focus {\n  outline: 0;\n}\n\n.op-container[_ngcontent-%COMP%]:hover {\n  border: 2px solid #ffd3b2;\n}\n\n.op-info-missing[_ngcontent-%COMP%] {\n  color: #808080;\n}\n\n.op-name[_ngcontent-%COMP%] {\n  background-color: transparent;\n  border: none;\n  cursor: pointer;\n  display: inline-block;\n  overflow-wrap: anywhere;\n  padding: 0;\n  text-align: right;\n  text-decoration: underline;\n  white-space: pre-wrap;\n}\n\n.op-name[_ngcontent-%COMP%]:focus {\n  outline: 0;\n}\n\n.op-type[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  border-radius: 4px;\n  display: inline-block;\n  font-family: 'Roboto Mono', monospace;\n  font-size: 10px;\n  height: 14px;\n  line-height: 14px;\n  margin-top: 3px;\n  padding: 1px 3px;\n  width: max-content;\n}\n\n.self-op-name[_ngcontent-%COMP%] {\n  font-weight: bold;\n  text-decoration: none;\n}\n\n.slot[_ngcontent-%COMP%] {\n  color: #707070;\n}"]});class eY{constructor(){this.onGraphOpNavigate=new Ef}get graphId(){return this.opInfo.graph_ids[this.opInfo.graph_ids.length-1]}get totalNumConsumers(){return this.consumerOps.reduce(((t,n)=>t+n.length),0)}}eY.ɵfac=function t(n){return new(n||eY)},eY.ɵcmp=_o({type:eY,selectors:[["graph-component"]],inputs:{opInfo:"opInfo",inputOps:"inputOps",consumerOps:"consumerOps"},outputs:{onGraphOpNavigate:"onGraphOpNavigate"},decls:9,vars:2,consts:function(){var t,n,e;return t=gu(t="undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}"):$localize`:␟fe55f9b193ea20aae5b5635e68d9386503847746␟4955133740841299851:{VAR_PLURAL, plural, =0 {consumer} =1 {consumer} other {consumers}}`,{VAR_PLURAL:"�0�"}),n="undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg(" {$icu}",{icu:t}):$localize`:␟baa460e2f2b857e26292b246fc18ae0ea9b5e537␟5556340343850165516: ${t}:ICU:`,e=gu(e="undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}"):$localize`:␟6aa75f627e0dc16150ef448464e0c857aaa0dc18␟5156712935150586878:{VAR_PLURAL, plural, =0 {tensor} =1 {tensor} other {tensors}}`,{VAR_PLURAL:"�0�"}),[[1,"graph-structure-container"],[4,"ngIf","ngIfElse"],["opInfoMissing",""],["noOpFocused",""],["class","inputs-container",4,"ngIf","ngIfElse"],["noInputs",""],[1,"self-op-container"],[1,"self-op-header"],[3,"kind","opName","opData","onOpNameClick"],["class","consumers-container",4,"ngIf","ngIfElse"],["noConsumers",""],[1,"inputs-container"],["class","input-op-section",4,"ngFor","ngForOf"],[1,"input-op-section"],[1,"input-slot-header"],[3,"kind","opName","slot","opData","onOpNameClick"],[1,"inputs-container","no-inputs-indicator"],[1,"consumers-container"],["class","slot-consumers-container",4,"ngFor","ngForOf"],[1,"slot-consumers-container"],[1,"slot-consumers-header"],n,["class","consumer-section",4,"ngFor","ngForOf"],[1,"consumer-section"],[1,"op-consumers-container"],"undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg(" {$icu}",{icu:e}):$localize`:␟893476c2c421cee47663c9732fa41a750d3a73df␟246067053735162634: ${e}:ICU:`,[1,"op-info-missing"],[1,"no-op-focused"]]},template:function t(n,e){if(1&n&&(Kg(0,"div"),Kg(1,"div"),Jp(2,"Graph Structure"),$g(),Kg(3,"div",0),Yg(4,$G,11,7,"div",1),$g(),Yg(5,tY,2,0,"ng-template",null,2,Kf),Yg(7,nY,2,0,"ng-template",null,3,Kf),$g()),2&n){const t=qg(8);ws(4),Jg("ngIf",null!=e.opInfo)("ngIfElse",t)}},directives:[WM,GG,jM],styles:["[_nghost-%COMP%] {\n  overflow-y: auto;\n}\n\n.consumers-container[_ngcontent-%COMP%] {\n  padding-bottom: 5px;\n  overflow-x: auto;\n  white-space: nowrap;\n}\n\n.consumer-section[_ngcontent-%COMP%] {\n  display: block;\n  margin: 5px 0;\n}\n\n.graph-structure-container[_ngcontent-%COMP%] {\n  font-size: 12px;\n  overflow-y: auto;\n  white-space: nowrap;\n}\n\n.inputs-container[_ngcontent-%COMP%] {\n  border-bottom: 1px solid rgb(0, 0, 0, 0.12);\n  margin-top: 5px;\n  overflow-x: auto;\n  padding-bottom: 0;\n  white-space: nowrap;\n}\n\n.input-op-section[_ngcontent-%COMP%] {\n  border-right: 1px solid rgb(0, 0, 0, 0.12);\n  display: inline-block;\n  margin-right: 5px;\n  padding-bottom: 5px;\n}\n\n.input-slot-header[_ngcontent-%COMP%] {\n  \n  background-color: #fff099;\n  margin-bottom: 5px;\n}\n\n.input-tensor-name[_ngcontent-%COMP%] {\n  display: block;\n  white-space: nowrap;\n}\n\n.no-op-focused[_ngcontent-%COMP%] {\n  color: #808080;\n  font-family: 'Roboto', Arial, Helvetica, sans-serif;\n  font-size: 13px;\n  white-space: normal;\n}\n\n.self-op-header[_ngcontent-%COMP%] {\n  font-weight: bold;\n  margin-bottom: 5px;\n}\n\n.self-op-container[_ngcontent-%COMP%] {\n  border-bottom: 1px solid rgb(0, 0, 0, 0.12);\n  padding-bottom: 5px;\n}\n\n.slot-consumers-container[_ngcontent-%COMP%] {\n  border-right: 1px solid rgb(0, 0, 0, 0.12);\n  display: inline-block;\n  margin-right: 5px;\n  padding-top: 5px;\n  vertical-align: top;\n}\n\n.slot-consumers-header[_ngcontent-%COMP%] {\n  white-space: nowrap;\n}"],changeDetection:0});class aY{constructor(t){this.store=t,this.opInfo$=this.store.pipe(lv(CW)),this.inputOps$=this.store.pipe(lv(MW)),this.consumerOps$=this.store.pipe(lv(PW))}onGraphOpNavigate(t){this.store.dispatch(OU(t))}}function oY(t,n){1&t&&(Kg(0,"div",12),Jp(1,"▶"),$g())}aY.ɵfac=function t(n){return new(n||aY)(Zg(cv))},aY.ɵcmp=_o({type:aY,selectors:[["tf-debugger-v2-graph"]],decls:4,vars:9,consts:[[3,"opInfo","inputOps","consumerOps","onGraphOpNavigate"]],template:function t(n,e){1&n&&(Kg(0,"graph-component",0),cp("onGraphOpNavigate",(function t(n){return e.onGraphOpNavigate(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("opInfo",kf(1,3,e.opInfo$))("inputOps",kf(2,5,e.inputOps$))("consumerOps",kf(3,7,e.consumerOps$))},directives:[eY],pipes:[oO],encapsulation:2});const rY=function(t,n){return{tensorDebugMode:t,array:n}};function iY(t,n){if(1&t&&tp(0,"debug-tensor-value",17),2&t){const t=gp(2).$implicit,n=gp(2);Jg("debugTensorValue",n.parseDebugTensorValue(ff(1,rY,n.graphExecutionData[t].tensor_debug_mode,n.graphExecutionData[t].debug_tensor_value)))}}function cY(t,n){if(1&t){const t=op();Kg(0,"div"),Kg(1,"div",13),Kg(2,"button",14),cp("click",(function n(){jr(t);const e=gp().$implicit,a=gp(2);return a.onTensorNameClick.emit({index:e,graph_id:a.graphExecutionData[e].graph_id,op_name:a.graphExecutionData[e].op_name})})),Jp(3),$g(),Kg(4,"div",15),Jp(5),$g(),$g(),Yg(6,iY,1,4,"debug-tensor-value",16),$g()}if(2&t){const t=gp().$implicit,n=gp(2);ws(2),_p("title",n.getTensorName(t)),ws(1),Kp(" ",n.getTensorName(t)," "),ws(2),Qp(n.graphExecutionData[t].op_type),ws(1),Jg("ngIf",null!==n.graphExecutionData[t].debug_tensor_value)}}function sY(t,n){1&t&&(Kg(0,"div",18),Jp(1," Loading... "),$g())}const lY=function(t){return{"input-of-focus":t}};function mY(t,n){if(1&t&&(Kg(0,"div",5),Kg(1,"div",6),Kg(2,"div",7),Yg(3,oY,2,0,"div",8),Jp(4),$g(),Yg(5,cY,7,4,"div",9),Yg(6,sY,2,0,"ng-template",10,11,Kf),$g(),$g()),2&t){const t=n.$implicit,e=qg(7),a=gp(2);ws(1),Jg("ngClass",uf(5,lY,a.isInputOfFocus(t))),ws(2),Jg("ngIf",t===a.focusIndex),ws(1),Kp(" ",t," "),ws(1),Jg("ngIf",a.graphExecutionData[t])("ngIfElse",e)}}function dY(t,n){if(1&t){const t=op();Kg(0,"cdk-virtual-scroll-viewport",3),cp("scrolledIndexChange",(function n(e){return jr(t),gp().onScrolledIndexChange.emit(e)})),Yg(1,mY,8,7,"div",4),$g()}if(2&t){const t=gp();ws(1),Jg("cdkVirtualForOf",t.graphExecutionIndices)}}class gY{constructor(){this.onScrolledIndexChange=new Ef,this.onTensorNameClick=new Ef,this.parseDebugTensorValue=tG,this.TEST_ONLY={getViewPort:()=>this.viewPort}}ngOnChanges(t){if(this.viewPort&&t.focusIndex&&null!==t.focusIndex.currentValue){const n=this.viewPort.getRenderedRange(),e=t.focusIndex.currentValue,a=Math.round((n.end-n.start)/3),o=Math.max(e-a,0);this.viewPort.scrollToIndex(o,e>=n.start&&e<n.end?"smooth":void 0)}}getTensorName(t){return`${this.graphExecutionData[t].op_name}:${this.graphExecutionData[t].output_slot}`}isInputOfFocus(t){return null!==this.focusInputIndices&&this.focusInputIndices.includes(t)}}gY.ɵfac=function t(n){return new(n||gY)},gY.ɵcmp=_o({type:gY,selectors:[["graph-executions-component"]],viewQuery:function t(n,e){var a;1&n&&Uf(PA,!0),2&n&&Vf(a=Zf())&&(e.viewPort=a.first)},inputs:{numGraphExecutions:"numGraphExecutions",graphExecutionData:"graphExecutionData",graphExecutionIndices:"graphExecutionIndices",focusIndex:"focusIndex",focusInputIndices:"focusInputIndices"},outputs:{onScrolledIndexChange:"onScrolledIndexChange",onTensorNameClick:"onTensorNameClick"},features:[pr],decls:4,vars:2,consts:[[1,"graph-executions-container"],[1,"graph-executions-title"],["itemSize","38","class","graph-executions-viewport",3,"scrolledIndexChange",4,"ngIf"],["itemSize","38",1,"graph-executions-viewport",3,"scrolledIndexChange"],["class","tensor-container",4,"cdkVirtualFor","cdkVirtualForOf"],[1,"tensor-container"],[1,"tensor-item",3,"ngClass"],[1,"graph-execution-index"],["class","graph-execution-focus",4,"ngIf"],[4,"ngIf","ngIfElse"],["class","tensor-item"],["dataLoading",""],[1,"graph-execution-focus"],[1,"tensor-name-and-op-type"],[1,"tensor-name",3,"title","click"],[1,"op-type"],[3,"debugTensorValue",4,"ngIf"],[3,"debugTensorValue"],[1,"loading-spinner"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"div",1),Jp(2),$g(),Yg(3,dY,2,1,"cdk-virtual-scroll-viewport",2),$g()),2&n&&(ws(2),Kp(" Graph Executions (",e.numGraphExecutions,") "),ws(1),Jg("ngIf",null!==e.numGraphExecutions&&e.numGraphExecutions>0))},directives:[WM,PA,fA,yA,HM,OG],styles:[".graph-executions-container[_ngcontent-%COMP%] {\n  border-left: 1px solid rgba(0, 0, 0, 0.12);\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n  margin-left: 8px;\n  padding-left: 10px;\n}\n\n.graph-execution-focus[_ngcontent-%COMP%] {\n  display: inline-block;\n}\n\n.graph-execution-index[_ngcontent-%COMP%] {\n  color: #757575;\n  display: inline-block;\n  padding-right: 4px;\n  text-align: right;\n  width: 40px;\n}\n\n.graph-executions-title[_ngcontent-%COMP%] {\n  box-shadow: 0 5px 3px -3px #ccc;\n  padding-bottom: 5px;\n}\n\n.graph-executions-viewport[_ngcontent-%COMP%] {\n  flex-grow: 1;\n  font-size: 12px;\n  width: 100%;\n  overflow-x: hidden;\n}\n\n.input-of-focus[_ngcontent-%COMP%] {\n  \n  background-color: #fff099;\n}\n\n.loading-spinner[_ngcontent-%COMP%] {\n  display: inline-block;\n}\n\n.op-type[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  border-radius: 4px;\n  direction: rtl;\n  display: block;\n  font-family: 'Roboto Mono', monospace;\n  font-size: 10px;\n  height: 14px;\n  line-height: 14px;\n  padding: 1px 3px;\n  width: max-content;\n}\n\n.tensor-container[_ngcontent-%COMP%] {\n  width: 100%;\n}\n\n.tensor-item[_ngcontent-%COMP%] {\n  border-bottom: 1px solid rgba(0, 0, 0, 0.12);\n  display: flex;\n  flex-wrap: nowrap;\n  height: 38px;\n  line-height: 38px;\n  text-align: left;\n  vertical-align: middle;\n  white-space: nowrap;\n  width: 100%;\n}\n\n.tensor-name[_ngcontent-%COMP%] {\n  background-color: transparent;\n  border: none;\n  box-sizing: border-box;\n  cursor: pointer;\n  direction: rtl;\n  display: block;\n  height: 16px;\n  line-height: 16px;\n  margin: 2px 0 1px;\n  max-width: calc(100% - 2px);\n  overflow: hidden;\n  padding: 0 2px;\n  text-align: right;\n  text-decoration: underline;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.tensor-name[_ngcontent-%COMP%]:focus {\n  outline: 1px solid #c6cad1;\n}\n\n.tensor-name-and-op-type[_ngcontent-%COMP%] {\n  direction: rtl;\n  display: inline-block;\n  overflow: hidden;\n  padding-right: 8px;\n  text-align: right;\n  width: 240px;\n}\n\ndebug-tensor-value[_ngcontent-%COMP%] {\n  display: inline-block;\n  margin: 2px 0;\n}"],changeDetection:0});class pY{constructor(t){this.store=t,this.numGraphExecutions$=this.store.pipe(lv(mW)),this.graphExecutionData$=this.store.pipe(lv(fW)),this.graphExecutionIndices$=this.store.pipe(lv(pv(mW,(t=>0===t?null:Array.from({length:t}).map(((t,n)=>n)))))),this.focusIndex$=this.store.pipe(lv(hW)),this.focusInputIndices$=this.store.pipe(lv(OW))}onScrolledIndexChange(t){this.store.dispatch(CU({index:t}))}onTensorNameClick(t){this.store.dispatch(MU(t))}}pY.ɵfac=function t(n){return new(n||pY)(Zg(cv))},pY.ɵcmp=_o({type:pY,selectors:[["tf-debugger-v2-graph-executions"]],decls:6,vars:15,consts:[[3,"numGraphExecutions","graphExecutionData","graphExecutionIndices","focusIndex","focusInputIndices","onScrolledIndexChange","onTensorNameClick"]],template:function t(n,e){1&n&&(Kg(0,"graph-executions-component",0),cp("onScrolledIndexChange",(function t(n){return e.onScrolledIndexChange(n)}))("onTensorNameClick",(function t(n){return e.onTensorNameClick(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),$g()),2&n&&Jg("numGraphExecutions",kf(1,5,e.numGraphExecutions$))("graphExecutionData",kf(2,7,e.graphExecutionData$))("graphExecutionIndices",kf(3,9,e.graphExecutionIndices$))("focusIndex",kf(4,11,e.focusIndex$))("focusInputIndices",kf(5,13,e.focusInputIndices$))},directives:[gY],pipes:[oO],encapsulation:2});const bY=function uY(){return window};function fY(t){const n=bY().require;return new Promise((e=>{n(t,e)}))}function hY(){return CR(this,void 0,void 0,(function*(){const t=bY();if(void 0===t.monaco){if(!t.require)throw new Error("loadMonaco() failed because function require() is unavailable");t.require.config({paths:{vs:"/tf-imports/vs"}}),yield fY(["vs/editor/editor.main"]),yield fY(["vs/python/python.contribution"])}}))}class _Y{constructor(t){this.resizeEventDebouncePeriodInMs=100,this.onResize=new Ef,this.ngUnsubscribe$=new x,this.onResize$=new x;const n=new ResizeObserver((()=>{this.onResize$.next()}));n.observe(t.nativeElement),this.ngUnsubscribe$.subscribe((()=>{n.unobserve(t.nativeElement)}))}ngOnInit(){this.onResize$.pipe(oe(1),ln(this.resizeEventDebouncePeriodInMs),de(this.ngUnsubscribe$)).subscribe((()=>{this.onResize.emit()}))}ngOnDestroy(){this.ngUnsubscribe$.next(),this.ngUnsubscribe$.complete()}}_Y.ɵfac=function t(n){return new(n||_Y)(Zg(xu))},_Y.ɵdir=vo({type:_Y,selectors:[["","detectResize",""]],inputs:{resizeEventDebouncePeriodInMs:"resizeEventDebouncePeriodInMs"},outputs:{onResize:"onResize"}});const CY=["codeViewerContainer"];class MY{constructor(){this.lines=null,this.focusedLineno=null,this.monaco=null,this.editor=null,this.decorations=[],this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(t){if(null===this.monaco)return;const n=t.monaco?this.lines:t.lines?t.lines.currentValue:null;if(n){const t=n.join("\n");null===this.editor?this.editor=this.monaco.editor.create(this.codeViewerContainer.nativeElement,{value:t,language:"python",readOnly:!0,fontSize:10,minimap:{enabled:!0}}):this.editor.setValue(t)}const e=t.monaco?this.focusedLineno:t.focusedLineno?t.focusedLineno.currentValue:null;if(e&&this.lines&&null!==this.monaco){this.editor.revealLineInCenter(e,this.monaco.editor.ScrollType.Smooth);const t=this.lines[e-1].length;this.decorations=this.editor.deltaDecorations(this.decorations,[{range:new this.monaco.Range(e,1,e,1),options:{isWholeLine:!0,linesDecorationsClassName:"highlight-gutter"}},{range:new this.monaco.Range(e,1,e,t+1),options:{inlineClassName:"highlight-line"}}])}}}MY.ɵfac=function t(n){return new(n||MY)},MY.ɵcmp=_o({type:MY,selectors:[["source-code-component"]],viewQuery:function t(n,e){var a;1&n&&jf(CY,!0,xu),2&n&&Vf(a=Zf())&&(e.codeViewerContainer=a.first)},inputs:{lines:"lines",focusedLineno:"focusedLineno",monaco:"monaco"},features:[pr],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),cp("onResize",(function t(){return e.onResize()})),$g()),2&n&&Jg("resizeEventDebouncePeriodInMs",e.RESIZE_DEBOUNCE_INTERVAL_MS)},directives:[_Y],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n  height: 100%;\n}\n\n[_nghost-%COMP%]     .highlight-gutter {\n  background: rgba(255, 111, 0, 0.7);\n  width: 5px !important;\n}\n\n[_nghost-%COMP%]     .highlight-line {\n  background: rgba(255, 111, 0, 0.3);\n}"],changeDetection:0});class OY{constructor(){this.lines=null,this.focusedLineno=null,this.monaco$=null}ngOnInit(){this.monaco$=Rt(hY()).pipe(ft((()=>window.monaco)))}}function PY(t,n){if(1&t&&(Kg(0,"div",6),Jp(1),$g()),2&t){const t=gp();ws(1),Kp(" ",t.focusedSourceLineSpec.file_path," ")}}function xY(t,n){1&t&&(Kg(0,"div",7),Jp(1," No file selected. Click a line number in the Stack Trace section to show the source code. "),$g())}function yY(t,n){if(1&t&&tp(0,"source-code",8),2&t){const t=gp();Jg("lines",t.focusedSourceFileContent.lines)("focusedLineno",t.focusedSourceLineSpec.lineno)}}OY.ɵfac=function t(n){return new(n||OY)},OY.ɵcmp=_o({type:OY,selectors:[["source-code"]],inputs:{lines:"lines",focusedLineno:"focusedLineno"},decls:2,vars:5,consts:[[3,"lines","focusedLineno","monaco"]],template:function t(n,e){1&n&&(tp(0,"source-code-component",0),yf(1,"async")),2&n&&Jg("lines",e.lines)("focusedLineno",e.focusedLineno)("monaco",kf(1,3,e.monaco$))},directives:[MY],pipes:[oO],encapsulation:2});class kY{constructor(){this.focusedSourceFileContent=null,this.focusedSourceLineSpec=null}}kY.ɵfac=function t(n){return new(n||kY)},kY.ɵcmp=_o({type:kY,selectors:[["source-files-component"]],inputs:{focusedSourceFileContent:"focusedSourceFileContent",focusedSourceLineSpec:"focusedSourceLineSpec"},decls:8,vars:3,consts:[[1,"source-files-container"],[1,"header-section"],[1,"title-tag"],["class","file-label",4,"ngIf","ngIfElse"],["noFileSelected",""],[3,"lines","focusedLineno",4,"ngIf"],[1,"file-label"],[1,"no-file-selected"],[3,"lines","focusedLineno"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Kg(1,"div",1),Kg(2,"div",2),Jp(3,"Source Code"),$g(),Yg(4,PY,2,1,"div",3),Yg(5,xY,2,0,"ng-template",null,4,Kf),$g(),Yg(7,yY,1,2,"source-code",5),$g()),2&n){const t=qg(6);ws(4),Jg("ngIf",null!==e.focusedSourceLineSpec)("ngIfElse",t),ws(3),Jg("ngIf",null!==e.focusedSourceFileContent&&null!==e.focusedSourceLineSpec&&null!==e.focusedSourceFileContent.lines)}},directives:[WM,OY],styles:[".header-section[_ngcontent-%COMP%] {\n  border-bottom: 1px solid rgba(0, 0, 0, 0.12);\n  display: flex;\n  height: 24px;\n  padding-bottom: 6px;\n  vertical-align: middle;\n  white-space: nowrap;\n  width: 100%;\n}\n\n.file-label[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-weight: normal;\n  white-space: normal;\n  overflow-wrap: anywhere;\n  overflow-y: auto;\n  padding: 0 20px;\n}\n\n.no-file-selected[_ngcontent-%COMP%] {\n  display: inline-block;\n  color: #666;\n  padding: 0 20px;\n  white-space: normal;\n}\n\n.source-files-container[_ngcontent-%COMP%] {\n  display: flex;\n  flex-direction: column;\n  font-family: 'Roboto Mono', monospace;\n  font-size: 10px;\n  height: 100%;\n}\n\n.title-tag[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-weight: bold;\n  height: 100%;\n  padding-left: 6px;\n  vertical-align: top;\n}\n\nsource-code[_ngcontent-%COMP%] {\n  flex-grow: 1;\n  width: 100%;\n}"]});class vY{constructor(t){this.store=t,this.focusedSourceFileContent$=this.store.pipe(lv(NW)),this.focusedSourceLineSpec$=this.store.pipe(lv(FW))}}vY.ɵfac=function t(n){return new(n||vY)(Zg(cv))},vY.ɵcmp=_o({type:vY,selectors:[["tf-debugger-v2-source-files"]],decls:3,vars:6,consts:[[3,"focusedSourceFileContent","focusedSourceLineSpec"]],template:function t(n,e){1&n&&(tp(0,"source-files-component",0),yf(1,"async"),yf(2,"async")),2&n&&Jg("focusedSourceFileContent",kf(1,2,e.focusedSourceFileContent$))("focusedSourceLineSpec",kf(2,4,e.focusedSourceLineSpec$))},directives:[kY],pipes:[oO],encapsulation:2});const wY=["stackFrameArray"];function SY(t,n){if(1&t&&(Kg(0,"span",13),Jp(1),$g()),2&t){const t=gp(3);ws(1),Kp(" #",t.executionIndex,": ")}}function EY(t,n){if(1&t&&(Kg(0,"span",14),Jp(1),$g()),2&t){const t=gp(3);ws(1),Kp(" ",t.opType," ")}}function AY(t,n){if(1&t&&(Kg(0,"div"),Jp(1," Eager execution "),Yg(2,SY,2,1,"span",11),Yg(3,EY,2,1,"span",12),$g()),2&t){const t=gp(2);ws(2),Jg("ngIf",null!==t.opType),ws(1),Jg("ngIf",null!==t.opType)}}function zY(t,n){if(1&t&&(Kg(0,"span",16),Jp(1),$g()),2&t){const t=gp(3);ws(1),Kp(' "',t.opName,'" ')}}function RY(t,n){if(1&t&&(Kg(0,"span",14),Jp(1),$g()),2&t){const t=gp(3);ws(1),Kp(" ",t.opType," ")}}function TY(t,n){if(1&t&&(Kg(0,"div"),Jp(1," Creation of graph op "),Yg(2,zY,2,1,"span",15),Yg(3,RY,2,1,"span",12),$g()),2&t){const t=gp(2);ws(2),Jg("ngIf",null!==t.opName),ws(1),Jg("ngIf",null!==t.opType)}}function DY(t,n){if(1&t&&(Kg(0,"span",17),Jp(1),$g()),2&t){const t=gp(2);ws(1),Kp(" (Host name: ",t.stackFramesForDisplay[0].host_name,") ")}}function IY(t,n){if(1&t&&(Kg(0,"div",7),Kg(1,"span"),Kg(2,"span",8),Yg(3,AY,4,2,"div",9),Yg(4,TY,4,2,"div",9),$g(),$g(),Kg(5,"div"),Yg(6,DY,2,1,"span",10),$g(),$g()),2&t){const t=gp();ws(2),Jg("ngSwitch",t.codeLocationType),ws(1),Jg("ngSwitchCase",t.CodeLocationType.EXECUTION),ws(1),Jg("ngSwitchCase",t.CodeLocationType.GRAPH_OP_CREATION),ws(2),Jg("ngIf",null!==t.stackFramesForDisplay&&t.stackFramesForDisplay.length>0)}}function NY(t,n){1&t&&(Kg(0,"div",18),Jp(1," Click an eager execution or graph op to show its original stack trace. "),$g())}function FY(t,n){1&t&&(Kg(0,"div",28),Jp(1," ⤓ "),$g())}const LY=function(t,n){return[t,n]};function HY(t,n){if(1&t){const t=op();Kg(0,"div",22),Kg(1,"div",23),Jp(2),$g(),Kg(3,"div",24),Yg(4,FY,2,0,"div",25),Kg(5,"div",26),cp("click",(function e(){jr(t);const a=n.$implicit;return gp(2).onSourceLineClicked.emit(a)})),Jp(6),$g(),Kg(7,"div",27),Jp(8),$g(),$g(),$g()}if(2&t){const t=n.$implicit,e=gp(2);Jg("ngClass",ff(6,LY,t.belongsToFocusedFile?"focused-file":"",t.focused?"focused-stack-frame":"")),ws(1),_p("title",t.file_path),ws(1),Kp(" ",t.concise_file_path," "),ws(2),Jg("ngIf",e.stickToBottommostFrameInFocusedFile&&t.focused),ws(2),Kp(" Line ",t.lineno," "),ws(2),Kp(" ",t.function_name," ")}}function BY(t,n){if(1&t&&(Kg(0,"div",19,20),Yg(2,HY,9,9,"div",21),$g()),2&t){const t=gp();ws(2),Jg("ngForOf",t.stackFramesForDisplay)}}function VY(t,n){}class jY{constructor(){this.stackFramesForDisplay=null,this.onSourceLineClicked=new Ef,this.CodeLocationType=TU}ngAfterViewChecked(){if(void 0===this.stackFrameArray)return;const t=this.stackFrameArray.nativeElement,n=t.querySelector(".focused-stack-frame");if(null!==n)return void this.scrollToElement(t,n);const e=t.querySelector(".stack-frame-container:last-child");null!==e&&this.scrollToElement(t,e)}scrollToElement(t,n){t.scrollTop=n.offsetTop}}jY.ɵfac=function t(n){return new(n||jY)},jY.ɵcmp=_o({type:jY,selectors:[["stack-trace-component"]],viewQuery:function t(n,e){var a;1&n&&Uf(wY,!0),2&n&&Vf(a=Zf())&&(e.stackFrameArray=a.first)},inputs:{codeLocationType:"codeLocationType",opType:"opType",opName:"opName",executionIndex:"executionIndex",stickToBottommostFrameInFocusedFile:"stickToBottommostFrameInFocusedFile",stackFramesForDisplay:"stackFramesForDisplay"},outputs:{onSourceLineClicked:"onSourceLineClicked"},decls:10,vars:4,consts:[[1,"stack-trace-container"],[1,"stack-trace-header"],[1,"stack-trace-title"],["class","stack-trace-aux-info",4,"ngIf","ngIfElse"],["noStackTrace",""],["class","stack-frame-array",4,"ngIf","ngIfElse"],["loadingSection",""],[1,"stack-trace-aux-info"],[1,"code-location-origin",3,"ngSwitch"],[4,"ngSwitchCase"],["class","stack-trace-host-name",4,"ngIf"],["class","eager-execution-index",4,"ngIf"],["class","op-type",4,"ngIf"],[1,"eager-execution-index"],[1,"op-type"],["class","op-name",4,"ngIf"],[1,"op-name"],[1,"stack-trace-host-name"],[1,"stack-trace-aux-info","no-stack-trace"],[1,"stack-frame-array"],["stackFrameArray",""],["class","stack-frame-container",3,"ngClass",4,"ngFor","ngForOf"],[1,"stack-frame-container",3,"ngClass"],[1,"stack-frame-file-path",3,"title"],[1,"stack-frame-lineno-function"],["class","stick-to-bottommost-indicator","title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",4,"ngIf"],[1,"stack-frame-lineno",3,"click"],[1,"stack-frame-function"],["title","Sticking to the bottommost frame in the current source file when navigating executions and graph ops. To remove this sticking, click any non-bottommost stack frame.",1,"stick-to-bottommost-indicator"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Kg(1,"div",1),Kg(2,"span",2),Jp(3," Stack Trace "),$g(),Yg(4,IY,7,4,"div",3),Yg(5,NY,2,0,"ng-template",null,4,Kf),$g(),Yg(7,BY,3,1,"div",5),Yg(8,VY,0,0,"ng-template",null,6,Kf),$g()),2&n){const t=qg(6),n=qg(9);ws(4),Jg("ngIf",null!==e.codeLocationType)("ngIfElse",t),ws(3),Jg("ngIf",null!==e.stackFramesForDisplay)("ngIfElse",n)}},directives:[WM,ZM,XM,jM,HM],styles:[".focused-file[_ngcontent-%COMP%] {\n  font-weight: bold;\n}\n\n.focused-stack-frame[_ngcontent-%COMP%] {\n  background-color: rgba(255, 111, 0, 0.3);\n}\n\n.no-stack-trace[_ngcontent-%COMP%] {\n  color: #808080;\n}\n\n.op-name[_ngcontent-%COMP%] {\n  word-wrap: anywhere;\n}\n\n.op-type[_ngcontent-%COMP%] {\n  background-color: #e3e5e8;\n  border: 1px solid #c0c0c0;\n  border-radius: 4px;\n  font-family: 'Roboto Mono', monospace;\n  font-size: 10px;\n  height: 14px;\n  line-height: 14px;\n  padding: 1px 3px;\n  width: max-content;\n}\n\n.stack-frame-array[_ngcontent-%COMP%] {\n  overflow-x: hidden;\n  overflow-y: auto;\n  \n  width: calc(100% - 8px);\n}\n\n.stack-frame-container[_ngcontent-%COMP%] {\n  border-bottom: 1px solid #a0a0a0;\n}\n\n.stack-frame-file-path[_ngcontent-%COMP%] {\n  max-width: 180px;\n  width: 180px;\n}\n\n.stack-frame-lineno-function[_ngcontent-%COMP%] {\n  text-align: right;\n  white-space: nowrap;\n}\n\n.stack-frame-function[_ngcontent-%COMP%] {\n  display: inline-block;\n  max-width: 200px;\n  padding-left: 10px;\n  text-align: left;\n  white-space: normal;\n  width: 200px;\n  word-wrap: anywhere;\n}\n\n.stack-frame-lineno[_ngcontent-%COMP%] {\n  cursor: pointer;\n  display: inline-block;\n  max-width: 80px;\n  text-align: left;\n  text-decoration: underline;\n  width: 80px;\n}\n\n.stack-trace-aux-info[_ngcontent-%COMP%] {\n  margin-top: 15px;\n  padding-left: 24px;\n}\n\n.stack-trace-container[_ngcontent-%COMP%] {\n  border-left: 1px solid rgba(0, 0, 0, 0.12);\n  box-sizing: border-box;\n  display: flex;\n  flex-flow: column;\n  font-size: 10px;\n  font-family: 'Roboto Mono', monospace;\n  height: 100%;\n  margin-left: 8px;\n  max-height: 360px;\n  overflow-x: hidden;\n  overflow-y: hidden;\n  padding-left: 8px;\n  width: 100%;\n}\n\n.stack-trace-header[_ngcontent-%COMP%] {\n  box-shadow: 0 5px 3px -3px #ccc;\n  padding-bottom: 3px;\n}\n.stack-trace-host-name[_ngcontent-%COMP%] {\n  color: #808080;\n}\n\n.stack-trace-title[_ngcontent-%COMP%] {\n  font-weight: bold;\n}\n\n.stick-to-bottommost-indicator[_ngcontent-%COMP%] {\n  display: inline-block;\n  font-weight: bold;\n  font-size: 12px;\n  padding-right: 3px;\n}"]});class UY{constructor(t){this.store=t,this.codeLocationType$=this.store.pipe(lv(pv(zW,(t=>null===t?null:t.codeLocationType)))),this.opType$=this.store.pipe(lv(pv(zW,(t=>null===t?null:t.opType)))),this.opName$=this.store.pipe(lv(pv(zW,(t=>null===t||t.codeLocationType!==TU.GRAPH_OP_CREATION?null:t.opName)))),this.executionIndex$=this.store.pipe(lv(pv(zW,(t=>null===t||t.codeLocationType!==TU.EXECUTION?null:t.executionIndex)))),this.stickToBottommostFrameInFocusedFile$=this.store.pipe(lv(LW)),this.stackFramesForDisplay$=this.store.pipe(lv(pv(RW,FW,((t,n)=>{if(null===t)return null;const e=[];for(const a of t){const{host_name:t,file_path:o,lineno:r,function_name:i}=a,c=o.split("/"),s=null!==n&&t===n.host_name&&o===n.file_path;e.push({host_name:t,file_path:o,concise_file_path:c[c.length-1],lineno:r,function_name:i,belongsToFocusedFile:s,focused:s&&r===n.lineno})}return e}))))}onSourceLineClicked(t){const{host_name:n,file_path:e,lineno:a,function_name:o}=t;this.store.dispatch(vU({stackFrame:{host_name:n,file_path:e,lineno:a,function_name:o}}))}}function WY(t,n){1&t&&tp(0,"tf-debugger-v2-inactive")}function GY(t,n){1&t&&(Kg(0,"div",3),tp(1,"tf-debugger-v2-alerts"),Kg(2,"div",4),tp(3,"tf-debugger-v2-timeline"),tp(4,"tf-debugger-v2-graph"),$g(),tp(5,"tf-debugger-v2-graph-executions"),$g(),Kg(6,"div",5),tp(7,"tf-debugger-v2-source-files"),tp(8,"tf-debugger-v2-stack-trace"),$g())}UY.ɵfac=function t(n){return new(n||UY)(Zg(cv))},UY.ɵcmp=_o({type:UY,selectors:[["tf-debugger-v2-stack-trace"]],decls:7,vars:18,consts:[[3,"codeLocationType","opType","opName","executionIndex","stickToBottommostFrameInFocusedFile","stackFramesForDisplay","onSourceLineClicked"]],template:function t(n,e){1&n&&(Kg(0,"stack-trace-component",0),cp("onSourceLineClicked",(function t(n){return e.onSourceLineClicked(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),$g()),2&n&&Jg("codeLocationType",kf(1,6,e.codeLocationType$))("opType",kf(2,8,e.opType$))("opName",kf(3,10,e.opName$))("executionIndex",kf(4,12,e.executionIndex$))("stickToBottommostFrameInFocusedFile",kf(5,14,e.stickToBottommostFrameInFocusedFile$))("stackFramesForDisplay",kf(6,16,e.stackFramesForDisplay$))},directives:[jY],pipes:[oO],encapsulation:2});class YY{constructor(){this.runs={},this.runIds=[],this.activeRunId=null}}YY.ɵfac=function t(n){return new(n||YY)},YY.ɵcmp=_o({type:YY,selectors:[["debugger-component"]],inputs:{runs:"runs",runIds:"runIds",activeRunId:"activeRunId"},decls:4,vars:2,consts:[[1,"debugger-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[1,"top-section"],[1,"top-center-section"],[1,"bottom-section"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Yg(1,WY,1,0,"tf-debugger-v2-inactive",1),Yg(2,GY,9,0,"ng-template",null,2,Kf),$g()),2&n){const t=qg(3);ws(1),Jg("ngIf",0===e.runIds.length)("ngIfElse",t)}},directives:[WM,Xj,UW,LG,aY,pY,vY,UY],styles:[".bottom-section[_ngcontent-%COMP%] {\n  box-sizing: border-box;\n  border-top: 1px solid rgba(0, 0, 0, 0.12);\n  display: flex;\n  flex-grow: 1;\n  height: 34%;\n  padding-top: 6px;\n}\n\n.debugger-container[_ngcontent-%COMP%] {\n  box-sizing: border-box;\n  background-color: #fff;\n  height: 100%;\n  overflow: hidden;\n}\n\n.top-section[_ngcontent-%COMP%] {\n  box-sizing: border-box;\n  display: flex;\n  flex-grow: 1;\n  height: 66%;\n  padding: 6px 0;\n}\n\ntf-debugger-v2-alerts[_ngcontent-%COMP%] {\n  border-right: 1px solid rgba(0, 0, 0, 0.12);\n  display: inline-block;\n  margin-right: 10px;\n  min-width: 160px;\n  width: calc(15% - 11px);\n}\n\ntf-debugger-v2-graph-executions[_ngcontent-%COMP%] {\n  display: inline-block;\n  flex-grow: 1;\n  min-width: 540px;\n  width: 540px;\n}\n\ntf-debugger-v2-source-files[_ngcontent-%COMP%] {\n  display: inline-block;\n  height: 100%;\n  width: 70%;\n}\n\ntf-debugger-v2-stack-trace[_ngcontent-%COMP%] {\n  display: inline-block;\n  flex-grow: 1;\n  height: 100%;\n  min-width: 540px;\n  width: 540px;\n}\n\n.top-center-section[_ngcontent-%COMP%] {\n  display: inline-block;\n  overflow: auto;\n  width: 55%;\n}\n\ntf-debugger-v2-timeline[_ngcontent-%COMP%] {\n  display: block;\n}\n\ntf-debugger-v2-graph[_ngcontent-%COMP%] {\n  border-top: 1px solid rgba(0, 0, 0, 0.12);\n  display: block;\n  margin-top: 5px;\n}"],changeDetection:0});class qY{constructor(t){this.store=t,this.runs$=this.store.pipe(lv(UU)),this.runsIds$=this.store.pipe(lv(pv(UU,(t=>Object.keys(t))))),this.activeRunId$=this.store.pipe(lv(GU))}ngOnInit(){this.store.dispatch(Jj())}ngOnDestroy(){this.store.dispatch(Qj())}}function ZY(t,n,e,a,o){if(e<=0||!Number.isInteger(e))throw new Error(`Invalid pageSize: ${e}`);if(n>a)throw new Error(`end index (${n}) exceeds total number of items (${a})`);if(n-t>e)throw new Error("begin-end span exceeds page size, which is not allowed");const r=[],i=Math.floor(t/e);(!(i in o)||o[i]<e&&i*e+o[i]<a)&&r.push(i);const c=Math.floor((n-1)/e);return c!==i&&(!(c in o)||c*e+o[c]<n&&n<a)&&r.push(c),r}qY.ɵfac=function t(n){return new(n||qY)(Zg(cv))},qY.ɵcmp=_o({type:qY,selectors:[["tf-debugger-v2"]],decls:4,vars:9,consts:[[3,"runs","runIds","activeRunId"]],template:function t(n,e){1&n&&(tp(0,"debugger-component",0),yf(1,"async"),yf(2,"async"),yf(3,"async")),2&n&&Jg("runs",kf(1,3,e.runs$))("runIds",kf(2,5,e.runsIds$))("activeRunId",kf(3,7,e.activeRunId$))},directives:[YY],pipes:[oO],encapsulation:2});class XY{constructor(t,n,e){this.actions$=t,this.store=n,this.dataSource=e,this.loadData$=Yv((()=>{const t=this.loadDebuggerRuns(Wt(this.onDebuggerDataPoll(),this.onCoreReload())).pipe(ee()),n=this.loadSourceFileList(t),e=this.createNumExecutionLoader(t),a=this.createNumAlertsAndBreakdownLoader(t),o=this.onAlertTypeFocused(),r=this.fetchExecutionDigestsForAlertTypeFocus(o),i=this.createInitialExecutionDetector(e).pipe(ee()),c=this.createExecutionDigestLoader(Wt(this.onExecutionScroll(),this.createInitialExecutionDigest(i),r)),s=this.createExecutionDataAndStackFramesLoader(Wt(this.onExecutionDigestFocused(),i.pipe(ye(this.store.select(GU),this.store.select(wW)),ft((([,t,n])=>({activeRunId:t,loadedExecutionData:n,focusIndex:0}))))));return Wt(a,c,s,this.createNumGraphExecutionLoader(t),n,this.onSourceFileFocused(),this.loadGraphExecutionPages(this.onGraphExecutionScroll()),this.loadGraphOpStackFrames(this.loadGraphOpInfo())).pipe(ft((()=>({}))))}),{dispatch:!1})}onDebuggerDataPoll(){return this.actions$.pipe(tw(Jj),se((t=>(function n(t,e,a){return t.pipe((function o(t){return n=>n.lift(new $n(t))})((t=>t.pipe(ye(e),(function n(t,e){return e?n=>new Pn(n,e).lift(new Mn(t)):n=>n.lift(new Mn(t))})((([,t])=>Zt(t)))))),de(a),ft((()=>{})))})(Z(t),this.store.select(YU).pipe(ft((t=>(function n(t){return t>6e4?6e4:t>4e3?t:2e3})(t)))),this.actions$.pipe(tw(Qj))))),he((()=>this.store.dispatch(Kj()))),ft((()=>{})))}onCoreReload(){return this.actions$.pipe(tw(uI,fI),he((()=>this.store.dispatch(Kj()))),ft((()=>{})))}loadDebuggerRuns(t){return t.pipe(ye(this.store.select(WU)),Gt((([,{state:t}])=>t!==fR.LOADING)),he((()=>this.store.dispatch($j()))),Tt((()=>this.dataSource.fetchRuns().pipe(he((t=>{this.store.dispatch(tU({runs:t}))})),ft((()=>{}))))))}createNumExecutionLoader(t){return t.pipe(ye(this.store.select(UU),this.store.select(nW)),Gt((([,t,n])=>Object.keys(t).length>0&&n.state!==fR.LOADING)),he((()=>this.store.dispatch(iU()))),Tt((([,t])=>{const n=Object.keys(t)[0];return this.dataSource.fetchExecutionDigests(n,0,0).pipe(he((t=>{this.store.dispatch(cU({numExecutions:t.num_digests}))})),ft((()=>{})))})))}createNumGraphExecutionLoader(t){return t.pipe(ye(this.store.select(UU),this.store.select(lW)),Gt((([,t,n])=>Object.keys(t).length>0&&n.state!==fR.LOADING)),he((()=>this.store.dispatch(uU()))),Tt((([,t])=>{const n=Object.keys(t)[0];return this.dataSource.fetchGraphExecutionDigests(n,0,0).pipe(he((t=>{this.store.dispatch(fU({numGraphExecutions:t.num_digests}))})),ft((()=>{})))})))}createNumAlertsAndBreakdownLoader(t){return t.pipe(ye(this.store.select(UU),this.store.select(ZU)),Gt((([,t,n])=>Object.keys(t).length>0&&n.state!==fR.LOADING)),he((()=>this.store.dispatch(eU()))),Tt((([,t])=>{const n=Object.keys(t)[0];return this.dataSource.fetchAlerts(n,0,0).pipe(he((t=>{this.store.dispatch(aU({numAlerts:t.num_alerts,alertsBreakdown:t.alerts_breakdown}))})),ft((()=>{})))})))}createInitialExecutionDetector(t){return t.pipe(ye(this.store.select(aW),this.store.select(eW)),Gt((([,t,n])=>t>0&&0===Object.keys(n.pageLoadedSizes).length)),ft((()=>{})))}createInitialExecutionDigest(t){return t.pipe(ye(this.store.select(aW),this.store.select(GU),this.store.select(rW)),Gt((([,,t])=>null!==t)),ft((([,t,n,e])=>({begin:0,end:Math.min(t,e),runId:n}))))}onExecutionScroll(){return this.actions$.pipe(tw(mU,dU,gU),ye(this.store.select(GU),this.store.select(oW),this.store.select(aW),this.store.select(iW),this.store.select(rW)),Gt((([t])=>null!==t)),ft((([,t,n,e,a,o])=>({runId:t,begin:n,end:Math.min(e,n+a),pageSize:o}))),ye(this.store.select(eW)),ft((([t,n])=>({props:t,loaded:n,missingPages:ZY(t.begin,t.end,t.pageSize,n.numExecutions,n.pageLoadedSizes)}))),Gt((({missingPages:t})=>t.length>0)),ft((({props:t,loaded:n,missingPages:e})=>{const{runId:a,pageSize:o}=t;return{begin:e[0]*o,end:Math.min(n.numExecutions,(e[e.length-1]+1)*o),runId:a}})))}createExecutionDigestLoader(t){return t.pipe(ye(this.store.select(eW)),Gt((([{begin:t,end:n},e])=>n>t&&!(function a(t,n,e){if(n>=e)throw new Error(`Expected begin to be less than end, but got begin=${n}, end=${e}`);return-1!==t.findIndex((t=>t.begin>=n&&t.end<=e))})(e.loadingRanges,t,n))),he((([{begin:t,end:n}])=>{this.store.dispatch(sU({begin:t,end:n}))})),Tt((([{runId:t,begin:n,end:e}])=>this.dataSource.fetchExecutionDigests(t,n,e).pipe(he((t=>{this.store.dispatch(lU(t))})),ft((()=>{}))))))}onExecutionDigestFocused(){return this.actions$.pipe(tw(pU),ye(this.store.select(GU),this.store.select(wW),this.store.select(oW)),ft((([t,n,e,a])=>({activeRunId:n,loadedExecutionData:e,focusIndex:a+t.displayIndex}))))}createExecutionDataAndStackFramesLoader(t){return t.pipe(Gt((({activeRunId:t,loadedExecutionData:n,focusIndex:e})=>null!==t&&null!==e&&void 0===n[e])),Tt((({activeRunId:t,focusIndex:n})=>{const e=n,a=e+1;return this.dataSource.fetchExecutionData(t,e,a).pipe(he((t=>{this.store.dispatch(bU(t))})),ft((t=>({executionData:t,begin:e,end:a}))))})),ft((({executionData:t})=>t.executions[0])),ye(this.store.select(GU),this.store.select(EW)),Gt((([t,n,e])=>{if(null===n)return!1;for(const n of t.stack_frame_ids)if(void 0===e[n])return!0;return!1})),Tt((([t,n])=>{const e=t.stack_frame_ids;return this.dataSource.fetchStackFrames(n,e).pipe(he((t=>{const n={};for(let a=0;a<e.length;++a)n[e[a]]=t.stack_frames[a];this.store.dispatch(EU({stackFrames:n}))})),ft((()=>{})))})))}onGraphExecutionScroll(){return this.actions$.pipe(tw(CU),ln(100),ye(this.store.select(GU),this.store.select(mW),this.store.select(dW)),Gt((([,t,n])=>null!==t&&n>0)),ft((([,t,n,e])=>({runId:t,numGraphExecutions:n,scrollBeginIndex:e}))),ye(this.store.select(pW),this.store.select(gW),this.store.select(bW),this.store.select(uW)),ft((([{runId:t,numGraphExecutions:n,scrollBeginIndex:e},a,o,r,i])=>{let c=ZY(e,Math.min(e+o,n),a,n,i);return c=c.filter((t=>-1===r.indexOf(t))),{runId:t,missingPages:c,pageSize:a,numGraphExecutions:n}})))}loadGraphExecutionPages(t){return t.pipe(Gt((({missingPages:t})=>t.length>0)),he((({missingPages:t})=>{t.forEach((t=>{this.store.dispatch(hU({pageIndex:t}))}))})),Tt((({runId:t,missingPages:n,pageSize:e,numGraphExecutions:a})=>{const o=n[0]*e,r=Math.min((n[n.length-1]+1)*e,a);return this.dataSource.fetchGraphExecutionData(t,o,r).pipe(he((t=>{this.store.dispatch(_U(t))})),ft((()=>{})))})))}loadGraphOpInfo(){return this.actions$.pipe(tw(OU,MU),ye(this.store.select(GU),this.store.select(SW)),Gt((([t,n,e])=>{const{graph_id:a,op_name:o}=t;return!(null===n||void 0!==e[a]&&e[a].has(o)&&(e[a].get(o)===fR.LOADING||e[a].get(o)===fR.LOADED))})),he((([{graph_id:t,op_name:n}])=>this.store.dispatch(PU({graph_id:t,op_name:n})))),Tt((([t,n])=>{const{graph_id:e,op_name:a}=t;return this.dataSource.fetchGraphOpInfo(n,e,a).pipe(he((t=>this.store.dispatch(xU({graphOpInfoResponse:t})))),ft((t=>({runId:n,stackFrameIds:t.stack_frame_ids}))))})))}loadGraphOpStackFrames(t){return t.pipe(ye(this.store.select(EW)),ft((([{runId:t,stackFrameIds:n},e])=>({runId:t,missingStackFrameIds:n.filter((t=>void 0===e[t]))}))),Gt((({runId:t,missingStackFrameIds:n})=>null!==t&&n.length>0)),Tt((({runId:t,missingStackFrameIds:n})=>this.dataSource.fetchStackFrames(t,n).pipe(he((t=>{const e={};for(let a=0;a<n.length;++a)e[n[a]]=t.stack_frames[a];this.store.dispatch(EU({stackFrames:e}))})),ft((()=>{}))))))}onAlertTypeFocused(){return this.actions$.pipe(tw(rU),ye(this.store.select(GU),this.store.select(JU),this.store.select(QU),this.store.select(KU),this.store.select(ZU)),Gt((([,t,n,e,a,o])=>null!==t&&null!==n&&e>0&&(null===a||Object.keys(a).length<e)&&o.state!==fR.LOADING)),he((()=>this.store.dispatch(eU()))),Tt((([,t,n])=>this.dataSource.fetchAlerts(t,0,-1,n))),he((({num_alerts:t,alerts_breakdown:n,alert_type:e,begin:a,end:o,alerts:r})=>{this.store.dispatch(oU({numAlerts:t,alertsBreakdown:n,alertType:e,begin:a,end:o,alerts:r}))})))}fetchExecutionDigestsForAlertTypeFocus(t){return t.pipe(ye(this.store.select(rW),this.store.select(iW),this.store.select(aW),this.store.select(eW),this.store.select(GU)),ft((([t,n,e,a,o,r])=>{const i=t.alerts[0].execution_index,c=ZY(Math.max(0,i-Math.floor(e/2)),Math.min(i+Math.floor(e/2),a),n,a,o.pageLoadedSizes);return 0===c.length?{runId:r,begin:0,end:0}:{runId:r,begin:c[0]*n,end:Math.min(o.numExecutions,(c[c.length-1]+1)*n)}})))}loadSourceFileList(t){return t.pipe(ye(this.store.select(GU),this.store.select(DW)),Gt((([,t,n])=>null!==t&&n.state!==fR.LOADING)),he((()=>this.store.dispatch(yU()))),Tt((([,t])=>this.dataSource.fetchSourceFileList(t).pipe(he((t=>{const n=[];t.forEach((([t,e])=>{n.push({host_name:t,file_path:e})})),this.store.dispatch(kU({sourceFiles:n}))})),ft((()=>{}))))))}onSourceFileFocused(){return this.actions$.pipe(tw(vU),ye(this.store.select(GU),this.store.select(IW),this.store.select(NW)),ft((([t,n,e,a])=>({runId:n,stackFrame:t.stackFrame,fileIndex:e,fileContent:a}))),Gt((({runId:t,fileContent:n})=>null!==t&&null!==n&&n.loadState===fR.NOT_LOADED)),he((({stackFrame:t})=>this.store.dispatch(wU({host_name:t.host_name,file_path:t.file_path})))),Tt((({fileIndex:t,runId:n})=>this.dataSource.fetchSourceFile(n,t).pipe(he((t=>{this.store.dispatch(SU(t))})),ft((()=>{}))))))}}XY.ɵfac=function t(n){return new(n||XY)(Za($v),Za(cv),Za(Yj))},XY.ɵprov=We({token:XY,factory:XY.ɵfac});class JY{}JY.ɵmod=xo({type:JY}),JY.ɵinj=Ge({factory:function t(n){return new(n||JY)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(JY,{declarations:[VW,UW],imports:[PO],exports:[UW]});class QY{}QY.ɵmod=xo({type:QY}),QY.ɵinj=Ge({factory:function t(n){return new(n||QY)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(QY,{declarations:[fG,MG,CG,hG,_G,OG],imports:[PO],exports:[OG]});class KY{}KY.ɵmod=xo({type:KY}),KY.ɵinj=Ge({factory:function t(n){return new(n||KY)},imports:[[PO,QY,vA]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(KY,{declarations:[gY,pY],imports:[PO,QY,vA],exports:[pY]});class $Y{}$Y.ɵmod=xo({type:$Y}),$Y.ɵinj=Ge({factory:function t(n){return new(n||$Y)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo($Y,{declarations:[eY,GG,aY],imports:[PO],exports:[aY]});class tq{}tq.ɵmod=xo({type:tq}),tq.ɵinj=Ge({factory:function t(n){return new(n||tq)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(tq,{declarations:[Zj,Xj],exports:[Xj]});class nq{}nq.ɵmod=xo({type:nq}),nq.ɵinj=Ge({factory:function t(n){return new(n||nq)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(nq,{declarations:[_Y],exports:[_Y]});const eq=["codeViewerContainer"];class aq{constructor(){this.firstText=null,this.secondText=null,this.renderSideBySide=!0,this.monaco=null,this.editor=null,this.RESIZE_DEBOUNCE_INTERVAL_MS=50}onResize(){this.editor&&this.editor.layout()}ngOnChanges(t){if(!this.monaco)return;const n=!this.editor;n&&(this.editor=this.monaco.editor.createDiffEditor(this.codeViewerContainer.nativeElement,{readOnly:!0,fontSize:10,minimap:{enabled:!0},renderSideBySide:this.renderSideBySide})),(n||t.firstText||t.secondText)&&this.editor.setModel({original:this.monaco.editor.createModel(this.firstText||""),modified:this.monaco.editor.createModel(this.secondText||"")}),t.renderSideBySide&&this.editor.updateOptions({renderSideBySide:this.renderSideBySide})}}aq.ɵfac=function t(n){return new(n||aq)},aq.ɵcmp=_o({type:aq,selectors:[["source-code-diff-component"]],viewQuery:function t(n,e){var a;1&n&&jf(eq,!0,xu),2&n&&Vf(a=Zf())&&(e.codeViewerContainer=a.first)},inputs:{firstText:"firstText",secondText:"secondText",renderSideBySide:"renderSideBySide",monaco:"monaco"},features:[pr],decls:2,vars:1,consts:[["detectResize","",1,"code-viewer-container",3,"resizeEventDebouncePeriodInMs","onResize"],["codeViewerContainer",""]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),cp("onResize",(function t(){return e.onResize()})),$g()),2&n&&Jg("resizeEventDebouncePeriodInMs",e.RESIZE_DEBOUNCE_INTERVAL_MS)},directives:[_Y],styles:[".code-viewer-container[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0});class oq{constructor(){this.firstText=null,this.secondText=null,this.renderSideBySide=!0,this.monaco$=null}ngOnInit(){this.monaco$=Rt(hY()).pipe(ft((()=>window.monaco)))}}oq.ɵfac=function t(n){return new(n||oq)},oq.ɵcmp=_o({type:oq,selectors:[["source-code-diff"]],inputs:{firstText:"firstText",secondText:"secondText",renderSideBySide:"renderSideBySide"},decls:2,vars:6,consts:[[3,"firstText","secondText","renderSideBySide","monaco"]],template:function t(n,e){1&n&&(tp(0,"source-code-diff-component",0),yf(1,"async")),2&n&&Jg("firstText",e.firstText)("secondText",e.secondText)("renderSideBySide",e.renderSideBySide)("monaco",kf(1,4,e.monaco$))},directives:[aq],pipes:[oO],styles:["source-code-diff-component[_ngcontent-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0});class rq{}rq.ɵmod=xo({type:rq}),rq.ɵinj=Ge({factory:function t(n){return new(n||rq)},imports:[[PO,nq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(rq,{declarations:[MY,OY,aq,oq],imports:[PO,nq],exports:[OY,oq]});class iq{}iq.ɵmod=xo({type:iq}),iq.ɵinj=Ge({factory:function t(n){return new(n||iq)},imports:[[PO,rq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(iq,{declarations:[kY,vY],imports:[PO,rq],exports:[vY]});class cq{}cq.ɵmod=xo({type:cq}),cq.ɵinj=Ge({factory:function t(n){return new(n||cq)},imports:[[PO,rq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(cq,{declarations:[jY,UY],imports:[PO,rq],exports:[UY]});class sq{}sq.ɵmod=xo({type:sq}),sq.ɵinj=Ge({factory:function t(n){return new(n||sq)},imports:[[PO,QY]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(sq,{declarations:[wG,EG],imports:[PO,QY],exports:[EG]});class lq{}lq.ɵmod=xo({type:lq}),lq.ɵinj=Ge({factory:function t(n){return new(n||lq)},imports:[[PO,sq,oA,KW]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(lq,{declarations:[NG,LG],imports:[PO,sq,oA,KW],exports:[LG]});const mq=new Fa("[plugins] Plugin registry config"),dq=new Map;class gq{constructor(t){if(!t)return;const n=new Set(t.map((t=>t.pluginName)));console.assert(n.size===t.length,"Cannot register the same plugin multiple times.");for(const n of t){const{pluginName:t,componentClass:e}=n;dq.set(t,e)}}static forPlugin(t,n){return{ngModule:gq,providers:[{provide:mq,multi:!0,useValue:{pluginName:t,componentClass:n}}]}}getComponent(t){return dq.get(t)||null}}gq.ɵmod=xo({type:gq}),gq.ɵinj=Ge({factory:function t(n){return new(n||gq)(Za(mq,8))}});class pq{}pq.ɵmod=xo({type:pq}),pq.ɵinj=Ge({factory:function t(n){return new(n||pq)},imports:[[JY,PO,KY,$Y,tq,iq,cq,qj,lq,Iv.forFeature(AU,(function bq(t,n){return LU(t,n)})),fw.forFeature([XY]),gq.forPlugin("debugger-v2",qY)]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(pq,{declarations:[YY,qY],imports:[JY,PO,KY,$Y,tq,iq,cq,qj,lq,Dv,uw,gq],exports:[qY]});const uq=["*"];function fq(t,n){if(1&t){const t=op();Kg(0,"div",0),cp("keydown",(function n(e){return jr(t),gp()._handleKeydown(e)}))("click",(function n(){return jr(t),gp().closed.emit("click")}))("@transformMenu.start",(function n(e){return jr(t),gp()._onAnimationStart(e)}))("@transformMenu.done",(function n(e){return jr(t),gp()._onAnimationDone(e)})),Kg(1,"div",1),hp(2),$g(),$g()}if(2&t){const t=gp();Jg("id",t.panelId)("ngClass",t._classList)("@transformMenu",t._panelAnimationState),Ng("aria-label",t.ariaLabel||null)("aria-labelledby",t.ariaLabelledby||null)("aria-describedby",t.ariaDescribedby||null)}}const hq={transformMenu:SP("transformMenu",[RP("void",zP({opacity:0,transform:"scale(0.8)"})),DP("void => enter",(function _q(t,n=null){return{type:3,steps:t,options:n}})([NP(".mat-menu-content, .mat-mdc-menu-content",EP("100ms linear",zP({opacity:1}))),EP("120ms cubic-bezier(0, 0, 0.2, 1)",zP({transform:"scale(1)"}))])),DP("* => void",EP("100ms 25ms linear",zP({opacity:0})))]),fadeInItems:SP("fadeInItems",[RP("showing",zP({opacity:1})),DP("void => *",[zP({opacity:0}),EP("400ms 100ms cubic-bezier(0.55, 0, 0.55, 0.2)")])])},Cq=new Fa("MatMenuContent");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Mq{constructor(t,n,e,a,o,r,i){this._template=t,this._componentFactoryResolver=n,this._appRef=e,this._injector=a,this._viewContainerRef=o,this._document=r,this._changeDetectorRef=i,this._attached=new x}attach(t={}){this._portal||(this._portal=new AA(this._template,this._viewContainerRef)),this.detach(),this._outlet||(this._outlet=new TA(this._document.createElement("div"),this._componentFactoryResolver,this._appRef,this._injector));const n=this._template.elementRef.nativeElement;n.parentNode.insertBefore(this._outlet.outletElement,n),this._changeDetectorRef&&this._changeDetectorRef.markForCheck(),this._portal.attach(this._outlet,t),this._attached.next()}detach(){this._portal.isAttached&&this._portal.detach()}ngOnDestroy(){this._outlet&&this._outlet.dispose()}}Mq.ɵfac=function t(n){return new(n||Mq)(Zg(Ju),Zg(Pu),Zg(pC),Zg(yd),Zg($u),Zg(zC),Zg(Vm))},Mq.ɵdir=vo({type:Mq,selectors:[["ng-template","matMenuContent",""]],features:[Mu([{provide:Cq,useExisting:Mq}])]}),Mq.ctorParameters=()=>[{type:Ju},{type:Pu},{type:pC},{type:yd},{type:$u},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Vm}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Oq=new Fa("MAT_MENU_PANEL"),Pq=aE(nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{}));class xq extends Pq{constructor(t,n,e,a){super(),this._elementRef=t,this._focusMonitor=e,this._parentMenu=a,this.role="menuitem",this._hovered=new x,this._focused=new x,this._highlighted=!1,this._triggersSubmenu=!1,a&&a.addItem&&a.addItem(this)}focus(t="program",n){this._focusMonitor?this._focusMonitor.focusVia(this._getHostElement(),t,n):this._getHostElement().focus(n),this._focused.next(this)}ngAfterViewInit(){this._focusMonitor&&this._focusMonitor.monitor(this._elementRef,!1)}ngOnDestroy(){this._focusMonitor&&this._focusMonitor.stopMonitoring(this._elementRef),this._parentMenu&&this._parentMenu.removeItem&&this._parentMenu.removeItem(this),this._hovered.complete(),this._focused.complete()}_getTabIndex(){return this.disabled?"-1":"0"}_getHostElement(){return this._elementRef.nativeElement}_checkDisabled(t){this.disabled&&(t.preventDefault(),t.stopPropagation())}_handleMouseEnter(){this._hovered.next(this)}getLabel(){var t,n;const e=this._elementRef.nativeElement.cloneNode(!0),a=e.querySelectorAll("mat-icon, .material-icons");for(let n=0;n<a.length;n++){const e=a[n];null===(t=e.parentNode)||void 0===t||t.removeChild(e)}return(null===(n=e.textContent)||void 0===n?void 0:n.trim())||""}}xq.ɵfac=function t(n){return new(n||xq)(Zg(xu),Zg(zC),Zg(TS),Zg(Oq,8))},xq.ɵcmp=_o({type:xq,selectors:[["","mat-menu-item",""]],hostAttrs:[1,"mat-focus-indicator"],hostVars:10,hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e._checkDisabled(n)}))("mouseenter",(function t(){return e._handleMouseEnter()})),2&n&&(Ng("role",e.role)("tabindex",e._getTabIndex())("aria-disabled",e.disabled.toString())("disabled",e.disabled||null),Dp("mat-menu-item",!0)("mat-menu-item-highlighted",e._highlighted)("mat-menu-item-submenu-trigger",e._triggersSubmenu))},inputs:{disabled:"disabled",disableRipple:"disableRipple",role:"role"},exportAs:["matMenuItem"],features:[hg],attrs:["mat-menu-item",""],ngContentSelectors:uq,decls:2,vars:2,consts:[["matRipple","",1,"mat-menu-ripple",3,"matRippleDisabled","matRippleTrigger"]],template:function t(n,e){1&n&&(bp(),hp(0),tp(1,"div",0)),2&n&&(ws(1),Jg("matRippleDisabled",e.disableRipple||e.disabled)("matRippleTrigger",e._getHostElement()))},directives:[zE],encapsulation:2,changeDetection:0}),xq.ctorParameters=()=>[{type:xu},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:TS},{type:void 0,decorators:[{type:Ie,args:[Oq]},{type:Ne}]}],xq.propDecorators={role:[{type:f_}],_checkDisabled:[{type:__,args:["click",["$event"]]}],_handleMouseEnter:[{type:__,args:["mouseenter"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const yq=new Fa("mat-menu-default-options",{providedIn:"root",factory:function kq(){return{overlapTrigger:!1,xPosition:"after",yPosition:"below",backdropClass:"cdk-overlay-transparent-backdrop"}}});let vq=0;class wq{constructor(t,n,e){this._elementRef=t,this._ngZone=n,this._defaultOptions=e,this._xPosition=this._defaultOptions.xPosition,this._yPosition=this._defaultOptions.yPosition,this._directDescendantItems=new zf,this._tabSubscription=s.EMPTY,this._classList={},this._panelAnimationState="void",this._animationDone=new x,this.overlayPanelClass=this._defaultOptions.overlayPanelClass||"",this.backdropClass=this._defaultOptions.backdropClass,this._overlapTrigger=this._defaultOptions.overlapTrigger,this._hasBackdrop=this._defaultOptions.hasBackdrop,this.closed=new Ef,this.close=this.closed,this.panelId="mat-menu-panel-"+vq++}get xPosition(){return this._xPosition}set xPosition(t){"before"===t||"after"===t||"undefined"!=typeof ngDevMode&&!ngDevMode||(function n(){throw Error('xPosition value must be either \'before\' or after\'.\n      Example: <mat-menu xPosition="before" #menu="matMenu"></mat-menu>')})(),this._xPosition=t,this.setPositionClasses()}get yPosition(){return this._yPosition}set yPosition(t){"above"===t||"below"===t||"undefined"!=typeof ngDevMode&&!ngDevMode||(function n(){throw Error('yPosition value must be either \'above\' or below\'.\n      Example: <mat-menu yPosition="above" #menu="matMenu"></mat-menu>')})(),this._yPosition=t,this.setPositionClasses()}get overlapTrigger(){return this._overlapTrigger}set overlapTrigger(t){this._overlapTrigger=Gw(t)}get hasBackdrop(){return this._hasBackdrop}set hasBackdrop(t){this._hasBackdrop=Gw(t)}set panelClass(t){const n=this._previousPanelClass;n&&n.length&&n.split(" ").forEach((t=>{this._classList[t]=!1})),this._previousPanelClass=t,t&&t.length&&(t.split(" ").forEach((t=>{this._classList[t]=!0})),this._elementRef.nativeElement.className="")}get classList(){return this.panelClass}set classList(t){this.panelClass=t}ngOnInit(){this.setPositionClasses()}ngAfterContentInit(){this._updateDirectDescendants(),this._keyManager=new mS(this._directDescendantItems).withWrap().withTypeAhead().withHomeAndEnd(),this._tabSubscription=this._keyManager.tabOut.subscribe((()=>this.closed.emit("tab"))),this._directDescendantItems.changes.pipe(ce(this._directDescendantItems),se((t=>Wt(...t.map((t=>t._focused)))))).subscribe((t=>this._keyManager.updateActiveItem(t)))}ngOnDestroy(){this._directDescendantItems.destroy(),this._tabSubscription.unsubscribe(),this.closed.complete()}_hovered(){return this._directDescendantItems.changes.pipe(ce(this._directDescendantItems),se((t=>Wt(...t.map((t=>t._hovered))))))}addItem(t){}removeItem(t){}_handleKeydown(t){const n=t.keyCode,e=this._keyManager;switch(n){case Bw:Ww(t)||(t.preventDefault(),this.closed.emit("keydown"));break;case 37:this.parentMenu&&"ltr"===this.direction&&this.closed.emit("keydown");break;case 39:this.parentMenu&&"rtl"===this.direction&&this.closed.emit("keydown");break;default:n!==jw&&n!==Uw||e.setFocusOrigin("keyboard"),e.onKeydown(t)}}focusFirstItem(t="program"){this.lazyContent?this._ngZone.onStable.pipe(Tn(1)).subscribe((()=>this._focusFirstItem(t))):this._focusFirstItem(t)}_focusFirstItem(t){const n=this._keyManager;if(n.setFocusOrigin(t).setFirstItemActive(),!n.activeItem&&this._directDescendantItems.length){let t=this._directDescendantItems.first._getHostElement().parentElement;for(;t;){if("menu"===t.getAttribute("role")){t.focus();break}t=t.parentElement}}}resetActiveItem(){this._keyManager.setActiveItem(-1)}setElevation(t){const n=`mat-elevation-z${Math.min(4+t,24)}`,e=Object.keys(this._classList).find((t=>t.startsWith("mat-elevation-z")));e&&e!==this._previousElevation||(this._previousElevation&&(this._classList[this._previousElevation]=!1),this._classList[n]=!0,this._previousElevation=n)}setPositionClasses(t=this.xPosition,n=this.yPosition){const e=this._classList;e["mat-menu-before"]="before"===t,e["mat-menu-after"]="after"===t,e["mat-menu-above"]="above"===n,e["mat-menu-below"]="below"===n}_startAnimation(){this._panelAnimationState="enter"}_resetAnimation(){this._panelAnimationState="void"}_onAnimationDone(t){this._animationDone.next(t),this._isAnimating=!1}_onAnimationStart(t){this._isAnimating=!0,"enter"===t.toState&&0===this._keyManager.activeItemIndex&&(t.element.scrollTop=0)}_updateDirectDescendants(){this._allItems.changes.pipe(ce(this._allItems)).subscribe((t=>{this._directDescendantItems.reset(t.filter((t=>t._parentMenu===this))),this._directDescendantItems.notifyOnChanges()}))}}wq.ɵfac=function t(n){return new(n||wq)(Zg(xu),Zg(J_),Zg(yq))},wq.ɵdir=vo({type:wq,contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,Cq,!0),Gf(a,xq,!0),Gf(a,xq,!1)),2&n&&(Vf(o=Zf())&&(e.lazyContent=o.first),Vf(o=Zf())&&(e._allItems=o),Vf(o=Zf())&&(e.items=o))},viewQuery:function t(n,e){var a;1&n&&Uf(Ju,!0),2&n&&Vf(a=Zf())&&(e.templateRef=a.first)},inputs:{backdropClass:"backdropClass",xPosition:"xPosition",yPosition:"yPosition",overlapTrigger:"overlapTrigger",hasBackdrop:"hasBackdrop",panelClass:["class","panelClass"],classList:"classList",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],ariaDescribedby:["aria-describedby","ariaDescribedby"]},outputs:{closed:"closed",close:"close"}}),wq.ctorParameters=()=>[{type:xu},{type:J_},{type:void 0,decorators:[{type:Ie,args:[yq]}]}],wq.propDecorators={_allItems:[{type:qd,args:[xq,{descendants:!0}]}],backdropClass:[{type:f_}],ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}],ariaDescribedby:[{type:f_,args:["aria-describedby"]}],xPosition:[{type:f_}],yPosition:[{type:f_}],templateRef:[{type:Xd,args:[Ju]}],items:[{type:qd,args:[xq,{descendants:!1}]}],lazyContent:[{type:Zd,args:[Cq]}],overlapTrigger:[{type:f_}],hasBackdrop:[{type:f_}],panelClass:[{type:f_,args:["class"]}],classList:[{type:f_}],closed:[{type:h_}],close:[{type:h_}]};class Sq extends wq{}Sq.ɵfac=function t(n){return Eq(n||Sq)},Sq.ɵdir=vo({type:Sq,features:[hg]});const Eq=tc(Sq);class Aq extends Sq{constructor(t,n,e){super(t,n,e)}}Aq.ɵfac=function t(n){return new(n||Aq)(Zg(xu),Zg(J_),Zg(yq))},Aq.ɵcmp=_o({type:Aq,selectors:[["mat-menu"]],exportAs:["matMenu"],features:[Mu([{provide:Oq,useExisting:Sq},{provide:Sq,useExisting:Aq}]),hg],ngContentSelectors:uq,decls:1,vars:0,consts:[["tabindex","-1","role","menu",1,"mat-menu-panel",3,"id","ngClass","keydown","click"],[1,"mat-menu-content"]],template:function t(n,e){1&n&&(bp(),Yg(0,fq,3,6,"ng-template"))},directives:[HM],styles:['.mat-menu-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;max-height:calc(100vh - 48px);border-radius:4px;outline:0;min-height:64px}.mat-menu-panel.ng-animating{pointer-events:none}.cdk-high-contrast-active .mat-menu-panel{outline:solid 1px}.mat-menu-content:not(:empty){padding-top:8px;padding-bottom:8px}.mat-menu-item{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer;outline:none;border:none;-webkit-tap-highlight-color:transparent;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;line-height:48px;height:48px;padding:0 16px;text-align:left;text-decoration:none;max-width:100%;position:relative}.mat-menu-item::-moz-focus-inner{border:0}.mat-menu-item[disabled]{cursor:default}[dir=rtl] .mat-menu-item{text-align:right}.mat-menu-item .mat-icon{margin-right:16px;vertical-align:middle}.mat-menu-item .mat-icon svg{vertical-align:top}[dir=rtl] .mat-menu-item .mat-icon{margin-left:16px;margin-right:0}.mat-menu-item[disabled]{pointer-events:none}.cdk-high-contrast-active .mat-menu-item.cdk-program-focused,.cdk-high-contrast-active .mat-menu-item.cdk-keyboard-focused,.cdk-high-contrast-active .mat-menu-item-highlighted{outline:dotted 1px}.mat-menu-item-submenu-trigger{padding-right:32px}.mat-menu-item-submenu-trigger::after{width:0;height:0;border-style:solid;border-width:5px 0 5px 5px;border-color:transparent transparent transparent currentColor;content:"";display:inline-block;position:absolute;top:50%;right:16px;transform:translateY(-50%)}[dir=rtl] .mat-menu-item-submenu-trigger{padding-right:16px;padding-left:32px}[dir=rtl] .mat-menu-item-submenu-trigger::after{right:auto;left:16px;transform:rotateY(180deg) translateY(-50%)}button.mat-menu-item{width:100%}.mat-menu-item .mat-menu-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}\n'],encapsulation:2,data:{animation:[hq.transformMenu,hq.fadeInItems]},changeDetection:0}),Aq.ctorParameters=()=>[{type:xu},{type:J_},{type:void 0,decorators:[{type:Ie,args:[yq]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const zq=new Fa("mat-menu-scroll-strategy"),Rq={provide:zq,deps:[hz],useFactory:function Tq(t){return()=>t.scrollStrategies.reposition()}},Dq=Nw({passive:!0});class Iq{constructor(t,n,e,a,o,r,i,c){this._overlay=t,this._element=n,this._viewContainerRef=e,this._parentMenu=o,this._menuItemInstance=r,this._dir=i,this._focusMonitor=c,this._overlayRef=null,this._menuOpen=!1,this._closingActionsSubscription=s.EMPTY,this._hoverSubscription=s.EMPTY,this._menuCloseSubscription=s.EMPTY,this._handleTouchStart=()=>this._openedBy="touch",this._openedBy=null,this.restoreFocus=!0,this.menuOpened=new Ef,this.onMenuOpen=this.menuOpened,this.menuClosed=new Ef,this.onMenuClose=this.menuClosed,n.nativeElement.addEventListener("touchstart",this._handleTouchStart,Dq),r&&(r._triggersSubmenu=this.triggersSubmenu()),this._scrollStrategy=a}get _deprecatedMatMenuTriggerFor(){return this.menu}set _deprecatedMatMenuTriggerFor(t){this.menu=t}get menu(){return this._menu}set menu(t){t!==this._menu&&(this._menu=t,this._menuCloseSubscription.unsubscribe(),t&&(t!==this._parentMenu||"undefined"!=typeof ngDevMode&&!ngDevMode||(function n(){throw Error("matMenuTriggerFor: menu cannot contain its own trigger. Assign a menu that is not a parent of the trigger or move the trigger outside of the menu.")})(),this._menuCloseSubscription=t.close.subscribe((t=>{this._destroyMenu(),"click"!==t&&"tab"!==t||!this._parentMenu||this._parentMenu.closed.emit(t)}))))}ngAfterContentInit(){this._checkMenu(),this._handleHover()}ngOnDestroy(){this._overlayRef&&(this._overlayRef.dispose(),this._overlayRef=null),this._element.nativeElement.removeEventListener("touchstart",this._handleTouchStart,Dq),this._menuCloseSubscription.unsubscribe(),this._closingActionsSubscription.unsubscribe(),this._hoverSubscription.unsubscribe()}get menuOpen(){return this._menuOpen}get dir(){return this._dir&&"rtl"===this._dir.value?"rtl":"ltr"}triggersSubmenu(){return!(!this._menuItemInstance||!this._parentMenu)}toggleMenu(){return this._menuOpen?this.closeMenu():this.openMenu()}openMenu(){if(this._menuOpen)return;this._checkMenu();const t=this._createOverlay(),n=t.getConfig();this._setPosition(n.positionStrategy),n.hasBackdrop=null==this.menu.hasBackdrop?!this.triggersSubmenu():this.menu.hasBackdrop,t.attach(this._getPortal()),this.menu.lazyContent&&this.menu.lazyContent.attach(this.menuData),this._closingActionsSubscription=this._menuClosingActions().subscribe((()=>this.closeMenu())),this._initMenu(),this.menu instanceof Sq&&this.menu._startAnimation()}closeMenu(){this.menu.close.emit()}focus(t="program",n){this._focusMonitor?this._focusMonitor.focusVia(this._element,t,n):this._element.nativeElement.focus(n)}_destroyMenu(){if(!this._overlayRef||!this.menuOpen)return;const t=this.menu;this._closingActionsSubscription.unsubscribe(),this._overlayRef.detach(),this._restoreFocus(),t instanceof Sq?(t._resetAnimation(),t.lazyContent?t._animationDone.pipe(Gt((t=>"void"===t.toState)),Tn(1),de(t.lazyContent._attached)).subscribe({next:()=>t.lazyContent.detach(),complete:()=>this._setIsMenuOpen(!1)}):this._setIsMenuOpen(!1)):(this._setIsMenuOpen(!1),t.lazyContent&&t.lazyContent.detach())}_initMenu(){this.menu.parentMenu=this.triggersSubmenu()?this._parentMenu:void 0,this.menu.direction=this.dir,this._setMenuElevation(),this._setIsMenuOpen(!0),this.menu.focusFirstItem(this._openedBy||"program")}_setMenuElevation(){if(this.menu.setElevation){let t=0,n=this.menu.parentMenu;for(;n;)t++,n=n.parentMenu;this.menu.setElevation(t)}}_restoreFocus(){this.restoreFocus&&(this._openedBy?this.triggersSubmenu()||this.focus(this._openedBy):this.focus()),this._openedBy=null}_setIsMenuOpen(t){this._menuOpen=t,this._menuOpen?this.menuOpened.emit():this.menuClosed.emit(),this.triggersSubmenu()&&(this._menuItemInstance._highlighted=t)}_checkMenu(){this.menu||"undefined"!=typeof ngDevMode&&!ngDevMode||(function t(){throw Error('matMenuTriggerFor: must pass in an mat-menu instance.\n\n    Example:\n      <mat-menu #menu="matMenu"></mat-menu>\n      <button [matMenuTriggerFor]="menu"></button>')})()}_createOverlay(){if(!this._overlayRef){const t=this._getOverlayConfig();this._subscribeToPositions(t.positionStrategy),this._overlayRef=this._overlay.create(t),this._overlayRef.keydownEvents().subscribe()}return this._overlayRef}_getOverlayConfig(){return new XA({positionStrategy:this._overlay.position().flexibleConnectedTo(this._element).withLockedPosition().withTransformOriginOn(".mat-menu-panel, .mat-mdc-menu-panel"),backdropClass:this.menu.backdropClass||"cdk-overlay-transparent-backdrop",panelClass:this.menu.overlayPanelClass,scrollStrategy:this._scrollStrategy(),direction:this._dir})}_subscribeToPositions(t){this.menu.setPositionClasses&&t.positionChanges.subscribe((t=>{this.menu.setPositionClasses("start"===t.connectionPair.overlayX?"after":"before","top"===t.connectionPair.overlayY?"below":"above")}))}_setPosition(t){let[n,e]="before"===this.menu.xPosition?["end","start"]:["start","end"],[a,o]="above"===this.menu.yPosition?["bottom","top"]:["top","bottom"],[r,i]=[a,o],[c,s]=[n,e],l=0;this.triggersSubmenu()?(s=n="before"===this.menu.xPosition?"start":"end",e=c="end"===n?"start":"end",l="bottom"===a?8:-8):this.menu.overlapTrigger||(r="top"===a?"bottom":"top",i="top"===o?"bottom":"top"),t.withPositions([{originX:n,originY:r,overlayX:c,overlayY:a,offsetY:l},{originX:e,originY:r,overlayX:s,overlayY:a,offsetY:l},{originX:n,originY:i,overlayX:c,overlayY:o,offsetY:-l},{originX:e,originY:i,overlayX:s,overlayY:o,offsetY:-l}])}_menuClosingActions(){const t=this._overlayRef.backdropClick(),n=this._overlayRef.detachments();return Wt(t,this._parentMenu?this._parentMenu.closed:Z(),this._parentMenu?this._parentMenu._hovered().pipe(Gt((t=>t!==this._menuItemInstance)),Gt((()=>this._menuOpen))):Z(),n)}_handleMousedown(t){AS(t)||(this._openedBy=0===t.button?"mouse":null,this.triggersSubmenu()&&t.preventDefault())}_handleKeydown(t){const n=t.keyCode;this.triggersSubmenu()&&(39===n&&"ltr"===this.dir||37===n&&"rtl"===this.dir)&&this.openMenu()}_handleClick(t){this.triggersSubmenu()?(t.stopPropagation(),this.openMenu()):this.toggleMenu()}_handleHover(){this.triggersSubmenu()&&(this._hoverSubscription=this._parentMenu._hovered().pipe(Gt((t=>t===this._menuItemInstance&&!t.disabled)),fn(0,lt)).subscribe((()=>{this._openedBy="mouse",this.menu instanceof Sq&&this.menu._isAnimating?this.menu._animationDone.pipe(Tn(1),fn(0,lt),de(this._parentMenu._hovered())).subscribe((()=>this.openMenu())):this.openMenu()})))}_getPortal(){return this._portal&&this._portal.templateRef===this.menu.templateRef||(this._portal=new AA(this.menu.templateRef,this._viewContainerRef)),this._portal}}Iq.ɵfac=function t(n){return new(n||Iq)(Zg(hz),Zg(xu),Zg($u),Zg(zq),Zg(Sq,8),Zg(xq,10),Zg(US,8),Zg(TS))},Iq.ɵdir=vo({type:Iq,selectors:[["","mat-menu-trigger-for",""],["","matMenuTriggerFor",""]],hostAttrs:["aria-haspopup","true",1,"mat-menu-trigger"],hostVars:2,hostBindings:function t(n,e){1&n&&cp("mousedown",(function t(n){return e._handleMousedown(n)}))("keydown",(function t(n){return e._handleKeydown(n)}))("click",(function t(n){return e._handleClick(n)})),2&n&&Ng("aria-expanded",e.menuOpen||null)("aria-controls",e.menuOpen?e.menu.panelId:null)},inputs:{restoreFocus:["matMenuTriggerRestoreFocus","restoreFocus"],_deprecatedMatMenuTriggerFor:["mat-menu-trigger-for","_deprecatedMatMenuTriggerFor"],menu:["matMenuTriggerFor","menu"],menuData:["matMenuTriggerData","menuData"]},outputs:{menuOpened:"menuOpened",onMenuOpen:"onMenuOpen",menuClosed:"menuClosed",onMenuClose:"onMenuClose"},exportAs:["matMenuTrigger"]}),Iq.ctorParameters=()=>[{type:hz},{type:xu},{type:$u},{type:void 0,decorators:[{type:Ie,args:[zq]}]},{type:Sq,decorators:[{type:Ne}]},{type:xq,decorators:[{type:Ne},{type:Fe}]},{type:US,decorators:[{type:Ne}]},{type:TS}],Iq.propDecorators={_deprecatedMatMenuTriggerFor:[{type:f_,args:["mat-menu-trigger-for"]}],menu:[{type:f_,args:["matMenuTriggerFor"]}],menuData:[{type:f_,args:["matMenuTriggerData"]}],restoreFocus:[{type:f_,args:["matMenuTriggerRestoreFocus"]}],menuOpened:[{type:h_}],onMenuOpen:[{type:h_}],menuClosed:[{type:h_}],onMenuClose:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class Nq{}Nq.ɵmod=xo({type:Nq}),Nq.ɵinj=Ge({factory:function t(n){return new(n||Nq)},providers:[Rq],imports:[tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Nq,{declarations:function(){return[Iq,Mq]},exports:function(){return[Iq,Mq,tE]}});class Fq{}Fq.ɵmod=xo({type:Fq}),Fq.ɵinj=Ge({factory:function t(n){return new(n||Fq)},providers:[Rq],imports:[[PO,tE,RE,yz,Nq],kA,tE,Nq]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Fq,{declarations:function(){return[Aq,xq]},imports:function(){return[PO,tE,RE,yz,Nq]},exports:function(){return[kA,tE,Aq,xq,Nq]}});const Lq={tooltipState:SP("state",[RP("initial, void, hidden",zP({opacity:0,transform:"scale(0)"})),RP("visible",zP({transform:"scale(1)"})),DP("* => visible",EP("200ms cubic-bezier(0, 0, 0.2, 1)",TP([zP({opacity:0,transform:"scale(0)",offset:0}),zP({opacity:.5,transform:"scale(0.99)",offset:.5}),zP({opacity:1,transform:"scale(1)",offset:1})]))),DP("* => hidden",EP("100ms cubic-bezier(0, 0, 0.2, 1)",zP({opacity:0})))])},Hq=Nw({passive:!0});function Bq(t){return Error(`Tooltip position "${t}" is invalid.`)}const Vq=new Fa("mat-tooltip-scroll-strategy"),jq={provide:Vq,deps:[hz],useFactory:function Uq(t){return()=>t.scrollStrategies.reposition({scrollThrottle:20})}},Wq=new Fa("mat-tooltip-default-options",{providedIn:"root",factory:function Gq(){return{showDelay:0,hideDelay:0,touchendHideDelay:1500}}});class Yq{constructor(t,n,e,a,o,r,i,c,s,l,m){this._overlay=t,this._elementRef=n,this._scrollDispatcher=e,this._viewContainerRef=a,this._ngZone=o,this._platform=r,this._ariaDescriber=i,this._focusMonitor=c,this._dir=l,this._defaultOptions=m,this._position="below",this._disabled=!1,this._viewInitialized=!1,this._pointerExitEventsInitialized=!1,this.showDelay=this._defaultOptions.showDelay,this.hideDelay=this._defaultOptions.hideDelay,this.touchGestures="auto",this._message="",this._passiveListeners=[],this._destroyed=new x,this._handleKeydown=t=>{this._isTooltipVisible()&&t.keyCode===Bw&&!Ww(t)&&(t.preventDefault(),t.stopPropagation(),this._ngZone.run((()=>this.hide(0))))},this._scrollStrategy=s,m&&(m.position&&(this.position=m.position),m.touchGestures&&(this.touchGestures=m.touchGestures)),o.runOutsideAngular((()=>{n.nativeElement.addEventListener("keydown",this._handleKeydown)}))}get position(){return this._position}set position(t){t!==this._position&&(this._position=t,this._overlayRef&&(this._updatePosition(),this._tooltipInstance&&this._tooltipInstance.show(0),this._overlayRef.updatePosition()))}get disabled(){return this._disabled}set disabled(t){this._disabled=Gw(t),this._disabled?this.hide(0):this._setupPointerEnterEventsIfNeeded()}get message(){return this._message}set message(t){this._ariaDescriber.removeDescription(this._elementRef.nativeElement,this._message),this._message=null!=t?String(t).trim():"",!this._message&&this._isTooltipVisible()?this.hide(0):(this._setupPointerEnterEventsIfNeeded(),this._updateTooltipMessage(),this._ngZone.runOutsideAngular((()=>{Promise.resolve().then((()=>{this._ariaDescriber.describe(this._elementRef.nativeElement,this.message)}))})))}get tooltipClass(){return this._tooltipClass}set tooltipClass(t){this._tooltipClass=t,this._tooltipInstance&&this._setTooltipClass(this._tooltipClass)}ngAfterViewInit(){this._viewInitialized=!0,this._setupPointerEnterEventsIfNeeded(),this._focusMonitor.monitor(this._elementRef).pipe(de(this._destroyed)).subscribe((t=>{t?"keyboard"===t&&this._ngZone.run((()=>this.show())):this._ngZone.run((()=>this.hide(0)))}))}ngOnDestroy(){const t=this._elementRef.nativeElement;clearTimeout(this._touchstartTimeout),this._overlayRef&&(this._overlayRef.dispose(),this._tooltipInstance=null),t.removeEventListener("keydown",this._handleKeydown),this._passiveListeners.forEach((([n,e])=>{t.removeEventListener(n,e,Hq)})),this._passiveListeners.length=0,this._destroyed.next(),this._destroyed.complete(),this._ariaDescriber.removeDescription(t,this.message),this._focusMonitor.stopMonitoring(t)}show(t=this.showDelay){if(this.disabled||!this.message||this._isTooltipVisible()&&!this._tooltipInstance._showTimeoutId&&!this._tooltipInstance._hideTimeoutId)return;const n=this._createOverlay();this._detach(),this._portal=this._portal||new EA(qq,this._viewContainerRef),this._tooltipInstance=n.attach(this._portal).instance,this._tooltipInstance.afterHidden().pipe(de(this._destroyed)).subscribe((()=>this._detach())),this._setTooltipClass(this._tooltipClass),this._updateTooltipMessage(),this._tooltipInstance.show(t)}hide(t=this.hideDelay){this._tooltipInstance&&this._tooltipInstance.hide(t)}toggle(){this._isTooltipVisible()?this.hide():this.show()}_isTooltipVisible(){return!!this._tooltipInstance&&this._tooltipInstance.isVisible()}_createOverlay(){if(this._overlayRef)return this._overlayRef;const t=this._scrollDispatcher.getAncestorScrollContainers(this._elementRef),n=this._overlay.position().flexibleConnectedTo(this._elementRef).withTransformOriginOn(".mat-tooltip").withFlexibleDimensions(!1).withViewportMargin(8).withScrollableContainers(t);return n.positionChanges.pipe(de(this._destroyed)).subscribe((t=>{this._tooltipInstance&&t.scrollableViewProperties.isOverlayClipped&&this._tooltipInstance.isVisible()&&this._ngZone.run((()=>this.hide(0)))})),this._overlayRef=this._overlay.create({direction:this._dir,positionStrategy:n,panelClass:"mat-tooltip-panel",scrollStrategy:this._scrollStrategy()}),this._updatePosition(),this._overlayRef.detachments().pipe(de(this._destroyed)).subscribe((()=>this._detach())),this._overlayRef}_detach(){this._overlayRef&&this._overlayRef.hasAttached()&&this._overlayRef.detach(),this._tooltipInstance=null}_updatePosition(){const t=this._overlayRef.getConfig().positionStrategy,n=this._getOrigin(),e=this._getOverlayPosition();t.withPositions([Object.assign(Object.assign({},n.main),e.main),Object.assign(Object.assign({},n.fallback),e.fallback)])}_getOrigin(){const t=!this._dir||"ltr"==this._dir.value,n=this.position;let e;if("above"==n||"below"==n)e={originX:"center",originY:"above"==n?"top":"bottom"};else if("before"==n||"left"==n&&t||"right"==n&&!t)e={originX:"start",originY:"center"};else if("after"==n||"right"==n&&t||"left"==n&&!t)e={originX:"end",originY:"center"};else if("undefined"==typeof ngDevMode||ngDevMode)throw Bq(n);const{x:a,y:o}=this._invertPosition(e.originX,e.originY);return{main:e,fallback:{originX:a,originY:o}}}_getOverlayPosition(){const t=!this._dir||"ltr"==this._dir.value,n=this.position;let e;if("above"==n)e={overlayX:"center",overlayY:"bottom"};else if("below"==n)e={overlayX:"center",overlayY:"top"};else if("before"==n||"left"==n&&t||"right"==n&&!t)e={overlayX:"end",overlayY:"center"};else if("after"==n||"right"==n&&t||"left"==n&&!t)e={overlayX:"start",overlayY:"center"};else if("undefined"==typeof ngDevMode||ngDevMode)throw Bq(n);const{x:a,y:o}=this._invertPosition(e.overlayX,e.overlayY);return{main:e,fallback:{overlayX:a,overlayY:o}}}_updateTooltipMessage(){this._tooltipInstance&&(this._tooltipInstance.message=this.message,this._tooltipInstance._markForCheck(),this._ngZone.onMicrotaskEmpty.pipe(Tn(1),de(this._destroyed)).subscribe((()=>{this._tooltipInstance&&this._overlayRef.updatePosition()})))}_setTooltipClass(t){this._tooltipInstance&&(this._tooltipInstance.tooltipClass=t,this._tooltipInstance._markForCheck())}_invertPosition(t,n){return"above"===this.position||"below"===this.position?"top"===n?n="bottom":"bottom"===n&&(n="top"):"end"===t?t="start":"start"===t&&(t="end"),{x:t,y:n}}_setupPointerEnterEventsIfNeeded(){!this._disabled&&this.message&&this._viewInitialized&&!this._passiveListeners.length&&(this._platformSupportsMouseEvents()?this._passiveListeners.push(["mouseenter",()=>{this._setupPointerExitEventsIfNeeded(),this.show()}]):"off"!==this.touchGestures&&(this._disableNativeGesturesIfNecessary(),this._passiveListeners.push(["touchstart",()=>{this._setupPointerExitEventsIfNeeded(),clearTimeout(this._touchstartTimeout),this._touchstartTimeout=setTimeout((()=>this.show()),500)}])),this._addListeners(this._passiveListeners))}_setupPointerExitEventsIfNeeded(){if(this._pointerExitEventsInitialized)return;this._pointerExitEventsInitialized=!0;const t=[];if(this._platformSupportsMouseEvents())t.push(["mouseleave",()=>this.hide()]);else if("off"!==this.touchGestures){this._disableNativeGesturesIfNecessary();const n=()=>{clearTimeout(this._touchstartTimeout),this.hide(this._defaultOptions.touchendHideDelay)};t.push(["touchend",n],["touchcancel",n])}this._addListeners(t),this._passiveListeners.push(...t)}_addListeners(t){t.forEach((([t,n])=>{this._elementRef.nativeElement.addEventListener(t,n,Hq)}))}_platformSupportsMouseEvents(){return!this._platform.IOS&&!this._platform.ANDROID}_disableNativeGesturesIfNecessary(){const t=this.touchGestures;if("off"!==t){const n=this._elementRef.nativeElement,e=n.style;("on"===t||"INPUT"!==n.nodeName&&"TEXTAREA"!==n.nodeName)&&(e.userSelect=e.msUserSelect=e.webkitUserSelect=e.MozUserSelect="none"),"on"!==t&&n.draggable||(e.webkitUserDrag="none"),e.touchAction="none",e.webkitTapHighlightColor="transparent"}}}Yq.ɵfac=function t(n){return new(n||Yq)(Zg(hz),Zg(xu),Zg(_A),Zg($u),Zg(J_),Zg(Sw),Zg(cS),Zg(TS),Zg(Vq),Zg(US,8),Zg(Wq,8))},Yq.ɵdir=vo({type:Yq,selectors:[["","matTooltip",""]],hostAttrs:[1,"mat-tooltip-trigger"],inputs:{showDelay:["matTooltipShowDelay","showDelay"],hideDelay:["matTooltipHideDelay","hideDelay"],touchGestures:["matTooltipTouchGestures","touchGestures"],position:["matTooltipPosition","position"],disabled:["matTooltipDisabled","disabled"],message:["matTooltip","message"],tooltipClass:["matTooltipClass","tooltipClass"]},exportAs:["matTooltip"]}),Yq.ctorParameters=()=>[{type:hz},{type:xu},{type:_A},{type:$u},{type:J_},{type:Sw},{type:cS},{type:TS},{type:void 0,decorators:[{type:Ie,args:[Vq]}]},{type:US,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[Wq]}]}],Yq.propDecorators={position:[{type:f_,args:["matTooltipPosition"]}],disabled:[{type:f_,args:["matTooltipDisabled"]}],showDelay:[{type:f_,args:["matTooltipShowDelay"]}],hideDelay:[{type:f_,args:["matTooltipHideDelay"]}],touchGestures:[{type:f_,args:["matTooltipTouchGestures"]}],message:[{type:f_,args:["matTooltip"]}],tooltipClass:[{type:f_,args:["matTooltipClass"]}]};class qq{constructor(t,n){this._changeDetectorRef=t,this._breakpointObserver=n,this._visibility="initial",this._closeOnInteraction=!1,this._onHide=new x,this._isHandset=this._breakpointObserver.observe("(max-width: 599.99px) and (orientation: portrait), (max-width: 959.99px) and (orientation: landscape)")}show(t){this._hideTimeoutId&&(clearTimeout(this._hideTimeoutId),this._hideTimeoutId=null),this._closeOnInteraction=!0,this._showTimeoutId=setTimeout((()=>{this._visibility="visible",this._showTimeoutId=null,this._markForCheck()}),t)}hide(t){this._showTimeoutId&&(clearTimeout(this._showTimeoutId),this._showTimeoutId=null),this._hideTimeoutId=setTimeout((()=>{this._visibility="hidden",this._hideTimeoutId=null,this._markForCheck()}),t)}afterHidden(){return this._onHide}isVisible(){return"visible"===this._visibility}ngOnDestroy(){this._onHide.complete()}_animationStart(){this._closeOnInteraction=!1}_animationDone(t){const n=t.toState;"hidden"!==n||this.isVisible()||this._onHide.next(),"visible"!==n&&"hidden"!==n||(this._closeOnInteraction=!0)}_handleBodyInteraction(){this._closeOnInteraction&&this.hide(0)}_markForCheck(){this._changeDetectorRef.markForCheck()}}qq.ɵfac=function t(n){return new(n||qq)(Zg(Vm),Zg(zz))},qq.ɵcmp=_o({type:qq,selectors:[["mat-tooltip-component"]],hostAttrs:["aria-hidden","true"],hostVars:2,hostBindings:function t(n,e){1&n&&cp("click",(function t(){return e._handleBodyInteraction()}),!1,or),2&n&&Tp("zoom","visible"===e._visibility?1:null)},decls:3,vars:7,consts:[[1,"mat-tooltip",3,"ngClass"]],template:function t(n,e){var a;1&n&&(Kg(0,"div",0),cp("@state.start",(function t(){return e._animationStart()}))("@state.done",(function t(n){return e._animationDone(n)})),yf(1,"async"),Jp(2),$g()),2&n&&(Dp("mat-tooltip-handset",null==(a=kf(1,5,e._isHandset))?null:a.matches),Jg("ngClass",e.tooltipClass)("@state",e._visibility),ws(2),Qp(e.message))},directives:[HM],pipes:[oO],styles:[".mat-tooltip-panel{pointer-events:none !important}.mat-tooltip{color:#fff;border-radius:4px;margin:14px;max-width:250px;padding-left:8px;padding-right:8px;overflow:hidden;text-overflow:ellipsis}.cdk-high-contrast-active .mat-tooltip{outline:solid 1px}.mat-tooltip-handset{margin:24px;padding-left:16px;padding-right:16px}\n"],encapsulation:2,data:{animation:[Lq.tooltipState]},changeDetection:0}),qq.ctorParameters=()=>[{type:Vm},{type:zz}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class Zq{}function Xq(t,n){if(1&t&&(Kg(0,"mat-option",19),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t),ws(1),Kp(" ",t," ")}}function Jq(t,n){if(1&t){const t=op();Kg(0,"mat-form-field",16),Kg(1,"mat-select",17),cp("selectionChange",(function n(e){return jr(t),gp(2)._changePageSize(e.value)})),Yg(2,Xq,2,2,"mat-option",18),$g(),$g()}if(2&t){const t=gp(2);Jg("appearance",t._formFieldAppearance)("color",t.color),ws(1),Jg("value",t.pageSize)("disabled",t.disabled)("aria-label",t._intl.itemsPerPageLabel),ws(1),Jg("ngForOf",t._displayedPageSizeOptions)}}function Qq(t,n){if(1&t&&(Kg(0,"div",20),Jp(1),$g()),2&t){const t=gp(2);ws(1),Qp(t.pageSize)}}function Kq(t,n){if(1&t&&(Kg(0,"div",12),Kg(1,"div",13),Jp(2),$g(),Yg(3,Jq,3,6,"mat-form-field",14),Yg(4,Qq,2,1,"div",15),$g()),2&t){const t=gp();ws(2),Kp(" ",t._intl.itemsPerPageLabel," "),ws(1),Jg("ngIf",t._displayedPageSizeOptions.length>1),ws(1),Jg("ngIf",t._displayedPageSizeOptions.length<=1)}}function $q(t,n){if(1&t){const t=op();Kg(0,"button",21),cp("click",(function n(){return jr(t),gp().firstPage()})),ui(),Kg(1,"svg",7),tp(2,"path",22),$g(),$g()}if(2&t){const t=gp();Jg("matTooltip",t._intl.firstPageLabel)("matTooltipDisabled",t._previousButtonsDisabled())("matTooltipPosition","above")("disabled",t._previousButtonsDisabled()),Ng("aria-label",t._intl.firstPageLabel)}}function tZ(t,n){if(1&t){const t=op();ui(),fi(),Kg(0,"button",23),cp("click",(function n(){return jr(t),gp().lastPage()})),ui(),Kg(1,"svg",7),tp(2,"path",24),$g(),$g()}if(2&t){const t=gp();Jg("matTooltip",t._intl.lastPageLabel)("matTooltipDisabled",t._nextButtonsDisabled())("matTooltipPosition","above")("disabled",t._nextButtonsDisabled()),Ng("aria-label",t._intl.lastPageLabel)}}Zq.ɵmod=xo({type:Zq}),Zq.ɵinj=Ge({factory:function t(n){return new(n||Zq)},providers:[jq],imports:[[BS,PO,yz,tE],tE,kA]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Zq,{declarations:function(){return[Yq,qq]},imports:function(){return[BS,PO,yz,tE]},exports:function(){return[Yq,qq,tE,kA]}});class nZ{constructor(){this.changes=new x,this.itemsPerPageLabel="Items per page:",this.nextPageLabel="Next page",this.previousPageLabel="Previous page",this.firstPageLabel="First page",this.lastPageLabel="Last page",this.getRangeLabel=(t,n,e)=>{if(0==e||0==n)return`0 of ${e}`;const a=t*n;return`${a+1} – ${a<(e=Math.max(e,0))?Math.min(a+n,e):a+n} of ${e}`}}}nZ.ɵfac=function t(n){return new(n||nZ)},nZ.ɵprov=We({factory:function t(){return new nZ},token:nZ,providedIn:"root"});const eZ={provide:nZ,deps:[[new Ne,new Le,nZ]],useFactory:function aZ(t){return t||new nZ}},oZ=new Fa("MAT_PAGINATOR_DEFAULT_OPTIONS"),rZ=nE(iE(class{}));
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class iZ extends rZ{constructor(t,n,e){if(super(),this._intl=t,this._changeDetectorRef=n,this._pageIndex=0,this._length=0,this._pageSizeOptions=[],this._hidePageSize=!1,this._showFirstLastButtons=!1,this.page=new Ef,this._intlChanges=t.changes.subscribe((()=>this._changeDetectorRef.markForCheck())),e){const{pageSize:t,pageSizeOptions:n,hidePageSize:a,showFirstLastButtons:o,formFieldAppearance:r}=e;null!=t&&(this._pageSize=t),null!=n&&(this._pageSizeOptions=n),null!=a&&(this._hidePageSize=a),null!=o&&(this._showFirstLastButtons=o),null!=r&&(this._formFieldAppearance=r)}}get pageIndex(){return this._pageIndex}set pageIndex(t){this._pageIndex=Math.max(Yw(t),0),this._changeDetectorRef.markForCheck()}get length(){return this._length}set length(t){this._length=Yw(t),this._changeDetectorRef.markForCheck()}get pageSize(){return this._pageSize}set pageSize(t){this._pageSize=Math.max(Yw(t),0),this._updateDisplayedPageSizeOptions()}get pageSizeOptions(){return this._pageSizeOptions}set pageSizeOptions(t){this._pageSizeOptions=(t||[]).map((t=>Yw(t))),this._updateDisplayedPageSizeOptions()}get hidePageSize(){return this._hidePageSize}set hidePageSize(t){this._hidePageSize=Gw(t)}get showFirstLastButtons(){return this._showFirstLastButtons}set showFirstLastButtons(t){this._showFirstLastButtons=Gw(t)}ngOnInit(){this._initialized=!0,this._updateDisplayedPageSizeOptions(),this._markInitialized()}ngOnDestroy(){this._intlChanges.unsubscribe()}nextPage(){if(!this.hasNextPage())return;const t=this.pageIndex;this.pageIndex++,this._emitPageEvent(t)}previousPage(){if(!this.hasPreviousPage())return;const t=this.pageIndex;this.pageIndex--,this._emitPageEvent(t)}firstPage(){if(!this.hasPreviousPage())return;const t=this.pageIndex;this.pageIndex=0,this._emitPageEvent(t)}lastPage(){if(!this.hasNextPage())return;const t=this.pageIndex;this.pageIndex=this.getNumberOfPages()-1,this._emitPageEvent(t)}hasPreviousPage(){return this.pageIndex>=1&&0!=this.pageSize}hasNextPage(){const t=this.getNumberOfPages()-1;return this.pageIndex<t&&0!=this.pageSize}getNumberOfPages(){return this.pageSize?Math.ceil(this.length/this.pageSize):0}_changePageSize(t){const n=this.pageIndex;this.pageIndex=Math.floor(this.pageIndex*this.pageSize/t)||0,this.pageSize=t,this._emitPageEvent(n)}_nextButtonsDisabled(){return this.disabled||!this.hasNextPage()}_previousButtonsDisabled(){return this.disabled||!this.hasPreviousPage()}_updateDisplayedPageSizeOptions(){this._initialized&&(this.pageSize||(this._pageSize=0!=this.pageSizeOptions.length?this.pageSizeOptions[0]:50),this._displayedPageSizeOptions=this.pageSizeOptions.slice(),-1===this._displayedPageSizeOptions.indexOf(this.pageSize)&&this._displayedPageSizeOptions.push(this.pageSize),this._displayedPageSizeOptions.sort(((t,n)=>t-n)),this._changeDetectorRef.markForCheck())}_emitPageEvent(t){this.page.emit({previousPageIndex:t,pageIndex:this.pageIndex,pageSize:this.pageSize,length:this.length})}}iZ.ɵfac=function t(n){return new(n||iZ)(Zg(nZ),Zg(Vm),Zg(oZ,8))},iZ.ɵcmp=_o({type:iZ,selectors:[["mat-paginator"]],hostAttrs:[1,"mat-paginator"],inputs:{disabled:"disabled",pageIndex:"pageIndex",length:"length",pageSize:"pageSize",pageSizeOptions:"pageSizeOptions",hidePageSize:"hidePageSize",showFirstLastButtons:"showFirstLastButtons",color:"color"},outputs:{page:"page"},exportAs:["matPaginator"],features:[hg],decls:14,vars:14,consts:[[1,"mat-paginator-outer-container"],[1,"mat-paginator-container"],["class","mat-paginator-page-size",4,"ngIf"],[1,"mat-paginator-range-actions"],[1,"mat-paginator-range-label"],["mat-icon-button","","type","button","class","mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-previous",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["viewBox","0 0 24 24","focusable","false",1,"mat-paginator-icon"],["d","M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-next",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"],["mat-icon-button","","type","button","class","mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click",4,"ngIf"],[1,"mat-paginator-page-size"],[1,"mat-paginator-page-size-label"],["class","mat-paginator-page-size-select",3,"appearance","color",4,"ngIf"],["class","mat-paginator-page-size-value",4,"ngIf"],[1,"mat-paginator-page-size-select",3,"appearance","color"],[3,"value","disabled","aria-label","selectionChange"],[3,"value",4,"ngFor","ngForOf"],[3,"value"],[1,"mat-paginator-page-size-value"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-first",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z"],["mat-icon-button","","type","button",1,"mat-paginator-navigation-last",3,"matTooltip","matTooltipDisabled","matTooltipPosition","disabled","click"],["d","M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"div",1),Yg(2,Kq,5,3,"div",2),Kg(3,"div",3),Kg(4,"div",4),Jp(5),$g(),Yg(6,$q,3,5,"button",5),Kg(7,"button",6),cp("click",(function t(){return e.previousPage()})),ui(),Kg(8,"svg",7),tp(9,"path",8),$g(),$g(),fi(),Kg(10,"button",9),cp("click",(function t(){return e.nextPage()})),ui(),Kg(11,"svg",7),tp(12,"path",10),$g(),$g(),Yg(13,tZ,3,5,"button",11),$g(),$g(),$g()),2&n&&(ws(2),Jg("ngIf",!e.hidePageSize),ws(3),Kp(" ",e._intl.getRangeLabel(e.pageIndex,e.pageSize,e.length)," "),ws(1),Jg("ngIf",e.showFirstLastButtons),ws(1),Jg("matTooltip",e._intl.previousPageLabel)("matTooltipDisabled",e._previousButtonsDisabled())("matTooltipPosition","above")("disabled",e._previousButtonsDisabled()),Ng("aria-label",e._intl.previousPageLabel),ws(3),Jg("matTooltip",e._intl.nextPageLabel)("matTooltipDisabled",e._nextButtonsDisabled())("matTooltipPosition","above")("disabled",e._nextButtonsDisabled()),Ng("aria-label",e._intl.nextPageLabel),ws(3),Jg("ngIf",e.showFirstLastButtons))},directives:[WM,eA,Yq,_F,jH,jM,YE],styles:[".mat-paginator{display:block}.mat-paginator-outer-container{display:flex}.mat-paginator-container{display:flex;align-items:center;justify-content:flex-end;padding:0 8px;flex-wrap:wrap-reverse;width:100%}.mat-paginator-page-size{display:flex;align-items:baseline;margin-right:8px}[dir=rtl] .mat-paginator-page-size{margin-right:0;margin-left:8px}.mat-paginator-page-size-label{margin:0 4px}.mat-paginator-page-size-select{margin:6px 4px 0 4px;width:56px}.mat-paginator-page-size-select.mat-form-field-appearance-outline{width:64px}.mat-paginator-page-size-select.mat-form-field-appearance-fill{width:64px}.mat-paginator-range-label{margin:0 32px 0 24px}.mat-paginator-range-actions{display:flex;align-items:center}.mat-paginator-icon{width:28px;fill:currentColor}[dir=rtl] .mat-paginator-icon{transform:rotate(180deg)}\n"],encapsulation:2,changeDetection:0}),iZ.ctorParameters=()=>[{type:nZ},{type:Vm},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[oZ]}]}],iZ.propDecorators={color:[{type:f_}],pageIndex:[{type:f_}],length:[{type:f_}],pageSize:[{type:f_}],pageSizeOptions:[{type:f_}],hidePageSize:[{type:f_}],showFirstLastButtons:[{type:f_}],page:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class cZ{}function sZ(t,n){if(1&t&&(ui(),tp(0,"circle",3)),2&t){const t=gp();Tp("animation-name","mat-progress-spinner-stroke-rotate-"+t._spinnerAnimationLabel)("stroke-dashoffset",t._getStrokeDashOffset(),"px")("stroke-dasharray",t._getStrokeCircumference(),"px")("stroke-width",t._getCircleStrokeWidth(),"%"),Ng("r",t._getCircleRadius())}}function lZ(t,n){if(1&t&&(ui(),tp(0,"circle",3)),2&t){const t=gp();Tp("stroke-dashoffset",t._getStrokeDashOffset(),"px")("stroke-dasharray",t._getStrokeCircumference(),"px")("stroke-width",t._getCircleStrokeWidth(),"%"),Ng("r",t._getCircleRadius())}}function mZ(t,n){if(1&t&&(ui(),tp(0,"circle",3)),2&t){const t=gp();Tp("animation-name","mat-progress-spinner-stroke-rotate-"+t._spinnerAnimationLabel)("stroke-dashoffset",t._getStrokeDashOffset(),"px")("stroke-dasharray",t._getStrokeCircumference(),"px")("stroke-width",t._getCircleStrokeWidth(),"%"),Ng("r",t._getCircleRadius())}}function dZ(t,n){if(1&t&&(ui(),tp(0,"circle",3)),2&t){const t=gp();Tp("stroke-dashoffset",t._getStrokeDashOffset(),"px")("stroke-dasharray",t._getStrokeCircumference(),"px")("stroke-width",t._getCircleStrokeWidth(),"%"),Ng("r",t._getCircleRadius())}}cZ.ɵmod=xo({type:cZ}),cZ.ɵinj=Ge({factory:function t(n){return new(n||cZ)},providers:[eZ],imports:[[PO,oA,UH,Zq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(cZ,{declarations:function(){return[iZ]},imports:function(){return[PO,oA,UH,Zq]},exports:function(){return[iZ]}});const gZ=".mat-progress-spinner{display:block;position:relative}.mat-progress-spinner svg{position:absolute;transform:rotate(-90deg);top:0;left:0;transform-origin:center;overflow:visible}.mat-progress-spinner circle{fill:transparent;transform-origin:center;transition:stroke-dashoffset 225ms linear}._mat-animation-noopable.mat-progress-spinner circle{transition:none;animation:none}.cdk-high-contrast-active .mat-progress-spinner circle{stroke:currentColor}.mat-progress-spinner.mat-progress-spinner-indeterminate-animation[mode=indeterminate]{animation:mat-progress-spinner-linear-rotate 2000ms linear infinite}._mat-animation-noopable.mat-progress-spinner.mat-progress-spinner-indeterminate-animation[mode=indeterminate]{transition:none;animation:none}.mat-progress-spinner.mat-progress-spinner-indeterminate-animation[mode=indeterminate] circle{transition-property:stroke;animation-duration:4000ms;animation-timing-function:cubic-bezier(0.35, 0, 0.25, 1);animation-iteration-count:infinite}._mat-animation-noopable.mat-progress-spinner.mat-progress-spinner-indeterminate-animation[mode=indeterminate] circle{transition:none;animation:none}.mat-progress-spinner.mat-progress-spinner-indeterminate-fallback-animation[mode=indeterminate]{animation:mat-progress-spinner-stroke-rotate-fallback 10000ms cubic-bezier(0.87, 0.03, 0.33, 1) infinite}._mat-animation-noopable.mat-progress-spinner.mat-progress-spinner-indeterminate-fallback-animation[mode=indeterminate]{transition:none;animation:none}.mat-progress-spinner.mat-progress-spinner-indeterminate-fallback-animation[mode=indeterminate] circle{transition-property:stroke}._mat-animation-noopable.mat-progress-spinner.mat-progress-spinner-indeterminate-fallback-animation[mode=indeterminate] circle{transition:none;animation:none}@keyframes mat-progress-spinner-linear-rotate{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}@keyframes mat-progress-spinner-stroke-rotate-100{0%{stroke-dashoffset:268.606171575px;transform:rotate(0)}12.5%{stroke-dashoffset:56.5486677px;transform:rotate(0)}12.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(72.5deg)}25%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(72.5deg)}25.0001%{stroke-dashoffset:268.606171575px;transform:rotate(270deg)}37.5%{stroke-dashoffset:56.5486677px;transform:rotate(270deg)}37.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(161.5deg)}50%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(161.5deg)}50.0001%{stroke-dashoffset:268.606171575px;transform:rotate(180deg)}62.5%{stroke-dashoffset:56.5486677px;transform:rotate(180deg)}62.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(251.5deg)}75%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(251.5deg)}75.0001%{stroke-dashoffset:268.606171575px;transform:rotate(90deg)}87.5%{stroke-dashoffset:56.5486677px;transform:rotate(90deg)}87.5001%{stroke-dashoffset:56.5486677px;transform:rotateX(180deg) rotate(341.5deg)}100%{stroke-dashoffset:268.606171575px;transform:rotateX(180deg) rotate(341.5deg)}}@keyframes mat-progress-spinner-stroke-rotate-fallback{0%{transform:rotate(0deg)}25%{transform:rotate(1170deg)}50%{transform:rotate(2340deg)}75%{transform:rotate(3510deg)}100%{transform:rotate(4680deg)}}\n",pZ=eE(class{constructor(t){this._elementRef=t}},"primary"),bZ=new Fa("mat-progress-spinner-default-options",{providedIn:"root",factory:function uZ(){return{diameter:100}}});class fZ extends pZ{constructor(t,n,e,a,o){super(t),this._elementRef=t,this._document=e,this._diameter=100,this._value=0,this._fallbackAnimation=!1,this.mode="determinate";const r=fZ._diameters;this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),r.has(e.head)||r.set(e.head,new Set([100])),this._fallbackAnimation=n.EDGE||n.TRIDENT,this._noopAnimations="NoopAnimations"===a&&!!o&&!o._forceAnimations,o&&(o.diameter&&(this.diameter=o.diameter),o.strokeWidth&&(this.strokeWidth=o.strokeWidth))}get diameter(){return this._diameter}set diameter(t){this._diameter=Yw(t),this._spinnerAnimationLabel=this._getSpinnerAnimationLabel(),!this._fallbackAnimation&&this._styleRoot&&this._attachStyleNode()}get strokeWidth(){return this._strokeWidth||this.diameter/10}set strokeWidth(t){this._strokeWidth=Yw(t)}get value(){return"determinate"===this.mode?this._value:0}set value(t){this._value=Math.max(0,Math.min(100,Yw(t)))}ngOnInit(){const t=this._elementRef.nativeElement;this._styleRoot=Lw(t)||this._document.head,this._attachStyleNode(),t.classList.add(`mat-progress-spinner-indeterminate${this._fallbackAnimation?"-fallback":""}-animation`)}_getCircleRadius(){return(this.diameter-10)/2}_getViewBox(){const t=2*this._getCircleRadius()+this.strokeWidth;return`0 0 ${t} ${t}`}_getStrokeCircumference(){return 2*Math.PI*this._getCircleRadius()}_getStrokeDashOffset(){return"determinate"===this.mode?this._getStrokeCircumference()*(100-this._value)/100:this._fallbackAnimation&&"indeterminate"===this.mode?.2*this._getStrokeCircumference():null}_getCircleStrokeWidth(){return this.strokeWidth/this.diameter*100}_attachStyleNode(){const t=this._styleRoot,n=this._diameter,e=fZ._diameters;let a=e.get(t);if(!a||!a.has(n)){const o=this._document.createElement("style");o.setAttribute("mat-spinner-animation",this._spinnerAnimationLabel),o.textContent=this._getAnimationText(),t.appendChild(o),a||(a=new Set,e.set(t,a)),a.add(n)}}_getAnimationText(){const t=this._getStrokeCircumference();return"\n @keyframes mat-progress-spinner-stroke-rotate-DIAMETER {\n    0%      { stroke-dashoffset: START_VALUE;  transform: rotate(0); }\n    12.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(0); }\n    12.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(72.5deg); }\n    25%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(72.5deg); }\n\n    25.0001%   { stroke-dashoffset: START_VALUE;  transform: rotate(270deg); }\n    37.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(270deg); }\n    37.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(161.5deg); }\n    50%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(161.5deg); }\n\n    50.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(180deg); }\n    62.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(180deg); }\n    62.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(251.5deg); }\n    75%     { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(251.5deg); }\n\n    75.0001%  { stroke-dashoffset: START_VALUE;  transform: rotate(90deg); }\n    87.5%   { stroke-dashoffset: END_VALUE;    transform: rotate(90deg); }\n    87.5001%  { stroke-dashoffset: END_VALUE;    transform: rotateX(180deg) rotate(341.5deg); }\n    100%    { stroke-dashoffset: START_VALUE;  transform: rotateX(180deg) rotate(341.5deg); }\n  }\n".replace(/START_VALUE/g,""+.95*t).replace(/END_VALUE/g,""+.2*t).replace(/DIAMETER/g,`${this._spinnerAnimationLabel}`)}_getSpinnerAnimationLabel(){return this.diameter.toString().replace(".","_")}}fZ.ɵfac=function t(n){return new(n||fZ)(Zg(xu),Zg(Sw),Zg(zC,8),Zg(dk,8),Zg(bZ))},fZ.ɵcmp=_o({type:fZ,selectors:[["mat-progress-spinner"]],hostAttrs:["role","progressbar",1,"mat-progress-spinner"],hostVars:10,hostBindings:function t(n,e){2&n&&(Ng("aria-valuemin","determinate"===e.mode?0:null)("aria-valuemax","determinate"===e.mode?100:null)("aria-valuenow","determinate"===e.mode?e.value:null)("mode",e.mode),Tp("width",e.diameter,"px")("height",e.diameter,"px"),Dp("_mat-animation-noopable",e._noopAnimations))},inputs:{color:"color",mode:"mode",diameter:"diameter",strokeWidth:"strokeWidth",value:"value"},exportAs:["matProgressSpinner"],features:[hg],decls:3,vars:8,consts:[["preserveAspectRatio","xMidYMid meet","focusable","false",3,"ngSwitch"],["cx","50%","cy","50%",3,"animation-name","stroke-dashoffset","stroke-dasharray","stroke-width",4,"ngSwitchCase"],["cx","50%","cy","50%",3,"stroke-dashoffset","stroke-dasharray","stroke-width",4,"ngSwitchCase"],["cx","50%","cy","50%"]],template:function t(n,e){1&n&&(ui(),Kg(0,"svg",0),Yg(1,sZ,1,9,"circle",1),Yg(2,lZ,1,7,"circle",2),$g()),2&n&&(Tp("width",e.diameter,"px")("height",e.diameter,"px"),Jg("ngSwitch","indeterminate"===e.mode),Ng("viewBox",e._getViewBox()),ws(1),Jg("ngSwitchCase",!0),ws(1),Jg("ngSwitchCase",!1))},directives:[ZM,XM],styles:[gZ],encapsulation:2,changeDetection:0}),fZ._diameters=new WeakMap,fZ.ctorParameters=()=>[{type:xu},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]},{type:void 0,decorators:[{type:Ie,args:[bZ]}]}],fZ.propDecorators={diameter:[{type:f_}],strokeWidth:[{type:f_}],mode:[{type:f_}],value:[{type:f_}]};class hZ extends fZ{constructor(t,n,e,a,o){super(t,n,e,a,o),this.mode="indeterminate"}}hZ.ɵfac=function t(n){return new(n||hZ)(Zg(xu),Zg(Sw),Zg(zC,8),Zg(dk,8),Zg(bZ))},hZ.ɵcmp=_o({type:hZ,selectors:[["mat-spinner"]],hostAttrs:["role","progressbar","mode","indeterminate",1,"mat-spinner","mat-progress-spinner"],hostVars:6,hostBindings:function t(n,e){2&n&&(Tp("width",e.diameter,"px")("height",e.diameter,"px"),Dp("_mat-animation-noopable",e._noopAnimations))},inputs:{color:"color"},features:[hg],decls:3,vars:8,consts:[["preserveAspectRatio","xMidYMid meet","focusable","false",3,"ngSwitch"],["cx","50%","cy","50%",3,"animation-name","stroke-dashoffset","stroke-dasharray","stroke-width",4,"ngSwitchCase"],["cx","50%","cy","50%",3,"stroke-dashoffset","stroke-dasharray","stroke-width",4,"ngSwitchCase"],["cx","50%","cy","50%"]],template:function t(n,e){1&n&&(ui(),Kg(0,"svg",0),Yg(1,mZ,1,9,"circle",1),Yg(2,dZ,1,7,"circle",2),$g()),2&n&&(Tp("width",e.diameter,"px")("height",e.diameter,"px"),Jg("ngSwitch","indeterminate"===e.mode),Ng("viewBox",e._getViewBox()),ws(1),Jg("ngSwitchCase",!0),ws(1),Jg("ngSwitchCase",!1))},directives:[ZM,XM],styles:[gZ],encapsulation:2,changeDetection:0}),hZ.ctorParameters=()=>[{type:xu},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]},{type:void 0,decorators:[{type:Ie,args:[bZ]}]}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class _Z{}function CZ(t,n){if(1&t){const t=op();Kg(0,"div",3),cp("@arrowPosition.start",(function n(){return jr(t),gp()._disableViewStateAnimation=!0}))("@arrowPosition.done",(function n(){return jr(t),gp()._disableViewStateAnimation=!1})),tp(1,"div",4),Kg(2,"div",5),tp(3,"div",6),tp(4,"div",7),tp(5,"div",8),$g(),$g()}if(2&t){const t=gp();Jg("@arrowOpacity",t._getArrowViewState())("@arrowPosition",t._getArrowViewState())("@allowChildren",t._getArrowDirectionState()),ws(2),Jg("@indicator",t._getArrowDirectionState()),ws(1),Jg("@leftPointer",t._getArrowDirectionState()),ws(1),Jg("@rightPointer",t._getArrowDirectionState())}}_Z.ɵmod=xo({type:_Z}),_Z.ɵinj=Ge({factory:function t(n){return new(n||_Z)},imports:[[tE,PO],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(_Z,{declarations:function(){return[fZ,hZ]},imports:function(){return[tE,PO]},exports:function(){return[fZ,hZ,tE]}});const MZ=iE(nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{}));class OZ extends MZ{constructor(){super(...arguments),this.sortables=new Map,this._stateChanges=new x,this.start="asc",this._direction="",this.sortChange=new Ef}get direction(){return this._direction}set direction(t){if(t&&"asc"!==t&&"desc"!==t&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(t){return Error(`${t} is not a valid sort direction ('asc' or 'desc').`)})(t);this._direction=t}get disableClear(){return this._disableClear}set disableClear(t){this._disableClear=Gw(t)}register(t){if("undefined"==typeof ngDevMode||ngDevMode){if(!t.id)throw(function n(){return Error("MatSortHeader must be provided with a unique id.")})();if(this.sortables.has(t.id))throw(function e(t){return Error(`Cannot have two MatSortables with the same id (${t}).`)})(t.id)}this.sortables.set(t.id,t)}deregister(t){this.sortables.delete(t.id)}sort(t){this.active!=t.id?(this.active=t.id,this.direction=t.start?t.start:this.start):this.direction=this.getNextSortDirection(t),this.sortChange.emit({active:this.active,direction:this.direction})}getNextSortDirection(t){if(!t)return"";let n=(function e(t,n){let e=["asc","desc"];return"desc"==t&&e.reverse(),n||e.push(""),e}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */)(t.start||this.start,null!=t.disableClear?t.disableClear:this.disableClear),a=n.indexOf(this.direction)+1;return a>=n.length&&(a=0),n[a]}ngOnInit(){this._markInitialized()}ngOnChanges(){this._stateChanges.next()}ngOnDestroy(){this._stateChanges.complete()}}OZ.ɵfac=function t(n){return PZ(n||OZ)},OZ.ɵdir=vo({type:OZ,selectors:[["","matSort",""]],hostAttrs:[1,"mat-sort"],inputs:{disabled:["matSortDisabled","disabled"],start:["matSortStart","start"],direction:["matSortDirection","direction"],disableClear:["matSortDisableClear","disableClear"],active:["matSortActive","active"]},outputs:{sortChange:"matSortChange"},exportAs:["matSort"],features:[hg,pr]}),OZ.propDecorators={active:[{type:f_,args:["matSortActive"]}],start:[{type:f_,args:["matSortStart"]}],direction:[{type:f_,args:["matSortDirection"]}],disableClear:[{type:f_,args:["matSortDisableClear"]}],sortChange:[{type:h_,args:["matSortChange"]}]};const PZ=tc(OZ),xZ=JS.ENTERING+" "+XS.STANDARD_CURVE,yZ={indicator:SP("indicator",[RP("active-asc, asc",zP({transform:"translateY(0px)"})),RP("active-desc, desc",zP({transform:"translateY(10px)"})),DP("active-asc <=> active-desc",EP(xZ))]),leftPointer:SP("leftPointer",[RP("active-asc, asc",zP({transform:"rotate(-45deg)"})),RP("active-desc, desc",zP({transform:"rotate(45deg)"})),DP("active-asc <=> active-desc",EP(xZ))]),rightPointer:SP("rightPointer",[RP("active-asc, asc",zP({transform:"rotate(45deg)"})),RP("active-desc, desc",zP({transform:"rotate(-45deg)"})),DP("active-asc <=> active-desc",EP(xZ))]),arrowOpacity:SP("arrowOpacity",[RP("desc-to-active, asc-to-active, active",zP({opacity:1})),RP("desc-to-hint, asc-to-hint, hint",zP({opacity:.54})),RP("hint-to-desc, active-to-desc, desc, hint-to-asc, active-to-asc, asc, void",zP({opacity:0})),DP("* => asc, * => desc, * => active, * => hint, * => void",EP("0ms")),DP("* <=> *",EP(xZ))]),arrowPosition:SP("arrowPosition",[DP("* => desc-to-hint, * => desc-to-active",EP(xZ,TP([zP({transform:"translateY(-25%)"}),zP({transform:"translateY(0)"})]))),DP("* => hint-to-desc, * => active-to-desc",EP(xZ,TP([zP({transform:"translateY(0)"}),zP({transform:"translateY(25%)"})]))),DP("* => asc-to-hint, * => asc-to-active",EP(xZ,TP([zP({transform:"translateY(25%)"}),zP({transform:"translateY(0)"})]))),DP("* => hint-to-asc, * => active-to-asc",EP(xZ,TP([zP({transform:"translateY(0)"}),zP({transform:"translateY(-25%)"})]))),RP("desc-to-hint, asc-to-hint, hint, desc-to-active, asc-to-active, active",zP({transform:"translateY(0)"})),RP("hint-to-desc, active-to-desc, desc",zP({transform:"translateY(-25%)"})),RP("hint-to-asc, active-to-asc, asc",zP({transform:"translateY(25%)"}))]),allowChildren:SP("allowChildren",[DP("* <=> *",[NP("@*",IP(),{optional:!0})])])};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class kZ{constructor(){this.changes=new x,this.sortButtonLabel=t=>`Change sorting for ${t}`}}kZ.ɵfac=function t(n){return new(n||kZ)},kZ.ɵprov=We({factory:function t(){return new kZ},token:kZ,providedIn:"root"});const vZ={provide:kZ,deps:[[new Ne,new Le,kZ]],useFactory:function wZ(t){return t||new kZ}},SZ=nE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{});class EZ extends SZ{constructor(t,n,e,a,o,r){if(super(),this._intl=t,this._sort=e,this._columnDef=a,this._focusMonitor=o,this._elementRef=r,this._showIndicatorHint=!1,this._arrowDirection="",this._disableViewStateAnimation=!1,this.arrowPosition="after",!e&&("undefined"==typeof ngDevMode||ngDevMode))throw(function i(){return Error("MatSortHeader must be placed within a parent element with the MatSort directive.")})();this._rerenderSubscription=Wt(e.sortChange,e._stateChanges,t.changes).subscribe((()=>{this._isSorted()&&this._updateArrowDirection(),!this._isSorted()&&this._viewState&&"active"===this._viewState.toState&&(this._disableViewStateAnimation=!1,this._setAnimationTransitionState({fromState:"active",toState:this._arrowDirection})),n.markForCheck()}))}get disableClear(){return this._disableClear}set disableClear(t){this._disableClear=Gw(t)}ngOnInit(){!this.id&&this._columnDef&&(this.id=this._columnDef.name),this._updateArrowDirection(),this._setAnimationTransitionState({toState:this._isSorted()?"active":this._arrowDirection}),this._sort.register(this)}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe((t=>this._setIndicatorHintVisible(!!t)))}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef),this._sort.deregister(this),this._rerenderSubscription.unsubscribe()}_setIndicatorHintVisible(t){this._isDisabled()&&t||(this._showIndicatorHint=t,this._isSorted()||(this._updateArrowDirection(),this._setAnimationTransitionState(this._showIndicatorHint?{fromState:this._arrowDirection,toState:"hint"}:{fromState:"hint",toState:this._arrowDirection})))}_setAnimationTransitionState(t){this._viewState=t,this._disableViewStateAnimation&&(this._viewState={toState:t.toState})}_toggleOnInteraction(){this._sort.sort(this),"hint"!==this._viewState.toState&&"active"!==this._viewState.toState||(this._disableViewStateAnimation=!0);const t=this._isSorted()?{fromState:this._arrowDirection,toState:"active"}:{fromState:"active",toState:this._arrowDirection};this._setAnimationTransitionState(t),this._showIndicatorHint=!1}_handleClick(){this._isDisabled()||this._toggleOnInteraction()}_handleKeydown(t){this._isDisabled()||t.keyCode!==Vw&&t.keyCode!==Hw||(t.preventDefault(),this._toggleOnInteraction())}_isSorted(){return this._sort.active==this.id&&("asc"===this._sort.direction||"desc"===this._sort.direction)}_getArrowDirectionState(){return`${this._isSorted()?"active-":""}${this._arrowDirection}`}_getArrowViewState(){const t=this._viewState.fromState;return(t?`${t}-to-`:"")+this._viewState.toState}_updateArrowDirection(){this._arrowDirection=this._isSorted()?this._sort.direction:this.start||this._sort.start}_isDisabled(){return this._sort.disabled||this.disabled}_getAriaSortAttribute(){return this._isSorted()?"asc"==this._sort.direction?"ascending":"descending":"none"}_renderArrow(){return!this._isDisabled()||this._isSorted()}}EZ.ɵfac=function t(n){return new(n||EZ)(Zg(kZ),Zg(Vm),Zg(OZ,8),Zg("MAT_SORT_HEADER_COLUMN_DEF",8),Zg(TS),Zg(xu))},EZ.ɵcmp=_o({type:EZ,selectors:[["","mat-sort-header",""]],hostAttrs:[1,"mat-sort-header"],hostVars:3,hostBindings:function t(n,e){1&n&&cp("click",(function t(){return e._handleClick()}))("keydown",(function t(n){return e._handleKeydown(n)}))("mouseenter",(function t(){return e._setIndicatorHintVisible(!0)}))("mouseleave",(function t(){return e._setIndicatorHintVisible(!1)})),2&n&&(Ng("aria-sort",e._getAriaSortAttribute()),Dp("mat-sort-header-disabled",e._isDisabled()))},inputs:{disabled:"disabled",arrowPosition:"arrowPosition",disableClear:"disableClear",id:["mat-sort-header","id"],start:"start"},exportAs:["matSortHeader"],features:[hg],attrs:["mat-sort-header",""],ngContentSelectors:["*"],decls:4,vars:6,consts:[["role","button",1,"mat-sort-header-container","mat-focus-indicator"],[1,"mat-sort-header-content"],["class","mat-sort-header-arrow",4,"ngIf"],[1,"mat-sort-header-arrow"],[1,"mat-sort-header-stem"],[1,"mat-sort-header-indicator"],[1,"mat-sort-header-pointer-left"],[1,"mat-sort-header-pointer-right"],[1,"mat-sort-header-pointer-middle"]],template:function t(n,e){1&n&&(bp(),Kg(0,"div",0),Kg(1,"div",1),hp(2),$g(),Yg(3,CZ,6,6,"div",2),$g()),2&n&&(Dp("mat-sort-header-sorted",e._isSorted())("mat-sort-header-position-before","before"==e.arrowPosition),Ng("tabindex",e._isDisabled()?null:0),ws(3),Jg("ngIf",e._renderArrow()))},directives:[WM],styles:[".mat-sort-header-container{display:flex;cursor:pointer;align-items:center;letter-spacing:normal;outline:0}[mat-sort-header].cdk-keyboard-focused .mat-sort-header-container,[mat-sort-header].cdk-program-focused .mat-sort-header-container{border-bottom:solid 1px currentColor}.mat-sort-header-disabled .mat-sort-header-container{cursor:default}.mat-sort-header-content{text-align:center;display:flex;align-items:center}.mat-sort-header-position-before{flex-direction:row-reverse}.mat-sort-header-arrow{height:12px;width:12px;min-width:12px;position:relative;display:flex;opacity:0}.mat-sort-header-arrow,[dir=rtl] .mat-sort-header-position-before .mat-sort-header-arrow{margin:0 0 0 6px}.mat-sort-header-position-before .mat-sort-header-arrow,[dir=rtl] .mat-sort-header-arrow{margin:0 6px 0 0}.mat-sort-header-stem{background:currentColor;height:10px;width:2px;margin:auto;display:flex;align-items:center}.cdk-high-contrast-active .mat-sort-header-stem{width:0;border-left:solid 2px}.mat-sort-header-indicator{width:100%;height:2px;display:flex;align-items:center;position:absolute;top:0;left:0}.mat-sort-header-pointer-middle{margin:auto;height:2px;width:2px;background:currentColor;transform:rotate(45deg)}.cdk-high-contrast-active .mat-sort-header-pointer-middle{width:0;height:0;border-top:solid 2px;border-left:solid 2px}.mat-sort-header-pointer-left,.mat-sort-header-pointer-right{background:currentColor;width:6px;height:2px;position:absolute;top:0}.cdk-high-contrast-active .mat-sort-header-pointer-left,.cdk-high-contrast-active .mat-sort-header-pointer-right{width:0;height:0;border-left:solid 6px;border-top:solid 2px}.mat-sort-header-pointer-left{transform-origin:right;left:0}.mat-sort-header-pointer-right{transform-origin:left;right:0}\n"],encapsulation:2,data:{animation:[yZ.indicator,yZ.leftPointer,yZ.rightPointer,yZ.arrowOpacity,yZ.arrowPosition,yZ.allowChildren]},changeDetection:0}),EZ.ctorParameters=()=>[{type:kZ},{type:Vm},{type:OZ,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ie,args:["MAT_SORT_HEADER_COLUMN_DEF"]},{type:Ne}]},{type:TS},{type:xu}],EZ.propDecorators={id:[{type:f_,args:["mat-sort-header"]}],arrowPosition:[{type:f_}],start:[{type:f_}],disableClear:[{type:f_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class AZ{}AZ.ɵmod=xo({type:AZ}),AZ.ɵinj=Ge({factory:function t(n){return new(n||AZ)},providers:[vZ],imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(AZ,{declarations:function(){return[OZ,EZ]},imports:function(){return[PO]},exports:function(){return[OZ,EZ]}});const zZ=[[["caption"]],[["colgroup"],["col"]]];function RZ(t,n){if(1&t&&(Kg(0,"th",3),Jp(1),$g()),2&t){const t=gp();Tp("text-align",t.justify),ws(1),Kp(" ",t.headerText," ")}}function TZ(t,n){if(1&t&&(Kg(0,"td",4),Jp(1),$g()),2&t){const t=n.$implicit,e=gp();Tp("text-align",e.justify),ws(1),Kp(" ",e.dataAccessor(t,e.name)," ")}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function DZ(t){return class extends t{constructor(...t){super(...t),this._sticky=!1,this._hasStickyChanged=!1}get sticky(){return this._sticky}set sticky(t){const n=this._sticky;this._sticky=Gw(t),this._hasStickyChanged=n!==this._sticky}hasStickyChanged(){const t=this._hasStickyChanged;return this._hasStickyChanged=!1,t}resetStickyChanged(){this._hasStickyChanged=!1}}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */const IZ=new Fa("CDK_TABLE"),NZ=new Fa("text-column-options");
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class FZ{constructor(t){this.template=t}}FZ.ɵfac=function t(n){return new(n||FZ)(Zg(Ju))},FZ.ɵdir=vo({type:FZ,selectors:[["","cdkCellDef",""]]}),FZ.ctorParameters=()=>[{type:Ju}];class LZ{constructor(t){this.template=t}}LZ.ɵfac=function t(n){return new(n||LZ)(Zg(Ju))},LZ.ɵdir=vo({type:LZ,selectors:[["","cdkHeaderCellDef",""]]}),LZ.ctorParameters=()=>[{type:Ju}];class HZ{constructor(t){this.template=t}}HZ.ɵfac=function t(n){return new(n||HZ)(Zg(Ju))},HZ.ɵdir=vo({type:HZ,selectors:[["","cdkFooterCellDef",""]]}),HZ.ctorParameters=()=>[{type:Ju}];const BZ=DZ(class{});class VZ extends BZ{constructor(t){super(),this._table=t,this._stickyEnd=!1}get name(){return this._name}set name(t){this._setNameInput(t)}get stickyEnd(){return this._stickyEnd}set stickyEnd(t){const n=this._stickyEnd;this._stickyEnd=Gw(t),this._hasStickyChanged=n!==this._stickyEnd}_updateColumnCssClassName(){this._columnCssClassName=[`cdk-column-${this.cssClassFriendlyName}`]}_setNameInput(t){t&&(this._name=t,this.cssClassFriendlyName=t.replace(/[^a-z0-9_-]/gi,"-"),this._updateColumnCssClassName())}}VZ.ɵfac=function t(n){return new(n||VZ)(Zg(IZ,8))},VZ.ɵdir=vo({type:VZ,selectors:[["","cdkColumnDef",""]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,FZ,!0),Gf(a,LZ,!0),Gf(a,HZ,!0)),2&n&&(Vf(o=Zf())&&(e.cell=o.first),Vf(o=Zf())&&(e.headerCell=o.first),Vf(o=Zf())&&(e.footerCell=o.first))},inputs:{sticky:"sticky",name:["cdkColumnDef","name"],stickyEnd:"stickyEnd"},features:[Mu([{provide:"MAT_SORT_HEADER_COLUMN_DEF",useExisting:VZ}]),hg]}),VZ.ctorParameters=()=>[{type:void 0,decorators:[{type:Ie,args:[IZ]},{type:Ne}]}],VZ.propDecorators={name:[{type:f_,args:["cdkColumnDef"]}],stickyEnd:[{type:f_,args:["stickyEnd"]}],cell:[{type:Zd,args:[FZ]}],headerCell:[{type:Zd,args:[LZ]}],footerCell:[{type:Zd,args:[HZ]}]};class jZ{constructor(t,n){const e=n.nativeElement.classList;for(const n of t._columnCssClassName)e.add(n)}}class UZ extends jZ{constructor(t,n){super(t,n)}}UZ.ɵfac=function t(n){return new(n||UZ)(Zg(VZ),Zg(xu))},UZ.ɵdir=vo({type:UZ,selectors:[["cdk-header-cell"],["th","cdk-header-cell",""]],hostAttrs:["role","columnheader",1,"cdk-header-cell"],features:[hg]}),UZ.ctorParameters=()=>[{type:VZ},{type:xu}];class WZ extends jZ{constructor(t,n){super(t,n)}}WZ.ɵfac=function t(n){return new(n||WZ)(Zg(VZ),Zg(xu))},WZ.ɵdir=vo({type:WZ,selectors:[["cdk-footer-cell"],["td","cdk-footer-cell",""]],hostAttrs:["role","gridcell",1,"cdk-footer-cell"],features:[hg]}),WZ.ctorParameters=()=>[{type:VZ},{type:xu}];class GZ extends jZ{constructor(t,n){super(t,n)}}GZ.ɵfac=function t(n){return new(n||GZ)(Zg(VZ),Zg(xu))},GZ.ɵdir=vo({type:GZ,selectors:[["cdk-cell"],["td","cdk-cell",""]],hostAttrs:["role","gridcell",1,"cdk-cell"],features:[hg]}),GZ.ctorParameters=()=>[{type:VZ},{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;class YZ{constructor(){this.tasks=[],this.endTasks=[]}}const qZ=new Fa("_COALESCED_STYLE_SCHEDULER");class ZZ{constructor(t){this._ngZone=t,this._currentSchedule=null,this._destroyed=new x}schedule(t){this._createScheduleIfNeeded(),this._currentSchedule.tasks.push(t)}scheduleEnd(t){this._createScheduleIfNeeded(),this._currentSchedule.endTasks.push(t)}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete()}_createScheduleIfNeeded(){this._currentSchedule||(this._currentSchedule=new YZ,this._getScheduleObservable().pipe(de(this._destroyed)).subscribe((()=>{for(;this._currentSchedule.tasks.length||this._currentSchedule.endTasks.length;){const t=this._currentSchedule;this._currentSchedule=new YZ;for(const n of t.tasks)n();for(const n of t.endTasks)n()}this._currentSchedule=null})))}_getScheduleObservable(){return this._ngZone.isStable?Rt(Promise.resolve(void 0)):this._ngZone.onStable.pipe(Tn(1))}}ZZ.ɵfac=function t(n){return new(n||ZZ)(Za(J_))},ZZ.ɵprov=We({token:ZZ,factory:ZZ.ɵfac}),ZZ.ctorParameters=()=>[{type:J_}];class XZ{constructor(t,n){this.template=t,this._differs=n}ngOnChanges(t){if(!this._columnsDiffer){const n=t.columns&&t.columns.currentValue||[];this._columnsDiffer=this._differs.find(n).create(),this._columnsDiffer.diff(n)}}getColumnsDiff(){return this._columnsDiffer.diff(this.columns)}extractCellTemplate(t){return this instanceof QZ?t.headerCell.template:this instanceof $Z?t.footerCell.template:t.cell.template}}XZ.ɵfac=function t(n){return new(n||XZ)(Zg(Ju),Zg(Wu))},XZ.ɵdir=vo({type:XZ,features:[pr]}),XZ.ctorParameters=()=>[{type:Ju},{type:Wu}];const JZ=DZ(class extends XZ{});class QZ extends JZ{constructor(t,n,e){super(t,n),this._table=e}ngOnChanges(t){super.ngOnChanges(t)}}QZ.ɵfac=function t(n){return new(n||QZ)(Zg(Ju),Zg(Wu),Zg(IZ,8))},QZ.ɵdir=vo({type:QZ,selectors:[["","cdkHeaderRowDef",""]],inputs:{columns:["cdkHeaderRowDef","columns"],sticky:["cdkHeaderRowDefSticky","sticky"]},features:[hg,pr]}),QZ.ctorParameters=()=>[{type:Ju},{type:Wu},{type:void 0,decorators:[{type:Ie,args:[IZ]},{type:Ne}]}];const KZ=DZ(class extends XZ{});class $Z extends KZ{constructor(t,n,e){super(t,n),this._table=e}ngOnChanges(t){super.ngOnChanges(t)}}$Z.ɵfac=function t(n){return new(n||$Z)(Zg(Ju),Zg(Wu),Zg(IZ,8))},$Z.ɵdir=vo({type:$Z,selectors:[["","cdkFooterRowDef",""]],inputs:{columns:["cdkFooterRowDef","columns"],sticky:["cdkFooterRowDefSticky","sticky"]},features:[hg,pr]}),$Z.ctorParameters=()=>[{type:Ju},{type:Wu},{type:void 0,decorators:[{type:Ie,args:[IZ]},{type:Ne}]}];class tX extends XZ{constructor(t,n,e){super(t,n),this._table=e}}tX.ɵfac=function t(n){return new(n||tX)(Zg(Ju),Zg(Wu),Zg(IZ,8))},tX.ɵdir=vo({type:tX,selectors:[["","cdkRowDef",""]],inputs:{columns:["cdkRowDefColumns","columns"],when:["cdkRowDefWhen","when"]},features:[hg]}),tX.ctorParameters=()=>[{type:Ju},{type:Wu},{type:void 0,decorators:[{type:Ie,args:[IZ]},{type:Ne}]}];class nX{constructor(t){this._viewContainer=t,nX.mostRecentCellOutlet=this}ngOnDestroy(){nX.mostRecentCellOutlet===this&&(nX.mostRecentCellOutlet=null)}}nX.ɵfac=function t(n){return new(n||nX)(Zg($u))},nX.ɵdir=vo({type:nX,selectors:[["","cdkCellOutlet",""]]}),nX.mostRecentCellOutlet=null,nX.ctorParameters=()=>[{type:$u}];class eX{}eX.ɵfac=function t(n){return new(n||eX)},eX.ɵcmp=_o({type:eX,selectors:[["cdk-header-row"],["tr","cdk-header-row",""]],hostAttrs:["role","row",1,"cdk-header-row"],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});class aX{}aX.ɵfac=function t(n){return new(n||aX)},aX.ɵcmp=_o({type:aX,selectors:[["cdk-footer-row"],["tr","cdk-footer-row",""]],hostAttrs:["role","row",1,"cdk-footer-row"],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});class oX{}oX.ɵfac=function t(n){return new(n||oX)},oX.ɵcmp=_o({type:oX,selectors:[["cdk-row"],["tr","cdk-row",""]],hostAttrs:["role","row",1,"cdk-row"],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});class rX{constructor(t){this.templateRef=t}}rX.ɵfac=function t(n){return new(n||rX)(Zg(Ju))},rX.ɵdir=vo({type:rX,selectors:[["ng-template","cdkNoDataRow",""]]}),rX.ctorParameters=()=>[{type:Ju}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const iX=["top","bottom","left","right"];class cX{constructor(t,n,e,a,o=!0,r=!0){this._isNativeHtmlTable=t,this._stickCellCss=n,this.direction=e,this._coalescedStyleScheduler=a,this._isBrowser=o,this._needsPositionStickyOnElement=r}clearStickyPositioning(t,n){const e=[];for(const n of t)if(n.nodeType===n.ELEMENT_NODE){e.push(n);for(let t=0;t<n.children.length;t++)e.push(n.children[t])}this._scheduleStyleChanges((()=>{for(const t of e)this._removeStickyStyle(t,n)}))}updateStickyColumns(t,n,e){if(!t.length||!this._isBrowser||!n.some((t=>t))&&!e.some((t=>t)))return;const a=t[0],o=a.children.length,r=this._getCellWidths(a),i=this._getStickyStartColumnPositions(r,n),c=this._getStickyEndColumnPositions(r,e);this._scheduleStyleChanges((()=>{const a="rtl"===this.direction,r=a?"right":"left",s=a?"left":"right";for(const a of t)for(let t=0;t<o;t++){const o=a.children[t];n[t]&&this._addStickyStyle(o,r,i[t]),e[t]&&this._addStickyStyle(o,s,c[t])}}))}stickRows(t,n,e){if(!this._isBrowser)return;const a="bottom"===e?t.slice().reverse():t,o="bottom"===e?n.slice().reverse():n,r=[],i=[];for(let t=0,n=0;t<a.length;t++){if(r[t]=n,!o[t])continue;const e=a[t];i[t]=this._isNativeHtmlTable?Array.from(e.children):[e],t!==a.length-1&&(n+=e.getBoundingClientRect().height)}this._scheduleStyleChanges((()=>{for(let t=0;t<a.length;t++){if(!o[t])continue;const n=r[t];for(const a of i[t])this._addStickyStyle(a,e,n)}}))}updateStickyFooterContainer(t,n){if(!this._isNativeHtmlTable)return;const e=t.querySelector("tfoot");this._scheduleStyleChanges((()=>{n.some((t=>!t))?this._removeStickyStyle(e,["bottom"]):this._addStickyStyle(e,"bottom",0)}))}_removeStickyStyle(t,n){for(const e of n)t.style[e]="";iX.some((e=>-1===n.indexOf(e)&&t.style[e]))?t.style.zIndex=this._getCalculatedZIndex(t):(t.style.zIndex="",this._needsPositionStickyOnElement&&(t.style.position=""),t.classList.remove(this._stickCellCss))}_addStickyStyle(t,n,e){t.classList.add(this._stickCellCss),t.style[n]=`${e}px`,t.style.zIndex=this._getCalculatedZIndex(t),this._needsPositionStickyOnElement&&(t.style.cssText+="position: -webkit-sticky; position: sticky; ")}_getCalculatedZIndex(t){const n={top:100,bottom:10,left:1,right:1};let e=0;for(const a of iX)t.style[a]&&(e+=n[a]);return e?`${e}`:""}_getCellWidths(t){const n=[],e=t.children;for(let t=0;t<e.length;t++)n.push(e[t].getBoundingClientRect().width);return n}_getStickyStartColumnPositions(t,n){const e=[];let a=0;for(let o=0;o<t.length;o++)n[o]&&(e[o]=a,a+=t[o]);return e}_getStickyEndColumnPositions(t,n){const e=[];let a=0;for(let o=t.length;o>0;o--)n[o]&&(e[o]=a,a+=t[o]);return e}_scheduleStyleChanges(t){this._coalescedStyleScheduler?this._coalescedStyleScheduler.schedule(t):t()}}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */function sX(t){return Error(`Could not find column with id "${t}".`)}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class lX{constructor(t,n){this.viewContainer=t,this.elementRef=n}}lX.ɵfac=function t(n){return new(n||lX)(Zg($u),Zg(xu))},lX.ɵdir=vo({type:lX,selectors:[["","rowOutlet",""]]}),lX.ctorParameters=()=>[{type:$u},{type:xu}];class mX{constructor(t,n){this.viewContainer=t,this.elementRef=n}}mX.ɵfac=function t(n){return new(n||mX)(Zg($u),Zg(xu))},mX.ɵdir=vo({type:mX,selectors:[["","headerRowOutlet",""]]}),mX.ctorParameters=()=>[{type:$u},{type:xu}];class dX{constructor(t,n){this.viewContainer=t,this.elementRef=n}}dX.ɵfac=function t(n){return new(n||dX)(Zg($u),Zg(xu))},dX.ɵdir=vo({type:dX,selectors:[["","footerRowOutlet",""]]}),dX.ctorParameters=()=>[{type:$u},{type:xu}];class gX{constructor(t,n){this.viewContainer=t,this.elementRef=n}}gX.ɵfac=function t(n){return new(n||gX)(Zg($u),Zg(xu))},gX.ɵdir=vo({type:gX,selectors:[["","noDataRowOutlet",""]]}),gX.ctorParameters=()=>[{type:$u},{type:xu}];class pX{constructor(t,n,e,a,o,r,i,c,s){this._differs=t,this._changeDetectorRef=n,this._elementRef=e,this._dir=o,this._platform=i,this._viewRepeater=c,this._coalescedStyleScheduler=s,this._onDestroy=new x,this._columnDefsByName=new Map,this._customColumnDefs=new Set,this._customRowDefs=new Set,this._customHeaderRowDefs=new Set,this._customFooterRowDefs=new Set,this._headerRowDefChanged=!0,this._footerRowDefChanged=!0,this._cachedRenderRowsMap=new Map,this.stickyCssClass="cdk-table-sticky",this.needsPositionStickyOnElement=!0,this._isShowingNoDataRow=!1,this._multiTemplateDataRows=!1,this.viewChange=new F({start:0,end:Number.MAX_VALUE}),a||this._elementRef.nativeElement.setAttribute("role","grid"),this._document=r,this._isNativeHtmlTable="TABLE"===this._elementRef.nativeElement.nodeName}get trackBy(){return this._trackByFn}set trackBy(t){"undefined"!=typeof ngDevMode&&!ngDevMode||null==t||"function"==typeof t||console.warn(`trackBy must be a function, but received ${JSON.stringify(t)}.`),this._trackByFn=t}get dataSource(){return this._dataSource}set dataSource(t){this._dataSource!==t&&this._switchDataSource(t)}get multiTemplateDataRows(){return this._multiTemplateDataRows}set multiTemplateDataRows(t){this._multiTemplateDataRows=Gw(t),this._rowOutlet&&this._rowOutlet.viewContainer.length&&(this._forceRenderDataRows(),this.updateStickyColumnStyles())}ngOnInit(){this._setupStickyStyler(),this._isNativeHtmlTable&&this._applyNativeTableSections(),this._dataDiffer=this._differs.find([]).create(((t,n)=>this.trackBy?this.trackBy(n.dataIndex,n.data):n))}ngAfterContentChecked(){if(this._cacheRowDefs(),this._cacheColumnDefs(),!this._headerRowDefs.length&&!this._footerRowDefs.length&&!this._rowDefs.length&&("undefined"==typeof ngDevMode||ngDevMode))throw(function t(){return Error("Missing definitions for header, footer, and row; cannot determine which columns should be rendered.")})();const n=this._renderUpdatedColumns()||this._headerRowDefChanged||this._footerRowDefChanged;this._headerRowDefChanged&&(this._forceRenderHeaderRows(),this._headerRowDefChanged=!1),this._footerRowDefChanged&&(this._forceRenderFooterRows(),this._footerRowDefChanged=!1),this.dataSource&&this._rowDefs.length>0&&!this._renderChangeSubscription?this._observeRenderChanges():n&&this.updateStickyColumnStyles(),this._checkStickyStates()}ngOnDestroy(){this._rowOutlet.viewContainer.clear(),this._noDataRowOutlet.viewContainer.clear(),this._headerRowOutlet.viewContainer.clear(),this._footerRowOutlet.viewContainer.clear(),this._cachedRenderRowsMap.clear(),this._onDestroy.next(),this._onDestroy.complete(),iA(this.dataSource)&&this.dataSource.disconnect(this)}renderRows(){this._renderRows=this._getAllRenderRows();const t=this._dataDiffer.diff(this._renderRows);if(!t)return void this._updateNoDataRow();const n=this._rowOutlet.viewContainer;this._viewRepeater?this._viewRepeater.applyChanges(t,n,((t,n,e)=>this._getEmbeddedViewArgs(t.item,e)),(t=>t.item.data),(t=>{1===t.operation&&t.context&&this._renderCellTemplateForItem(t.record.item.rowDef,t.context)})):t.forEachOperation(((t,e,a)=>{if(null==t.previousIndex){const n=t.item;this._renderRow(this._rowOutlet,n.rowDef,a,{$implicit:n.data})}else if(null==a)n.remove(e);else{const t=n.get(e);n.move(t,a)}})),this._updateRowIndexContext(),t.forEachIdentityChange((t=>{n.get(t.currentIndex).context.$implicit=t.item.data})),this._updateNoDataRow(),this.updateStickyColumnStyles()}addColumnDef(t){this._customColumnDefs.add(t)}removeColumnDef(t){this._customColumnDefs.delete(t)}addRowDef(t){this._customRowDefs.add(t)}removeRowDef(t){this._customRowDefs.delete(t)}addHeaderRowDef(t){this._customHeaderRowDefs.add(t),this._headerRowDefChanged=!0}removeHeaderRowDef(t){this._customHeaderRowDefs.delete(t),this._headerRowDefChanged=!0}addFooterRowDef(t){this._customFooterRowDefs.add(t),this._footerRowDefChanged=!0}removeFooterRowDef(t){this._customFooterRowDefs.delete(t),this._footerRowDefChanged=!0}updateStickyHeaderRowStyles(){const t=this._getRenderedRows(this._headerRowOutlet),n=this._elementRef.nativeElement.querySelector("thead");n&&(n.style.display=t.length?"":"none");const e=this._headerRowDefs.map((t=>t.sticky));this._stickyStyler.clearStickyPositioning(t,["top"]),this._stickyStyler.stickRows(t,e,"top"),this._headerRowDefs.forEach((t=>t.resetStickyChanged()))}updateStickyFooterRowStyles(){const t=this._getRenderedRows(this._footerRowOutlet),n=this._elementRef.nativeElement.querySelector("tfoot");n&&(n.style.display=t.length?"":"none");const e=this._footerRowDefs.map((t=>t.sticky));this._stickyStyler.clearStickyPositioning(t,["bottom"]),this._stickyStyler.stickRows(t,e,"bottom"),this._stickyStyler.updateStickyFooterContainer(this._elementRef.nativeElement,e),this._footerRowDefs.forEach((t=>t.resetStickyChanged()))}updateStickyColumnStyles(){const t=this._getRenderedRows(this._headerRowOutlet),n=this._getRenderedRows(this._rowOutlet),e=this._getRenderedRows(this._footerRowOutlet);this._stickyStyler.clearStickyPositioning([...t,...n,...e],["left","right"]),t.forEach(((t,n)=>{this._addStickyColumnStyles([t],this._headerRowDefs[n])})),this._rowDefs.forEach((t=>{const e=[];for(let a=0;a<n.length;a++)this._renderRows[a].rowDef===t&&e.push(n[a]);this._addStickyColumnStyles(e,t)})),e.forEach(((t,n)=>{this._addStickyColumnStyles([t],this._footerRowDefs[n])})),Array.from(this._columnDefsByName.values()).forEach((t=>t.resetStickyChanged()))}_getAllRenderRows(){const t=[],n=this._cachedRenderRowsMap;this._cachedRenderRowsMap=new Map;for(let e=0;e<this._data.length;e++){let a=this._data[e];const o=this._getRenderRowsForData(a,e,n.get(a));this._cachedRenderRowsMap.has(a)||this._cachedRenderRowsMap.set(a,new WeakMap);for(let n=0;n<o.length;n++){let e=o[n];const a=this._cachedRenderRowsMap.get(e.data);a.has(e.rowDef)?a.get(e.rowDef).push(e):a.set(e.rowDef,[e]),t.push(e)}}return t}_getRenderRowsForData(t,n,e){return this._getRowDefs(t,n).map((a=>{const o=e&&e.has(a)?e.get(a):[];if(o.length){const t=o.shift();return t.dataIndex=n,t}return{data:t,rowDef:a,dataIndex:n}}))}_cacheColumnDefs(){this._columnDefsByName.clear(),bX(this._getOwnDefs(this._contentColumnDefs),this._customColumnDefs).forEach((t=>{if(this._columnDefsByName.has(t.name)&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(t){return Error(`Duplicate column definition name provided: "${t}".`)})(t.name);this._columnDefsByName.set(t.name,t)}))}_cacheRowDefs(){this._headerRowDefs=bX(this._getOwnDefs(this._contentHeaderRowDefs),this._customHeaderRowDefs),this._footerRowDefs=bX(this._getOwnDefs(this._contentFooterRowDefs),this._customFooterRowDefs),this._rowDefs=bX(this._getOwnDefs(this._contentRowDefs),this._customRowDefs);const t=this._rowDefs.filter((t=>!t.when));if(!this.multiTemplateDataRows&&t.length>1&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("There can only be one default row without a when predicate function.")})();this._defaultRowDef=t[0]}_renderUpdatedColumns(){const t=(t,n)=>t||!!n.getColumnsDiff(),n=this._rowDefs.reduce(t,!1);n&&this._forceRenderDataRows();const e=this._headerRowDefs.reduce(t,!1);e&&this._forceRenderHeaderRows();const a=this._footerRowDefs.reduce(t,!1);return a&&this._forceRenderFooterRows(),n||e||a}_switchDataSource(t){this._data=[],iA(this.dataSource)&&this.dataSource.disconnect(this),this._renderChangeSubscription&&(this._renderChangeSubscription.unsubscribe(),this._renderChangeSubscription=null),t||(this._dataDiffer&&this._dataDiffer.diff([]),this._rowOutlet.viewContainer.clear()),this._dataSource=t}_observeRenderChanges(){if(!this.dataSource)return;let t;if(iA(this.dataSource)?t=this.dataSource.connect(this):pt(this.dataSource)?t=this.dataSource:Array.isArray(this.dataSource)&&(t=Z(this.dataSource)),void 0===t&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("Provided data source did not match an array, Observable, or DataSource")})();this._renderChangeSubscription=t.pipe(de(this._onDestroy)).subscribe((t=>{this._data=t||[],this.renderRows()}))}_forceRenderHeaderRows(){this._headerRowOutlet.viewContainer.length>0&&this._headerRowOutlet.viewContainer.clear(),this._headerRowDefs.forEach(((t,n)=>this._renderRow(this._headerRowOutlet,t,n))),this.updateStickyHeaderRowStyles()}_forceRenderFooterRows(){this._footerRowOutlet.viewContainer.length>0&&this._footerRowOutlet.viewContainer.clear(),this._footerRowDefs.forEach(((t,n)=>this._renderRow(this._footerRowOutlet,t,n))),this.updateStickyFooterRowStyles()}_addStickyColumnStyles(t,n){const e=Array.from(n.columns||[]).map((t=>{const n=this._columnDefsByName.get(t);if(!n&&("undefined"==typeof ngDevMode||ngDevMode))throw sX(t);return n})),a=e.map((t=>t.sticky)),o=e.map((t=>t.stickyEnd));this._stickyStyler.updateStickyColumns(t,a,o)}_getRenderedRows(t){const n=[];for(let e=0;e<t.viewContainer.length;e++){const a=t.viewContainer.get(e);n.push(a.rootNodes[0])}return n}_getRowDefs(t,n){if(1==this._rowDefs.length)return[this._rowDefs[0]];let e=[];if(this.multiTemplateDataRows)e=this._rowDefs.filter((e=>!e.when||e.when(n,t)));else{let a=this._rowDefs.find((e=>e.when&&e.when(n,t)))||this._defaultRowDef;a&&e.push(a)}if(!e.length&&("undefined"==typeof ngDevMode||ngDevMode))throw(function a(t){return Error(`Could not find a matching row definition for theprovided row data: ${JSON.stringify(t)}`)})(t);return e}_getEmbeddedViewArgs(t,n){return{templateRef:t.rowDef.template,context:{$implicit:t.data},index:n}}_renderRow(t,n,e,a={}){const o=t.viewContainer.createEmbeddedView(n.template,a,e);return this._renderCellTemplateForItem(n,a),o}_renderCellTemplateForItem(t,n){for(let e of this._getCellTemplates(t))nX.mostRecentCellOutlet&&nX.mostRecentCellOutlet._viewContainer.createEmbeddedView(e,n);this._changeDetectorRef.markForCheck()}_updateRowIndexContext(){const t=this._rowOutlet.viewContainer;for(let n=0,e=t.length;n<e;n++){const a=t.get(n).context;a.count=e,a.first=0===n,a.last=n===e-1,a.even=n%2==0,a.odd=!a.even,this.multiTemplateDataRows?(a.dataIndex=this._renderRows[n].dataIndex,a.renderIndex=n):a.index=this._renderRows[n].dataIndex}}_getCellTemplates(t){return t&&t.columns?Array.from(t.columns,(n=>{const e=this._columnDefsByName.get(n);if(!e&&("undefined"==typeof ngDevMode||ngDevMode))throw sX(n);return t.extractCellTemplate(e)})):[]}_applyNativeTableSections(){const t=this._document.createDocumentFragment(),n=[{tag:"thead",outlets:[this._headerRowOutlet]},{tag:"tbody",outlets:[this._rowOutlet,this._noDataRowOutlet]},{tag:"tfoot",outlets:[this._footerRowOutlet]}];for(const e of n){const n=this._document.createElement(e.tag);n.setAttribute("role","rowgroup");for(const t of e.outlets)n.appendChild(t.elementRef.nativeElement);t.appendChild(n)}this._elementRef.nativeElement.appendChild(t)}_forceRenderDataRows(){this._dataDiffer.diff([]),this._rowOutlet.viewContainer.clear(),this.renderRows()}_checkStickyStates(){const t=(t,n)=>t||n.hasStickyChanged();this._headerRowDefs.reduce(t,!1)&&this.updateStickyHeaderRowStyles(),this._footerRowDefs.reduce(t,!1)&&this.updateStickyFooterRowStyles(),Array.from(this._columnDefsByName.values()).reduce(t,!1)&&this.updateStickyColumnStyles()}_setupStickyStyler(){this._stickyStyler=new cX(this._isNativeHtmlTable,this.stickyCssClass,this._dir?this._dir.value:"ltr",this._coalescedStyleScheduler,this._platform.isBrowser,this.needsPositionStickyOnElement),(this._dir?this._dir.change:Z()).pipe(de(this._onDestroy)).subscribe((t=>{this._stickyStyler.direction=t,this.updateStickyColumnStyles()}))}_getOwnDefs(t){return t.filter((t=>!t._table||t._table===this))}_updateNoDataRow(){if(this._noDataRow){const t=0===this._rowOutlet.viewContainer.length;if(t!==this._isShowingNoDataRow){const n=this._noDataRowOutlet.viewContainer;t?n.createEmbeddedView(this._noDataRow.templateRef):n.clear(),this._isShowingNoDataRow=t}}}}function bX(t,n){return t.concat(Array.from(n))}
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */pX.ɵfac=function t(n){return new(n||pX)(Zg(Wu),Zg(Vm),Zg(xu),Xg("role"),Zg(US,8),Zg(zC),Zg(Sw),Zg(gA,8),Zg(qZ,8))},pX.ɵcmp=_o({type:pX,selectors:[["cdk-table"],["table","cdk-table",""]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,rX,!0),Gf(a,VZ,!0),Gf(a,tX,!0),Gf(a,QZ,!0),Gf(a,$Z,!0)),2&n&&(Vf(o=Zf())&&(e._noDataRow=o.first),Vf(o=Zf())&&(e._contentColumnDefs=o),Vf(o=Zf())&&(e._contentRowDefs=o),Vf(o=Zf())&&(e._contentHeaderRowDefs=o),Vf(o=Zf())&&(e._contentFooterRowDefs=o))},viewQuery:function t(n,e){var a;1&n&&(jf(lX,!0),jf(mX,!0),jf(dX,!0),jf(gX,!0)),2&n&&(Vf(a=Zf())&&(e._rowOutlet=a.first),Vf(a=Zf())&&(e._headerRowOutlet=a.first),Vf(a=Zf())&&(e._footerRowOutlet=a.first),Vf(a=Zf())&&(e._noDataRowOutlet=a.first))},hostAttrs:[1,"cdk-table"],inputs:{trackBy:"trackBy",dataSource:"dataSource",multiTemplateDataRows:"multiTemplateDataRows"},exportAs:["cdkTable"],features:[Mu([{provide:IZ,useExisting:pX},{provide:gA,useClass:sA},{provide:qZ,useClass:ZZ}])],ngContentSelectors:["caption","colgroup, col"],decls:6,vars:0,consts:[["headerRowOutlet",""],["rowOutlet",""],["noDataRowOutlet",""],["footerRowOutlet",""]],template:function t(n,e){1&n&&(bp(zZ),hp(0),hp(1,1),ap(2,0),ap(3,1),ap(4,2),ap(5,3))},directives:[mX,lX,gX,dX],encapsulation:2}),pX.ctorParameters=()=>[{type:Wu},{type:Vm},{type:xu},{type:String,decorators:[{type:Be,args:["role"]}]},{type:US,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ie,args:[zC]}]},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[gA]}]},{type:ZZ,decorators:[{type:Ne},{type:Ie,args:[qZ]}]}],pX.propDecorators={trackBy:[{type:f_}],dataSource:[{type:f_}],multiTemplateDataRows:[{type:f_}],_rowOutlet:[{type:Xd,args:[lX,{static:!0}]}],_headerRowOutlet:[{type:Xd,args:[mX,{static:!0}]}],_footerRowOutlet:[{type:Xd,args:[dX,{static:!0}]}],_noDataRowOutlet:[{type:Xd,args:[gX,{static:!0}]}],_contentColumnDefs:[{type:qd,args:[VZ,{descendants:!0}]}],_contentRowDefs:[{type:qd,args:[tX,{descendants:!0}]}],_contentHeaderRowDefs:[{type:qd,args:[QZ,{descendants:!0}]}],_contentFooterRowDefs:[{type:qd,args:[$Z,{descendants:!0}]}],_noDataRow:[{type:Zd,args:[rX]}]};class uX{constructor(t,n){this._table=t,this._options=n,this.justify="start",this._options=n||{}}get name(){return this._name}set name(t){this._name=t,this._syncColumnDefName()}ngOnInit(){if(this._syncColumnDefName(),void 0===this.headerText&&(this.headerText=this._createDefaultHeaderText()),this.dataAccessor||(this.dataAccessor=this._options.defaultDataAccessor||((t,n)=>t[n])),this._table)this.columnDef.cell=this.cell,this.columnDef.headerCell=this.headerCell,this._table.addColumnDef(this.columnDef);else if("undefined"==typeof ngDevMode||ngDevMode)throw(function t(){return Error("Text column could not find a parent table for registration.")})()}ngOnDestroy(){this._table&&this._table.removeColumnDef(this.columnDef)}_createDefaultHeaderText(){const t=this.name;if(!t&&("undefined"==typeof ngDevMode||ngDevMode))throw(function n(){return Error("Table text column must have a name.")})();return this._options&&this._options.defaultHeaderTextTransform?this._options.defaultHeaderTextTransform(t):t[0].toUpperCase()+t.slice(1)}_syncColumnDefName(){this.columnDef&&(this.columnDef.name=this.name)}}uX.ɵfac=function t(n){return new(n||uX)(Zg(pX,8),Zg(NZ,8))},uX.ɵcmp=_o({type:uX,selectors:[["cdk-text-column"]],viewQuery:function t(n,e){var a;1&n&&(jf(VZ,!0),jf(FZ,!0),jf(LZ,!0)),2&n&&(Vf(a=Zf())&&(e.columnDef=a.first),Vf(a=Zf())&&(e.cell=a.first),Vf(a=Zf())&&(e.headerCell=a.first))},inputs:{justify:"justify",name:"name",headerText:"headerText",dataAccessor:"dataAccessor"},decls:3,vars:0,consts:[["cdkColumnDef",""],["cdk-header-cell","",3,"text-align",4,"cdkHeaderCellDef"],["cdk-cell","",3,"text-align",4,"cdkCellDef"],["cdk-header-cell",""],["cdk-cell",""]],template:function t(n,e){1&n&&(np(0,0),Yg(1,RZ,2,3,"th",1),Yg(2,TZ,2,3,"td",2),ep())},directives:[VZ,LZ,FZ,UZ,GZ],encapsulation:2}),uX.ctorParameters=()=>[{type:pX,decorators:[{type:Ne}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[NZ]}]}],uX.propDecorators={name:[{type:f_}],headerText:[{type:f_}],dataAccessor:[{type:f_}],justify:[{type:f_}],columnDef:[{type:Xd,args:[VZ,{static:!0}]}],cell:[{type:Xd,args:[FZ,{static:!0}]}],headerCell:[{type:Xd,args:[LZ,{static:!0}]}]};class fX{}fX.ɵmod=xo({type:fX}),fX.ɵinj=Ge({factory:function t(n){return new(n||fX)},imports:[[vA]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(fX,{declarations:function(){return[pX,tX,FZ,nX,LZ,HZ,VZ,GZ,oX,UZ,WZ,eX,QZ,aX,$Z,lX,mX,dX,uX,rX,gX]},imports:function(){return[vA]},exports:function(){return[pX,tX,FZ,nX,LZ,HZ,VZ,GZ,oX,UZ,WZ,eX,QZ,aX,$Z,lX,mX,dX,uX,rX,gX]}});const hX=[[["caption"]],[["colgroup"],["col"]]];function _X(t,n){if(1&t&&(Kg(0,"th",3),Jp(1),$g()),2&t){const t=gp();Tp("text-align",t.justify),ws(1),Kp(" ",t.headerText," ")}}function CX(t,n){if(1&t&&(Kg(0,"td",4),Jp(1),$g()),2&t){const t=n.$implicit,e=gp();Tp("text-align",e.justify),ws(1),Kp(" ",e.dataAccessor(t,e.name)," ")}}class MX extends pX{constructor(){super(...arguments),this.stickyCssClass="mat-table-sticky",this.needsPositionStickyOnElement=!1}}MX.ɵfac=function t(n){return OX(n||MX)},MX.ɵcmp=_o({type:MX,selectors:[["mat-table"],["table","mat-table",""]],hostAttrs:[1,"mat-table"],exportAs:["matTable"],features:[Mu([{provide:gA,useClass:sA},{provide:pX,useExisting:MX},{provide:IZ,useExisting:MX},{provide:qZ,useClass:ZZ}]),hg],ngContentSelectors:["caption","colgroup, col"],decls:6,vars:0,consts:[["headerRowOutlet",""],["rowOutlet",""],["noDataRowOutlet",""],["footerRowOutlet",""]],template:function t(n,e){1&n&&(bp(hX),hp(0),hp(1,1),ap(2,0),ap(3,1),ap(4,2),ap(5,3))},directives:[mX,lX,gX,dX],styles:['mat-table{display:block}mat-header-row{min-height:56px}mat-row,mat-footer-row{min-height:48px}mat-row,mat-header-row,mat-footer-row{display:flex;border-width:0;border-bottom-width:1px;border-style:solid;align-items:center;box-sizing:border-box}mat-row::after,mat-header-row::after,mat-footer-row::after{display:inline-block;min-height:inherit;content:""}mat-cell:first-of-type,mat-header-cell:first-of-type,mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] mat-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}mat-cell:last-of-type,mat-header-cell:last-of-type,mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] mat-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}mat-cell,mat-header-cell,mat-footer-cell{flex:1;display:flex;align-items:center;overflow:hidden;word-wrap:break-word;min-height:inherit}table.mat-table{border-spacing:0}tr.mat-header-row{height:56px}tr.mat-row,tr.mat-footer-row{height:48px}th.mat-header-cell{text-align:left}[dir=rtl] th.mat-header-cell{text-align:right}th.mat-header-cell,td.mat-cell,td.mat-footer-cell{padding:0;border-bottom-width:1px;border-bottom-style:solid}th.mat-header-cell:first-of-type,td.mat-cell:first-of-type,td.mat-footer-cell:first-of-type{padding-left:24px}[dir=rtl] th.mat-header-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:first-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:first-of-type:not(:only-of-type){padding-left:0;padding-right:24px}th.mat-header-cell:last-of-type,td.mat-cell:last-of-type,td.mat-footer-cell:last-of-type{padding-right:24px}[dir=rtl] th.mat-header-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-cell:last-of-type:not(:only-of-type),[dir=rtl] td.mat-footer-cell:last-of-type:not(:only-of-type){padding-right:0;padding-left:24px}.mat-table-sticky{position:-webkit-sticky;position:sticky}\n'],encapsulation:2});const OX=tc(MX);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class PX extends FZ{}PX.ɵfac=function t(n){return xX(n||PX)},PX.ɵdir=vo({type:PX,selectors:[["","matCellDef",""]],features:[Mu([{provide:FZ,useExisting:PX}]),hg]});const xX=tc(PX);class yX extends LZ{}yX.ɵfac=function t(n){return kX(n||yX)},yX.ɵdir=vo({type:yX,selectors:[["","matHeaderCellDef",""]],features:[Mu([{provide:LZ,useExisting:yX}]),hg]});const kX=tc(yX);class vX extends HZ{}vX.ɵfac=function t(n){return wX(n||vX)},vX.ɵdir=vo({type:vX,selectors:[["","matFooterCellDef",""]],features:[Mu([{provide:HZ,useExisting:vX}]),hg]});const wX=tc(vX);class SX extends VZ{get name(){return this._name}set name(t){this._setNameInput(t)}_updateColumnCssClassName(){super._updateColumnCssClassName(),this._columnCssClassName.push(`mat-column-${this.cssClassFriendlyName}`)}}SX.ɵfac=function t(n){return EX(n||SX)},SX.ɵdir=vo({type:SX,selectors:[["","matColumnDef",""]],inputs:{sticky:"sticky",name:["matColumnDef","name"]},features:[Mu([{provide:VZ,useExisting:SX},{provide:"MAT_SORT_HEADER_COLUMN_DEF",useExisting:SX}]),hg]}),SX.propDecorators={name:[{type:f_,args:["matColumnDef"]}]};const EX=tc(SX);class AX extends UZ{}AX.ɵfac=function t(n){return zX(n||AX)},AX.ɵdir=vo({type:AX,selectors:[["mat-header-cell"],["th","mat-header-cell",""]],hostAttrs:["role","columnheader",1,"mat-header-cell"],features:[hg]});const zX=tc(AX);class RX extends WZ{}RX.ɵfac=function t(n){return TX(n||RX)},RX.ɵdir=vo({type:RX,selectors:[["mat-footer-cell"],["td","mat-footer-cell",""]],hostAttrs:["role","gridcell",1,"mat-footer-cell"],features:[hg]});const TX=tc(RX);class DX extends GZ{}DX.ɵfac=function t(n){return IX(n||DX)},DX.ɵdir=vo({type:DX,selectors:[["mat-cell"],["td","mat-cell",""]],hostAttrs:["role","gridcell",1,"mat-cell"],features:[hg]});const IX=tc(DX);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class NX extends QZ{}NX.ɵfac=function t(n){return FX(n||NX)},NX.ɵdir=vo({type:NX,selectors:[["","matHeaderRowDef",""]],inputs:{columns:["matHeaderRowDef","columns"],sticky:["matHeaderRowDefSticky","sticky"]},features:[Mu([{provide:QZ,useExisting:NX}]),hg]});const FX=tc(NX);class LX extends $Z{}LX.ɵfac=function t(n){return HX(n||LX)},LX.ɵdir=vo({type:LX,selectors:[["","matFooterRowDef",""]],inputs:{columns:["matFooterRowDef","columns"],sticky:["matFooterRowDefSticky","sticky"]},features:[Mu([{provide:$Z,useExisting:LX}]),hg]});const HX=tc(LX);class BX extends tX{}BX.ɵfac=function t(n){return VX(n||BX)},BX.ɵdir=vo({type:BX,selectors:[["","matRowDef",""]],inputs:{columns:["matRowDefColumns","columns"],when:["matRowDefWhen","when"]},features:[Mu([{provide:tX,useExisting:BX}]),hg]});const VX=tc(BX);class jX extends eX{}jX.ɵfac=function t(n){return UX(n||jX)},jX.ɵcmp=_o({type:jX,selectors:[["mat-header-row"],["tr","mat-header-row",""]],hostAttrs:["role","row",1,"mat-header-row"],exportAs:["matHeaderRow"],features:[Mu([{provide:eX,useExisting:jX}]),hg],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});const UX=tc(jX);class WX extends aX{}WX.ɵfac=function t(n){return GX(n||WX)},WX.ɵcmp=_o({type:WX,selectors:[["mat-footer-row"],["tr","mat-footer-row",""]],hostAttrs:["role","row",1,"mat-footer-row"],exportAs:["matFooterRow"],features:[Mu([{provide:aX,useExisting:WX}]),hg],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});const GX=tc(WX);class YX extends oX{}YX.ɵfac=function t(n){return qX(n||YX)},YX.ɵcmp=_o({type:YX,selectors:[["mat-row"],["tr","mat-row",""]],hostAttrs:["role","row",1,"mat-row"],exportAs:["matRow"],features:[Mu([{provide:oX,useExisting:YX}]),hg],decls:1,vars:0,consts:[["cdkCellOutlet",""]],template:function t(n,e){1&n&&ap(0,0)},directives:[nX],encapsulation:2});const qX=tc(YX);class ZX extends rX{}ZX.ɵfac=function t(n){return XX(n||ZX)},ZX.ɵdir=vo({type:ZX,selectors:[["ng-template","matNoDataRow",""]],features:[Mu([{provide:rX,useExisting:ZX}]),hg]});const XX=tc(ZX);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class JX extends uX{}JX.ɵfac=function t(n){return QX(n||JX)},JX.ɵcmp=_o({type:JX,selectors:[["mat-text-column"]],features:[hg],decls:3,vars:0,consts:[["matColumnDef",""],["mat-header-cell","",3,"text-align",4,"matHeaderCellDef"],["mat-cell","",3,"text-align",4,"matCellDef"],["mat-header-cell",""],["mat-cell",""]],template:function t(n,e){1&n&&(np(0,0),Yg(1,_X,2,3,"th",1),Yg(2,CX,2,3,"td",2),ep())},directives:[SX,yX,PX,AX,DX],encapsulation:2});const QX=tc(JX);class KX{}KX.ɵmod=xo({type:KX}),KX.ɵinj=Ge({factory:function t(n){return new(n||KX)},imports:[[fX,tE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(KX,{declarations:function(){return[MX,yX,NX,SX,PX,BX,vX,LX,AX,DX,RX,jX,YX,WX,ZX,JX]},imports:function(){return[fX,tE]},exports:function(){return[tE,MX,yX,NX,SX,PX,BX,vX,LX,AX,DX,RX,jX,YX,WX,ZX,JX]}});class $X extends rA{constructor(t=[]){super(),this._renderData=new F([]),this._filter=new F(""),this._internalPageChanges=new x,this._renderChangesSubscription=s.EMPTY,this.sortingDataAccessor=(t,n)=>{const e=t[n];if(qw(e)){const t=Number(e);return t<9007199254740991?t:e}return e},this.sortData=(t,n)=>{const e=n.active,a=n.direction;return e&&""!=a?t.sort(((t,n)=>{let o=this.sortingDataAccessor(t,e),r=this.sortingDataAccessor(n,e);const i=typeof o,c=typeof r;i!==c&&("number"===i&&(o+=""),"number"===c&&(r+=""));let s=0;return null!=o&&null!=r?o>r?s=1:o<r&&(s=-1):null!=o?s=1:null!=r&&(s=-1),s*("asc"==a?1:-1)})):t},this.filterPredicate=(t,n)=>{const e=Object.keys(t).reduce(((n,e)=>n+t[e]+"◬"),"").toLowerCase(),a=n.trim().toLowerCase();return-1!=e.indexOf(a)},this._data=new F(t),this._updateChangeSubscription()}get data(){return this._data.value}set data(t){this._data.next(t)}get filter(){return this._filter.value}set filter(t){this._filter.next(t)}get sort(){return this._sort}set sort(t){this._sort=t,this._updateChangeSubscription()}get paginator(){return this._paginator}set paginator(t){this._paginator=t,this._updateChangeSubscription()}_updateChangeSubscription(){const t=this._sort?Wt(this._sort.sortChange,this._sort.initialized):Z(null),n=this._paginator?Wt(this._paginator.page,this._internalPageChanges,this._paginator.initialized):Z(null),e=Et([this._data,this._filter]).pipe(ft((([t])=>this._filterData(t)))),a=Et([e,t]).pipe(ft((([t])=>this._orderData(t)))),o=Et([a,n]).pipe(ft((([t])=>this._pageData(t))));this._renderChangesSubscription.unsubscribe(),this._renderChangesSubscription=o.subscribe((t=>this._renderData.next(t)))}_filterData(t){return this.filteredData=this.filter?t.filter((t=>this.filterPredicate(t,this.filter))):t,this.paginator&&this._updatePaginator(this.filteredData.length),this.filteredData}_orderData(t){return this.sort?this.sortData(t.slice(),this.sort):t}_pageData(t){if(!this.paginator)return t;const n=this.paginator.pageIndex*this.paginator.pageSize;return t.slice(n,n+this.paginator.pageSize)}_updatePaginator(t){Promise.resolve().then((()=>{const n=this.paginator;if(n&&(n.length=t,n.pageIndex>0)){const t=Math.ceil(n.length/n.pageSize)-1||0,e=Math.min(n.pageIndex,t);e!==n.pageIndex&&(n.pageIndex=e,this._internalPageChanges.next())}}))}connect(){return this._renderData}disconnect(){}}const tJ=["dialogPopup"],nJ=["hueSlider"],eJ=["alphaSlider"];function aJ(t,n){if(1&t&&tp(0,"div"),2&t){const t=gp();nb("arrow arrow-",t.cpUsePosition,""),Tp("top",t.arrowTop,"px")}}function oJ(t,n){if(1&t){const t=op();Kg(0,"div",26),cp("newValue",(function n(e){return jr(t),gp().onColorChange(e)}))("dragStart",(function n(){return jr(t),gp().onDragStart("saturation-lightness")}))("dragEnd",(function n(){return jr(t),gp().onDragEnd("saturation-lightness")})),tp(1,"div",13),$g()}if(2&t){const t=gp();Tp("background-color",t.hueSliderColor),Jg("rgX",1)("rgY",1),ws(1),Tp("top",null==t.slider?null:t.slider.v,"px")("left",null==t.slider?null:t.slider.s,"px")}}function rJ(t,n){if(1&t){const t=op();Kg(0,"button",27),cp("click",(function n(e){jr(t);const a=gp();return a.onAddPresetColor(e,a.selectedColor)})),Jp(1),$g()}if(2&t){const t=gp();Fp(t.cpAddColorButtonClass),Jg("disabled",t.cpPresetColors&&t.cpPresetColors.length>=t.cpMaxPresetColorsLength),ws(1),Kp(" ",t.cpAddColorButtonText," ")}}function iJ(t,n){1&t&&tp(0,"div",28)}function cJ(t,n){if(1&t){const t=op();Kg(0,"input",34),cp("keyup.enter",(function n(e){return jr(t),gp(2).onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp(2).onAlphaInput(e)})),$g()}if(2&t){const t=gp(2);Jg("rg",1)("value",null==t.cmykText?null:t.cmykText.a)}}function sJ(t,n){1&t&&(Kg(0,"div"),Jp(1,"A"),$g())}function lJ(t,n){if(1&t){const t=op();Kg(0,"div",29),Kg(1,"div",30),Kg(2,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onCyanInput(e)})),$g(),Kg(3,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onMagentaInput(e)})),$g(),Kg(4,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onYellowInput(e)})),$g(),Kg(5,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onBlackInput(e)})),$g(),Yg(6,cJ,1,2,"input",32),$g(),Kg(7,"div",30),Kg(8,"div"),Jp(9,"C"),$g(),Kg(10,"div"),Jp(11,"M"),$g(),Kg(12,"div"),Jp(13,"Y"),$g(),Kg(14,"div"),Jp(15,"K"),$g(),Yg(16,sJ,2,0,"div",33),$g(),$g()}if(2&t){const t=gp();Tp("display",3!==t.format?"none":"block"),ws(2),Jg("rg",100)("value",null==t.cmykText?null:t.cmykText.c),ws(1),Jg("rg",100)("value",null==t.cmykText?null:t.cmykText.m),ws(1),Jg("rg",100)("value",null==t.cmykText?null:t.cmykText.y),ws(1),Jg("rg",100)("value",null==t.cmykText?null:t.cmykText.k),ws(1),Jg("ngIf","disabled"!==t.cpAlphaChannel),ws(10),Jg("ngIf","disabled"!==t.cpAlphaChannel)}}function mJ(t,n){if(1&t){const t=op();Kg(0,"input",34),cp("keyup.enter",(function n(e){return jr(t),gp(2).onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp(2).onAlphaInput(e)})),$g()}if(2&t){const t=gp(2);Jg("rg",1)("value",null==t.hslaText?null:t.hslaText.a)}}function dJ(t,n){1&t&&(Kg(0,"div"),Jp(1,"A"),$g())}function gJ(t,n){if(1&t){const t=op();Kg(0,"div",35),Kg(1,"div",30),Kg(2,"input",36),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onHueInput(e)})),$g(),Kg(3,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onSaturationInput(e)})),$g(),Kg(4,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onLightnessInput(e)})),$g(),Yg(5,mJ,1,2,"input",32),$g(),Kg(6,"div",30),Kg(7,"div"),Jp(8,"H"),$g(),Kg(9,"div"),Jp(10,"S"),$g(),Kg(11,"div"),Jp(12,"L"),$g(),Yg(13,dJ,2,0,"div",33),$g(),$g()}if(2&t){const t=gp();Tp("display",2!==t.format?"none":"block"),ws(2),Jg("rg",360)("value",null==t.hslaText?null:t.hslaText.h),ws(1),Jg("rg",100)("value",null==t.hslaText?null:t.hslaText.s),ws(1),Jg("rg",100)("value",null==t.hslaText?null:t.hslaText.l),ws(1),Jg("ngIf","disabled"!==t.cpAlphaChannel),ws(8),Jg("ngIf","disabled"!==t.cpAlphaChannel)}}function pJ(t,n){if(1&t){const t=op();Kg(0,"input",34),cp("keyup.enter",(function n(e){return jr(t),gp(2).onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp(2).onAlphaInput(e)})),$g()}if(2&t){const t=gp(2);Jg("rg",1)("value",null==t.rgbaText?null:t.rgbaText.a)}}function bJ(t,n){1&t&&(Kg(0,"div"),Jp(1,"A"),$g())}function uJ(t,n){if(1&t){const t=op();Kg(0,"div",37),Kg(1,"div",30),Kg(2,"input",38),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onRedInput(e)})),$g(),Kg(3,"input",38),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onGreenInput(e)})),$g(),Kg(4,"input",38),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onBlueInput(e)})),$g(),Yg(5,pJ,1,2,"input",32),$g(),Kg(6,"div",30),Kg(7,"div"),Jp(8,"R"),$g(),Kg(9,"div"),Jp(10,"G"),$g(),Kg(11,"div"),Jp(12,"B"),$g(),Yg(13,bJ,2,0,"div",33),$g(),$g()}if(2&t){const t=gp();Tp("display",1!==t.format?"none":"block"),ws(2),Jg("rg",255)("value",null==t.rgbaText?null:t.rgbaText.r),ws(1),Jg("rg",255)("value",null==t.rgbaText?null:t.rgbaText.g),ws(1),Jg("rg",255)("value",null==t.rgbaText?null:t.rgbaText.b),ws(1),Jg("ngIf","disabled"!==t.cpAlphaChannel),ws(8),Jg("ngIf","disabled"!==t.cpAlphaChannel)}}function fJ(t,n){if(1&t){const t=op();Kg(0,"input",34),cp("keyup.enter",(function n(e){return jr(t),gp(2).onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp(2).onAlphaInput(e)})),$g()}if(2&t){const t=gp(2);Jg("rg",1)("value",t.hexAlpha)}}function hJ(t,n){1&t&&(Kg(0,"div"),Jp(1,"A"),$g())}function _J(t,n){if(1&t){const t=op();Kg(0,"div",39),Kg(1,"div",30),Kg(2,"input",40),cp("blur",(function n(){return jr(t),gp().onHexInput(null)}))("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onHexInput(e)})),$g(),Yg(3,fJ,1,2,"input",32),$g(),Kg(4,"div",30),Kg(5,"div"),Jp(6,"Hex"),$g(),Yg(7,hJ,2,0,"div",33),$g(),$g()}if(2&t){const t=gp();Tp("display",0!==t.format?"none":"block"),Dp("hex-alpha","forced"===t.cpAlphaChannel),ws(2),Jg("value",t.hexText),ws(1),Jg("ngIf","forced"===t.cpAlphaChannel),ws(4),Jg("ngIf","forced"===t.cpAlphaChannel)}}function CJ(t,n){if(1&t){const t=op();Kg(0,"input",34),cp("keyup.enter",(function n(e){return jr(t),gp(2).onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp(2).onAlphaInput(e)})),$g()}if(2&t){const t=gp(2);Jg("rg",1)("value",null==t.hslaText?null:t.hslaText.a)}}function MJ(t,n){if(1&t){const t=op();Kg(0,"div",41),Kg(1,"div",30),Kg(2,"input",31),cp("keyup.enter",(function n(e){return jr(t),gp().onAcceptColor(e)}))("newValue",(function n(e){return jr(t),gp().onValueInput(e)})),$g(),Yg(3,CJ,1,2,"input",32),$g(),Kg(4,"div",30),Kg(5,"div"),Jp(6,"V"),$g(),Kg(7,"div"),Jp(8,"A"),$g(),$g(),$g()}if(2&t){const t=gp();ws(2),Jg("rg",100)("value",null==t.hslaText?null:t.hslaText.l),ws(1),Jg("ngIf","disabled"!==t.cpAlphaChannel)}}function OJ(t,n){if(1&t){const t=op();Kg(0,"div",42),Kg(1,"span",43),cp("click",(function n(){return jr(t),gp().onFormatToggle(-1)})),$g(),Kg(2,"span",43),cp("click",(function n(){return jr(t),gp().onFormatToggle(1)})),$g(),$g()}}function PJ(t,n){if(1&t){const t=op();Kg(0,"span",50),cp("click",(function n(e){jr(t);const a=gp().$implicit;return gp(3).onRemovePresetColor(e,a)})),$g()}2&t&&Fp(gp(4).cpRemoveColorButtonClass)}function xJ(t,n){if(1&t){const t=op();Kg(0,"div",48),cp("click",(function e(){jr(t);const a=n.$implicit;return gp(3).setColorFromString(a)})),Yg(1,PJ,1,3,"span",49),$g()}if(2&t){const t=n.$implicit,e=gp(3);Tp("background-color",t),ws(1),Jg("ngIf",e.cpAddColorButton)}}function yJ(t,n){if(1&t&&(Kg(0,"div"),Yg(1,xJ,2,3,"div",47),$g()),2&t){const t=gp(2);Fp(t.cpPresetColorsClass),ws(1),Jg("ngForOf",t.cpPresetColors)}}function kJ(t,n){if(1&t&&(Kg(0,"div"),Jp(1),$g()),2&t){const t=gp(2);Fp(t.cpPresetEmptyMessageClass),ws(1),Qp(t.cpPresetEmptyMessage)}}function vJ(t,n){if(1&t&&(Kg(0,"div",44),tp(1,"hr"),Kg(2,"div",45),Jp(3),$g(),Yg(4,yJ,2,4,"div",46),Yg(5,kJ,2,4,"div",46),$g()),2&t){const t=gp();ws(3),Qp(t.cpPresetLabel),ws(1),Jg("ngIf",null==t.cpPresetColors?null:t.cpPresetColors.length),ws(1),Jg("ngIf",!(null!=t.cpPresetColors&&t.cpPresetColors.length)&&t.cpAddColorButton)}}function wJ(t,n){if(1&t){const t=op();Kg(0,"button",53),cp("click",(function n(e){return jr(t),gp(2).onCancelColor(e)})),Jp(1),$g()}if(2&t){const t=gp(2);Fp(t.cpCancelButtonClass),ws(1),Qp(t.cpCancelButtonText)}}function SJ(t,n){if(1&t){const t=op();Kg(0,"button",53),cp("click",(function n(e){return jr(t),gp(2).onAcceptColor(e)})),Jp(1),$g()}if(2&t){const t=gp(2);Fp(t.cpOKButtonClass),ws(1),Qp(t.cpOKButtonText)}}function EJ(t,n){if(1&t&&(Kg(0,"div",51),Yg(1,wJ,2,4,"button",52),Yg(2,SJ,2,4,"button",52),$g()),2&t){const t=gp();ws(1),Jg("ngIf",t.cpCancelButton),ws(1),Jg("ngIf",t.cpOKButton)}}var AJ;!(function(t){t[t.HEX=0]="HEX",t[t.RGBA=1]="RGBA",t[t.HSLA=2]="HSLA",t[t.CMYK=3]="CMYK"})(AJ||(AJ={}));class zJ{constructor(t,n,e,a){this.r=t,this.g=n,this.b=e,this.a=a}}class RJ{constructor(t,n,e,a){this.h=t,this.s=n,this.v=e,this.a=a}}class TJ{constructor(t,n,e,a){this.h=t,this.s=n,this.l=e,this.a=a}}class DJ{constructor(t,n,e,a,o=1){this.c=t,this.m=n,this.y=e,this.k=a,this.a=o}}class IJ{constructor(){this.newValue=new Ef}inputChange(t){const n=t.target.value;if(void 0===this.rg)this.newValue.emit(n);else{const t=parseFloat(n);this.newValue.emit({v:t,rg:this.rg})}}}IJ.ɵfac=function t(n){return new(n||IJ)},IJ.ɵdir=vo({type:IJ,selectors:[["","text",""]],hostBindings:function t(n,e){1&n&&cp("input",(function t(n){return e.inputChange(n)}))},inputs:{rg:"rg",text:"text"},outputs:{newValue:"newValue"}}),IJ.propDecorators={rg:[{type:f_}],text:[{type:f_}],newValue:[{type:h_}],inputChange:[{type:__,args:["input",["$event"]]}]};class NJ{constructor(t){this.elRef=t,this.dragEnd=new Ef,this.dragStart=new Ef,this.newValue=new Ef,this.listenerMove=t=>this.move(t),this.listenerStop=()=>this.stop()}mouseDown(t){this.start(t)}touchStart(t){this.start(t)}move(t){t.preventDefault(),this.setCursor(t)}start(t){this.setCursor(t),t.stopPropagation(),document.addEventListener("mouseup",this.listenerStop),document.addEventListener("touchend",this.listenerStop),document.addEventListener("mousemove",this.listenerMove),document.addEventListener("touchmove",this.listenerMove),this.dragStart.emit()}stop(){document.removeEventListener("mouseup",this.listenerStop),document.removeEventListener("touchend",this.listenerStop),document.removeEventListener("mousemove",this.listenerMove),document.removeEventListener("touchmove",this.listenerMove),this.dragEnd.emit()}getX(t){const n=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==t.pageX?t.pageX:t.touches[0].pageX)-n.left-window.pageXOffset}getY(t){const n=this.elRef.nativeElement.getBoundingClientRect();return(void 0!==t.pageY?t.pageY:t.touches[0].pageY)-n.top-window.pageYOffset}setCursor(t){const n=this.elRef.nativeElement.offsetWidth,e=this.elRef.nativeElement.offsetHeight,a=Math.max(0,Math.min(this.getX(t),n)),o=Math.max(0,Math.min(this.getY(t),e));void 0!==this.rgX&&void 0!==this.rgY?this.newValue.emit({s:a/n,v:1-o/e,rgX:this.rgX,rgY:this.rgY}):void 0===this.rgX&&void 0!==this.rgY?this.newValue.emit({v:o/e,rgY:this.rgY}):void 0!==this.rgX&&void 0===this.rgY&&this.newValue.emit({v:a/n,rgX:this.rgX})}}NJ.ɵfac=function t(n){return new(n||NJ)(Zg(xu))},NJ.ɵdir=vo({type:NJ,selectors:[["","slider",""]],hostBindings:function t(n,e){1&n&&cp("mousedown",(function t(n){return e.mouseDown(n)}))("touchstart",(function t(n){return e.touchStart(n)}))},inputs:{rgX:"rgX",rgY:"rgY",slider:"slider"},outputs:{dragEnd:"dragEnd",dragStart:"dragStart",newValue:"newValue"}}),NJ.ctorParameters=()=>[{type:xu}],NJ.propDecorators={rgX:[{type:f_}],rgY:[{type:f_}],slider:[{type:f_}],dragEnd:[{type:h_}],dragStart:[{type:h_}],newValue:[{type:h_}],mouseDown:[{type:__,args:["mousedown",["$event"]]}],touchStart:[{type:__,args:["touchstart",["$event"]]}]};class FJ{constructor(t,n,e,a){this.h=t,this.s=n,this.v=e,this.a=a}}class LJ{constructor(t,n,e,a){this.h=t,this.s=n,this.v=e,this.a=a}}class HJ{constructor(){this.active=null}setActive(t){this.active&&this.active!==t&&"inline"!==this.active.cpDialogDisplay&&this.active.closeDialog(),this.active=t}hsva2hsla(t){const n=t.h,e=t.s,a=t.v,o=t.a;if(0===a)return new TJ(n,0,0,o);if(0===e&&1===a)return new TJ(n,1,1,o);{const t=a*(2-e)/2;return new TJ(n,a*e/(1-Math.abs(2*t-1)),t,o)}}hsla2hsva(t){const n=Math.min(t.h,1),e=Math.min(t.s,1),a=Math.min(t.l,1),o=Math.min(t.a,1);if(0===a)return new RJ(n,0,0,o);{const t=a+e*(1-Math.abs(2*a-1))/2;return new RJ(n,2*(t-a)/t,t,o)}}hsvaToRgba(t){let n,e,a;const o=t.h,r=t.s,i=t.v,c=t.a,s=Math.floor(6*o),l=6*o-s,m=i*(1-r),d=i*(1-l*r),g=i*(1-(1-l)*r);switch(s%6){case 0:n=i,e=g,a=m;break;case 1:n=d,e=i,a=m;break;case 2:n=m,e=i,a=g;break;case 3:n=m,e=d,a=i;break;case 4:n=g,e=m,a=i;break;case 5:n=i,e=m,a=d;break;default:n=0,e=0,a=0}return new zJ(n,e,a,c)}cmykToRgb(t){return new zJ((1-t.c)*(1-t.k),(1-t.m)*(1-t.k),(1-t.y)*(1-t.k),t.a)}rgbaToCmyk(t){const n=1-Math.max(t.r,t.g,t.b);return 1===n?new DJ(0,0,0,1,t.a):new DJ((1-t.r-n)/(1-n),(1-t.g-n)/(1-n),(1-t.b-n)/(1-n),n,t.a)}rgbaToHsva(t){let n,e;const a=Math.min(t.r,1),o=Math.min(t.g,1),r=Math.min(t.b,1),i=Math.min(t.a,1),c=Math.max(a,o,r),s=Math.min(a,o,r),l=c,m=c-s;if(e=0===c?0:m/c,c===s)n=0;else{switch(c){case a:n=(o-r)/m+(o<r?6:0);break;case o:n=(r-a)/m+2;break;case r:n=(a-o)/m+4;break;default:n=0}n/=6}return new RJ(n,e,l,i)}rgbaToHex(t,n){let e="#"+(1<<24|t.r<<16|t.g<<8|t.b).toString(16).substr(1);return n&&(e+=(256|Math.round(255*t.a)).toString(16).substr(1)),e}normalizeCMYK(t){return new DJ(t.c/100,t.m/100,t.y/100,t.k/100,t.a)}denormalizeCMYK(t){return new DJ(Math.floor(100*t.c),Math.floor(100*t.m),Math.floor(100*t.y),Math.floor(100*t.k),t.a)}denormalizeRGBA(t){return new zJ(Math.round(255*t.r),Math.round(255*t.g),Math.round(255*t.b),t.a)}stringToHsva(t="",n=!1){let e=null;t=(t||"").toLowerCase();const a=[{re:/(rgb)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*%?,\s*(\d{1,3})\s*%?(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(t){return new zJ(parseInt(t[2],10)/255,parseInt(t[3],10)/255,parseInt(t[4],10)/255,isNaN(parseFloat(t[5]))?1:parseFloat(t[5]))}},{re:/(hsl)a?\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(t){return new TJ(parseInt(t[2],10)/360,parseInt(t[3],10)/100,parseInt(t[4],10)/100,isNaN(parseFloat(t[5]))?1:parseFloat(t[5]))}}];a.push(n?{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})?$/,parse:function(t){return new zJ(parseInt(t[1],16)/255,parseInt(t[2],16)/255,parseInt(t[3],16)/255,parseInt(t[4]||"FF",16)/255)}}:{re:/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/,parse:function(t){return new zJ(parseInt(t[1],16)/255,parseInt(t[2],16)/255,parseInt(t[3],16)/255,1)}}),a.push({re:/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/,parse:function(t){return new zJ(parseInt(t[1]+t[1],16)/255,parseInt(t[2]+t[2],16)/255,parseInt(t[3]+t[3],16)/255,1)}});for(const n in a)if(a.hasOwnProperty(n)){const o=a[n],r=o.re.exec(t),i=r&&o.parse(r);if(i)return i instanceof zJ?e=this.rgbaToHsva(i):i instanceof TJ&&(e=this.hsla2hsva(i)),e}return e}outputFormat(t,n,e){switch("auto"===n&&(n=t.a<1?"rgba":"hex"),n){case"hsla":const n=this.hsva2hsla(t),a=new TJ(Math.round(360*n.h),Math.round(100*n.s),Math.round(100*n.l),Math.round(100*n.a)/100);return t.a<1||"always"===e?"hsla("+a.h+","+a.s+"%,"+a.l+"%,"+a.a+")":"hsl("+a.h+","+a.s+"%,"+a.l+"%)";case"rgba":const o=this.denormalizeRGBA(this.hsvaToRgba(t));return t.a<1||"always"===e?"rgba("+o.r+","+o.g+","+o.b+","+Math.round(100*o.a)/100+")":"rgb("+o.r+","+o.g+","+o.b+")";default:const r="always"===e||"forced"===e;return this.rgbaToHex(this.denormalizeRGBA(this.hsvaToRgba(t)),r)}}}HJ.ɵfac=function t(n){return new(n||HJ)},HJ.ɵprov=We({token:HJ,factory:HJ.ɵfac}),HJ.ctorParameters=()=>[];class BJ{constructor(t,n,e){this.elRef=t,this.cdRef=n,this.service=e,this.isIE10=!1,this.dialogArrowSize=10,this.dialogArrowOffset=15,this.dialogInputFields=[AJ.HEX,AJ.RGBA,AJ.HSLA,AJ.CMYK],this.useRootViewContainer=!1}handleEsc(t){this.show&&"popup"===this.cpDialogDisplay&&this.onCancelColor(t)}handleEnter(t){this.show&&"popup"===this.cpDialogDisplay&&this.onAcceptColor(t)}ngOnInit(){this.slider=new FJ(0,0,0,0),this.sliderDimMax=new LJ(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.format=this.cpCmykEnabled?AJ.CMYK:"rgba"===this.cpOutputFormat?AJ.RGBA:"hsla"===this.cpOutputFormat?AJ.HSLA:AJ.HEX,this.listenerMouseDown=t=>{this.onMouseDown(t)},this.listenerResize=()=>{this.onResize()},this.openDialog(this.initialColor,!1)}ngOnDestroy(){this.closeDialog()}ngAfterViewInit(){230===this.cpWidth&&"inline"!==this.cpDialogDisplay||(this.sliderDimMax=new LJ(this.hueSlider.nativeElement.offsetWidth||140,this.cpWidth,130,this.alphaSlider.nativeElement.offsetWidth||140),this.updateColorPicker(!1),this.cdRef.detectChanges())}openDialog(t,n=!0){this.service.setActive(this),this.width||(this.cpWidth=this.directiveElementRef.nativeElement.offsetWidth),this.height||(this.height=320),this.setInitialColor(t),this.setColorFromString(t,n),this.openColorPicker()}closeDialog(){this.closeColorPicker()}setupDialog(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u,f,h,_,C,M,O,P,x,y,k,v,w,S,E,A,z,R,T,D){this.setInitialColor(e),this.setColorMode(c),this.isIE10=10===(function I(){let t="";"undefined"!=typeof navigator&&(t=navigator.userAgent.toLowerCase());const n=t.indexOf("msie ");return n>0&&parseInt(t.substring(n+5,t.indexOf(".",n)),10)})(),this.directiveInstance=t,this.directiveElementRef=n,this.cpDisableInput=d,this.cpCmykEnabled=s,this.cpAlphaChannel=l,this.cpOutputFormat=m,this.cpDialogDisplay=r,this.cpIgnoredElements=g,this.cpSaveClickOutside=p,this.cpCloseClickOutside=b,this.useRootViewContainer=u,this.width=this.cpWidth=parseInt(a,10),this.height=this.cpHeight=parseInt(o,10),this.cpPosition=f,this.cpPositionOffset=parseInt(h,10),this.cpOKButton=k,this.cpOKButtonText=w,this.cpOKButtonClass=v,this.cpCancelButton=S,this.cpCancelButtonText=A,this.cpCancelButtonClass=E,this.fallbackColor=i||"#fff",this.setPresetConfig(C,M),this.cpPresetColorsClass=O,this.cpMaxPresetColorsLength=P,this.cpPresetEmptyMessage=x,this.cpPresetEmptyMessageClass=y,this.cpAddColorButton=z,this.cpAddColorButtonText=T,this.cpAddColorButtonClass=R,this.cpRemoveColorButtonClass=D,_||(this.dialogArrowOffset=0),"inline"===r&&(this.dialogArrowSize=0,this.dialogArrowOffset=0),"hex"===m&&"always"!==l&&"forced"!==l&&(this.cpAlphaChannel="disabled")}setColorMode(t){switch(t.toString().toUpperCase()){case"1":case"C":case"COLOR":this.cpColorMode=1;break;case"2":case"G":case"GRAYSCALE":this.cpColorMode=2;break;case"3":case"P":case"PRESETS":this.cpColorMode=3;break;default:this.cpColorMode=1}}setInitialColor(t){this.initialColor=t}setPresetConfig(t,n){this.cpPresetLabel=t,this.cpPresetColors=n}setColorFromString(t,n=!0,e=!0){let a;"always"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel?(a=this.service.stringToHsva(t,!0),a||this.hsva||(a=this.service.stringToHsva(t,!1))):a=this.service.stringToHsva(t,!1),a||this.hsva||(a=this.service.stringToHsva(this.fallbackColor,!1)),a&&(this.hsva=a,this.sliderH=this.hsva.h,"hex"===this.cpOutputFormat&&"disabled"===this.cpAlphaChannel&&(this.hsva.a=1),this.updateColorPicker(n,e))}onResize(){"fixed"===this.position?this.setDialogPosition():"inline"!==this.cpDialogDisplay&&this.closeColorPicker()}onDragEnd(t){this.directiveInstance.sliderDragEnd({slider:t,color:this.outputColor})}onDragStart(t){this.directiveInstance.sliderDragStart({slider:t,color:this.outputColor})}onMouseDown(t){!this.show||this.isIE10||"popup"!==this.cpDialogDisplay||t.target===this.directiveElementRef.nativeElement||this.isDescendant(this.elRef.nativeElement,t.target)||this.isDescendant(this.directiveElementRef.nativeElement,t.target)||0!==this.cpIgnoredElements.filter((n=>n===t.target)).length||(this.cpSaveClickOutside?this.directiveInstance.colorSelected(this.outputColor):(this.hsva=null,this.setColorFromString(this.initialColor,!1),this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor),this.directiveInstance.colorCanceled()),this.cpCloseClickOutside&&this.closeColorPicker())}onAcceptColor(t){t.stopPropagation(),this.outputColor&&this.directiveInstance.colorSelected(this.outputColor),"popup"===this.cpDialogDisplay&&this.closeColorPicker()}onCancelColor(t){this.hsva=null,t.stopPropagation(),this.directiveInstance.colorCanceled(),this.setColorFromString(this.initialColor,!0),"popup"===this.cpDialogDisplay&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.initialColor,!0),this.closeColorPicker())}onFormatToggle(t){const n=this.dialogInputFields.length-(this.cpCmykEnabled?0:1),e=((this.dialogInputFields.indexOf(this.format)+t)%n+n)%n;this.format=this.dialogInputFields[e]}onColorChange(t){this.hsva.s=t.s/t.rgX,this.hsva.v=t.v/t.rgY,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"lightness",value:this.hsva.v,color:this.outputColor}),this.directiveInstance.sliderChanged({slider:"saturation",value:this.hsva.s,color:this.outputColor})}onHueChange(t){this.hsva.h=t.v/t.rgX,this.sliderH=this.hsva.h,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"hue",value:this.hsva.h,color:this.outputColor})}onValueChange(t){this.hsva.v=t.v/t.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"value",value:this.hsva.v,color:this.outputColor})}onAlphaChange(t){this.hsva.a=t.v/t.rgX,this.updateColorPicker(),this.directiveInstance.sliderChanged({slider:"alpha",value:this.hsva.a,color:this.outputColor})}onHexInput(t){if(null===t)this.updateColorPicker();else{t&&"#"!==t[0]&&(t="#"+t);let n=/^#([a-f0-9]{3}|[a-f0-9]{6})$/gi;"always"===this.cpAlphaChannel&&(n=/^#([a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/gi);const e=n.test(t);e&&(t.length<5&&(t="#"+t.substring(1).split("").map((t=>t+t)).join("")),"forced"===this.cpAlphaChannel&&(t+=Math.round(255*this.hsva.a).toString(16)),this.setColorFromString(t,!0,!1)),this.directiveInstance.inputChanged({input:"hex",valid:e,value:t,color:this.outputColor})}}onRedInput(t){const n=this.service.hsvaToRgba(this.hsva),e=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;e&&(n.r=t.v/t.rg,this.hsva=this.service.rgbaToHsva(n),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"red",valid:e,value:n.r,color:this.outputColor})}onBlueInput(t){const n=this.service.hsvaToRgba(this.hsva),e=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;e&&(n.b=t.v/t.rg,this.hsva=this.service.rgbaToHsva(n),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"blue",valid:e,value:n.b,color:this.outputColor})}onGreenInput(t){const n=this.service.hsvaToRgba(this.hsva),e=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;e&&(n.g=t.v/t.rg,this.hsva=this.service.rgbaToHsva(n),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"green",valid:e,value:n.g,color:this.outputColor})}onHueInput(t){const n=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;n&&(this.hsva.h=t.v/t.rg,this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"hue",valid:n,value:this.hsva.h,color:this.outputColor})}onValueInput(t){const n=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;n&&(this.hsva.v=t.v/t.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"value",valid:n,value:this.hsva.v,color:this.outputColor})}onAlphaInput(t){const n=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;n&&(this.hsva.a=t.v/t.rg,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"alpha",valid:n,value:this.hsva.a,color:this.outputColor})}onLightnessInput(t){const n=this.service.hsva2hsla(this.hsva),e=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;e&&(n.l=t.v/t.rg,this.hsva=this.service.hsla2hsva(n),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"lightness",valid:e,value:n.l,color:this.outputColor})}onSaturationInput(t){const n=this.service.hsva2hsla(this.hsva),e=!isNaN(t.v)&&t.v>=0&&t.v<=t.rg;e&&(n.s=t.v/t.rg,this.hsva=this.service.hsla2hsva(n),this.sliderH=this.hsva.h,this.updateColorPicker()),this.directiveInstance.inputChanged({input:"saturation",valid:e,value:n.s,color:this.outputColor})}onCyanInput(t){!isNaN(t.v)&&t.v>=0&&t.v<=t.rg&&(this.cmyk.c=t.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"cyan",valid:!0,value:this.cmyk.c,color:this.outputColor})}onMagentaInput(t){!isNaN(t.v)&&t.v>=0&&t.v<=t.rg&&(this.cmyk.m=t.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"magenta",valid:!0,value:this.cmyk.m,color:this.outputColor})}onYellowInput(t){!isNaN(t.v)&&t.v>=0&&t.v<=t.rg&&(this.cmyk.y=t.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"yellow",valid:!0,value:this.cmyk.y,color:this.outputColor})}onBlackInput(t){!isNaN(t.v)&&t.v>=0&&t.v<=t.rg&&(this.cmyk.k=t.v,this.updateColorPicker(!1,!0,!0)),this.directiveInstance.inputChanged({input:"black",valid:!0,value:this.cmyk.k,color:this.outputColor})}onAddPresetColor(t,n){t.stopPropagation(),this.cpPresetColors.filter((t=>t===n)).length||(this.cpPresetColors=this.cpPresetColors.concat(n),this.directiveInstance.presetColorsChanged(this.cpPresetColors))}onRemovePresetColor(t,n){t.stopPropagation(),this.cpPresetColors=this.cpPresetColors.filter((t=>t!==n)),this.directiveInstance.presetColorsChanged(this.cpPresetColors)}openColorPicker(){this.show||(this.show=!0,this.hidden=!0,setTimeout((()=>{this.hidden=!1,this.setDialogPosition(),this.cdRef.detectChanges()}),0),this.directiveInstance.stateChanged(!0),this.isIE10||(document.addEventListener("mousedown",this.listenerMouseDown),document.addEventListener("touchstart",this.listenerMouseDown)),window.addEventListener("resize",this.listenerResize))}closeColorPicker(){this.show&&(this.show=!1,this.directiveInstance.stateChanged(!1),this.isIE10||(document.removeEventListener("mousedown",this.listenerMouseDown),document.removeEventListener("touchstart",this.listenerMouseDown)),window.removeEventListener("resize",this.listenerResize),this.cdRef.destroyed||this.cdRef.detectChanges())}updateColorPicker(t=!0,n=!0,e=!1){if(this.sliderDimMax){let a,o,r;2===this.cpColorMode&&(this.hsva.s=0);const i=this.outputColor;if(o=this.service.hsva2hsla(this.hsva),this.cpCmykEnabled?(e?(r=this.service.cmykToRgb(this.service.normalizeCMYK(this.cmyk)),this.hsva=this.service.rgbaToHsva(r)):(r=this.service.hsvaToRgba(this.hsva),this.cmyk=this.service.denormalizeCMYK(this.service.rgbaToCmyk(r))),r=this.service.denormalizeRGBA(r),this.sliderH=this.hsva.h):r=this.service.denormalizeRGBA(this.service.hsvaToRgba(this.hsva)),a=this.service.denormalizeRGBA(this.service.hsvaToRgba(new RJ(this.sliderH||this.hsva.h,1,1,1))),n&&(this.hslaText=new TJ(Math.round(360*o.h),Math.round(100*o.s),Math.round(100*o.l),Math.round(100*o.a)/100),this.rgbaText=new zJ(r.r,r.g,r.b,Math.round(100*r.a)/100),this.cpCmykEnabled&&(this.cmykText=new DJ(this.cmyk.c,this.cmyk.m,this.cmyk.y,this.cmyk.k,Math.round(100*this.cmyk.a)/100)),this.hexText=this.service.rgbaToHex(r,"always"===this.cpAlphaChannel),this.hexAlpha=this.rgbaText.a),"auto"===this.cpOutputFormat&&this.format!==AJ.RGBA&&this.format!==AJ.CMYK&&this.hsva.a<1&&(this.format=this.hsva.a<1?AJ.RGBA:AJ.HEX),this.hueSliderColor="rgb("+a.r+","+a.g+","+a.b+")",this.alphaSliderColor="rgb("+r.r+","+r.g+","+r.b+")",this.outputColor=this.service.outputFormat(this.hsva,this.cpOutputFormat,this.cpAlphaChannel),this.selectedColor=this.service.outputFormat(this.hsva,"rgba",null),this.format!==AJ.CMYK)this.cmykColor="";else if("always"===this.cpAlphaChannel||"enabled"===this.cpAlphaChannel||"forced"===this.cpAlphaChannel){const t=Math.round(100*this.cmyk.a)/100;this.cmykColor=`cmyka(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k},${t})`}else this.cmykColor=`cmyk(${this.cmyk.c},${this.cmyk.m},${this.cmyk.y},${this.cmyk.k})`;this.slider=new FJ((this.sliderH||this.hsva.h)*this.sliderDimMax.h-8,this.hsva.s*this.sliderDimMax.s-8,(1-this.hsva.v)*this.sliderDimMax.v-8,this.hsva.a*this.sliderDimMax.a-8),t&&i!==this.outputColor&&(this.cpCmykEnabled&&this.directiveInstance.cmykChanged(this.cmykColor),this.directiveInstance.colorChanged(this.outputColor))}}setDialogPosition(){if("inline"===this.cpDialogDisplay)this.position="relative";else{let t,n="static",e="",a=null,o=null,r=this.directiveElementRef.nativeElement.parentNode;const i=this.dialogElement.nativeElement.offsetHeight;for(;null!==r&&"HTML"!==r.tagName;){if(t=window.getComputedStyle(r),n=t.getPropertyValue("position"),e=t.getPropertyValue("transform"),"static"!==n&&null===a&&(a=r),e&&"none"!==e&&null===o&&(o=r),"fixed"===n){a=o;break}r=r.parentNode}const c=this.createDialogBox(this.directiveElementRef.nativeElement,"fixed"!==n);if(this.useRootViewContainer||"fixed"===n&&(!a||a instanceof HTMLUnknownElement))this.top=c.top,this.left=c.left;else{null===a&&(a=r);const t=this.createDialogBox(a,"fixed"!==n);this.top=c.top-t.top,this.left=c.left-t.left}"fixed"===n&&(this.position="fixed");let s=this.cpPosition;"auto"===this.cpPosition&&(s=(function t(n){let e="right",a="bottom";const{height:o,width:r,top:i,bottom:c,left:s,right:l}=n,m=i-o<0,d=c+o>(window.innerHeight||document.documentElement.clientHeight),g=s-r<0,p=l+r>(window.innerWidth||document.documentElement.clientWidth);return d&&(a="top"),m&&(a="bottom"),g&&(e="right"),p&&(e="left"),m&&d&&g&&p?["left","right","top","bottom"].reduce(((t,e)=>n[t]>n[e]?t:e)):g&&p?m?"bottom":d||i>c?"top":"bottom":m&&d?g?"right":p||s>l?"left":"right":`${a}-${e}`})(this.dialogElement.nativeElement.getBoundingClientRect())),"top"===s?(this.arrowTop=i-1,this.top-=i+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"bottom"===s?(this.top+=c.height+this.dialogArrowSize,this.left+=this.cpPositionOffset/100*c.width-this.dialogArrowOffset):"top-left"===s||"left-top"===s?(this.top-=i-c.height+c.height*this.cpPositionOffset/100,this.left-=this.cpWidth+this.dialogArrowSize-2-this.dialogArrowOffset):"top-right"===s||"right-top"===s?(this.top-=i-c.height+c.height*this.cpPositionOffset/100,this.left+=c.width+this.dialogArrowSize-2-this.dialogArrowOffset):"left"===s||"bottom-left"===s||"left-bottom"===s?(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left-=this.cpWidth+this.dialogArrowSize-2):(this.top+=c.height*this.cpPositionOffset/100-this.dialogArrowOffset,this.left+=c.width+this.dialogArrowSize-2)}}isDescendant(t,n){let e=n.parentNode;for(;null!==e;){if(e===t)return!0;e=e.parentNode}return!1}createDialogBox(t,n){return{top:t.getBoundingClientRect().top+(n?window.pageYOffset:0),left:t.getBoundingClientRect().left+(n?window.pageXOffset:0),width:t.offsetWidth,height:t.offsetHeight}}}BJ.ɵfac=function t(n){return new(n||BJ)(Zg(xu),Zg(Vm),Zg(HJ))},BJ.ɵcmp=_o({type:BJ,selectors:[["color-picker"]],viewQuery:function t(n,e){var a;1&n&&(jf(tJ,!0),jf(nJ,!0),jf(eJ,!0)),2&n&&(Vf(a=Zf())&&(e.dialogElement=a.first),Vf(a=Zf())&&(e.hueSlider=a.first),Vf(a=Zf())&&(e.alphaSlider=a.first))},hostBindings:function t(n,e){1&n&&cp("keyup.esc",(function t(n){return e.handleEsc(n)}),!1,ar)("keyup.enter",(function t(n){return e.handleEnter(n)}),!1,ar)},decls:28,vars:47,consts:[[1,"color-picker",3,"click"],["dialogPopup",""],[3,"class","top",4,"ngIf"],["class","saturation-lightness",3,"slider","rgX","rgY","background-color","newValue","dragStart","dragEnd",4,"ngIf"],[1,"hue-alpha","box"],[1,"left"],[1,"selected-color-background"],[1,"selected-color"],["type","button",3,"class","disabled","click",4,"ngIf"],[1,"right"],["style","height: 16px;",4,"ngIf"],[1,"hue",3,"slider","rgX","newValue","dragStart","dragEnd"],["hueSlider",""],[1,"cursor"],[1,"value",3,"slider","rgX","newValue","dragStart","dragEnd"],["valueSlider",""],[1,"alpha",3,"slider","rgX","newValue","dragStart","dragEnd"],["alphaSlider",""],["class","cmyk-text",3,"display",4,"ngIf"],["class","hsla-text",3,"display",4,"ngIf"],["class","rgba-text",3,"display",4,"ngIf"],["class","hex-text",3,"hex-alpha","display",4,"ngIf"],["class","value-text",4,"ngIf"],["class","type-policy",4,"ngIf"],["class","preset-area",4,"ngIf"],["class","button-area",4,"ngIf"],[1,"saturation-lightness",3,"slider","rgX","rgY","newValue","dragStart","dragEnd"],["type","button",3,"disabled","click"],[2,"height","16px"],[1,"cmyk-text"],[1,"box"],["type","number","pattern","[0-9]*","min","0","max","100",3,"text","rg","value","keyup.enter","newValue"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue",4,"ngIf"],[4,"ngIf"],["type","number","pattern","[0-9]+([\\.,][0-9]{1,2})?","min","0","max","1","step","0.1",3,"text","rg","value","keyup.enter","newValue"],[1,"hsla-text"],["type","number","pattern","[0-9]*","min","0","max","360",3,"text","rg","value","keyup.enter","newValue"],[1,"rgba-text"],["type","number","pattern","[0-9]*","min","0","max","255",3,"text","rg","value","keyup.enter","newValue"],[1,"hex-text"],[3,"text","value","blur","keyup.enter","newValue"],[1,"value-text"],[1,"type-policy"],[1,"type-policy-arrow",3,"click"],[1,"preset-area"],[1,"preset-label"],[3,"class",4,"ngIf"],["class","preset-color",3,"backgroundColor","click",4,"ngFor","ngForOf"],[1,"preset-color",3,"click"],[3,"class","click",4,"ngIf"],[3,"click"],[1,"button-area"],["type","button",3,"class","click",4,"ngIf"],["type","button",3,"click"]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),cp("click",(function t(n){return n.stopPropagation()})),Yg(2,aJ,1,5,"div",2),Yg(3,oJ,2,8,"div",3),Kg(4,"div",4),Kg(5,"div",5),tp(6,"div",6),tp(7,"div",7),Yg(8,rJ,2,5,"button",8),$g(),Kg(9,"div",9),Yg(10,iJ,1,0,"div",10),Kg(11,"div",11,12),cp("newValue",(function t(n){return e.onHueChange(n)}))("dragStart",(function t(){return e.onDragStart("hue")}))("dragEnd",(function t(){return e.onDragEnd("hue")})),tp(13,"div",13),$g(),Kg(14,"div",14,15),cp("newValue",(function t(n){return e.onValueChange(n)}))("dragStart",(function t(){return e.onDragStart("value")}))("dragEnd",(function t(){return e.onDragEnd("value")})),tp(16,"div",13),$g(),Kg(17,"div",16,17),cp("newValue",(function t(n){return e.onAlphaChange(n)}))("dragStart",(function t(){return e.onDragStart("alpha")}))("dragEnd",(function t(){return e.onDragEnd("alpha")})),tp(19,"div",13),$g(),$g(),$g(),Yg(20,lJ,17,12,"div",18),Yg(21,gJ,14,10,"div",19),Yg(22,uJ,14,10,"div",20),Yg(23,_J,8,7,"div",21),Yg(24,MJ,9,3,"div",22),Yg(25,OJ,3,0,"div",23),Yg(26,vJ,6,3,"div",24),Yg(27,EJ,3,2,"div",25),$g()),2&n&&(Tp("display",e.show?"block":"none")("visibility",e.hidden?"hidden":"visible")("top",e.top,"px")("left",e.left,"px")("position",e.position)("height",e.cpHeight,"px")("width",e.cpWidth,"px"),Dp("open",e.show),ws(2),Jg("ngIf","popup"==e.cpDialogDisplay),ws(1),Jg("ngIf",1===(e.cpColorMode||1)),ws(4),Tp("background-color",e.selectedColor),ws(1),Jg("ngIf",e.cpAddColorButton),ws(2),Jg("ngIf","disabled"===e.cpAlphaChannel),ws(1),Tp("display",1===(e.cpColorMode||1)?"block":"none"),Jg("rgX",1),ws(2),Tp("left",null==e.slider?null:e.slider.h,"px"),ws(1),Tp("display",2===(e.cpColorMode||1)?"block":"none"),Jg("rgX",1),ws(2),Tp("right",null==e.slider?null:e.slider.v,"px"),ws(1),Tp("display","disabled"===e.cpAlphaChannel?"none":"block")("background-color",e.alphaSliderColor),Jg("rgX",1),ws(2),Tp("left",null==e.slider?null:e.slider.a,"px"),ws(1),Jg("ngIf",!e.cpDisableInput&&1===(e.cpColorMode||1)),ws(1),Jg("ngIf",!e.cpDisableInput&&1===(e.cpColorMode||1)),ws(1),Jg("ngIf",!e.cpDisableInput&&1===(e.cpColorMode||1)),ws(1),Jg("ngIf",!e.cpDisableInput&&1===(e.cpColorMode||1)),ws(1),Jg("ngIf",!e.cpDisableInput&&2===(e.cpColorMode||1)),ws(1),Jg("ngIf",!e.cpDisableInput&&1===(e.cpColorMode||1)),ws(1),Jg("ngIf",(null==e.cpPresetColors?null:e.cpPresetColors.length)||e.cpAddColorButton),ws(1),Jg("ngIf",e.cpOKButton||e.cpCancelButton))},directives:[WM,NJ,IJ,jM],styles:['.color-picker{-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;background-color:#fff;border:1px solid #777;cursor:default;height:auto;position:absolute;user-select:none;width:230px;z-index:1000}.color-picker *{box-sizing:border-box;font-size:11px;margin:0}.color-picker input{color:#000;font-size:13px;height:26px;min-width:0;text-align:center;width:0}.color-picker input:-moz-submit-invalid,.color-picker input:-moz-ui-invalid,.color-picker input:invalid{box-shadow:none}.color-picker input::-webkit-inner-spin-button,.color-picker input::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}.color-picker .arrow{border-style:solid;height:0;position:absolute;width:0;z-index:999999}.color-picker .arrow.arrow-top{border-color:#777 transparent transparent;border-width:10px 5px;left:8px}.color-picker .arrow.arrow-bottom{border-color:transparent transparent #777;border-width:10px 5px;left:8px;top:-20px}.color-picker .arrow.arrow-left-top,.color-picker .arrow.arrow-top-left{border-color:transparent transparent transparent #777;border-width:5px 10px;bottom:8px;right:-21px}.color-picker .arrow.arrow-right-top,.color-picker .arrow.arrow-top-right{border-color:transparent #777 transparent transparent;border-width:5px 10px;bottom:8px;left:-20px}.color-picker .arrow.arrow-bottom-left,.color-picker .arrow.arrow-left,.color-picker .arrow.arrow-left-bottom{border-color:transparent transparent transparent #777;border-width:5px 10px;right:-21px;top:8px}.color-picker .arrow.arrow-bottom-right,.color-picker .arrow.arrow-right,.color-picker .arrow.arrow-right-bottom{border-color:transparent #777 transparent transparent;border-width:5px 10px;left:-20px;top:8px}.color-picker .cursor{border:2px solid #222;border-radius:50%;cursor:default;height:16px;position:relative;width:16px}.color-picker .box{display:flex;padding:4px 8px}.color-picker .left{padding:16px 8px;position:relative}.color-picker .right{flex:1 1 auto;padding:12px 8px}.color-picker .button-area{padding:0 16px 16px;text-align:right}.color-picker .button-area button{margin-left:8px}.color-picker .preset-area{padding:4px 15px}.color-picker .preset-area .preset-label{color:#555;font-size:11px;overflow:hidden;padding:4px;text-align:left;text-overflow:ellipsis;white-space:nowrap;width:100%}.color-picker .preset-area .preset-color{border:1px solid #a9a9a9;border-radius:25%;cursor:pointer;display:inline-block;height:18px;margin:4px 6px 8px;position:relative;width:18px}.color-picker .preset-area .preset-empty-message{font-style:italic;margin-bottom:8px;margin-top:4px;min-height:18px;text-align:center}.color-picker .hex-text{font-size:11px;padding:4px 8px;width:100%}.color-picker .hex-text .box{padding:0 24px 8px 8px}.color-picker .hex-text .box div{clear:left;color:#555;flex:1 1 auto;float:left;text-align:center}.color-picker .hex-text .box input{border:1px solid #a9a9a9;flex:1 1 auto;padding:1px}.color-picker .hex-alpha .box div:first-child,.color-picker .hex-alpha .box input:first-child{flex-grow:3;margin-right:8px}.color-picker .cmyk-text,.color-picker .hsla-text,.color-picker .rgba-text,.color-picker .value-text{font-size:11px;padding:4px 8px;width:100%}.color-picker .cmyk-text .box,.color-picker .hsla-text .box,.color-picker .rgba-text .box{padding:0 24px 8px 8px}.color-picker .value-text .box{padding:0 8px 8px}.color-picker .cmyk-text .box div,.color-picker .hsla-text .box div,.color-picker .rgba-text .box div,.color-picker .value-text .box div{color:#555;flex:1 1 auto;margin-right:8px;text-align:center}.color-picker .cmyk-text .box div:last-child,.color-picker .hsla-text .box div:last-child,.color-picker .rgba-text .box div:last-child,.color-picker .value-text .box div:last-child{margin-right:0}.color-picker .cmyk-text .box input,.color-picker .hsla-text .box input,.color-picker .rgba-text .box input,.color-picker .value-text .box input{border:1px solid #a9a9a9;flex:1;float:left;margin:0 8px 0 0;padding:1px}.color-picker .cmyk-text .box input:last-child,.color-picker .hsla-text .box input:last-child,.color-picker .rgba-text .box input:last-child,.color-picker .value-text .box input:last-child{margin-right:0}.color-picker .hue-alpha{align-items:center;margin-bottom:3px}.color-picker .hue{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwkUFWbCCAAAAFxJREFUaN7t0kEKg0AQAME2x83/n2qu5qCgD1iDhCoYdpnbQC9bbY1qVO/jvc6k3ad91s7/7F1/csgPrujuQ17BDYSFsBAWwgJhISyEBcJCWAgLhIWwEBYIi2f7Ar/1TCgFH2X9AAAAAElFTkSuQmCC");direction:ltr}.color-picker .hue,.color-picker .value{background-size:100% 100%;border:none;cursor:pointer;height:16px;margin-bottom:16px;width:100%}.color-picker .value{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAACTklEQVR42u3SYUcrABhA4U2SkmRJMmWSJklKJiWZZpKUJJskKUmaTFImKZOUzMySpGRmliRNJilJSpKSJEtmSpIpmWmSdO736/6D+x7OP3gUCoWCv1cqlSQlJZGcnExKSgqpqamkpaWRnp5ORkYGmZmZqFQqsrKyyM7OJicnh9zcXNRqNXl5eeTn56PRaCgoKKCwsJCioiK0Wi3FxcWUlJRQWlpKWVkZ5eXlVFRUUFlZiU6no6qqiurqampqaqitraWurg69Xk99fT0GgwGj0UhDQwONjY00NTXR3NxMS0sLra2ttLW10d7ejslkwmw209HRQWdnJ11dXXR3d9PT00Nvby99fX309/czMDDA4OAgFouFoaEhrFYrw8PDjIyMMDo6ytjYGDabjfHxcSYmJpicnGRqagq73c709DQzMzPMzs4yNzfH/Pw8DocDp9OJy+XC7XazsLDA4uIiS0tLLC8vs7KywurqKmtra3g8HrxeLz6fD7/fz/r6OhsbG2xubrK1tcX29jaBQICdnR2CwSC7u7vs7e2xv7/PwcEBh4eHHB0dcXx8zMnJCaenp5ydnXF+fs7FxQWXl5dcXV1xfX3Nzc0Nt7e33N3dEQqFuL+/5+HhgXA4TCQS4fHxkaenJ56fn3l5eeH19ZVoNMrb2xvv7+98fHwQi8WIx+N8fn6SSCT4+vri+/ubn58ffn9/+VcKgSWwBJbAElgCS2AJLIElsASWwBJYAktgCSyBJbAElsASWAJLYAksgSWwBJbAElgCS2AJLIElsP4/WH8AmJ5Z6jHS4h8AAAAASUVORK5CYII=");direction:rtl}.color-picker .alpha{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJYAAAAQCAYAAAD06IYnAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AIWDwYQlZMa3gAAAWVJREFUaN7tmEGO6jAQRCsOArHgBpyAJYGjcGocxAm4A2IHpmoWE0eBH+ezmFlNvU06shJ3W6VEelWMUQAIIF9f6qZpimsA1LYtS2uF51/u27YVAFZVRUkEoGHdPV/sIcbIEIIkUdI/9Xa7neyv61+SWFUVAVCSct00TWn2fv6u3+Ecfd3tXzy/0+nEUu+SPjo/kqzrmiQpScN6v98XewfA8/lMkiLJ2WxGSUopcT6fM6U0NX9/frfbjev1WtfrlZfLhYfDQQHG/AIOlnGwjINlHCxjHCzjYJm/TJWdCwquJXseFFzGwDNNeiKMOJTO8xQdDQaeB29+K9efeLaBo9J7vdvtJj1RjFFjfiv7qv95tjx/7leSQgh93e1ffMeIp6O+YQjho/N791t1XVOSSI7N//K+4/GoxWLBx+PB5/Op5XLJ+/3OlJJWqxU3m83ovv5iGf8KjYNlHCxjHCzjYBkHy5gf5gusvQU7U37jTAAAAABJRU5ErkJggg==");background-size:100% 100%;border:none;cursor:pointer;direction:ltr;height:16px;width:100%}.color-picker .type-policy{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAAgCAYAAAAffCjxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAACewAAAnsB01CO3AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAIASURBVEiJ7ZY9axRRFIafsxMStrLQJpAgpBFhi+C9w1YSo00I6RZ/g9vZpBf/QOr4GyRgkSKNSrAadsZqQGwCkuAWyRZJsySwvhZ7N/vhzrgbLH3Ld8597jlzz50zJokyxXH8DqDVar0qi6v8BbItqSGpEcfxdlmsFWXkvX8AfAVWg3UKPEnT9GKujMzsAFgZsVaCN1VTQd77XUnrgE1kv+6935268WRpzrnHZvYRWC7YvC3pRZZl3wozqtVqiyH9IgjAspkd1Gq1xUJQtVrdB9ZKIAOthdg/Qc65LUk7wNIMoCVJO865rYFhkqjX6/d7vV4GPJwBMqofURS5JEk6FYBer/eeYb/Mo9WwFnPOvQbeAvfuAAK4BN4sAJtAG/gJIElmNuiJyba3EGNmZiPeZuEVmVell/Y/6N+CzDn3AXhEOOo7Hv/3BeAz8IzQkMPnJbuPx1wC+yYJ7/0nYIP5S/0FHKdp+rwCEEXRS/rf5Hl1Gtb2M0iSpCOpCZzPATmX1EySpHMLAsiy7MjMDoHrGSDXZnaYZdnRwBh7J91utwmczAA6CbG3GgPleX4jqUH/a1CktqRGnuc3hSCAMB32gKspkCtgb3KCQMmkjeP4WNJThrNNZval1WptTIsv7JtQ4tmIdRa8qSoEpWl6YWZNoAN0zKxZNPehpLSBZv2t+Q0CJ9lLnARQLAAAAABJRU5ErkJggg==");background-position:50%;background-repeat:no-repeat;background-size:8px 16px;height:24px;position:absolute;right:12px;top:218px;width:16px}.color-picker .type-policy .type-policy-arrow{display:block;height:50%;width:100%}.color-picker .selected-color{border:1px solid #a9a9a9;border-radius:50%;height:40px;left:8px;position:absolute;top:16px;width:40px}.color-picker .selected-color-background{background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAAh0lEQVRYR+2W0QlAMQgD60zdfwOdqa8TmI/wQMr5K0I5bZLIzLOa2nt37VVVbd+dDx5obgCC3KBLwJ2ff4PnVidkf+ucIhw80HQaCLo3DMH3CRK3iFsmAWVl6hPNDwt8EvNE5q+YuEXcMgkonVM6SdyCoEvAnZ8v1Hjx817MilmxSUB5rdLJDycZgUAZUch/AAAAAElFTkSuQmCC");border-radius:50%;height:40px;width:40px}.color-picker .saturation-lightness{background-image:url("data:image/png;base64,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");background-size:100% 100%;border:none;cursor:pointer;direction:ltr;height:130px;touch-action:manipulation;width:100%}.color-picker .cp-add-color-button-class{background:transparent;border:0;cursor:pointer;display:inline;margin:3px -3px;padding:0;position:absolute}.color-picker .cp-add-color-button-class:hover{text-decoration:underline}.color-picker .cp-add-color-button-class:disabled{color:#999;cursor:not-allowed}.color-picker .cp-add-color-button-class:disabled:hover{text-decoration:none}.color-picker .cp-remove-color-button-class{background:#fff;border-radius:50%;box-shadow:1px 1px 5px #333;cursor:pointer;display:block;height:10px;position:absolute;right:-5px;text-align:center;top:-5px;width:10px}.color-picker .cp-remove-color-button-class:before{bottom:3.5px;content:"x";display:inline-block;font-size:10px;position:relative}'],encapsulation:2}),BJ.ctorParameters=()=>[{type:xu},{type:Vm},{type:HJ}],BJ.propDecorators={dialogElement:[{type:Xd,args:["dialogPopup",{static:!0}]}],hueSlider:[{type:Xd,args:["hueSlider",{static:!0}]}],alphaSlider:[{type:Xd,args:["alphaSlider",{static:!0}]}],handleEsc:[{type:__,args:["document:keyup.esc",["$event"]]}],handleEnter:[{type:__,args:["document:keyup.enter",["$event"]]}]};class VJ{constructor(t,n,e,a,o,r){this.injector=t,this.cfr=n,this.appRef=e,this.vcRef=a,this.elRef=o,this._service=r,this.dialogCreated=!1,this.ignoreChanges=!1,this.viewAttachedToAppRef=!1,this.cpWidth="230px",this.cpHeight="auto",this.cpToggle=!1,this.cpDisabled=!1,this.cpIgnoredElements=[],this.cpFallbackColor="",this.cpColorMode="color",this.cpCmykEnabled=!1,this.cpOutputFormat="auto",this.cpAlphaChannel="enabled",this.cpDisableInput=!1,this.cpDialogDisplay="popup",this.cpSaveClickOutside=!0,this.cpCloseClickOutside=!0,this.cpUseRootViewContainer=!1,this.cpPosition="auto",this.cpPositionOffset="0%",this.cpPositionRelativeToArrow=!1,this.cpOKButton=!1,this.cpOKButtonText="OK",this.cpOKButtonClass="cp-ok-button-class",this.cpCancelButton=!1,this.cpCancelButtonText="Cancel",this.cpCancelButtonClass="cp-cancel-button-class",this.cpPresetLabel="Preset colors",this.cpPresetColorsClass="cp-preset-colors-class",this.cpMaxPresetColorsLength=6,this.cpPresetEmptyMessage="No colors added",this.cpPresetEmptyMessageClass="preset-empty-message",this.cpAddColorButton=!1,this.cpAddColorButtonText="Add color",this.cpAddColorButtonClass="cp-add-color-button-class",this.cpRemoveColorButtonClass="cp-remove-color-button-class",this.cpInputChange=new Ef(!0),this.cpToggleChange=new Ef(!0),this.cpSliderChange=new Ef(!0),this.cpSliderDragEnd=new Ef(!0),this.cpSliderDragStart=new Ef(!0),this.colorPickerOpen=new Ef(!0),this.colorPickerClose=new Ef(!0),this.colorPickerCancel=new Ef(!0),this.colorPickerSelect=new Ef(!0),this.colorPickerChange=new Ef(!1),this.cpCmykColorChange=new Ef(!0),this.cpPresetColorsChange=new Ef(!0)}handleClick(){this.inputFocus()}handleFocus(){this.inputFocus()}handleInput(t){this.inputChange(t)}ngOnDestroy(){null!=this.cmpRef&&(this.viewAttachedToAppRef&&this.appRef.detachView(this.cmpRef.hostView),this.cmpRef.destroy(),this.cmpRef=null,this.dialog=null)}ngOnChanges(t){t.cpToggle&&!this.cpDisabled&&(t.cpToggle.currentValue?this.openDialog():t.cpToggle.currentValue||this.closeDialog()),t.colorPicker&&(this.dialog&&!this.ignoreChanges&&("inline"===this.cpDialogDisplay&&this.dialog.setInitialColor(t.colorPicker.currentValue),this.dialog.setColorFromString(t.colorPicker.currentValue,!1),this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay&&this.cmpRef.changeDetectorRef.detectChanges()),this.ignoreChanges=!1),(t.cpPresetLabel||t.cpPresetColors)&&this.dialog&&this.dialog.setPresetConfig(this.cpPresetLabel,this.cpPresetColors)}openDialog(){if(this.dialogCreated)this.dialog&&this.dialog.openDialog(this.colorPicker);else{let t=this.vcRef;if(this.dialogCreated=!0,this.viewAttachedToAppRef=!1,this.cpUseRootViewContainer&&"inline"!==this.cpDialogDisplay){const n=this.injector.get(this.appRef.componentTypes[0],yd.NULL);n!==yd.NULL?(t=n.vcRef||n.viewContainerRef||this.vcRef,t===this.vcRef&&console.warn("You are using cpUseRootViewContainer, but the root component is not exposing viewContainerRef!Please expose it by adding 'public vcRef: ViewContainerRef' to the constructor.")):this.viewAttachedToAppRef=!0}const n=this.cfr.resolveComponentFactory(BJ);if(this.viewAttachedToAppRef)this.cmpRef=n.create(this.injector),this.appRef.attachView(this.cmpRef.hostView),document.body.appendChild(this.cmpRef.hostView.rootNodes[0]);else{const e=Wd.fromResolvedProviders([],t.parentInjector);this.cmpRef=t.createComponent(n,0,e,[])}this.cmpRef.instance.setupDialog(this,this.elRef,this.colorPicker,this.cpWidth,this.cpHeight,this.cpDialogDisplay,this.cpFallbackColor,this.cpColorMode,this.cpCmykEnabled,this.cpAlphaChannel,this.cpOutputFormat,this.cpDisableInput,this.cpIgnoredElements,this.cpSaveClickOutside,this.cpCloseClickOutside,this.cpUseRootViewContainer,this.cpPosition,this.cpPositionOffset,this.cpPositionRelativeToArrow,this.cpPresetLabel,this.cpPresetColors,this.cpPresetColorsClass,this.cpMaxPresetColorsLength,this.cpPresetEmptyMessage,this.cpPresetEmptyMessageClass,this.cpOKButton,this.cpOKButtonClass,this.cpOKButtonText,this.cpCancelButton,this.cpCancelButtonClass,this.cpCancelButtonText,this.cpAddColorButton,this.cpAddColorButtonClass,this.cpAddColorButtonText,this.cpRemoveColorButtonClass),this.dialog=this.cmpRef.instance,this.vcRef!==t&&this.cmpRef.changeDetectorRef.detectChanges()}}closeDialog(){this.dialog&&"popup"===this.cpDialogDisplay&&this.dialog.closeDialog()}cmykChanged(t){this.cpCmykColorChange.emit(t)}stateChanged(t){this.cpToggleChange.emit(t),t?this.colorPickerOpen.emit(this.colorPicker):this.colorPickerClose.emit(this.colorPicker)}colorChanged(t,n=!0){this.ignoreChanges=n,this.colorPickerChange.emit(t)}colorSelected(t){this.colorPickerSelect.emit(t)}colorCanceled(){this.colorPickerCancel.emit()}inputFocus(){const t=this.elRef.nativeElement,n=this.cpIgnoredElements.filter((n=>n===t));this.cpDisabled||n.length||("undefined"!=typeof document&&t===document.activeElement?this.openDialog():this.dialog&&this.dialog.show?this.closeDialog():this.openDialog())}inputChange(t){this.dialog?this.dialog.setColorFromString(t.target.value,!0):(this.colorPicker=t.target.value,this.colorPickerChange.emit(this.colorPicker))}inputChanged(t){this.cpInputChange.emit(t)}sliderChanged(t){this.cpSliderChange.emit(t)}sliderDragEnd(t){this.cpSliderDragEnd.emit(t)}sliderDragStart(t){this.cpSliderDragStart.emit(t)}presetColorsChanged(t){this.cpPresetColorsChange.emit(t)}}VJ.ɵfac=function t(n){return new(n||VJ)(Zg(yd),Zg(Pu),Zg(pC),Zg($u),Zg(xu),Zg(HJ))},VJ.ɵdir=vo({type:VJ,selectors:[["","colorPicker",""]],hostBindings:function t(n,e){1&n&&cp("click",(function t(){return e.handleClick()}))("focus",(function t(){return e.handleFocus()}))("input",(function t(n){return e.handleInput(n)}))},inputs:{cpWidth:"cpWidth",cpHeight:"cpHeight",cpToggle:"cpToggle",cpDisabled:"cpDisabled",cpIgnoredElements:"cpIgnoredElements",cpFallbackColor:"cpFallbackColor",cpColorMode:"cpColorMode",cpCmykEnabled:"cpCmykEnabled",cpOutputFormat:"cpOutputFormat",cpAlphaChannel:"cpAlphaChannel",cpDisableInput:"cpDisableInput",cpDialogDisplay:"cpDialogDisplay",cpSaveClickOutside:"cpSaveClickOutside",cpCloseClickOutside:"cpCloseClickOutside",cpUseRootViewContainer:"cpUseRootViewContainer",cpPosition:"cpPosition",cpPositionOffset:"cpPositionOffset",cpPositionRelativeToArrow:"cpPositionRelativeToArrow",cpOKButton:"cpOKButton",cpOKButtonText:"cpOKButtonText",cpOKButtonClass:"cpOKButtonClass",cpCancelButton:"cpCancelButton",cpCancelButtonText:"cpCancelButtonText",cpCancelButtonClass:"cpCancelButtonClass",cpPresetLabel:"cpPresetLabel",cpPresetColorsClass:"cpPresetColorsClass",cpMaxPresetColorsLength:"cpMaxPresetColorsLength",cpPresetEmptyMessage:"cpPresetEmptyMessage",cpPresetEmptyMessageClass:"cpPresetEmptyMessageClass",cpAddColorButton:"cpAddColorButton",cpAddColorButtonText:"cpAddColorButtonText",cpAddColorButtonClass:"cpAddColorButtonClass",cpRemoveColorButtonClass:"cpRemoveColorButtonClass",colorPicker:"colorPicker",cpPresetColors:"cpPresetColors"},outputs:{cpInputChange:"cpInputChange",cpToggleChange:"cpToggleChange",cpSliderChange:"cpSliderChange",cpSliderDragEnd:"cpSliderDragEnd",cpSliderDragStart:"cpSliderDragStart",colorPickerOpen:"colorPickerOpen",colorPickerClose:"colorPickerClose",colorPickerCancel:"colorPickerCancel",colorPickerSelect:"colorPickerSelect",colorPickerChange:"colorPickerChange",cpCmykColorChange:"cpCmykColorChange",cpPresetColorsChange:"cpPresetColorsChange"},exportAs:["ngxColorPicker"],features:[pr]}),VJ.ctorParameters=()=>[{type:yd},{type:Pu},{type:pC},{type:$u},{type:xu},{type:HJ}],VJ.propDecorators={colorPicker:[{type:f_}],cpWidth:[{type:f_}],cpHeight:[{type:f_}],cpToggle:[{type:f_}],cpDisabled:[{type:f_}],cpIgnoredElements:[{type:f_}],cpFallbackColor:[{type:f_}],cpColorMode:[{type:f_}],cpCmykEnabled:[{type:f_}],cpOutputFormat:[{type:f_}],cpAlphaChannel:[{type:f_}],cpDisableInput:[{type:f_}],cpDialogDisplay:[{type:f_}],cpSaveClickOutside:[{type:f_}],cpCloseClickOutside:[{type:f_}],cpUseRootViewContainer:[{type:f_}],cpPosition:[{type:f_}],cpPositionOffset:[{type:f_}],cpPositionRelativeToArrow:[{type:f_}],cpOKButton:[{type:f_}],cpOKButtonText:[{type:f_}],cpOKButtonClass:[{type:f_}],cpCancelButton:[{type:f_}],cpCancelButtonText:[{type:f_}],cpCancelButtonClass:[{type:f_}],cpPresetLabel:[{type:f_}],cpPresetColors:[{type:f_}],cpPresetColorsClass:[{type:f_}],cpMaxPresetColorsLength:[{type:f_}],cpPresetEmptyMessage:[{type:f_}],cpPresetEmptyMessageClass:[{type:f_}],cpAddColorButton:[{type:f_}],cpAddColorButtonText:[{type:f_}],cpAddColorButtonClass:[{type:f_}],cpRemoveColorButtonClass:[{type:f_}],cpInputChange:[{type:h_}],cpToggleChange:[{type:h_}],cpSliderChange:[{type:h_}],cpSliderDragEnd:[{type:h_}],cpSliderDragStart:[{type:h_}],colorPickerOpen:[{type:h_}],colorPickerClose:[{type:h_}],colorPickerCancel:[{type:h_}],colorPickerSelect:[{type:h_}],colorPickerChange:[{type:h_}],cpCmykColorChange:[{type:h_}],cpPresetColorsChange:[{type:h_}],handleClick:[{type:__,args:["click"]}],handleFocus:[{type:__,args:["focus"]}],handleInput:[{type:__,args:["input",["$event"]]}]};class jJ{}jJ.ɵmod=xo({type:jJ}),jJ.ɵinj=Ge({factory:function t(n){return new(n||jJ)},providers:[HJ],imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(jJ,{declarations:function(){return[BJ,VJ,IJ,NJ]},imports:function(){return[PO]},exports:function(){return[VJ]}});const UJ=["container"];var WJ,GJ,YJ,qJ,ZJ;!(function(t){t[t.NONE=0]="NONE",t[t.LEFT=1]="LEFT",t[t.RIGHT=2]="RIGHT"})(WJ||(WJ={}));class XJ{constructor(t){this.changeDetector=t,this.tickCount=20,this.value=new Ef,this.Position=WJ,this.activeThumb=WJ.NONE,this.offsetXFromOriginOfActiveThumb=0,this.ngUnsubscribe=new x}getThumbPosition(t){const n=this.getClippedValue(t),e=this.max-this.min;return e<=0?"50%":(n-this.min)/e*100+"%"}getTrackWidth(){const t=this.max-this.min;return t<=0?"0%":(this.getClippedValue(this.upperValue)-this.getClippedValue(this.lowerValue))/t*100+"%"}getClippedValue(t){return Math.min(Math.max(t,this.min),this.max)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}ngOnInit(){Vt(document,"mousemove",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{this.handleMouseMove(t)})),Vt(document,"mouseup",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{this.handleMouseOut(t)}))}handleMouseDown(t,n){this.activeThumb=n,this.offsetXFromOriginOfActiveThumb=6-t.offsetX}calculateValueFromMouseEvent(t){const{left:n,right:e}=this.container.nativeElement.getBoundingClientRect(),a=t.clientX-n+this.offsetXFromOriginOfActiveThumb;let o;if(null!==this.tickCount&&this.tickCount>0){const t=(e-n)/this.tickCount;o=Math.round(a/t)*t/(e-n)}else o=a/(e-n);return this.getClippedValue(this.min+(this.max-this.min)*o)}handleMouseMove(t){if(this.activeThumb===WJ.NONE)return;const n=this.calculateValueFromMouseEvent(t);let e=[this.lowerValue,this.upperValue];this.activeThumb===WJ.LEFT?(n>this.upperValue&&(this.activeThumb=WJ.RIGHT),e=[n,this.upperValue]):(n<this.lowerValue&&(this.activeThumb=WJ.LEFT),e=[this.lowerValue,n]),this.maybeNotifyNextValue(e),this.changeDetector.markForCheck()}maybeNotifyNextValue(t){const[n,e]=t.sort(((t,n)=>t-n));this.lowerValue===n&&this.upperValue===e||this.value.emit({lowerValue:n,upperValue:e})}handleMouseOut(t){this.activeThumb!==WJ.NONE&&(this.activeThumb=WJ.NONE,this.changeDetector.markForCheck())}handleInputChange(t,n){const e=this.getClippedValue(Number(t.target.value));if(isNaN(e))return;let a=[this.lowerValue,this.upperValue];a=n===WJ.LEFT?[e,this.upperValue]:[this.lowerValue,e],this.maybeNotifyNextValue(a)}isThumbActive(t){return this.activeThumb===t}}XJ.ɵfac=function t(n){return new(n||XJ)(Zg(Vm))},XJ.ɵcmp=_o({type:XJ,selectors:[["tb-range-input"]],viewQuery:function t(n,e){var a;1&n&&jf(UJ,!0,xu),2&n&&Vf(a=Zf())&&(e.container=a.first)},inputs:{min:"min",max:"max",lowerValue:"lowerValue",upperValue:"upperValue",tickCount:"tickCount"},outputs:{value:"value"},decls:8,vars:14,consts:[["type","number",1,"lower-input",3,"value","change"],["type","number",1,"upper-input",3,"value","change"],[1,"container"],["container",""],[1,"slider-track"],[1,"slider-track-fill"],[1,"thumb",3,"mousedown"]],template:function t(n,e){1&n&&(Kg(0,"input",0),cp("change",(function t(n){return e.handleInputChange(n,e.Position.LEFT)})),$g(),Kg(1,"input",1),cp("change",(function t(n){return e.handleInputChange(n,e.Position.RIGHT)})),$g(),Kg(2,"span",2,3),tp(4,"span",4),tp(5,"span",5),Kg(6,"span",6),cp("mousedown",(function t(n){return e.handleMouseDown(n,e.Position.LEFT)})),$g(),Kg(7,"span",6),cp("mousedown",(function t(n){return e.handleMouseDown(n,e.Position.RIGHT)})),$g(),$g()),2&n&&(Jg("value",e.lowerValue),ws(1),Jg("value",e.upperValue),ws(4),Tp("left",e.getThumbPosition(e.lowerValue))("width",e.getTrackWidth()),ws(1),Tp("left",e.getThumbPosition(e.lowerValue)),Dp("active",e.isThumbActive(e.Position.LEFT)),ws(1),Tp("left",e.getThumbPosition(e.upperValue)),Dp("active",e.isThumbActive(e.Position.RIGHT)))},styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{box-sizing:border-box;display:inline-grid;grid-gap:10px;grid-template-areas:"lower-input upper-input" "slider slider";font-size:0;lower-width:100px;padding:6px}input[_ngcontent-%COMP%]{box-sizing:border-box;overflow:hidden;width:100%}.lower-input[_ngcontent-%COMP%]{grid-area:lower-input}.upper-input[_ngcontent-%COMP%]{grid-area:upper-input;justify-self:flex-end}.container[_ngcontent-%COMP%]{grid-area:slider;align-items:center;box-sizing:border-box;display:inline-flex;height:12px;justify-content:center;position:relative;width:100%}.slider-track[_ngcontent-%COMP%]{background:rgba(0,0,0,.26);height:2px;width:100%}.slider-track-fill[_ngcontent-%COMP%]{background:#f57c00;position:absolute;height:2px}.thumb[_ngcontent-%COMP%]{background:#f57c00;border-radius:100%;display:inline-block;height:12px;margin-left:-6px;position:absolute;top:0;transform-origin:center;transition:transform .3s ease;box-shadow:0 0 0 1px rgba(0,0,0,.26);width:12px;will-change:transform}.thumb.active[_ngcontent-%COMP%]{transform:scale(1.2)}'],changeDetection:0});class JJ{}JJ.ɵmod=xo({type:JJ}),JJ.ɵinj=Ge({factory:function t(n){return new(n||JJ)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(JJ,{declarations:[XJ],imports:[PO],exports:[XJ]}),(function(t){t.ASC="asc",t.DESC="desc",t.UNSET=""})(GJ||(GJ={})),(function(t){t.USER="user",t.BEFORE="before",t.AFTER="after",t.REGEX="regex"})(YJ||(YJ={})),(function(t){t[t.EXPERIMENT_NAME=0]="EXPERIMENT_NAME",t[t.HPARAM=1]="HPARAM",t[t.METRIC=2]="METRIC",t[t.RUN_NAME=3]="RUN_NAME"})(qJ||(qJ={})),(function(t){t.CHECKBOX="checkbox",t.RUN_NAME="run_name",t.EXPERIMENT_NAME="experiment_name",t.RUN_COLOR="run_color"})(ZJ||(ZJ={}));const QJ=["filter"];function KJ(t,n){1&t&&ap(0)}function $J(t,n){1&t&&ap(0)}function tQ(t,n){1&t&&ap(0)}const nQ=function(t){return{item:t}};function eQ(t,n){if(1&t&&(np(0),Yg(1,tQ,1,0,"ng-container",16),ep()),2&t){const t=n.$implicit;gp();const e=qg(20);ws(1),Jg("ngTemplateOutlet",e)("ngTemplateOutletContext",uf(2,nQ,t))}}function aQ(t,n){1&t&&(Kg(0,"div",17),tp(1,"mat-spinner",18),$g())}function oQ(t,n){1&t&&(Kg(0,"div",19),Jp(1,"No Runs"),$g())}function rQ(t,n){if(1&t&&(Kg(0,"div",19),Kg(1,"span"),Jp(2,'No runs match "'),Kg(3,"code"),Jp(4),$g(),Jp(5,'"'),$g(),$g()),2&t){const t=gp();ws(4),Qp(t.regexFilter)}}const iQ=function(){return[5,10,20]};function cQ(t,n){if(1&t){const t=op();Kg(0,"mat-paginator",20),cp("page",(function n(e){return jr(t),gp().onPaginationChange.emit(e)})),$g()}if(2&t){const t=gp();Jg("pageSizeOptions",bf(4,iQ))("pageIndex",t.paginationOption.pageIndex)("pageSize",t.paginationOption.pageSize)("length",t.filteredItemsLength)}}function sQ(t,n){if(1&t){const t=op();Kg(0,"div",22),Kg(1,"span",23),Jp(2),$g(),Kg(3,"button",24),cp("click",(function n(){return jr(t),gp(2).onSelectAllPages.emit()})),Jp(4," Select all runs "),$g(),$g()}if(2&t){const t=gp(2);ws(2),$p("All runs in this page are selected but not all runs (",t.numSelectedItems," of ",t.allItemsLength,") are selected.")}}function lQ(t,n){if(1&t&&Yg(0,sQ,5,2,"div",21),2&t){const t=gp();Jg("ngIf",t.allPageItemsSelected()&&t.numSelectedItems!==t.allItemsLength)}}function mQ(t,n){if(1&t){const t=op();Kg(0,"mat-checkbox",34),cp("change",(function n(){return jr(t),gp(3).handlePageToggle()})),$g()}if(2&t){const t=gp(3);Jg("checked",t.allPageItemsSelected())("indeterminate",!t.allPageItemsSelected()&&t.somePageItemsSelected())}}const dQ=function(t){return{type:t}};function gQ(t,n){if(1&t&&(Kg(0,"span",35),Jp(1,"Experiment"),$g()),2&t){const t=gp(3);Jg("mat-sort-header",uf(1,dQ,t.SortType.EXPERIMENT_NAME))}}function pQ(t,n){if(1&t&&(Kg(0,"span",35),Jp(1,"Run"),$g()),2&t){const t=gp(3);Jg("mat-sort-header",uf(1,dQ,t.SortType.RUN_NAME))}}function bQ(t,n){1&t&&tp(0,"span")}const uQ=function(t){return["column",t]};function fQ(t,n){if(1&t&&(Kg(0,"span",29),np(1,30),Yg(2,mQ,1,2,"mat-checkbox",31),Yg(3,gQ,2,3,"span",32),Yg(4,pQ,2,3,"span",32),Yg(5,bQ,1,0,"span",33),ep(),$g()),2&t){const t=n.$implicit,e=gp(2);Jg("ngClass",uf(6,uQ,"tb-column-"+t)),ws(1),Jg("ngSwitch",t),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.CHECKBOX),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.EXPERIMENT_NAME),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.RUN_NAME),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.RUN_COLOR)}}function hQ(t,n){if(1&t){const t=op();np(0),Kg(1,"div",44),cp("click",(function n(e){return jr(t),e.stopPropagation()})),Kg(2,"tb-range-input",45),cp("value",(function n(e){jr(t);const a=gp(2).$implicit;return gp(2).handleHparamIntervalChanged(a,e)})),$g(),$g(),ep()}if(2&t){const t=gp(2).$implicit;ws(2),Jg("min",t.filter.minValue)("max",t.filter.maxValue)("lowerValue",t.filter.filterLowerValue)("upperValue",t.filter.filterUpperValue)}}function _Q(t,n){if(1&t){const t=op();Kg(0,"div",47),cp("click",(function n(e){return jr(t),e.stopPropagation()})),Kg(1,"mat-checkbox",43),cp("change",(function e(){jr(t);const a=n.$implicit,o=gp(3).$implicit;return gp(2).handleHparamDiscreteChanged(o,a)})),Kg(2,"span"),Jp(3),$g(),$g(),$g()}if(2&t){const t=n.$implicit,e=gp(3).$implicit;ws(1),Jg("checked",e.filter.filterValues.includes(t)),ws(2),Qp(t)}}function CQ(t,n){if(1&t&&(np(0),Yg(1,_Q,4,2,"div",46),ep()),2&t){const t=gp(2).$implicit;ws(1),Jg("ngForOf",t.filter.possibleValues)}}function MQ(t,n){if(1&t){const t=op();np(0),Kg(1,"button",39),tp(2,"mat-icon",40),$g(),Kg(3,"mat-menu",null,41),Kg(5,"div",42),cp("click",(function n(e){return jr(t),e.stopPropagation()})),Kg(6,"mat-checkbox",43),cp("change",(function n(){jr(t);const e=gp().$implicit;return gp(2).handleHparamIncludeUndefinedToggled(e)})),Kg(7,"span"),Jp(8,"(show empty value)"),$g(),$g(),$g(),Yg(9,hQ,3,4,"ng-container",38),Yg(10,CQ,2,1,"ng-container",38),$g(),ep()}if(2&t){const t=qg(4),n=gp().$implicit,e=gp(2);ws(1),Jg("matMenuTriggerFor",t),Ng("aria-label","Filter hparam "+(n.displayName||n.name)),ws(5),Jg("checked",n.filter.includeUndefined),ws(3),Jg("ngIf",n.filter.type===e.DomainType.INTERVAL),ws(1),Jg("ngIf",n.filter.type===e.DomainType.DISCRETE)}}const OQ=function(t,n){return{type:t,name:n}};function PQ(t,n){if(1&t&&(Kg(0,"span",36),Kg(1,"span",37),Jp(2),$g(),Yg(3,MQ,11,5,"ng-container",38),$g()),2&t){const t=n.$implicit,e=gp(2);Jg("mat-sort-header",ff(3,OQ,e.SortType.HPARAM,t.name)),ws(2),Qp(t.displayName||t.name),ws(1),Jg("ngIf",t.filter)}}function xQ(t,n){if(1&t){const t=op();np(0),Kg(1,"button",39),tp(2,"mat-icon",40),$g(),Kg(3,"mat-menu",null,41),Kg(5,"div",42),cp("click",(function n(e){return jr(t),e.stopPropagation()})),Kg(6,"mat-checkbox",43),cp("change",(function n(){jr(t);const e=gp().$implicit;return gp(2).handleMetricIncludeUndefinedChanged(e)})),Kg(7,"span"),Jp(8,"(show empty value)"),$g(),$g(),$g(),Kg(9,"div",44),cp("click",(function n(e){return jr(t),e.stopPropagation()})),Kg(10,"tb-range-input",45),cp("value",(function n(e){jr(t);const a=gp().$implicit;return gp(2).handleMetricFilterChanged(a,e)})),$g(),$g(),$g(),ep()}if(2&t){const t=qg(4),n=gp().$implicit;ws(1),Jg("matMenuTriggerFor",t),Ng("aria-label","Filter metric "+(n.displayName||n.tag)),ws(5),Jg("checked",n.filter.includeUndefined),ws(4),Jg("min",n.filter.minValue)("max",n.filter.maxValue)("lowerValue",n.filter.filterLowerValue)("upperValue",n.filter.filterUpperValue)}}const yQ=function(t,n){return{type:t,tag:n}};function kQ(t,n){if(1&t&&(Kg(0,"span",36),Kg(1,"span",37),Jp(2),$g(),Yg(3,xQ,11,7,"ng-container",38),$g()),2&t){const t=n.$implicit,e=gp(2);Jg("mat-sort-header",ff(3,yQ,e.SortType.METRIC,t.tag)),ws(2),Qp(t.displayName||t.tag),ws(1),Jg("ngIf",t.filter)}}function vQ(t,n){if(1&t){const t=op();Kg(0,"div",25),Kg(1,"div",26),cp("matSortChange",(function n(e){return jr(t),gp().handleSortChange(e)})),Yg(2,fQ,6,8,"span",27),Yg(3,PQ,4,6,"span",28),Yg(4,kQ,4,6,"span",28),$g(),$g()}if(2&t){const t=gp();ws(1),Jg("matSortActive",t.sortOption.column),ws(1),Jg("ngForOf",t.columns),ws(1),Jg("ngForOf",t.hparamColumns)("ngForTrackBy",t.trackByHparamColumn),ws(1),Jg("ngForOf",t.metricColumns)("ngForTrackBy",t.trackByMetricColumn)}}function wQ(t,n){if(1&t){const t=op();Kg(0,"span"),Kg(1,"mat-checkbox",43),cp("change",(function n(){jr(t);const e=gp(2).item;return gp().onSelectionToggle.emit(e)})),$g(),$g()}if(2&t){const t=gp(2).item;ws(1),Jg("checked",t.selected)}}function SQ(t,n){if(1&t&&(Kg(0,"span",37),Jp(1),$g()),2&t){const t=gp(2).item;Ng("title",t.experimentName),ws(1),Qp(t.experimentAlias)}}function EQ(t,n){if(1&t&&(Kg(0,"span",37),Jp(1),$g()),2&t){const t=gp(2).item;ws(1),Qp(t.run.name)}}const AQ=function(t){return{"run-color-swatch":!0,"no-color":t}};function zQ(t,n){if(1&t){const t=op();Kg(0,"span"),Kg(1,"button",53),cp("colorPickerChange",(function n(e){jr(t);const a=gp(2).item;return gp().onRunColorChange.emit({runId:a.run.id,newColor:e})})),$g(),$g()}if(2&t){const t=gp(2).item;ws(1),Tp("background",t.runColor),Jg("ngClass",uf(9,AQ,!t.runColor))("colorPicker",t.runColor)("cpDialogDisplay","popup")("cpPosition","bottom-right")("cpPositionOffset",-20)("cpUseRootViewContainer",!0)("cpOutputFormat","hex")}}function RQ(t,n){if(1&t&&(Kg(0,"span",51),np(1,30),Yg(2,wQ,2,1,"span",33),Yg(3,SQ,2,2,"span",52),Yg(4,EQ,2,1,"span",52),Yg(5,zQ,2,11,"span",33),ep(),$g()),2&t){const t=n.$implicit,e=gp(2);Jg("ngClass",uf(6,uQ,"tb-column-"+t)),ws(1),Jg("ngSwitch",t),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.CHECKBOX),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.EXPERIMENT_NAME),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.RUN_NAME),ws(1),Jg("ngSwitchCase",e.RunsTableColumn.RUN_COLOR)}}function TQ(t,n){if(1&t&&(Kg(0,"span",54),Jp(1),$g()),2&t){const t=n.$implicit,e=gp().item;ws(1),Qp(e.hparams.get(t.name))}}function DQ(t,n){if(1&t&&(Kg(0,"span",54),Jp(1),$g()),2&t){const t=n.$implicit,e=gp().item;ws(1),Qp(e.metrics.get(t.tag))}}function IQ(t,n){if(1&t&&(Kg(0,"div",48),Yg(1,RQ,6,8,"span",49),Yg(2,TQ,2,1,"span",50),Yg(3,DQ,2,1,"span",50),$g()),2&t){const t=n.item,e=gp();Ng("data-id",t.run.id),ws(1),Jg("ngForOf",e.columns),ws(1),Jg("ngForOf",e.hparamColumns),ws(1),Jg("ngForOf",e.metricColumns)}}class NQ extends nZ{constructor(){super(...arguments),this.itemsPerPageLabel="Show runs:"}}NQ.ɵfac=function t(n){return FQ(n||NQ)},NQ.ɵprov=We({token:NQ,factory:NQ.ɵfac});const FQ=tc(NQ);class LQ{constructor(){this.dataSource=new $X,this.DomainType=wD,this.RunsTableColumn=ZJ,this.SortType=qJ,this.onRegexFilterChange=new Ef,this.onSelectionToggle=new Ef,this.onPageSelectionToggle=new Ef,this.onSelectAllPages=new Ef,this.onPaginationChange=new Ef,this.onSortChange=new Ef,this.onRunColorChange=new Ef,this.onHparamDiscreteFilterChanged=new Ef,this.onHparamIntervalFilterChanged=new Ef,this.onMetricFilterChanged=new Ef}ngOnChanges(){this.dataSource.data=this.pageItems}getHparamColumnId(t){return`h:${t.name}`}getMetricColumnId(t){return`m:${t.tag}`}getColumnIds(){return[...this.columns,...this.hparamColumns.map(this.getHparamColumnId),...this.metricColumns.map(this.getMetricColumnId)]}allPageItemsSelected(){return Boolean(this.pageItems.length)&&this.pageItems.every((t=>t.selected))}somePageItemsSelected(){return this.pageItems.some((t=>t.selected))}handlePageToggle(){this.onPageSelectionToggle.emit({items:this.pageItems})}handleSortChange(t){let n;switch(t.direction){case"asc":n=GJ.ASC;break;case"desc":n=GJ.DESC;break;default:n=GJ.UNSET}this.onSortChange.emit({key:t.active,direction:n})}onFilterKeyUp(t){this.onRegexFilterChange.emit(t.target.value)}tableTrackBy(t,n){return n.run.id}handleHparamIncludeUndefinedToggled(t){const{name:n,filter:e}=t;if(!e)throw new RangeError("Invariant error: require filter to exist for it to change");e.type===wD.DISCRETE?this.onHparamDiscreteFilterChanged.emit({hparamName:n,includeUndefined:!e.includeUndefined,filterValues:e.filterValues}):this.onHparamIntervalFilterChanged.emit({name:n,includeUndefined:!e.includeUndefined,filterLowerValue:e.filterLowerValue,filterUpperValue:e.filterUpperValue})}handleHparamIntervalChanged(t,n){const{name:e,filter:a}=t;if(!a)throw new RangeError("Invariant error: require filter to exist for it to change");this.onHparamIntervalFilterChanged.emit({name:e,includeUndefined:a.includeUndefined,filterLowerValue:n.lowerValue,filterUpperValue:n.upperValue})}handleHparamDiscreteChanged(t,n){const{name:e,filter:a}=t;if(!a)throw new RangeError("Invariant error: require filter to exist for it to change");if(a.type!==wD.DISCRETE)throw new RangeError(`Invariant error: expected discrete domain for ${e}`);const o=new Set([...a.filterValues]);o.has(n)?o.delete(n):o.add(n),this.onHparamDiscreteFilterChanged.emit({hparamName:e,includeUndefined:a.includeUndefined,filterValues:[...o]})}handleMetricIncludeUndefinedChanged(t){if(!t.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:t.tag,includeUndefined:!t.filter.includeUndefined,filterLowerValue:t.filter.filterLowerValue,filterUpperValue:t.filter.filterUpperValue})}handleMetricFilterChanged(t,n){if(!t.filter)throw new RangeError("Invariant error: require filter to exist for it to change");this.onMetricFilterChanged.emit({name:t.tag,includeUndefined:t.filter.includeUndefined,filterLowerValue:n.lowerValue,filterUpperValue:n.upperValue})}trackByHparamColumn(t){return t.name}trackByMetricColumn(t){return t.tag}}LQ.ɵfac=function t(n){return new(n||LQ)},LQ.ɵcmp=_o({type:LQ,selectors:[["runs-table-component"]],viewQuery:function t(n,e){var a;1&n&&(jf(QJ,!0,xu),jf(iZ,!0),jf(OZ,!0)),2&n&&(Vf(a=Zf())&&(e.filter=a.first),Vf(a=Zf())&&(e.paginator=a.first),Vf(a=Zf())&&(e.sort=a.first))},hostVars:2,hostBindings:function t(n,e){2&n&&Dp("flex-layout",e.useFlexibleLayout)},inputs:{showExperimentName:"showExperimentName",columns:"columns",hparamColumns:"hparamColumns",metricColumns:"metricColumns",allItemsLength:"allItemsLength",filteredItemsLength:"filteredItemsLength",useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",pageItems:"pageItems",loading:"loading",numSelectedItems:"numSelectedItems",sortOption:"sortOption",paginationOption:"paginationOption",regexFilter:"regexFilter"},outputs:{onRegexFilterChange:"onRegexFilterChange",onSelectionToggle:"onSelectionToggle",onPageSelectionToggle:"onPageSelectionToggle",onSelectAllPages:"onSelectAllPages",onPaginationChange:"onPaginationChange",onSortChange:"onSortChange",onRunColorChange:"onRunColorChange",onHparamDiscreteFilterChanged:"onHparamDiscreteFilterChanged",onHparamIntervalFilterChanged:"onHparamIntervalFilterChanged",onMetricFilterChanged:"onMetricFilterChanged"},features:[Mu([{provide:nZ,useClass:NQ}]),pr],decls:21,vars:8,consts:[[1,"filter-row"],[1,"run-filter"],["svgIcon","search_24px"],["matInput","","autocomplete","off","placeholder","Filter runs (regex)",3,"keyup"],["filter",""],[1,"table-container"],["role","table"],[4,"ngTemplateOutlet"],["role","rowgroup",1,"rows"],[4,"ngFor","ngForOf","ngForTrackBy"],["class","loading",4,"ngIf"],["class","no-runs",4,"ngIf"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page",4,"ngIf"],["selectAll",""],["header",""],["row",""],[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"loading"],["mode","indeterminate","diameter","28"],[1,"no-runs"],["showFirstLastButtons","",3,"pageSizeOptions","pageIndex","pageSize","length","page"],["class","select-all","role","row",4,"ngIf"],["role","row",1,"select-all"],["role","columnheader"],["mat-button","",3,"click"],["role","rowgroup",1,"header"],["matSort","","role","row",3,"matSortActive","matSortChange"],["role","columnheader",3,"ngClass",4,"ngFor","ngForOf"],["role","columnheader","class","column",3,"mat-sort-header",4,"ngFor","ngForOf","ngForTrackBy"],["role","columnheader",3,"ngClass"],[3,"ngSwitch"],[3,"checked","indeterminate","change",4,"ngSwitchCase"],[3,"mat-sort-header",4,"ngSwitchCase"],[4,"ngSwitchCase"],[3,"checked","indeterminate","change"],[3,"mat-sort-header"],["role","columnheader",1,"column",3,"mat-sort-header"],[1,"name"],[4,"ngIf"],["mat-icon-button","",3,"matMenuTriggerFor"],["svgIcon","filter_alt_24px"],["filterMenu","matMenu"],["mat-menu-item","","role","menuitemcheckbox","disableRipple","",1,"filter-menu-checkbox-row",3,"click"],[3,"checked","change"],["disableRipple","","mat-menu-item","",1,"range-input-container",3,"click"],[3,"min","max","lowerValue","upperValue","value"],["mat-menu-item","","class","filter-menu-checkbox-row","role","menuitemcheckbox",3,"click",4,"ngFor","ngForOf"],["mat-menu-item","","role","menuitemcheckbox",1,"filter-menu-checkbox-row",3,"click"],["role","row"],["role","cell",3,"ngClass",4,"ngFor","ngForOf"],["role","cell","class","column",4,"ngFor","ngForOf"],["role","cell",3,"ngClass"],["class","name",4,"ngSwitchCase"],[3,"ngClass","colorPicker","cpDialogDisplay","cpPosition","cpPositionOffset","cpUseRootViewContainer","cpOutputFormat","colorPickerChange"],["role","cell",1,"column"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Kg(1,"div",1),tp(2,"mat-icon",2),Kg(3,"input",3,4),cp("keyup",(function t(n){return e.onFilterKeyUp(n)})),$g(),$g(),$g(),Kg(5,"div",5),Kg(6,"div",6),Yg(7,KJ,1,0,"ng-container",7),Yg(8,$J,1,0,"ng-container",7),Kg(9,"div",8),Yg(10,eQ,2,4,"ng-container",9),$g(),$g(),Yg(11,aQ,2,0,"div",10),Yg(12,oQ,2,0,"div",11),Yg(13,rQ,6,1,"div",11),$g(),Yg(14,cQ,1,5,"mat-paginator",12),Yg(15,lQ,1,1,"ng-template",null,13,Kf),Yg(17,vQ,5,6,"ng-template",null,14,Kf),Yg(19,IQ,4,4,"ng-template",null,15,Kf)),2&n){const t=qg(16),n=qg(18);ws(7),Jg("ngTemplateOutlet",n),ws(1),Jg("ngTemplateOutlet",t),ws(2),Jg("ngForOf",e.pageItems)("ngForTrackBy",e.tableTrackBy),ws(1),Jg("ngIf",e.loading),ws(1),Jg("ngIf",!e.loading&&0===e.allItemsLength),ws(1),Jg("ngIf",!e.loading&&e.allItemsLength>0&&0===e.filteredItemsLength),ws(1),Jg("ngIf",e.usePagination)}},directives:[BB,PV,tO,jM,WM,hZ,iZ,eA,OZ,HM,ZM,XM,rV,EZ,Iq,Aq,xq,XJ,VJ],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{background-color:#fff;display:block;font-size:13px;overflow:hidden}.table-container[_ngcontent-%COMP%]{contain:layout paint;height:100%;max-width:100%;overflow-x:auto;overflow-y:auto;will-change:scroll-position}.flex-layout[_nghost-%COMP%]   .name[_ngcontent-%COMP%]{word-break:break-word;overflow-wrap:break-word}.flex-layout[_nghost-%COMP%]   mat-paginator[_ngcontent-%COMP%]{border-top:1px solid #ebebeb;padding-bottom:12px}[role=table][_ngcontent-%COMP%]{display:table;width:100%}[role=table][_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{color:#212121;white-space:nowrap}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]{contain:strict;display:table-row;height:43px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]{border-bottom:1px solid #0000001f;display:table-cell;padding:5px;vertical-align:middle}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:first-child{padding-left:24px}[role=table][_ngcontent-%COMP%]   [role=row][_ngcontent-%COMP%]   .column[_ngcontent-%COMP%]:last-child{padding-right:24px}[role=rowgroup][_ngcontent-%COMP%]{display:table-row-group}[role=rowgroup].header[_ngcontent-%COMP%]{display:table-header-group}.loading[_ngcontent-%COMP%], .no-runs[_ngcontent-%COMP%]{align-items:center;border:0;border-bottom-width:1px;border-color:#0000001f;border-style:solid;display:flex;height:48px;padding:0 24px}.loading[_ngcontent-%COMP%]{justify-content:center}.select-all[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{padding-bottom:12px;padding-top:12px}.select-all-content[_ngcontent-%COMP%], .select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:400;line-height:1.6;text-align:left}.select-all-content[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-weight:500;padding:0 4px}.filter-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:48px;padding:0 16px;border-bottom:1px solid #ebebeb}.run-filter[_ngcontent-%COMP%]{display:flex;color:#212121;flex:1}.run-filter[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-left:5px;margin-right:5px}.tb-column-checkbox[_ngcontent-%COMP%], .tb-column-run_color[_ngcontent-%COMP%]{width:20px}.run-color-swatch[_ngcontent-%COMP%]{border-radius:100%;border:1px solid #ebebeb;height:20px;width:20px;outline:none}.run-color-swatch.no-color[_ngcontent-%COMP%]{border-color:#c6cad1;border-width:2px}.range-input-container[_ngcontent-%COMP%]{height:auto}[_nghost-%COMP%]     mat-paginator mat-form-field{margin:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label{display:flex;height:100%;align-items:center}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-inner-container{margin-left:0}.filter-menu-checkbox-row[_ngcontent-%COMP%]   mat-checkbox[_ngcontent-%COMP%]     label .mat-checkbox-label{overflow:hidden;text-overflow:ellipsis}'],changeDetection:0});const HQ=Ok("[Runs] Fetch Runs Requested",{_as:"props",_p:void 0}),BQ=Ok("[Runs] Fetch Runs Succeeded",{_as:"props",_p:void 0}),VQ=Ok("[Runs] Fetch Runs Failed",{_as:"props",_p:void 0}),jQ=Ok("[Runs] Run Selection Toggled",{_as:"props",_p:void 0}),UQ=Ok("[Runs] Run Page Selection Toggled",{_as:"props",_p:void 0}),WQ=Ok("[Runs] Runs Select All",{_as:"props",_p:void 0}),GQ=Ok("[Runs] Run Selector Pagination Option Changed",{_as:"props",_p:void 0}),YQ=Ok("[Runs] Run Selector Sort Changed",{_as:"props",_p:void 0}),qQ=Ok("[Runs] Run Selector Regex Filter Changed",{_as:"props",_p:void 0}),ZQ=Ok("[Runs] Run Color Changed",{_as:"props",_p:void 0}),XQ=Ok("[Runs] Run Table Shown",{_as:"props",_p:void 0}),JQ=Ok("[Runs] Run Discrete Hparam Filter Changed",{_as:"props",_p:void 0}),QQ=Ok("[Runs] Run Interval Hparam Filter Changed",{_as:"props",_p:void 0}),KQ=Ok("[Runs] Run Metric Filter Changed",{_as:"props",_p:void 0}),$Q=pv(FD,(t=>t.state===fR.LOADING));function tK(t,n){switch(n.type){case qJ.EXPERIMENT_NAME:return[t.experimentAlias,t.run.name,t.run.id];case qJ.RUN_NAME:return[t.run.name,t.experimentAlias,t.run.id];case qJ.HPARAM:return[t.hparams.get(n.name),t.run.name,t.experimentAlias,t.run.id];case qJ.METRIC:return[t.metrics.get(n.tag),t.run.name,t.experimentAlias,t.run.id];default:throw new Error(`Not yet implemented: ${n}`)}}function nK(t,n){return void 0===n?t.includeUndefined:t.type===wD.DISCRETE?t.filterValues.includes(n):t.type===wD.INTERVAL&&t.filterLowerValue<=n&&n<=t.filterUpperValue}class eK{constructor(t){this.store=t,this.loading$=null,this.hparamColumns$=Z([]),this.metricColumns$=Z([]),this.useFlexibleLayout=!1,this.usePagination=!1,this.columns=[ZJ.RUN_NAME],this.showHparamsAndMetrics=!1,this.sortOption$=this.store.select(WD),this.paginationOption$=this.store.select(jD),this.regexFilter$=this.store.select(UD)}isExperimentNameVisible(){return this.columns.some((t=>t===ZJ.EXPERIMENT_NAME))}ngOnInit(){const t=this.experimentIds.map((t=>this.getRunTableItemsForExperiment(t)));this.allUnsortedRunTableItems$=Et(t).pipe(ft((t=>[].concat(...t))),ae(1)),this.allItemsLength$=this.allUnsortedRunTableItems$.pipe(ft((t=>t.length)));const n=this.getFilteredItems$(this.allUnsortedRunTableItems$).pipe(ae(1));this.filteredItemsLength$=n.pipe(ft((t=>t.length))),this.pageItems$=this.sortedAndSlicedItems$(n),this.numSelectedItems$=this.allUnsortedRunTableItems$.pipe(ft((t=>t.reduce(((t,n)=>t+Number(n.selected)),0))));const e=this.experimentIds.map((t=>this.store.select($Q,{experimentId:t})));if(this.loading$=Et(e).pipe(ft((t=>t.some((t=>t))))),this.showHparamsAndMetrics){const t=this.store.select(HD,{experimentIds:this.experimentIds});this.hparamColumns$=Et([this.store.select(JD),t]).pipe(ft((([t,{hparams:n}])=>n.map((({name:n,displayName:e})=>{const a=t.get(n);if(!a)throw new RangeError(`Invariant error: a filter for ${n} must exist when the hparam exists`);return{displayName:e,name:n,filter:a}}))))),this.metricColumns$=Et([this.store.select(QD),t]).pipe(ft((([t,{metrics:n}])=>n.map((({tag:n,displayName:e})=>{const a=t.get(n);if(!a)throw new RangeError(`Invariant error: a filter for ${n} must exist when the metric exists`);return{displayName:e,tag:n,filter:a}})))))}this.store.dispatch(XQ({experimentIds:this.experimentIds}))}getFilteredItems$(t){return Et([t,this.store.select(UD)]).pipe(ft((([t,n])=>{if(!n)return t;let e=null;try{e=n?new RegExp(n):null}catch(t){}if(!e)return[];const a=this.columns.includes(ZJ.EXPERIMENT_NAME);return t.filter((t=>a?e.test(t.run.name)||e.test(t.experimentAlias):e.test(t.run.name)))})),sn(this.store.select(JD),this.store.select(QD)),ft((([t,n,e])=>this.showHparamsAndMetrics?t.filter((({hparams:t,metrics:a})=>[...n.entries()].every((([n,e])=>nK(e,t.get(n))))&&[...e.entries()].every((([t,n])=>nK(n,a.get(t)))))):t)))}sortedAndSlicedItems$(t){const n=Et([t,this.store.select(WD)]).pipe(ft((([t,n])=>(function e(t,n){const e=n.key,a=[...t];return null===e||n.direction===GJ.UNSET||a.sort(((t,a)=>{const o=tK(t,e),r=tK(a,e);if(o.length!==r.length)throw new Error(`Invariant error: a given sort should result in same number of items: ${n}`);for(let t=0;t<o.length;t++){const e=o[t],a=r[t];if(e!==a){if(void 0===e||void 0===a)return void 0===a?-1:1;if(typeof e!=typeof a)throw new Error(`Cannot compare values of different types: ${typeof e} vs. ${typeof a}`);return e<a==(n.direction===GJ.ASC)?-1:1}}return 0})),a})(t,n))));return Et([n,this.store.select(jD)]).pipe(ft((([t,n])=>{if(!this.usePagination)return t.slice();const{pageSize:e,pageIndex:a}=n;return t.slice(a*e,(a+1)*e)})),ce([]))}getRunTableItemsForExperiment(t){return Et([this.store.select(ID,{experimentId:t}),this.store.select(cR,{experimentId:t}),this.store.select(KD),this.store.select(GD),this.store.select(oR)]).pipe(ft((([n,e,a,o,r])=>n.map((n=>{const i=new Map;(n.hparams||[]).forEach((t=>{i.set(t.name,t.value)}));const c=new Map;return(n.metrics||[]).forEach((t=>{c.set(t.tag,t.value)})),{run:n,experimentName:(null==e?void 0:e.name)||"",experimentAlias:r[t],selected:Boolean(a&&a.get(n.id)),runColor:o[n.id],hparams:i,metrics:c}})))))}onRunSelectionToggle(t){this.store.dispatch(jQ({experimentIds:this.experimentIds,runId:t.run.id}))}onPageSelectionToggle(t){const{items:n}=t,e=n.map((({run:t})=>t.id));this.store.dispatch(UQ({experimentIds:this.experimentIds,runIds:e}))}onSelectAllPages(){if(!this.usePagination)throw new Error("Select all events cannot be dispatched when pagination is disabled");this.store.dispatch(WQ({experimentIds:this.experimentIds}))}onPaginationChange(t){if(!this.usePagination)throw new Error("Pagination events cannot be dispatched when pagination is disabled");const{pageIndex:n,pageSize:e}=t;this.store.dispatch(GQ({pageIndex:n,pageSize:e}))}onSortChange(t){this.store.dispatch(YQ(t))}onRegexFilterChange(t){this.store.dispatch(qQ({regexString:t}))}onRunColorChange({runId:t,newColor:n}){this.store.dispatch(ZQ({runId:t,newColor:n}))}onHparamDiscreteFilterChanged(t){const{hparamName:n,filterValues:e,includeUndefined:a}=t;this.store.dispatch(JQ({hparamName:n,filterValues:e,includeUndefined:a}))}onHparamIntervalFilterChanged(t){const{name:n,filterLowerValue:e,filterUpperValue:a,includeUndefined:o}=t;this.store.dispatch(QQ({hparamName:n,filterLowerValue:e,filterUpperValue:a,includeUndefined:o}))}onMetricFilterChanged(t){const{name:n,includeUndefined:e,filterLowerValue:a,filterUpperValue:o}=t;this.store.dispatch(KQ({metricTag:n,includeUndefined:e,filterLowerValue:a,filterUpperValue:o}))}}eK.ɵfac=function t(n){return new(n||eK)(Zg(cv))},eK.ɵcmp=_o({type:eK,selectors:[["runs-table"]],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("flex-layout",e.useFlexibleLayout)},inputs:{useFlexibleLayout:"useFlexibleLayout",usePagination:"usePagination",columns:"columns",experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics"},decls:11,vars:34,consts:[[3,"useFlexibleLayout","numSelectedItems","columns","hparamColumns","metricColumns","showExperimentName","pageItems","filteredItemsLength","allItemsLength","loading","paginationOption","regexFilter","sortOption","usePagination","onSelectionToggle","onPageSelectionToggle","onSelectAllPages","onPaginationChange","onRegexFilterChange","onSortChange","onRunColorChange","onHparamIntervalFilterChanged","onHparamDiscreteFilterChanged","onMetricFilterChanged"]],template:function t(n,e){1&n&&(Kg(0,"runs-table-component",0),cp("onSelectionToggle",(function t(n){return e.onRunSelectionToggle(n)}))("onPageSelectionToggle",(function t(n){return e.onPageSelectionToggle(n)}))("onSelectAllPages",(function t(){return e.onSelectAllPages()}))("onPaginationChange",(function t(n){return e.onPaginationChange(n)}))("onRegexFilterChange",(function t(n){return e.onRegexFilterChange(n)}))("onSortChange",(function t(n){return e.onSortChange(n)}))("onRunColorChange",(function t(n){return e.onRunColorChange(n)}))("onHparamIntervalFilterChanged",(function t(n){return e.onHparamIntervalFilterChanged(n)}))("onHparamDiscreteFilterChanged",(function t(n){return e.onHparamDiscreteFilterChanged(n)}))("onMetricFilterChanged",(function t(n){return e.onMetricFilterChanged(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),yf(10,"async"),$g()),2&n&&Jg("useFlexibleLayout",e.useFlexibleLayout)("numSelectedItems",kf(1,14,e.numSelectedItems$))("columns",e.columns)("hparamColumns",kf(2,16,e.hparamColumns$))("metricColumns",kf(3,18,e.metricColumns$))("showExperimentName",e.isExperimentNameVisible())("pageItems",kf(4,20,e.pageItems$))("filteredItemsLength",kf(5,22,e.filteredItemsLength$))("allItemsLength",kf(6,24,e.allItemsLength$))("loading",kf(7,26,e.loading$))("paginationOption",kf(8,28,e.paginationOption$))("regexFilter",kf(9,30,e.regexFilter$))("sortOption",kf(10,32,e.sortOption$))("usePagination",e.usePagination)},directives:[LQ],pipes:[oO],styles:[".flex-layout[_nghost-%COMP%] {\n        display: flex;\n      }\n\n      .flex-layout[_nghost-%COMP%]    > runs-table-component[_ngcontent-%COMP%] {\n        width: 100%;\n      }"],changeDetection:0});class aK{}aK.ɵmod=xo({type:aK}),aK.ɵinj=Ge({factory:function t(n){return new(n||aK)},imports:[[jJ,PO,oA,mV,VB,xV,Fq,cZ,_Z,AZ,KX,JJ]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(aK,{declarations:[eK,LQ],imports:[jJ,PO,oA,mV,VB,xV,Fq,cZ,_Z,AZ,KX,JJ],exports:[eK]});class oK{}oK.ɵfac=function t(n){return new(n||oK)},oK.ɵcmp=_o({type:oK,selectors:[["runs-selector-component"]],inputs:{experimentIds:"experimentIds",showHparamsAndMetrics:"showHparamsAndMetrics",columns:"columns",hparamAndMetricSpecs:"hparamAndMetricSpecs"},decls:1,vars:4,consts:[[3,"useFlexibleLayout","columns","experimentIds","showHparamsAndMetrics"]],template:function t(n,e){1&n&&tp(0,"runs-table",0),2&n&&Jg("useFlexibleLayout",!0)("columns",e.columns)("experimentIds",e.experimentIds)("showHparamsAndMetrics",e.showHparamsAndMetrics)},directives:[eK],styles:["runs-table[_ngcontent-%COMP%] {\n        height: 100%;\n      }"],changeDetection:0});class rK{constructor(t){this.store=t,this.experimentIds$=this.store.select(eR).pipe(ft((t=>null!=t?t:[]))),this.columns$=this.store.select(eR).pipe(ft((t=>[ZJ.CHECKBOX,ZJ.RUN_NAME,t&&t.length>1?ZJ.EXPERIMENT_NAME:null,ZJ.RUN_COLOR].filter((t=>null!==t)))))}}rK.ɵfac=function t(n){return new(n||rK)(Zg(cv))},rK.ɵcmp=_o({type:rK,selectors:[["runs-selector"]],inputs:{showHparamsAndMetrics:"showHparamsAndMetrics"},decls:3,vars:7,consts:[[3,"experimentIds","columns","showHparamsAndMetrics"]],template:function t(n,e){1&n&&(tp(0,"runs-selector-component",0),yf(1,"async"),yf(2,"async")),2&n&&Jg("experimentIds",kf(1,3,e.experimentIds$))("columns",kf(2,5,e.columns$))("showHparamsAndMetrics",e.showHparamsAndMetrics)},directives:[oK],pipes:[oO],encapsulation:2,changeDetection:0});class iK{}iK.ɵmod=xo({type:iK}),iK.ɵinj=Ge({factory:function t(n){return new(n||iK)},imports:[[PO,aK]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(iK,{declarations:[oK,rK],imports:[PO,aK],exports:[rK]});const cK=Ok("[Metrics] Metrics Tag Metadata Requested"),sK=Ok("[Metrics] Metrics Tag Metadata Loaded",{_as:"props",_p:void 0}),lK=Ok("[Metrics] Metrics Tag Metadata Failed"),mK=Ok("[Metrics] Metrics Settings Change Tooltip",{_as:"props",_p:void 0});Ok("[Metrics] Metrics Settings Toggle Show Data Download");const dK=Ok("[Metrics] Metrics Setting Toggle Ignore Outlier"),gK=Ok("[Metrics] Metrics Setting Change X Axis Type",{_as:"props",_p:void 0}),pK=Ok("[Metrics] Metrics Setting Change Scalar Smoothing",{_as:"props",_p:void 0}),bK=Ok("[Metrics] Metrics Setting Partition Non Monotonic X Toggled"),uK=Ok("[Metrics] Metrics Setting Change Image Brightness",{_as:"props",_p:void 0}),fK=Ok("[Metrics] Metrics Setting Change Image Contrast",{_as:"props",_p:void 0}),hK=Ok("[Metrics] Image Brightness Setting Reset"),_K=Ok("[Metrics] Image Contrast Setting Reset"),CK=Ok("[Metrics] Metrics Setting Toggle Image Show Actual Size"),MK=Ok("[Metrics] Metrics Setting Change Histogram Mode",{_as:"props",_p:void 0}),OK=Ok("[Metrics] Multiple Time Series Requested",{_as:"props",_p:void 0}),PK=Ok("[Metrics] Fetch Time Series Request Failed",{_as:"props",_p:void 0}),xK=Ok("[Metrics] Fetch Time Series Response Loaded",{_as:"props",_p:void 0}),yK=Ok("[Metrics] Card Visibility Changed",{_as:"props",_p:void 0}),kK=Ok("[Metrics] Card Step Slider Changed",{_as:"props",_p:void 0}),vK=Ok("[Metrics] Tag Filter Changed",{_as:"props",_p:void 0}),wK=Ok("[Metrics] Metrics Tag Group Expansion Changed",{_as:"props",_p:void 0}),SK=Ok("[Metrics] Card Pin State Toggled",{_as:"props",_p:void 0});function EK(t,n,e){const a=Object.keys(t);return{initialState:Object.assign(Object.assign(Object.assign({},t),n),{privateRouteContextedState:{}}),reducers:Uv({},jv(KV,((n,{before:o,after:r})=>{const i=Xz(r.routeKind,r.params),c=o?Xz(o.routeKind,o.params):null;if(c===i)return n;let s=Object.assign({},n.privateRouteContextedState);if(c){const t={};for(const e of a)t[e]=n[e];s=Object.assign(Object.assign({},s),{[c]:t})}let l=n.privateRouteContextedState&&n.privateRouteContextedState[i]?n.privateRouteContextedState[i]:null;c&&null===l&&(l=t);let m=Object.assign(Object.assign(Object.assign({},n),l),{privateRouteContextedState:s});return e?e(m):m})))}}function AK(t,n){const e={};for(const a of Object.keys(t))e[a]=n(t[a],a);return e}function zK(...t){return(n,e)=>{let a=n;for(const n of t)a=n(a,e);return a}}function RK(t,n,e){const{plugin:a,tag:o,runId:r,sample:i}=n[t],c=AT(e,a,o,i);if(c){if(null!==r&&c.runToSeries.hasOwnProperty(r)){const t=c.runToSeries[r].length;return t>0?t-1:null}const t=Object.values(c.runToSeries).map((t=>t.length));if(t.length)return Math.max(...t)-1}return null}function TK(t,n,e,a){const o=Object.assign({},n);for(const r in t){if(!t.hasOwnProperty(r))continue;const i=RK(r,t,e);if(null===i){n.hasOwnProperty(r)&&(o[r]=null);continue}const c=n.hasOwnProperty(r)?n[r]:null,s=RK(r,t,a),l=null!==c&&c===s,m=null===c||l;(null!==c&&c>i||m)&&(o[r]=i)}return o}function DK(t){const n=AK(t.runToLoadState,(t=>t===fR.LOADING?fR.LOADING:fR.NOT_LOADED));return Object.assign(Object.assign({},t),{runToLoadState:n})}function IK(t,n,e,a){return JSON.stringify([t,n,e||"",a])}const{initialState:NK,reducers:FK}=EK({tagMetadataLoaded:fR.NOT_LOADED,tagMetadata:{scalars:{tagDescriptions:{},tagToRuns:{}},histograms:{tagDescriptions:{},tagToRuns:{}},images:{tagDescriptions:{},tagRunSampledInfo:{}}},cardList:[],cardToPinnedCopy:new Map,pinnedCardToOriginal:new Map,unresolvedImportedPinnedCards:[],cardMetadataMap:{},cardStepIndex:{},tagFilter:"",tagGroupExpanded:new Map},{timeSeriesData:{scalars:{},histograms:{},images:{}},settings:YT,visibleCards:new Set},(t=>Object.assign(Object.assign({},t),{visibleCards:new Set}))),LK=NK,HK=Uv(NK,jv(XV,((t,{routeKind:n,partialState:e})=>{if(n!==Yz.EXPERIMENT&&n!==Yz.COMPARE_EXPERIMENT)return t;const a=new Set;for(const n of t.pinnedCardToOriginal.keys()){const{plugin:e,tag:o,runId:r,sample:i}=t.cardMetadataMap[n];a.add(IK(e,o,r,i))}const o=e,r=[];for(const n of[...t.unresolvedImportedPinnedCards,...o.metrics.pinnedCards]){const t=IK(n.plugin,n.tag,n.runId,n.sample);a.has(t)||(a.add(t),r.push(n))}const i=IT(r,t.cardList,t.cardMetadataMap,t.cardToPinnedCopy,t.pinnedCardToOriginal,t.cardStepIndex),c=o.metrics.smoothing;let s=t.settings;if(Number.isFinite(c)&&null!==c){const n=Math.max(0,Math.min(.999,Number(c.toPrecision(3))));s=Object.assign(Object.assign({},t.settings),{scalarSmoothing:n})}return Object.assign(Object.assign(Object.assign({},t),i),{settings:s})})),jv(fI,uI,(t=>{const n=t.tagMetadataLoaded===fR.LOADING?fR.LOADING:fR.NOT_LOADED,e=AK(t.timeSeriesData,((t,n)=>AK(t,(t=>bT(n)?AK(t,(t=>DK(t))):DK(t)))));return Object.assign(Object.assign({},t),{tagMetadataLoaded:n,timeSeriesData:e})})),jv(cK,(t=>Object.assign(Object.assign({},t),{tagMetadataLoaded:fR.LOADING}))),jv(lK,(t=>Object.assign(Object.assign({},t),{tagMetadataLoaded:fR.FAILED}))),jv(sK,((t,{tagMetadata:n})=>{const e={scalars:BK(n,gT.SCALARS),histograms:BK(n,gT.HISTOGRAMS),images:n[gT.IMAGES]},a=Object.assign({},t.cardMetadataMap),o=(function r(t){const n=[];for(let e of Object.keys(t)){const a=e;let o;if(bT(a)){if(!fT(a))throw new Error("Multi-run, sampled plugin support not yet implemented");{const e=t[a].tagRunSampledInfo;for(const t of Object.keys(e))for(const o of Object.keys(e[t])){const{maxSamplesPerStep:r}=e[t][o];for(let e=0;e<r;e++)n.push({plugin:a,tag:t,runId:o,sample:e})}}}else if(fT(a)){o=t[a].tagToRuns;for(const t of Object.keys(o))for(const e of o[t])n.push({plugin:a,tag:t,runId:e})}else{o=t[a].tagToRuns;for(const t of Object.keys(o))n.push({plugin:a,tag:t,runId:null})}}return n})(e),i=[];for(const n of o){const e=RT(n);t.cardMetadataMap.hasOwnProperty(e)||(a[e]=n,i.push(e))}const c=[...t.cardList,...i],s=IT(t.unresolvedImportedPinnedCards,i,a,t.cardToPinnedCopy,t.pinnedCardToOriginal,t.cardStepIndex);return Object.assign(Object.assign(Object.assign({},t),s),{tagMetadataLoaded:fR.LOADED,tagMetadata:e,cardList:c})})),jv(vK,((t,{tagFilter:n})=>Object.assign(Object.assign({},t),{tagFilter:n}))),jv(mK,((t,{sort:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{tooltipSort:n})}))),jv(dK,(t=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{ignoreOutliers:!t.settings.ignoreOutliers})}))),jv(gK,((t,{xAxisType:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{xAxisType:n})}))),jv(pK,((t,{smoothing:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{scalarSmoothing:n})}))),jv(bK,(t=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{scalarPartitionNonMonotonicX:!t.settings.scalarPartitionNonMonotonicX})}))),jv(uK,((t,{brightnessInMilli:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{imageBrightnessInMilli:n})}))),jv(fK,((t,{contrastInMilli:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{imageContrastInMilli:n})}))),jv(hK,(t=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{imageBrightnessInMilli:NK.settings.imageBrightnessInMilli})}))),jv(_K,(t=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{imageContrastInMilli:NK.settings.imageContrastInMilli})}))),jv(CK,(t=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{imageShowActualSize:!t.settings.imageShowActualSize})}))),jv(MK,((t,{histogramMode:n})=>Object.assign(Object.assign({},t),{settings:Object.assign(Object.assign({},t.settings),{histogramMode:n})}))),jv(OK,((t,{requests:n})=>{if(!n.length)return t;const e=Object.assign({},t.timeSeriesData);for(const a of n){const{plugin:n,tag:o,sample:r}=a;e[n]=zT(e,n,o,r);const i=AT(e,n,o,r),c=hT(a)?[a.runId]:DT(t.tagMetadata,n,o,r);i.runToLoadState=TT(fR.LOADING,c,i.runToLoadState)}return Object.assign(Object.assign({},t),{timeSeriesData:e})})),jv(PK,((t,{request:n})=>{const e=Object.assign({},t.timeSeriesData),{plugin:a,tag:o,sample:r}=n;e[a]=zT(e,a,o,r);const i=AT(e,a,o,r),c=hT(n)?[n.runId]:DT(t.tagMetadata,a,o,r);return i.runToLoadState=TT(fR.FAILED,c,i.runToLoadState),Object.assign(Object.assign({},t),{timeSeriesData:e})})),jv(xK,((t,{response:n})=>{const e=Object.assign({},t.timeSeriesData),{plugin:a,tag:o,runId:r,sample:i}=n;e[a]=zT(e,a,o,i);const c=AT(e,a,o,i);if(CT(n)){const n=r?[r]:DT(t.tagMetadata,a,o,i);c.runToLoadState=TT(fR.FAILED,n,c.runToLoadState)}else{const t=n.runToSeries;c.runToSeries=Object.assign({},c.runToSeries),c.runToLoadState=Object.assign({},c.runToLoadState);for(const n in t)t.hasOwnProperty(n)&&(c.runToSeries[n]=t[n],c.runToLoadState[n]=fR.LOADED)}return Object.assign(Object.assign({},t),{timeSeriesData:e,cardStepIndex:TK(t.cardMetadataMap,t.cardStepIndex,e,t.timeSeriesData)})})),jv(kK,((t,{cardId:n,stepIndex:e})=>{const a=RK(n,t.cardMetadataMap,t.timeSeriesData);let o=e;return null===a?o=null:e>a&&(o=a),Object.assign(Object.assign({},t),{cardStepIndex:Object.assign(Object.assign({},t.cardStepIndex),{[n]:o})})})),jv(wK,((t,{tagGroup:n})=>{const e=new Map(t.tagGroupExpanded);return e.set(n,!e.get(n)),Object.assign(Object.assign({},t),{tagGroupExpanded:e})})),jv(yK,((t,{enteredCards:n,exitedCards:e})=>{if(0===n.size&&0===e.size)return t;const a=new Set(t.visibleCards);return n.forEach((t=>{a.add(t)})),e.forEach((t=>{if(a.delete(t),n.has(t))throw new Error("A 'cardVisibilityChanged' with an invalid payload contains overlapping sets")})),Object.assign(Object.assign({},t),{visibleCards:a})})),jv(SK,((t,{cardId:n})=>{const e=t.pinnedCardToOriginal.has(n),a=!e&&!t.cardToPinnedCopy.has(n);if(a&&!FT(t))return t;let o=new Map(t.cardToPinnedCopy),r=new Map(t.pinnedCardToOriginal),i=Object.assign({},t.cardMetadataMap),c=Object.assign({},t.cardStepIndex);if(e){const e=t.pinnedCardToOriginal.get(n);o.delete(e),r.delete(n),delete i[n],delete c[n]}else if(a){const t=NT(n,o,r,c,i);o=t.cardToPinnedCopy,r=t.pinnedCardToOriginal,i=t.cardMetadataMap,c=t.cardStepIndex}else{const e=t.cardToPinnedCopy.get(n);o.delete(n),r.delete(e),delete i[e],delete c[e]}return Object.assign(Object.assign({},t),{cardMetadataMap:i,cardStepIndex:c,cardToPinnedCopy:o,pinnedCardToOriginal:r})})));function BK(t,n){return{tagDescriptions:t[n].tagDescriptions,tagToRuns:VK(t[n].runTagInfo)}}function VK(t){const n={};for(const e in t)for(const a of t[e])n[a]=[...n[a]||[],e];return n}const jK=pv(JT,$T,((t,n,e)=>n?Object.assign(Object.assign({},n),{loadState:t,id:e}):null)),UK=Ok("[Metrics Effects] Init");class WK{constructor(t,n,e){this.actions$=t,this.store=n,this.dataSource=e,this.dashboardShownWithoutData$=this.actions$.pipe(tw(UK,gI,KV),ye(this.store.select(NI),this.store.select(ZT)),Gt((([,t,n])=>t===dT&&n===fR.NOT_LOADED))),this.reloadRequestedWhileShown$=this.actions$.pipe(tw(fI,uI),ye(this.store.select(NI)),Gt((([,t])=>t===dT))),this.loadTagMetadata$=Wt(this.dashboardShownWithoutData$,this.reloadRequestedWhileShown$).pipe(ye(this.store.select(ZT),this.store.select(eR)),Gt((([,t,n])=>t!==fR.LOADING&&null!==n)),he((()=>{this.store.dispatch(cK())})),se((([,,t])=>this.dataSource.fetchTagMetadata(t).pipe(he((t=>{this.store.dispatch(sK({tagMetadata:t}))})),on((()=>(this.store.dispatch(lK()),Z(null)))))))),this.visibleCardsWithoutDataChanged$=this.actions$.pipe(tw(yK),se((()=>this.getVisibleCardFetchInfos().pipe(Tn(1)))),ft((t=>t.filter((t=>t.loadState===fR.NOT_LOADED))))),this.visibleCardsReloaded$=this.reloadRequestedWhileShown$.pipe(se((()=>this.getVisibleCardFetchInfos().pipe(Tn(1)))),ft((t=>t.filter((t=>t.loadState!==fR.LOADING))))),this.loadTimeSeries$=Wt(this.visibleCardsWithoutDataChanged$,this.visibleCardsReloaded$).pipe(Gt((t=>t.length>0)),ye(this.store.select(eR).pipe(Gt((t=>null!==t)))),Tt((([t,n])=>this.fetchTimeSeriesForCards(t,n)))),this.allEffects$=Yv((()=>Wt(this.loadTagMetadata$,this.loadTimeSeries$)),{dispatch:!1})}ngrxOnInitEffects(){return UK()}getVisibleCardFetchInfos(){return this.store.select(nD).pipe(se((t=>t.size?Ht([...t].map((t=>this.store.select(jK,t).pipe(Tn(1))))):Z([]))),ft((t=>t.filter(Boolean))))}fetchTimeSeries(t){return this.dataSource.fetchTimeSeries([t]).pipe(he((t=>{const n=t.filter(CT);n.length&&console.error("Time series response contained errors:",n),this.store.dispatch(xK({response:t[0]}))})),on((()=>(this.store.dispatch(PK({request:t})),Z(null)))))}fetchTimeSeriesForCards(t,n){return Z(t.map((t=>{const{plugin:e,tag:a,runId:o,sample:r}=t;return fT(e)?{plugin:e,tag:a,sample:r,runId:o}:{plugin:e,tag:a,sample:r,experimentIds:n}}))).pipe(he((t=>{this.store.dispatch(OK({requests:t}))})),Tt((t=>Wt(...t.map((t=>this.fetchTimeSeries(t)))))))}}WK.ɵfac=function t(n){return new(n||WK)(Za($v),Za(cv),Za(_T))},WK.ɵprov=We({token:WK,factory:WK.ɵfac});const GK=new Fa("Metrics Store Config"),YK=new Fa("Metrics Initial Settings Config"),qK=new WeakMap;class ZK{constructor(t,n){this.root=t,this.buffer=n,this.destroyedTargets=new Set}initialize(t){this.intersectionObserver||(this.intersectionCallback=t,this.intersectionObserver=new IntersectionObserver(this.onCardIntersection.bind(this),{threshold:0,root:this.root,rootMargin:this.buffer}))}add(t){this.ensureInitialized()&&this.intersectionObserver.observe(t)}willDestroy(t){this.ensureInitialized()&&this.destroyedTargets.add(t)}ensureInitialized(){if(!this.intersectionObserver)throw new Error("CardObserver must be initialized before use");return!0}onCardIntersection(t){t.sort(((t,n)=>t.time-n.time));const n=new Set,e=new Set;for(const a of t){const t=a.target,o=qK.get(t);if(!o)throw new Error("A CardObserver element must be associated with a CardId");a.isIntersecting?(n.add(o),e.delete(o)):(n.delete(o),e.add(o)),this.destroyedTargets.has(t)&&!a.isIntersecting&&(this.destroyedTargets.delete(t),this.intersectionObserver.unobserve(t))}this.intersectionCallback(n,e)}onCardIntersectionForTest(t){this.onCardIntersection(t)}}class XK{constructor(t,n){this.host=t,this.store=n}onCardIntersection(t,n){this.store.dispatch(yK({enteredCards:t,exitedCards:n}))}ngOnInit(){qK.set(this.host.nativeElement,this.cardId),this.cardObserver||(this.cardObserver=new ZK),this.cardObserver.initialize(this.onCardIntersection.bind(this)),this.cardObserver.add(this.host.nativeElement)}ngOnDestroy(){this.cardObserver&&this.cardObserver.willDestroy(this.host.nativeElement)}hostForTest(){return this.host}}XK.ɵfac=function t(n){return new(n||XK)(Zg(xu),Zg(cv))},XK.ɵdir=vo({type:XK,selectors:[["","cardLazyLoader",""]],inputs:{cardId:["cardLazyLoader","cardId"],cardObserver:"cardObserver"}});const JK="/scalar_summary";function QK(t,n){let e=t;return n&&t.startsWith(n+"/")&&(e=t.slice(n.length+1)),e.endsWith(JK)&&(e=e.slice(0,-JK.length)),e||t}function KK(t,n){let e=0,a=0;for(;;){if(e===t.length)return a===n.length?0:-1;if(a===n.length)return 1;if(t$(t[e])&&t$(n[a])){const o=e,r=a;e=$K(t,e+1),a=$K(n,a+1);const i=Number(t.slice(o,e)),c=Number(n.slice(r,a));if(i<c)return-1;if(i>c)return 1}else{if(n$(t[e])){if(!n$(n[a]))return-1}else{if(n$(n[a]))return 1;if(t[e]<n[a])return-1;if(t[e]>n[a])return 1}e++,a++}}}function $K(t,n){let e;!(function(t){t[t.NATURAL=0]="NATURAL",t[t.REAL=1]="REAL",t[t.EXPONENT_SIGN=2]="EXPONENT_SIGN",t[t.EXPONENT=3]="EXPONENT"})(e||(e={}));let a=e.NATURAL,o=n;for(;o<t.length;o++)if(a===e.NATURAL){if("."===t[o])a=e.REAL;else if("e"===t[o]||"E"===t[o])a=e.EXPONENT_SIGN;else if(!t$(t[o]))break}else if(a===e.REAL){if("e"===t[o]||"E"===t[o])a=e.EXPONENT_SIGN;else if(!t$(t[o]))break}else if(a===e.EXPONENT_SIGN){if(!t$(t[o])&&"+"!==t[o]&&"-"!==t[o])break;a=e.EXPONENT}else if(a===e.EXPONENT&&!t$(t[o]))break;return o}function t$(t){return"0"<=t&&t<="9"}function n$(t){return"/"===t||t$(t)}const e$=["panel"];function a$(t,n){if(1&t&&(Kg(0,"div",0,1),hp(2),$g()),2&t){const t=gp();Jg("id",t.id)("ngClass",t._classList)}}let o$=0;class r${constructor(t,n){this.source=t,this.option=n}}const i$=aE(class{}),c$=new Fa("mat-autocomplete-default-options",{providedIn:"root",factory:function s$(){return{autoActiveFirstOption:!1}}});class l$ extends i${constructor(t,n,e){super(),this._changeDetectorRef=t,this._elementRef=n,this._activeOptionChanges=s.EMPTY,this.showPanel=!1,this._isOpen=!1,this.displayWith=null,this.optionSelected=new Ef,this.opened=new Ef,this.closed=new Ef,this.optionActivated=new Ef,this._classList={},this.id="mat-autocomplete-"+o$++,this._autoActiveFirstOption=!!e.autoActiveFirstOption}get isOpen(){return this._isOpen&&this.showPanel}get autoActiveFirstOption(){return this._autoActiveFirstOption}set autoActiveFirstOption(t){this._autoActiveFirstOption=Gw(t)}set classList(t){this._classList=t&&t.length?t.split(" ").reduce(((t,n)=>(t[n.trim()]=!0,t)),{}):{},this._setVisibilityClasses(this._classList),this._elementRef.nativeElement.className=""}ngAfterContentInit(){this._keyManager=new lS(this.options).withWrap(),this._activeOptionChanges=this._keyManager.change.subscribe((t=>{this.optionActivated.emit({source:this,option:this.options.toArray()[t]||null})})),this._setVisibility()}ngOnDestroy(){this._activeOptionChanges.unsubscribe()}_setScrollTop(t){this.panel&&(this.panel.nativeElement.scrollTop=t)}_getScrollTop(){return this.panel?this.panel.nativeElement.scrollTop:0}_setVisibility(){this.showPanel=!!this.options.length,this._setVisibilityClasses(this._classList),this._changeDetectorRef.markForCheck()}_emitSelectEvent(t){const n=new r$(this,t);this.optionSelected.emit(n)}_setVisibilityClasses(t){t[this._visibleClass]=this.showPanel,t[this._hiddenClass]=!this.showPanel}}l$.ɵfac=function t(n){return new(n||l$)(Zg(Vm),Zg(xu),Zg(c$))},l$.ɵdir=vo({type:l$,viewQuery:function t(n,e){var a;1&n&&(jf(Ju,!0),Uf(e$,!0)),2&n&&(Vf(a=Zf())&&(e.template=a.first),Vf(a=Zf())&&(e.panel=a.first))},inputs:{displayWith:"displayWith",autoActiveFirstOption:"autoActiveFirstOption",classList:["class","classList"],panelWidth:"panelWidth"},outputs:{optionSelected:"optionSelected",opened:"opened",closed:"closed",optionActivated:"optionActivated"},features:[hg]}),l$.ctorParameters=()=>[{type:Vm},{type:xu},{type:void 0,decorators:[{type:Ie,args:[c$]}]}],l$.propDecorators={template:[{type:Xd,args:[Ju,{static:!0}]}],panel:[{type:Xd,args:["panel"]}],displayWith:[{type:f_}],autoActiveFirstOption:[{type:f_}],panelWidth:[{type:f_}],optionSelected:[{type:h_}],opened:[{type:h_}],closed:[{type:h_}],optionActivated:[{type:h_}],classList:[{type:f_,args:["class"]}]};class m$ extends l${constructor(){super(...arguments),this._visibleClass="mat-autocomplete-visible",this._hiddenClass="mat-autocomplete-hidden"}}m$.ɵfac=function t(n){return d$(n||m$)},m$.ɵcmp=_o({type:m$,selectors:[["mat-autocomplete"]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,HE,!0),Gf(a,YE,!0)),2&n&&(Vf(o=Zf())&&(e.optionGroups=o),Vf(o=Zf())&&(e.options=o))},hostAttrs:[1,"mat-autocomplete"],inputs:{disableRipple:"disableRipple"},exportAs:["matAutocomplete"],features:[Mu([{provide:WE,useExisting:m$}]),hg],ngContentSelectors:["*"],decls:1,vars:0,consts:[["role","listbox",1,"mat-autocomplete-panel",3,"id","ngClass"],["panel",""]],template:function t(n,e){1&n&&(bp(),Yg(0,a$,3,2,"ng-template"))},directives:[HM],styles:[".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}.cdk-high-contrast-active .mat-autocomplete-panel{outline:solid 1px}\n"],encapsulation:2,changeDetection:0}),m$.propDecorators={optionGroups:[{type:qd,args:[HE,{descendants:!0}]}],options:[{type:qd,args:[YE,{descendants:!0}]}]};const d$=tc(m$);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class g${constructor(t){this.elementRef=t}}g$.ɵfac=function t(n){return new(n||g$)(Zg(xu))},g$.ɵdir=vo({type:g$}),g$.ctorParameters=()=>[{type:xu}];class p$ extends g${}p$.ɵfac=function t(n){return b$(n||p$)},p$.ɵdir=vo({type:p$,selectors:[["","matAutocompleteOrigin",""]],exportAs:["matAutocompleteOrigin"],features:[hg]});const b$=tc(p$),u$=new Fa("mat-autocomplete-scroll-strategy"),f$={provide:u$,deps:[hz],useFactory:function h$(t){return()=>t.scrollStrategies.reposition()}},_$={provide:MF,useExisting:aa((()=>M$)),multi:!0};class C${constructor(t,n,e,a,o,r,i,c,l,m){this._element=t,this._overlay=n,this._viewContainerRef=e,this._zone=a,this._changeDetectorRef=o,this._dir=i,this._formField=c,this._document=l,this._viewportRuler=m,this._componentDestroyed=!1,this._autocompleteDisabled=!1,this._manuallyFloatingLabel=!1,this._viewportSubscription=s.EMPTY,this._canOpenOnNextFocus=!0,this._closeKeyEventStream=new x,this._windowBlurHandler=()=>{this._canOpenOnNextFocus=this._document.activeElement!==this._element.nativeElement||this.panelOpen},this._onChange=()=>{},this._onTouched=()=>{},this.position="auto",this.autocompleteAttribute="off",this._overlayAttached=!1,this.optionSelections=Lt((()=>this.autocomplete&&this.autocomplete.options?Wt(...this.autocomplete.options.map((t=>t.onSelectionChange))):this._zone.onStable.pipe(Tn(1),se((()=>this.optionSelections))))),this._scrollStrategy=r}get autocompleteDisabled(){return this._autocompleteDisabled}set autocompleteDisabled(t){this._autocompleteDisabled=Gw(t)}ngAfterViewInit(){const t=this._getWindow();void 0!==t&&this._zone.runOutsideAngular((()=>t.addEventListener("blur",this._windowBlurHandler)))}ngOnChanges(t){t.position&&this._positionStrategy&&(this._setStrategyPositions(this._positionStrategy),this.panelOpen&&this._overlayRef.updatePosition())}ngOnDestroy(){const t=this._getWindow();void 0!==t&&t.removeEventListener("blur",this._windowBlurHandler),this._viewportSubscription.unsubscribe(),this._componentDestroyed=!0,this._destroyPanel(),this._closeKeyEventStream.complete()}get panelOpen(){return this._overlayAttached&&this.autocomplete.showPanel}openPanel(){this._attachOverlay(),this._floatLabel()}closePanel(){this._resetLabel(),this._overlayAttached&&(this.panelOpen&&this.autocomplete.closed.emit(),this.autocomplete._isOpen=this._overlayAttached=!1,this._overlayRef&&this._overlayRef.hasAttached()&&(this._overlayRef.detach(),this._closingActionsSubscription.unsubscribe()),this._componentDestroyed||this._changeDetectorRef.detectChanges())}updatePosition(){this._overlayAttached&&this._overlayRef.updatePosition()}get panelClosingActions(){return Wt(this.optionSelections,this.autocomplete._keyManager.tabOut.pipe(Gt((()=>this._overlayAttached))),this._closeKeyEventStream,this._getOutsideClickStream(),this._overlayRef?this._overlayRef.detachments().pipe(Gt((()=>this._overlayAttached))):Z()).pipe(ft((t=>t instanceof UE?t:null)))}get activeOption(){return this.autocomplete&&this.autocomplete._keyManager?this.autocomplete._keyManager.activeItem:null}_getOutsideClickStream(){return Wt(Vt(this._document,"click"),Vt(this._document,"touchend")).pipe(Gt((t=>{const n=this._isInsideShadowRoot&&t.composedPath?t.composedPath()[0]:t.target,e=this._formField?this._formField._elementRef.nativeElement:null,a=this.connectedTo?this.connectedTo.elementRef.nativeElement:null;return this._overlayAttached&&n!==this._element.nativeElement&&(!e||!e.contains(n))&&(!a||!a.contains(n))&&!!this._overlayRef&&!this._overlayRef.overlayElement.contains(n)})))}writeValue(t){Promise.resolve(null).then((()=>this._setTriggerValue(t)))}registerOnChange(t){this._onChange=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this._element.nativeElement.disabled=t}_handleKeydown(t){const n=t.keyCode;if(n!==Bw||Ww(t)||t.preventDefault(),this.activeOption&&n===Hw&&this.panelOpen)this.activeOption._selectViaInteraction(),this._resetActiveItem(),t.preventDefault();else if(this.autocomplete){const e=this.autocomplete._keyManager.activeItem,a=n===jw||n===Uw;this.panelOpen||9===n?this.autocomplete._keyManager.onKeydown(t):a&&this._canOpen()&&this.openPanel(),(a||this.autocomplete._keyManager.activeItem!==e)&&this._scrollToOption(this.autocomplete._keyManager.activeItemIndex||0)}}_handleInput(t){let n=t.target,e=n.value;"number"===n.type&&(e=""==e?null:parseFloat(e)),this._previousValue!==e&&(this._previousValue=e,this._onChange(e),this._canOpen()&&this._document.activeElement===t.target&&this.openPanel())}_handleFocus(){this._canOpenOnNextFocus?this._canOpen()&&(this._previousValue=this._element.nativeElement.value,this._attachOverlay(),this._floatLabel(!0)):this._canOpenOnNextFocus=!0}_floatLabel(t=!1){this._formField&&"auto"===this._formField.floatLabel&&(t?this._formField._animateAndLockLabel():this._formField.floatLabel="always",this._manuallyFloatingLabel=!0)}_resetLabel(){this._manuallyFloatingLabel&&(this._formField.floatLabel="auto",this._manuallyFloatingLabel=!1)}_subscribeToClosingActions(){return Wt(this._zone.onStable.pipe(Tn(1)),this.autocomplete.options.changes.pipe(he((()=>this._positionStrategy.reapplyLastPosition())),fn(0))).pipe(se((()=>{const t=this.panelOpen;return this._resetActiveItem(),this.autocomplete._setVisibility(),this.panelOpen&&(this._overlayRef.updatePosition(),t!==this.panelOpen&&this.autocomplete.opened.emit()),this.panelClosingActions})),Tn(1)).subscribe((t=>this._setValueAndClose(t)))}_destroyPanel(){this._overlayRef&&(this.closePanel(),this._overlayRef.dispose(),this._overlayRef=null)}_setTriggerValue(t){const n=this.autocomplete&&this.autocomplete.displayWith?this.autocomplete.displayWith(t):t,e=null!=n?n:"";this._formField?this._formField._control.value=e:this._element.nativeElement.value=e,this._previousValue=e}_setValueAndClose(t){t&&t.source&&(this._clearPreviousSelectedOption(t.source),this._setTriggerValue(t.source.value),this._onChange(t.source.value),this._element.nativeElement.focus(),this.autocomplete._emitSelectEvent(t.source)),this.closePanel()}_clearPreviousSelectedOption(t){this.autocomplete.options.forEach((n=>{n!==t&&n.selected&&n.deselect()}))}_attachOverlay(){if(!this.autocomplete&&("undefined"==typeof ngDevMode||ngDevMode))throw(function t(){return Error("Attempting to open an undefined instance of `mat-autocomplete`. Make sure that the id passed to the `matAutocomplete` is correct and that you're attempting to open it after the ngAfterContentInit hook.")})();null==this._isInsideShadowRoot&&(this._isInsideShadowRoot=!!Lw(this._element.nativeElement));let n=this._overlayRef;n?(this._positionStrategy.setOrigin(this._getConnectedElement()),n.updateSize({width:this._getPanelWidth()})):(this._portal=new AA(this.autocomplete.template,this._viewContainerRef),n=this._overlay.create(this._getOverlayConfig()),this._overlayRef=n,n.keydownEvents().subscribe((t=>{(t.keyCode===Bw&&!Ww(t)||t.keyCode===jw&&Ww(t,"altKey"))&&(this._resetActiveItem(),this._closeKeyEventStream.next(),t.stopPropagation(),t.preventDefault())})),this._viewportSubscription=this._viewportRuler.change().subscribe((()=>{this.panelOpen&&n&&n.updateSize({width:this._getPanelWidth()})}))),n&&!n.hasAttached()&&(n.attach(this._portal),this._closingActionsSubscription=this._subscribeToClosingActions());const e=this.panelOpen;this.autocomplete._setVisibility(),this.autocomplete._isOpen=this._overlayAttached=!0,this.panelOpen&&e!==this.panelOpen&&this.autocomplete.opened.emit()}_getOverlayConfig(){return new XA({positionStrategy:this._getOverlayPosition(),scrollStrategy:this._scrollStrategy(),width:this._getPanelWidth(),direction:this._dir})}_getOverlayPosition(){const t=this._overlay.position().flexibleConnectedTo(this._getConnectedElement()).withFlexibleDimensions(!1).withPush(!1);return this._setStrategyPositions(t),this._positionStrategy=t,t}_setStrategyPositions(t){const n=[{originX:"start",originY:"bottom",overlayX:"start",overlayY:"top"},{originX:"end",originY:"bottom",overlayX:"end",overlayY:"top"}],e=this._aboveClass,a=[{originX:"start",originY:"top",overlayX:"start",overlayY:"bottom",panelClass:e},{originX:"end",originY:"top",overlayX:"end",overlayY:"bottom",panelClass:e}];let o;o="above"===this.position?a:"below"===this.position?n:[...n,...a],t.withPositions(o)}_getConnectedElement(){return this.connectedTo?this.connectedTo.elementRef:this._formField?this._formField.getConnectedOverlayOrigin():this._element}_getPanelWidth(){return this.autocomplete.panelWidth||this._getHostWidth()}_getHostWidth(){return this._getConnectedElement().nativeElement.getBoundingClientRect().width}_resetActiveItem(){this.autocomplete._keyManager.setActiveItem(this.autocomplete.autoActiveFirstOption?0:-1)}_canOpen(){const t=this._element.nativeElement;return!t.readOnly&&!t.disabled&&!this._autocompleteDisabled}_getWindow(){var t;return(null===(t=this._document)||void 0===t?void 0:t.defaultView)||window}_scrollToOption(t){const n=this.autocomplete,e=qE(t,n.options,n.optionGroups);if(0===t&&1===e)n._setScrollTop(0);else{const e=n.options.toArray()[t];if(e){const t=e._getHostElement(),a=ZE(t.offsetTop,t.offsetHeight,n._getScrollTop(),n.panel.nativeElement.offsetHeight);n._setScrollTop(a)}}}}C$.ɵfac=function t(n){return new(n||C$)(Zg(xu),Zg(hz),Zg($u),Zg(J_),Zg(Vm),Zg(u$),Zg(US,8),Zg(hF,9),Zg(zC,8),Zg(MA))},C$.ɵdir=vo({type:C$,inputs:{position:["matAutocompletePosition","position"],autocompleteAttribute:["autocomplete","autocompleteAttribute"],autocompleteDisabled:["matAutocompleteDisabled","autocompleteDisabled"],autocomplete:["matAutocomplete","autocomplete"],connectedTo:["matAutocompleteConnectedTo","connectedTo"]},features:[pr]}),C$.ctorParameters=()=>[{type:xu},{type:hz},{type:$u},{type:J_},{type:Vm},{type:void 0,decorators:[{type:Ie,args:[u$]}]},{type:US,decorators:[{type:Ne}]},{type:_F,decorators:[{type:Ne},{type:Ie,args:[hF]},{type:He}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]},{type:MA}],C$.propDecorators={autocomplete:[{type:f_,args:["matAutocomplete"]}],position:[{type:f_,args:["matAutocompletePosition"]}],connectedTo:[{type:f_,args:["matAutocompleteConnectedTo"]}],autocompleteAttribute:[{type:f_,args:["autocomplete"]}],autocompleteDisabled:[{type:f_,args:["matAutocompleteDisabled"]}]};class M$ extends C${constructor(){super(...arguments),this._aboveClass="mat-autocomplete-panel-above"}}M$.ɵfac=function t(n){return O$(n||M$)},M$.ɵdir=vo({type:M$,selectors:[["input","matAutocomplete",""],["textarea","matAutocomplete",""]],hostAttrs:[1,"mat-autocomplete-trigger"],hostVars:7,hostBindings:function t(n,e){1&n&&cp("focusin",(function t(){return e._handleFocus()}))("blur",(function t(){return e._onTouched()}))("input",(function t(n){return e._handleInput(n)}))("keydown",(function t(n){return e._handleKeydown(n)})),2&n&&Ng("autocomplete",e.autocompleteAttribute)("role",e.autocompleteDisabled?null:"combobox")("aria-autocomplete",e.autocompleteDisabled?null:"list")("aria-activedescendant",e.panelOpen&&e.activeOption?e.activeOption.id:null)("aria-expanded",e.autocompleteDisabled?null:e.panelOpen.toString())("aria-owns",e.autocompleteDisabled||!e.panelOpen||null==e.autocomplete?null:e.autocomplete.id)("aria-haspopup",!e.autocompleteDisabled)},exportAs:["matAutocompleteTrigger"],features:[Mu([_$]),hg]});const O$=tc(M$);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class P${}function x$(t,n){1&t&&tp(0,"mat-icon",7)}function y$(t,n){if(1&t&&(Kg(0,"mat-option",8),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t),ws(1),Qp(t)}}P$.ɵmod=xo({type:P$}),P$.ɵinj=Ge({factory:function t(n){return new(n||P$)},providers:[f$],imports:[[yz,XE,tE,PO],kA,XE,tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(P$,{declarations:function(){return[m$,M$,p$]},imports:function(){return[yz,XE,tE,PO]},exports:function(){return[m$,M$,p$,kA,XE,tE]}});class k${constructor(){this.onRegexFilterValueChange=new Ef}onFilterKeyUp(t){"Enter"===t.key&&this.autocompleteTrigger.closePanel()}onCompletionAccepted(t){this.onRegexFilterValueChange.emit((function n(t){return t.replace($D,"\\$&")})(t))}}k$.ɵfac=function t(n){return new(n||k$)},k$.ɵcmp=_o({type:k$,selectors:[["metrics-tag-filter-component"]],viewQuery:function t(n,e){var a;1&n&&jf(M$,!0),2&n&&Vf(a=Zf())&&(e.autocompleteTrigger=a.first)},hostVars:2,hostBindings:function t(n,e){2&n&&Dp("valid",e.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid",completions:"completions"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:7,vars:4,consts:[[1,"tag-filter"],["svgIcon","search_24px"],["matInput","","autocomplete","off","placeholder","Filter tags (regex)",3,"value","matAutocomplete","input","keyup"],["svgIcon","error_24px","class","error-icon","title","Invalid regex filter. The result may be stale.",4,"ngIf"],[3,"optionSelected"],["filterMatches","matAutocomplete"],[3,"value",4,"ngFor","ngForOf"],["svgIcon","error_24px","title","Invalid regex filter. The result may be stale.",1,"error-icon"],[3,"value"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),tp(1,"mat-icon",1),Kg(2,"input",2),cp("input",(function t(n){return e.onRegexFilterValueChange.emit(n.target.value)}))("keyup",(function t(n){return e.onFilterKeyUp(n)})),$g(),Yg(3,x$,1,0,"mat-icon",3),$g(),Kg(4,"mat-autocomplete",4,5),cp("optionSelected",(function t(n){return e.onCompletionAccepted(n.option.value)})),Yg(6,y$,2,2,"mat-option",6),$g()),2&n){const t=qg(5);ws(2),Jg("value",e.regexFilterValue)("matAutocomplete",t),ws(1),Jg("ngIf",!e.isRegexFilterValid),ws(3),Jg("ngForOf",e.completions)}},directives:[BB,PV,M$,WM,m$,jM,YE],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.tag-filter[_ngcontent-%COMP%]{display:flex;position:relative}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}[_nghost-%COMP%]{color:#212121;font-size:13px}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   input[_ngcontent-%COMP%]{caret-color:currentColor}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}'],changeDetection:0});class v${constructor(t){this.store=t,this.tagFilter$=this.store.select(MD),this.isTagFilterRegexValid$=this.tagFilter$.pipe(ft((t=>{try{return new RegExp(t),!0}catch(t){return!1}}))),this.completions$=this.store.select(eD).pipe(ft((t=>t.map((({tag:t})=>t)))),se((t=>Et([Z(t),this.store.select(MD)]))),ft((([t,n])=>{try{return[t,new RegExp(n)]}catch(n){return[t,null]}})),Gt((([,t])=>null!==t)),ft((([t,n])=>t.filter((t=>n.test(t))).sort(KK))))}onTagFilterChange(t){this.store.dispatch(vK({tagFilter:t}))}}function w$(t,n){if(1&t&&(Kg(0,"span",2),Jp(1),$g()),2&t){const t=gp();ws(1),Qp(t.firstTextPart())}}v$.ɵfac=function t(n){return new(n||v$)(Zg(cv))},v$.ɵcmp=_o({type:v$,selectors:[["metrics-tag-filter"]],decls:4,vars:9,consts:[[3,"regexFilterValue","isRegexFilterValid","completions","onRegexFilterValueChange"]],template:function t(n,e){1&n&&(Kg(0,"metrics-tag-filter-component",0),cp("onRegexFilterValueChange",(function t(n){return e.onTagFilterChange(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("regexFilterValue",kf(1,3,e.tagFilter$))("isRegexFilterValid",kf(2,5,e.isTagFilterRegexValid$))("completions",kf(3,7,e.completions$))},directives:[k$],pipes:[oO],encapsulation:2,changeDetection:0});class S${parseValue(){const t=this.value.lastIndexOf("/");return-1===t?{first:"",second:this.value}:{first:this.value.slice(0,t),second:this.value.slice(t)}}firstTextPart(){return this.parseValue().first}secondTextPart(){return this.parseValue().second}}function E$(t,n,e){return n||e?[e,n?n.name:"..."].filter(Boolean).join("/"):t}S$.ɵfac=function t(n){return new(n||S$)},S$.ɵcmp=_o({type:S$,selectors:[["tb-truncated-path"]],inputs:{value:"value"},decls:3,vars:2,consts:[["class","first-text-part",4,"ngIf"],[1,"second-text-part"],[1,"first-text-part"]],template:function t(n,e){1&n&&(Yg(0,w$,2,1,"span",0),Kg(1,"span",1),Jp(2),$g()),2&n&&(Jg("ngIf",e.firstTextPart().length>0),ws(2),Qp(e.secondTextPart()))},directives:[WM],styles:["[_nghost-%COMP%]{display:inline-flex;white-space:nowrap}.first-text-part[_ngcontent-%COMP%]{flex:1 1 4ch;max-width:max-content}.first-text-part[_ngcontent-%COMP%], .second-text-part[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis}"]});class A${}A$.ɵfac=function t(n){return new(n||A$)},A$.ɵcmp=_o({type:A$,selectors:[["card-run-name-component"]],inputs:{name:"name"},decls:1,vars:1,template:function t(n,e){1&n&&Jp(0),2&n&&Qp(e.name)},encapsulation:2,changeDetection:0});class z${constructor(t){this.store=t}ngOnInit(){this.name$=Et([this.store.select(DD,{runId:this.runId}),this.store.select(TD,{runId:this.runId}),this.store.select(oR)]).pipe(ft((([t,n,e])=>E$(this.runId,t,n?e[n]:null))))}}function R$(t,n){1&t&&tp(0,"mat-spinner",17)}function T$(t,n){if(1&t&&(Kg(0,"div",15),Jp(1),Yg(2,R$,1,0,"mat-spinner",16),$g()),2&t){const t=gp();ws(1),Kp(" Step ",t.stepValues[t.stepIndex]," "),ws(1),Jg("ngIf",t.loadState===t.DataLoadState.LOADING)}}z$.ɵfac=function t(n){return new(n||z$)(Zg(cv))},z$.ɵcmp=_o({type:z$,selectors:[["card-run-name"]],inputs:{runId:"runId"},decls:3,vars:6,consts:[[3,"name"]],template:function t(n,e){1&n&&(tp(0,"card-run-name-component",0),yf(1,"async"),yf(2,"async")),2&n&&(Jg("name",kf(1,2,e.name$)),Ng("title",kf(2,4,e.name$)))},directives:[A$],pipes:[oO],encapsulation:2,changeDetection:0});const D$=function(t){return{filter:t}};function I$(t,n){if(1&t){const t=op();np(0),Kg(1,"div",18),Kg(2,"mat-slider",19),cp("input",(function n(e){return jr(t),gp().onSliderInput(e)})),$g(),$g(),Kg(3,"div",20),tp(4,"img",21),$g(),ep()}if(2&t){const t=gp();ws(2),Jg("disabled",t.stepValues.length<=1)("min",0)("max",t.stepValues.length-1)("step",1)("tickInterval",1)("value",t.stepIndex),ws(2),Cp("alt","Image at step ",t.stepValues[t.stepIndex],""),_p("src",t.imageUrl,Xc),Jg("ngStyle",uf(9,D$,t.cssFilter()))}}function N$(t,n){1&t&&(Kg(0,"div",23),Jp(1," Data failed to load. "),$g())}function F$(t,n){if(1&t&&Yg(0,N$,2,0,"div",22),2&t){const t=gp();Jg("ngIf",t.loadState===t.DataLoadState.FAILED)}}const L$=function(t){return{backgroundColor:t}};class H${constructor(){this.DataLoadState=fR,this.onActualSizeToggle=new Ef,this.stepIndexChange=new Ef,this.onPinClicked=new Ef}cssFilter(){return`contrast(${this.contrastInMilli/10}%) brightness(${this.brightnessInMilli/1e3})`}onSliderInput(t){this.stepIndexChange.emit(t.value)}}H$.ɵfac=function t(n){return new(n||H$)},H$.ɵcmp=_o({type:H$,selectors:[["image-card-component"]],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("actual-size",e.showActualSize)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",sample:"sample",imageUrl:"imageUrl",stepIndex:"stepIndex",stepValues:"stepValues",brightnessInMilli:"brightnessInMilli",contrastInMilli:"contrastInMilli",showActualSize:"showActualSize",runColorScale:"runColorScale",allowToggleActualSize:"allowToggleActualSize",isPinned:"isPinned"},outputs:{onActualSizeToggle:"onActualSizeToggle",stepIndexChange:"stepIndexChange",onPinClicked:"onPinClicked"},decls:16,vars:12,consts:function(){return[[1,"heading"],[1,"tag",3,"title","value"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],["class","step",4,"ngIf"],[1,"controls"],["mat-icon-button","",1,"pin-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Pin card"):$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`],[3,"svgIcon"],["mat-icon-button","","title","Toggle actual image size",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle actual image size"):$localize`:A button on an image card that toggles actual image size.␟3ca05ef3a6e3a37065f5e0f69c5d5a2178d90791␟7635101936664789140:Toggle actual image size`],["svgIcon","image_search_24px"],[4,"ngIf","ngIfElse"],["noImageData",""],[1,"step"],["diameter","18",4,"ngIf"],["diameter","18"],[1,"slider-row"],["color","primary",1,"step-slider",3,"disabled","min","max","step","tickInterval","value","input"],[1,"img-container"],[3,"alt","src","ngStyle"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function t(n,e){if(1&n&&(Kg(0,"div",0),tp(1,"tb-truncated-path",1),Kg(2,"div",2),tp(3,"span",3),tp(4,"card-run-name",4),$g(),Yg(5,T$,3,2,"div",5),Kg(6,"span",6),Kg(7,"button",7),lu(8,8),cp("click",(function t(){return e.onPinClicked.emit(!e.isPinned)})),tp(9,"mat-icon",9),$g(),Kg(10,"button",10),lu(11,11),cp("click",(function t(){return e.onActualSizeToggle.emit()})),tp(12,"mat-icon",12),$g(),$g(),$g(),Yg(13,I$,5,11,"ng-container",13),Yg(14,F$,1,1,"ng-template",null,14,Kf)),2&n){const t=qg(15);ws(1),_p("title",e.tag),_p("value",e.title),ws(2),Jg("ngStyle",uf(10,L$,e.runColorScale(e.runId))),ws(1),Jg("runId",e.runId),ws(1),Jg("ngIf",null!==e.stepIndex&&e.stepIndex<e.stepValues.length),ws(2),Ng("title",e.isPinned?"Unpin card":"Pin card"),ws(2),Jg("svgIcon",e.isPinned?"keep_24px":"keep_outline_24px"),ws(1),Jg("disabled",!e.allowToggleActualSize),ws(3),Jg("ngIf",null!==e.stepIndex&&e.stepIndex<e.stepValues.length)("ngIfElse",t)}},directives:[S$,$M,z$,WM,eA,BB,hZ,XW],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;overflow:auto;padding:16px;padding-top:4px}.actual-size[_nghost-%COMP%]{height:auto}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run step";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px;position:relative}.tag[_ngcontent-%COMP%]{grid-area:tag;overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.step[_ngcontent-%COMP%]{grid-area:step;display:flex}.step[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{margin-left:4px;margin-right:0}.run[_ngcontent-%COMP%], .step[_ngcontent-%COMP%]{font-size:13px;color:#616161;height:15px}.controls[_ngcontent-%COMP%]{color:#616161;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px;white-space:nowrap}.img-container[_ngcontent-%COMP%]{flex:1 1 0;overflow-y:auto;position:relative}.img-container[_ngcontent-%COMP%]   img[_ngcontent-%COMP%]{image-rendering:-moz-crisp-edges;image-rendering:pixelated}.actual-size[_nghost-%COMP%]   .img-container[_ngcontent-%COMP%]{overflow:auto;flex:none}[_nghost-%COMP%]:not(.actual-size)   img[_ngcontent-%COMP%]{position:absolute;max-height:100%;max-width:100%;width:auto;height:100%;object-fit:contain}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:24px}.step-slider[_ngcontent-%COMP%]{flex:1}[_nghost-%COMP%]     .mat-slider-min-value .mat-slider-thumb{background-color:#f57c00}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0});class B${constructor(t,n){this.store=t,this.dataSource=n,this.fullWidthChanged=new Ef,this.pinStateChanged=new Ef,this.brightnessInMilli$=this.store.select(hD),this.contrastInMilli$=this.store.select(_D),this.actualSizeGlobalSetting$=this.store.select(CD),this.showActualSize=!1,this.actualSizeUiToggled=!1,this.actualSizeUiToggleSubject=new F(this.actualSizeUiToggled),this.ngUnsubscribe=new x}onStepIndexChanged(t){this.store.dispatch(kK({cardId:this.cardId,stepIndex:t}))}isImageCardMetadata(t){const{plugin:n}=t;return n===gT.IMAGES}onActualSizeToggle(){this.actualSizeUiToggled=!this.actualSizeUiToggled,this.actualSizeUiToggleSubject.next(this.actualSizeUiToggled)}ngOnInit(){Et([this.actualSizeGlobalSetting$,this.actualSizeUiToggleSubject]).pipe(de(this.ngUnsubscribe),he((([t,n])=>{this.showActualSize=t||n,this.fullWidthChanged.emit(this.showActualSize)}))).subscribe((()=>{}));const t=this.store.select($T,this.cardId).pipe(Gt((t=>!!t&&this.isImageCardMetadata(t))),ft((t=>t)),ae(1)),n=Et([t,this.store.select(QT,this.cardId)]).pipe(ft((([t,n])=>{const e=t.runId;return n&&n.hasOwnProperty(e)?n[e]:[]})),vn(((t,n)=>t.length===n.length&&0===t.length||t===n)),ae(1));this.stepIndex$=this.store.select(aD,this.cardId),this.loadState$=this.store.select(JT,this.cardId);const e=Et([n,this.stepIndex$]).pipe(ft((([t,n])=>null!==n&&t[n]?t[n]:null)));this.tag$=t.pipe(ft((t=>t.tag))),this.title$=this.tag$.pipe(ft((t=>QK(t,this.groupName)))),this.runId$=t.pipe(ft((t=>t.runId))),this.sample$=t.pipe(ft((t=>t.sample))),this.imageUrl$=e.pipe(ft((t=>t?this.dataSource.imageUrl(t.imageId):null))),this.stepValues$=n.pipe(ft((t=>t.map((t=>t.step))))),this.isPinned$=this.store.select(cD,this.cardId)}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}}var V$,j$,U$;function W$(t,n){1&t&&(Kg(0,"span"),Jp(1,"scalar"),$g())}function G$(t,n){1&t&&(Kg(0,"span"),Jp(1,"histogram"),$g())}function Y$(t,n){1&t&&(Kg(0,"span"),Jp(1,"unknown"),$g())}function q$(t,n){if(1&t&&(np(0,13),Yg(1,W$,2,0,"span",14),Yg(2,G$,2,0,"span",14),Yg(3,Y$,2,0,"span",15),ep()),2&t){const t=gp(2);Jg("ngSwitch",t.cardMetadata.plugin),ws(1),Jg("ngSwitchCase",t.PluginType.SCALARS),ws(1),Jg("ngSwitchCase",t.PluginType.HISTOGRAMS)}}function Z$(t,n){1&t&&ap(0)}function X$(t,n){if(1&t&&(Kg(0,"option",16),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t.id),ws(1),Qp(t.name)}}function J$(t,n){if(1&t){const t=op();np(0),Kg(1,"h2"),Yg(2,q$,4,3,"ng-template",null,2,Kf),Kg(4,"span"),Jp(5,"Download "),$g(),Yg(6,Z$,1,0,"ng-container",3),Kg(7,"span"),Jp(8," data for "),$g(),Kg(9,"code",4),Jp(10),$g(),$g(),Kg(11,"mat-dialog-content"),Kg(12,"mat-form-field",5),Kg(13,"mat-label"),Jp(14,"Select a run to download a data for a series"),$g(),Kg(15,"select",6),cp("change",(function n(e){return jr(t),gp().runSelected.emit(e.target.value)})),Kg(16,"option",7),Jp(17,"-"),$g(),Yg(18,X$,2,2,"option",8),$g(),$g(),Kg(19,"div",9),Kg(20,"span"),Jp(21,"Download as…"),$g(),Jp(22," "),Kg(23,"a",10),Jp(24,"JSON"),$g(),Kg(25,"a",10),Jp(26,"CSV"),$g(),$g(),$g(),Kg(27,"mat-dialog-actions",11),Kg(28,"button",12),Jp(29,"Close"),$g(),$g(),ep()}if(2&t){const t=qg(3),n=gp();ws(6),Jg("ngTemplateOutlet",t),ws(3),Jg("title",n.cardMetadata.tag),ws(1),Qp(n.cardMetadata.tag),ws(5),Jg("value",n.selectedRunId||""),ws(1),Jg("value",""),ws(2),Jg("ngForOf",n.runs),ws(5),Jg("disabled",!n.downloadUrlJson)("download",n.getDownloadName("json")),Ng("href",n.downloadUrlJson,Xc),ws(2),Jg("disabled",!n.downloadUrlCsv)("download",n.getDownloadName("csv")),Ng("href",n.downloadUrlCsv,Xc)}}function Q$(t,n){1&t&&Jp(0,"Loading...")}B$.ɵfac=function t(n){return new(n||B$)(Zg(cv),Zg(_T))},B$.ɵcmp=_o({type:B$,selectors:[["image-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",pinStateChanged:"pinStateChanged"},decls:13,vars:38,consts:[[3,"loadState","title","tag","runId","sample","imageUrl","stepIndex","stepValues","brightnessInMilli","contrastInMilli","runColorScale","showActualSize","allowToggleActualSize","isPinned","stepIndexChange","onActualSizeToggle","onPinClicked"]],template:function t(n,e){1&n&&(Kg(0,"image-card-component",0),cp("stepIndexChange",(function t(n){return e.onStepIndexChanged(n)}))("onActualSizeToggle",(function t(){return e.onActualSizeToggle()}))("onPinClicked",(function t(n){return e.pinStateChanged.emit(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),yf(10,"async"),yf(11,"async"),yf(12,"async"),$g()),2&n&&Jg("loadState",kf(1,14,e.loadState$))("title",kf(2,16,e.title$))("tag",kf(3,18,e.tag$))("runId",kf(4,20,e.runId$))("sample",kf(5,22,e.sample$))("imageUrl",kf(6,24,e.imageUrl$))("stepIndex",kf(7,26,e.stepIndex$))("stepValues",kf(8,28,e.stepValues$))("brightnessInMilli",kf(9,30,e.brightnessInMilli$))("contrastInMilli",kf(10,32,e.contrastInMilli$))("runColorScale",e.runColorScale)("showActualSize",e.showActualSize)("allowToggleActualSize",!1===kf(11,34,e.actualSizeGlobalSetting$))("isPinned",kf(12,36,e.isPinned$))},directives:[H$],pipes:[oO],encapsulation:2,changeDetection:0}),(function(t){t[t.SVG=0]="SVG",t[t.WEBGL=1]="WEBGL"})(V$||(V$={})),(function(t){t[t.LINEAR=0]="LINEAR",t[t.LOG10=1]="LOG10",t[t.TIME=2]="TIME"})(j$||(j$={}));class K${constructor(){this.runSelected=new Ef,this.PluginType=gT}getDownloadName(t){const n=this.runs.find((t=>t.id===this.selectedRunId));return n?`${n.name}.${t}`:""}}K$.ɵfac=function t(n){return new(n||K$)},K$.ɵcmp=_o({type:K$,selectors:[["data_download_dialog_component"]],inputs:{cardMetadata:"cardMetadata",runs:"runs",selectedRunId:"selectedRunId",downloadUrlCsv:"downloadUrlCsv",downloadUrlJson:"downloadUrlJson"},outputs:{runSelected:"runSelected"},decls:3,vars:2,consts:[[4,"ngIf","ngIfElse"],["noCardMetadata",""],["dataName",""],[4,"ngTemplateOutlet"],[1,"tag-name",3,"title"],["appearance","fill",1,"run-selector"],["matNativeControl","","name","run","cdkFocusInitial","","required","",3,"value","change"],["selected","",3,"value"],[3,"value",4,"ngFor","ngForOf"],[1,"download-controls"],["mat-stroked-button","",3,"disabled","download"],["align","end"],["mat-button","","mat-dialog-close",""],[3,"ngSwitch"],[4,"ngSwitchCase"],[4,"NgSwitchDefault"],[3,"value"]],template:function t(n,e){if(1&n&&(Yg(0,J$,30,12,"ng-container",0),Yg(1,Q$,1,0,"ng-template",null,1,Kf)),2&n){const t=qg(2);Jg("ngIf",e.cardMetadata)("ngIfElse",t)}},directives:[WM,tO,_B,_F,sF,PV,rL,lL,jM,aA,CB,eA,fB,ZM,XM],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}h2[_ngcontent-%COMP%]{font-size:1.25em;overflow-wrap:break-word}.run-selector[_ngcontent-%COMP%]{font-size:.9em;width:100%}.download-controls[_ngcontent-%COMP%]{font-size:.9em}.download-controls[_ngcontent-%COMP%]   a[_ngcontent-%COMP%]{margin:3px 10px 3px 0}'],changeDetection:0});class $${constructor(t,n,e){this.selectedRunId$=new F(null),this.cardMetadata$=t.select($T,e.cardId).pipe(Gt((t=>Boolean(t)))),this.downloadUrlCsv$=Et([t.select($T,e.cardId),this.selectedRunId$]).pipe(ft((([t,e])=>t&&e?n.downloadUrl(t.plugin,t.tag,e,"csv"):null)),ce(null)),this.downloadUrlJson$=Et([t.select($T,e.cardId),this.selectedRunId$]).pipe(ft((([t,e])=>t&&e?n.downloadUrl(t.plugin,t.tag,e,"json"):null)),ce(null)),this.runs$=Et([t.select(ND),t.select(QT,e.cardId)]).pipe(ft((([t,n])=>n?Object.keys(n).map((n=>t.get(n))).filter(Boolean):[])))}}$$.ɵfac=function t(n){return new(n||$$)(Zg(cv),Zg(_T),Zg(sB))},$$.ɵcmp=_o({type:$$,selectors:[["data_download_dialog"]],decls:6,vars:15,consts:[[3,"cardMetadata","runs","selectedRunId","downloadUrlCsv","downloadUrlJson","runSelected"]],template:function t(n,e){1&n&&(Kg(0,"data_download_dialog_component",0),cp("runSelected",(function t(n){return e.selectedRunId$.next(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),$g()),2&n&&Jg("cardMetadata",kf(1,5,e.cardMetadata$))("runs",kf(2,7,e.runs$))("selectedRunId",kf(3,9,e.selectedRunId$))("downloadUrlCsv",kf(4,11,e.downloadUrlCsv$))("downloadUrlJson",kf(5,13,e.downloadUrlJson$))},directives:[K$],pipes:[oO],encapsulation:2,changeDetection:0}),(function(t){t[t.ORIGINAL=0]="ORIGINAL",t[t.DERIVED=1]="DERIVED"})(U$||(U$={}));const t0=Math.pow(10,4);class n0{constructor(t){this.host=t,this.ignoreYOutliers=!1,this.smoothingEnabled=!1,this.smoothingWeight=.6,this.tooltipColumns=[],this.tooltipPosition=BT.AUTO,this.tooltipSortingMethod=VT.DEFAULT,this.seriesDataList=[],this.xAxisType=jT.STEP,this.yAxisType=UT.LINEAR,this.element=document.createElement("vz-line-chart2"),this.element.yValueAccessor=t=>t.y,this.element.ignoreYOutliers=this.ignoreYOutliers,this.element.smoothingEnabled=this.smoothingEnabled,this.element.smoothingWeight=this.smoothingWeight,this.element.tooltipColumns=this.tooltipColumns,this.element.tooltipPosition=this.tooltipPosition,this.element.tooltipSortingMethod=this.tooltipSortingMethod,this.element.xType=this.xAxisType,this.element.yScaleType=this.yAxisType}ngOnInit(){this.host.nativeElement.appendChild(this.element)}ngOnChanges(t){const n=this.element.isDataFitToDomain();t.colorScale&&this.colorScale&&(this.element.colorScale={scale:this.colorScale}),t.defaultXRange&&(this.element.defaultXRange=this.defaultXRange),t.defaultYRange&&(this.element.defaultYRange=this.defaultYRange),t.ignoreYOutliers&&(this.element.ignoreYOutliers=this.ignoreYOutliers),t.smoothingEnabled&&(this.element.smoothingEnabled=this.smoothingEnabled),t.smoothingWeight&&(this.element.smoothingWeight=this.smoothingWeight),t.tooltipColumns&&(this.element.tooltipColumns=this.tooltipColumns),t.tooltipPosition&&(this.element.tooltipPosition=this.tooltipPosition),t.tooltipSortingMethod&&(this.element.tooltipSortingMethod=this.tooltipSortingMethod),t.xAxisType&&(this.element.xType=this.xAxisType),t.yAxisType&&(this.element.yScaleType=this.yAxisType),this.shouldUpdateSeriesData(t)&&this.updateSeriesData(),n&&(t.seriesDataList||t.smoothingEnabled||t.smoothingWeight&&this.smoothingEnabled)&&this.element.resetDomain(),this.element.redraw()}shouldUpdateSeriesData(t){if(t.seriesDataList)return!0;const n=t.xAxisType?t.xAxisType.previousValue:null;return!(!n||this.isWallTimeBased(n)===this.isWallTimeBased(this.xAxisType))}updateSeriesData(){for(const t of this.seriesDataList){const{seriesId:n,metadata:e,points:a}=t,o=this.formatByXAxisType(a);this.element.setSeriesData(n,o),this.element.setSeriesMetadata(n,e)}const t=this.seriesDataList.filter((t=>t.visible)).map((({seriesId:t})=>t));this.element.setVisibleSeries(t),this.element.commitChanges()}isWallTimeBased(t){return t===jT.WALL_TIME||t===jT.RELATIVE}formatByXAxisType(t){return t.map((t=>this.isWallTimeBased(this.xAxisType)?Object.assign(Object.assign({},t),{wall_time:new Date(1e3*t.x)}):Object.assign(Object.assign({},t),{step:t.x})))}resetDomain(){this.element.resetDomain()}redraw(){this.element.redraw()}}function e0(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function a0(t){return 1===t.length&&(t=(function n(t){return function(n,e){return e0(t(n),e)}})(t)),{left:function(n,e,a,o){for(null==a&&(a=0),null==o&&(o=n.length);a<o;){var r=a+o>>>1;t(n[r],e)<0?a=r+1:o=r}return a},right:function(n,e,a,o){for(null==a&&(a=0),null==o&&(o=n.length);a<o;){var r=a+o>>>1;t(n[r],e)>0?o=r:a=r+1}return a}}}n0.ɵfac=function t(n){return new(n||n0)(Zg(xu))},n0.ɵcmp=_o({type:n0,selectors:[["tb-line-chart"]],inputs:{colorScale:"colorScale",defaultXRange:"defaultXRange",defaultYRange:"defaultYRange",ignoreYOutliers:"ignoreYOutliers",smoothingEnabled:"smoothingEnabled",smoothingWeight:"smoothingWeight",tooltipColumns:"tooltipColumns",tooltipPosition:"tooltipPosition",tooltipSortingMethod:"tooltipSortingMethod",seriesDataList:"seriesDataList",xAxisType:"xAxisType",yAxisType:"yAxisType"},features:[pr],decls:0,vars:0,template:function t(n,e){},styles:["\n      tb-line-chart > vz-line-chart2 {\n        height: 100%;\n      }\n    "],encapsulation:2});var o0=a0(e0).right;function r0(t,n){var e,a,o,r=t.length,i=-1;if(null==n){for(;++i<r;)if(null!=(e=t[i])&&e>=e)for(a=o=e;++i<r;)null!=(e=t[i])&&(a>e&&(a=e),o<e&&(o=e))}else for(;++i<r;)if(null!=(e=n(t[i],i,t))&&e>=e)for(a=o=e;++i<r;)null!=(e=n(t[i],i,t))&&(a>e&&(a=e),o<e&&(o=e));return[a,o]}var i0=Array.prototype.slice;function c0(t){return function(){return t}}function s0(t){return t}function l0(t,n,e){t=+t,n=+n,e=(o=arguments.length)<2?(n=t,t=0,1):o<3?1:+e;for(var a=-1,o=0|Math.max(0,Math.ceil((n-t)/e)),r=new Array(o);++a<o;)r[a]=t+a*e;return r}var m0=Math.sqrt(50),d0=Math.sqrt(10),g0=Math.sqrt(2);function p0(t,n,e){var a,o,r,i,c=-1;if(e=+e,(t=+t)==(n=+n)&&e>0)return[t];if((a=n<t)&&(o=t,t=n,n=o),0===(i=b0(t,n,e))||!isFinite(i))return[];if(i>0)for(t=Math.ceil(t/i),n=Math.floor(n/i),r=new Array(o=Math.ceil(n-t+1));++c<o;)r[c]=(t+c)*i;else for(t=Math.floor(t*i),n=Math.ceil(n*i),r=new Array(o=Math.ceil(t-n+1));++c<o;)r[c]=(t-c)/i;return a&&r.reverse(),r}function b0(t,n,e){var a=(n-t)/Math.max(0,e),o=Math.floor(Math.log(a)/Math.LN10),r=a/Math.pow(10,o);return o>=0?(r>=m0?10:r>=d0?5:r>=g0?2:1)*Math.pow(10,o):-Math.pow(10,-o)/(r>=m0?10:r>=d0?5:r>=g0?2:1)}function u0(t,n,e){var a=Math.abs(n-t)/Math.max(0,e),o=Math.pow(10,Math.floor(Math.log(a)/Math.LN10)),r=a/o;return r>=m0?o*=10:r>=d0?o*=5:r>=g0&&(o*=2),n<t?-o:o}function f0(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function h0(){var t=s0,n=r0,e=f0;function a(a){var o,r,i=a.length,c=new Array(i);for(o=0;o<i;++o)c[o]=t(a[o],o,a);var s=n(c),l=s[0],m=s[1],d=e(c,l,m);Array.isArray(d)||(d=u0(l,m,d),d=l0(Math.ceil(l/d)*d,m,d));for(var g=d.length;d[0]<=l;)d.shift(),--g;for(;d[g-1]>m;)d.pop(),--g;var p,b=new Array(g+1);for(o=0;o<=g;++o)(p=b[o]=[]).x0=o>0?d[o-1]:l,p.x1=o<g?d[o]:m;for(o=0;o<i;++o)l<=(r=c[o])&&r<=m&&b[o0(d,r,0,g)].push(a[o]);return b}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:c0(n),a):t},a.domain=function(t){return arguments.length?(n="function"==typeof t?t:c0([t[0],t[1]]),a):n},a.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?c0(i0.call(t)):c0(t),a):e},a}var _0=Array.prototype.slice;function C0(t){return t}var M0=1e-6;function O0(t){return"translate("+(t+.5)+",0)"}function P0(t){return"translate(0,"+(t+.5)+")"}function x0(t){return function(n){return+t(n)}}function y0(t){var n=Math.max(0,t.bandwidth()-1)/2;return t.round()&&(n=Math.round(n)),function(e){return+t(e)+n}}function k0(){return!this.__axis}function v0(t,n){var e=[],a=null,o=null,r=6,i=6,c=3,s=1===t||4===t?-1:1,l=4===t||2===t?"x":"y",m=1===t||3===t?O0:P0;function d(d){var g=null==a?n.ticks?n.ticks.apply(n,e):n.domain():a,p=null==o?n.tickFormat?n.tickFormat.apply(n,e):C0:o,b=Math.max(r,0)+c,u=n.range(),f=+u[0]+.5,h=+u[u.length-1]+.5,_=(n.bandwidth?y0:x0)(n.copy()),C=d.selection?d.selection():d,M=C.selectAll(".domain").data([null]),O=C.selectAll(".tick").data(g,n).order(),P=O.exit(),x=O.enter().append("g").attr("class","tick"),y=O.select("line"),k=O.select("text");M=M.merge(M.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),O=O.merge(x),y=y.merge(x.append("line").attr("stroke","currentColor").attr(l+"2",s*r)),k=k.merge(x.append("text").attr("fill","currentColor").attr(l,s*b).attr("dy",1===t?"0em":3===t?"0.71em":"0.32em")),d!==C&&(M=M.transition(d),O=O.transition(d),y=y.transition(d),k=k.transition(d),P=P.transition(d).attr("opacity",M0).attr("transform",(function(t){return isFinite(t=_(t))?m(t):this.getAttribute("transform")})),x.attr("opacity",M0).attr("transform",(function(t){var n=this.parentNode.__axis;return m(n&&isFinite(n=n(t))?n:_(t))}))),P.remove(),M.attr("d",4===t||2==t?i?"M"+s*i+","+f+"H0.5V"+h+"H"+s*i:"M0.5,"+f+"V"+h:i?"M"+f+","+s*i+"V0.5H"+h+"V"+s*i:"M"+f+",0.5H"+h),O.attr("opacity",1).attr("transform",(function(t){return m(_(t))})),y.attr(l+"2",s*r),k.attr(l,s*b).text(p),C.filter(k0).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",2===t?"start":4===t?"end":"middle"),C.each((function(){this.__axis=_}))}return d.scale=function(t){return arguments.length?(n=t,d):n},d.ticks=function(){return e=_0.call(arguments),d},d.tickArguments=function(t){return arguments.length?(e=null==t?[]:_0.call(t),d):e.slice()},d.tickValues=function(t){return arguments.length?(a=null==t?null:_0.call(t),d):a&&a.slice()},d.tickFormat=function(t){return arguments.length?(o=t,d):o},d.tickSize=function(t){return arguments.length?(r=i=+t,d):r},d.tickSizeInner=function(t){return arguments.length?(r=+t,d):r},d.tickSizeOuter=function(t){return arguments.length?(i=+t,d):i},d.tickPadding=function(t){return arguments.length?(c=+t,d):c},d}var w0={value:function(){}};function S0(){for(var t,n=0,e=arguments.length,a={};n<e;++n){if(!(t=arguments[n]+"")||t in a||/[\s.]/.test(t))throw new Error("illegal type: "+t);a[t]=[]}return new E0(a)}function E0(t){this._=t}function A0(t,n){return t.trim().split(/^|\s+/).map((function(t){var e="",a=t.indexOf(".");if(a>=0&&(e=t.slice(a+1),t=t.slice(0,a)),t&&!n.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:e}}))}function z0(t,n){for(var e,a=0,o=t.length;a<o;++a)if((e=t[a]).name===n)return e.value}function R0(t,n,e){for(var a=0,o=t.length;a<o;++a)if(t[a].name===n){t[a]=w0,t=t.slice(0,a).concat(t.slice(a+1));break}return null!=e&&t.push({name:n,value:e}),t}E0.prototype=S0.prototype={constructor:E0,on:function(t,n){var e,a=this._,o=A0(t+"",a),r=-1,i=o.length;if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++r<i;)if(e=(t=o[r]).type)a[e]=R0(a[e],t.name,n);else if(null==n)for(e in a)a[e]=R0(a[e],t.name,null);return this}for(;++r<i;)if((e=(t=o[r]).type)&&(e=z0(a[e],t.name)))return e},copy:function(){var t={},n=this._;for(var e in n)t[e]=n[e].slice();return new E0(t)},call:function(t,n){if((e=arguments.length-2)>0)for(var e,a,o=new Array(e),r=0;r<e;++r)o[r]=arguments[r+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(r=0,e=(a=this._[t]).length;r<e;++r)a[r].value.apply(n,o)},apply:function(t,n,e){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var a=this._[t],o=0,r=a.length;o<r;++o)a[o].value.apply(n,e)}};var T0="http://www.w3.org/1999/xhtml",D0={svg:"http://www.w3.org/2000/svg",xhtml:T0,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function I0(t){var n=t+="",e=n.indexOf(":");return e>=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),D0.hasOwnProperty(n)?{space:D0[n],local:t}:t}function N0(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===T0&&n.documentElement.namespaceURI===T0?n.createElement(t):n.createElementNS(e,t)}}function F0(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function L0(t){var n=I0(t);return(n.local?F0:N0)(n)}function H0(){}function B0(t){return null==t?H0:function(){return this.querySelector(t)}}function V0(){return[]}function j0(t){return null==t?V0:function(){return this.querySelectorAll(t)}}function U0(t){return function(){return this.matches(t)}}function W0(t){return new Array(t.length)}function G0(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}function Y0(t,n,e,a,o,r){for(var i,c=0,s=n.length,l=r.length;c<l;++c)(i=n[c])?(i.__data__=r[c],a[c]=i):e[c]=new G0(t,r[c]);for(;c<s;++c)(i=n[c])&&(o[c]=i)}function q0(t,n,e,a,o,r,i){var c,s,l,m={},d=n.length,g=r.length,p=new Array(d);for(c=0;c<d;++c)(s=n[c])&&(p[c]=l="$"+i.call(s,s.__data__,c,n),l in m?o[c]=s:m[l]=s);for(c=0;c<g;++c)(s=m[l="$"+i.call(t,r[c],c,r)])?(a[c]=s,s.__data__=r[c],m[l]=null):e[c]=new G0(t,r[c]);for(c=0;c<d;++c)(s=n[c])&&m[p[c]]===s&&(o[c]=s)}function Z0(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function X0(t){return function(){this.removeAttribute(t)}}function J0(t){return function(){this.removeAttributeNS(t.space,t.local)}}function Q0(t,n){return function(){this.setAttribute(t,n)}}function K0(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}function $0(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}function t1(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}function n1(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function e1(t){return function(){this.style.removeProperty(t)}}function a1(t,n,e){return function(){this.style.setProperty(t,n,e)}}function o1(t,n,e){return function(){var a=n.apply(this,arguments);null==a?this.style.removeProperty(t):this.style.setProperty(t,a,e)}}function r1(t,n){return t.style.getPropertyValue(n)||n1(t).getComputedStyle(t,null).getPropertyValue(n)}function i1(t){return function(){delete this[t]}}function c1(t,n){return function(){this[t]=n}}function s1(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}function l1(t){return t.trim().split(/^|\s+/)}function m1(t){return t.classList||new d1(t)}function d1(t){this._node=t,this._names=l1(t.getAttribute("class")||"")}function g1(t,n){for(var e=m1(t),a=-1,o=n.length;++a<o;)e.add(n[a])}function p1(t,n){for(var e=m1(t),a=-1,o=n.length;++a<o;)e.remove(n[a])}function b1(t){return function(){g1(this,t)}}function u1(t){return function(){p1(this,t)}}function f1(t,n){return function(){(n.apply(this,arguments)?g1:p1)(this,t)}}function h1(){this.textContent=""}function _1(t){return function(){this.textContent=t}}function C1(t){return function(){var n=t.apply(this,arguments);this.textContent=null==n?"":n}}function M1(){this.innerHTML=""}function O1(t){return function(){this.innerHTML=t}}function P1(t){return function(){var n=t.apply(this,arguments);this.innerHTML=null==n?"":n}}function x1(){this.nextSibling&&this.parentNode.appendChild(this)}function y1(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function k1(){return null}function v1(){var t=this.parentNode;t&&t.removeChild(this)}function w1(){var t=this.cloneNode(!1),n=this.parentNode;return n?n.insertBefore(t,this.nextSibling):t}function S1(){var t=this.cloneNode(!0),n=this.parentNode;return n?n.insertBefore(t,this.nextSibling):t}G0.prototype={constructor:G0,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,n){return this._parent.insertBefore(t,n)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},d1.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var n=this._names.indexOf(t);n>=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var E1={},A1=null;function z1(t,n,e){return t=R1(t,n,e),function(n){var e=n.relatedTarget;e&&(e===this||8&e.compareDocumentPosition(this))||t.call(this,n)}}function R1(t,n,e){return function(a){var o=A1;A1=a;try{t.call(this,this.__data__,n,e)}finally{A1=o}}}function T1(t){return t.trim().split(/^|\s+/).map((function(t){var n="",e=t.indexOf(".");return e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}}))}function D1(t){return function(){var n=this.__on;if(n){for(var e,a=0,o=-1,r=n.length;a<r;++a)e=n[a],t.type&&e.type!==t.type||e.name!==t.name?n[++o]=e:this.removeEventListener(e.type,e.listener,e.capture);++o?n.length=o:delete this.__on}}}function I1(t,n,e){var a=E1.hasOwnProperty(t.type)?z1:R1;return function(o,r,i){var c,s=this.__on,l=a(n,r,i);if(s)for(var m=0,d=s.length;m<d;++m)if((c=s[m]).type===t.type&&c.name===t.name)return this.removeEventListener(c.type,c.listener,c.capture),this.addEventListener(c.type,c.listener=l,c.capture=e),void(c.value=n);this.addEventListener(t.type,l,e),c={type:t.type,name:t.name,value:n,listener:l,capture:e},s?s.push(c):this.__on=[c]}}function N1(t,n,e){var a=n1(t),o=a.CustomEvent;"function"==typeof o?o=new o(n,e):(o=a.document.createEvent("Event"),e?(o.initEvent(n,e.bubbles,e.cancelable),o.detail=e.detail):o.initEvent(n,!1,!1)),t.dispatchEvent(o)}function F1(t,n){return function(){return N1(this,t,n)}}function L1(t,n){return function(){return N1(this,t,n.apply(this,arguments))}}"undefined"!=typeof document&&("onmouseenter"in document.documentElement||(E1={mouseenter:"mouseover",mouseleave:"mouseout"}));var H1=[null];function B1(t,n){this._groups=t,this._parents=n}function V1(){return new B1([[document.documentElement]],H1)}function j1(t){return"string"==typeof t?new B1([[document.querySelector(t)]],[document.documentElement]):new B1([[t]],H1)}function U1(){for(var t,n=A1;t=n.sourceEvent;)n=t;return n}function W1(t,n){var e=t.ownerSVGElement||t;if(e.createSVGPoint){var a=e.createSVGPoint();return a.x=n.clientX,a.y=n.clientY,[(a=a.matrixTransform(t.getScreenCTM().inverse())).x,a.y]}var o=t.getBoundingClientRect();return[n.clientX-o.left-t.clientLeft,n.clientY-o.top-t.clientTop]}function G1(t){var n=U1();return n.changedTouches&&(n=n.changedTouches[0]),W1(t,n)}function Y1(){A1.preventDefault(),A1.stopImmediatePropagation()}function q1(t){var n=t.document.documentElement,e=j1(t).on("dragstart.drag",Y1,!0);"onselectstart"in n?e.on("selectstart.drag",Y1,!0):(n.__noselect=n.style.MozUserSelect,n.style.MozUserSelect="none")}function Z1(t,n){var e=t.document.documentElement,a=j1(t).on("dragstart.drag",null);n&&(a.on("click.drag",Y1,!0),setTimeout((function(){a.on("click.drag",null)}),0)),"onselectstart"in e?a.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}function X1(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function J1(t,n){var e=Object.create(t.prototype);for(var a in n)e[a]=n[a];return e}function Q1(){}B1.prototype=V1.prototype={constructor:B1,select:function K1(t){"function"!=typeof t&&(t=B0(t));for(var n=this._groups,e=n.length,a=new Array(e),o=0;o<e;++o)for(var r,i,c=n[o],s=c.length,l=a[o]=new Array(s),m=0;m<s;++m)(r=c[m])&&(i=t.call(r,r.__data__,m,c))&&("__data__"in r&&(i.__data__=r.__data__),l[m]=i);return new B1(a,this._parents)},selectAll:function $1(t){"function"!=typeof t&&(t=j0(t));for(var n=this._groups,e=n.length,a=[],o=[],r=0;r<e;++r)for(var i,c=n[r],s=c.length,l=0;l<s;++l)(i=c[l])&&(a.push(t.call(i,i.__data__,l,c)),o.push(i));return new B1(a,o)},filter:function t2(t){"function"!=typeof t&&(t=U0(t));for(var n=this._groups,e=n.length,a=new Array(e),o=0;o<e;++o)for(var r,i=n[o],c=i.length,s=a[o]=[],l=0;l<c;++l)(r=i[l])&&t.call(r,r.__data__,l,i)&&s.push(r);return new B1(a,this._parents)},data:function n2(t,n){if(!t)return b=new Array(this.size()),m=-1,this.each((function(t){b[++m]=t})),b;var e=n?q0:Y0,a=this._parents,o=this._groups;"function"!=typeof t&&(t=(function r(t){return function(){return t}})(t));for(var i=o.length,c=new Array(i),s=new Array(i),l=new Array(i),m=0;m<i;++m){var d=a[m],g=o[m],p=g.length,b=t.call(d,d&&d.__data__,m,a),u=b.length,f=s[m]=new Array(u),h=c[m]=new Array(u);e(d,g,f,h,l[m]=new Array(p),b,n);for(var _,C,M=0,O=0;M<u;++M)if(_=f[M]){for(M>=O&&(O=M+1);!(C=h[O])&&++O<u;);_._next=C||null}}return(c=new B1(c,a))._enter=s,c._exit=l,c},enter:function e2(){return new B1(this._enter||this._groups.map(W0),this._parents)},exit:function a2(){return new B1(this._exit||this._groups.map(W0),this._parents)},join:function o2(t,n,e){var a=this.enter(),o=this,r=this.exit();return a="function"==typeof t?t(a):a.append(t+""),null!=n&&(o=n(o)),null==e?r.remove():e(r),a&&o?a.merge(o).order():o},merge:function r2(t){for(var n=this._groups,e=t._groups,a=n.length,o=Math.min(a,e.length),r=new Array(a),i=0;i<o;++i)for(var c,s=n[i],l=e[i],m=s.length,d=r[i]=new Array(m),g=0;g<m;++g)(c=s[g]||l[g])&&(d[g]=c);for(;i<a;++i)r[i]=n[i];return new B1(r,this._parents)},order:function i2(){for(var t=this._groups,n=-1,e=t.length;++n<e;)for(var a,o=t[n],r=o.length-1,i=o[r];--r>=0;)(a=o[r])&&(i&&4^a.compareDocumentPosition(i)&&i.parentNode.insertBefore(a,i),i=a);return this},sort:function c2(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=Z0);for(var e=this._groups,a=e.length,o=new Array(a),r=0;r<a;++r){for(var i,c=e[r],s=c.length,l=o[r]=new Array(s),m=0;m<s;++m)(i=c[m])&&(l[m]=i);l.sort(n)}return new B1(o,this._parents).order()},call:function s2(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function l2(){var t=new Array(this.size()),n=-1;return this.each((function(){t[++n]=this})),t},node:function m2(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var a=t[n],o=0,r=a.length;o<r;++o){var i=a[o];if(i)return i}return null},size:function d2(){var t=0;return this.each((function(){++t})),t},empty:function g2(){return!this.node()},each:function p2(t){for(var n=this._groups,e=0,a=n.length;e<a;++e)for(var o,r=n[e],i=0,c=r.length;i<c;++i)(o=r[i])&&t.call(o,o.__data__,i,r);return this},attr:function b2(t,n){var e=I0(t);if(arguments.length<2){var a=this.node();return e.local?a.getAttributeNS(e.space,e.local):a.getAttribute(e)}return this.each((null==n?e.local?J0:X0:"function"==typeof n?e.local?t1:$0:e.local?K0:Q0)(e,n))},style:function u2(t,n,e){return arguments.length>1?this.each((null==n?e1:"function"==typeof n?o1:a1)(t,n,null==e?"":e)):r1(this.node(),t)},property:function f2(t,n){return arguments.length>1?this.each((null==n?i1:"function"==typeof n?s1:c1)(t,n)):this.node()[t]},classed:function h2(t,n){var e=l1(t+"");if(arguments.length<2){for(var a=m1(this.node()),o=-1,r=e.length;++o<r;)if(!a.contains(e[o]))return!1;return!0}return this.each(("function"==typeof n?f1:n?b1:u1)(e,n))},text:function _2(t){return arguments.length?this.each(null==t?h1:("function"==typeof t?C1:_1)(t)):this.node().textContent},html:function C2(t){return arguments.length?this.each(null==t?M1:("function"==typeof t?P1:O1)(t)):this.node().innerHTML},raise:function M2(){return this.each(x1)},lower:function O2(){return this.each(y1)},append:function P2(t){var n="function"==typeof t?t:L0(t);return this.select((function(){return this.appendChild(n.apply(this,arguments))}))},insert:function x2(t,n){var e="function"==typeof t?t:L0(t),a=null==n?k1:"function"==typeof n?n:B0(n);return this.select((function(){return this.insertBefore(e.apply(this,arguments),a.apply(this,arguments)||null)}))},remove:function y2(){return this.each(v1)},clone:function k2(t){return this.select(t?S1:w1)},datum:function v2(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function w2(t,n,e){var a,o,r=T1(t+""),i=r.length;if(!(arguments.length<2)){for(c=n?I1:D1,null==e&&(e=!1),a=0;a<i;++a)this.each(c(r[a],n,e));return this}var c=this.node().__on;if(c)for(var s,l=0,m=c.length;l<m;++l)for(a=0,s=c[l];a<i;++a)if((o=r[a]).type===s.type&&o.name===s.name)return s.value},dispatch:function S2(t,n){return this.each(("function"==typeof n?L1:F1)(t,n))}};var E2=.7,A2=1/E2,z2="\\s*([+-]?\\d+)\\s*",R2="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",T2="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",D2=/^#([0-9a-f]{3,8})$/,I2=new RegExp("^rgb\\("+[z2,z2,z2]+"\\)$"),N2=new RegExp("^rgb\\("+[T2,T2,T2]+"\\)$"),F2=new RegExp("^rgba\\("+[z2,z2,z2,R2]+"\\)$"),L2=new RegExp("^rgba\\("+[T2,T2,T2,R2]+"\\)$"),H2=new RegExp("^hsl\\("+[R2,T2,T2]+"\\)$"),B2=new RegExp("^hsla\\("+[R2,T2,T2,R2]+"\\)$"),V2={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function j2(){return this.rgb().formatHex()}function U2(){return this.rgb().formatRgb()}function W2(t){var n,e;return t=(t+"").trim().toLowerCase(),(n=D2.exec(t))?(e=n[1].length,n=parseInt(n[1],16),6===e?G2(n):3===e?new X2(n>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):8===e?Y2(n>>24&255,n>>16&255,n>>8&255,(255&n)/255):4===e?Y2(n>>12&15|n>>8&240,n>>8&15|n>>4&240,n>>4&15|240&n,((15&n)<<4|15&n)/255):null):(n=I2.exec(t))?new X2(n[1],n[2],n[3],1):(n=N2.exec(t))?new X2(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=F2.exec(t))?Y2(n[1],n[2],n[3],n[4]):(n=L2.exec(t))?Y2(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=H2.exec(t))?$2(n[1],n[2]/100,n[3]/100,1):(n=B2.exec(t))?$2(n[1],n[2]/100,n[3]/100,n[4]):V2.hasOwnProperty(t)?G2(V2[t]):"transparent"===t?new X2(NaN,NaN,NaN,0):null}function G2(t){return new X2(t>>16&255,t>>8&255,255&t,1)}function Y2(t,n,e,a){return a<=0&&(t=n=e=NaN),new X2(t,n,e,a)}function q2(t){return t instanceof Q1||(t=W2(t)),t?new X2((t=t.rgb()).r,t.g,t.b,t.opacity):new X2}function Z2(t,n,e,a){return 1===arguments.length?q2(t):new X2(t,n,e,null==a?1:a)}function X2(t,n,e,a){this.r=+t,this.g=+n,this.b=+e,this.opacity=+a}function J2(){return"#"+K2(this.r)+K2(this.g)+K2(this.b)}function Q2(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}function K2(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function $2(t,n,e,a){return a<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new e5(t,n,e,a)}function t5(t){if(t instanceof e5)return new e5(t.h,t.s,t.l,t.opacity);if(t instanceof Q1||(t=W2(t)),!t)return new e5;if(t instanceof e5)return t;var n=(t=t.rgb()).r/255,e=t.g/255,a=t.b/255,o=Math.min(n,e,a),r=Math.max(n,e,a),i=NaN,c=r-o,s=(r+o)/2;return c?(i=n===r?(e-a)/c+6*(e<a):e===r?(a-n)/c+2:(n-e)/c+4,c/=s<.5?r+o:2-r-o,i*=60):c=s>0&&s<1?0:i,new e5(i,c,s,t.opacity)}function n5(t,n,e,a){return 1===arguments.length?t5(t):new e5(t,n,e,null==a?1:a)}function e5(t,n,e,a){this.h=+t,this.s=+n,this.l=+e,this.opacity=+a}function a5(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}function o5(t){return function(){return t}}function r5(t,n){return function(e){return t+e*n}}function i5(t,n){var e=n-t;return e?r5(t,e):o5(isNaN(t)?n:t)}X1(Q1,W2,{copy:function(t){return Object.assign(new this.constructor,this,t)},displayable:function(){return this.rgb().displayable()},hex:j2,formatHex:j2,formatHsl:function c5(){return t5(this).formatHsl()},formatRgb:U2,toString:U2}),X1(X2,Z2,J1(Q1,{brighter:function(t){return t=null==t?A2:Math.pow(A2,t),new X2(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?E2:Math.pow(E2,t),new X2(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:J2,formatHex:J2,formatRgb:Q2,toString:Q2})),X1(e5,n5,J1(Q1,{brighter:function(t){return t=null==t?A2:Math.pow(A2,t),new e5(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?E2:Math.pow(E2,t),new e5(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,a=e+(e<.5?e:1-e)*n,o=2*e-a;return new X2(a5(t>=240?t-240:t+120,o,a),a5(t,o,a),a5(t<120?t+240:t-120,o,a),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"hsl(":"hsla(")+(this.h||0)+", "+100*(this.s||0)+"%, "+100*(this.l||0)+"%"+(1===t?")":", "+t+")")}}));var s5=(function t(n){var e=(function a(t){return 1==(t=+t)?i5:function(n,e){return e-n?(function a(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(a){return Math.pow(t+a*n,e)}})(n,e,t):o5(isNaN(n)?e:n)}})(n);function o(t,n){var a=e((t=Z2(t)).r,(n=Z2(n)).r),o=e(t.g,n.g),r=e(t.b,n.b),i=i5(t.opacity,n.opacity);return function(n){return t.r=a(n),t.g=o(n),t.b=r(n),t.opacity=i(n),t+""}}return o.gamma=t,o})(1),l5=(function d5(t){return function(n){var e,a,o=n.length,r=new Array(o),i=new Array(o),c=new Array(o);for(e=0;e<o;++e)a=Z2(n[e]),r[e]=a.r||0,i[e]=a.g||0,c[e]=a.b||0;return r=t(r),i=t(i),c=t(c),a.opacity=1,function(t){return a.r=r(t),a.g=i(t),a.b=c(t),a+""}}})((function m5(t){var n=t.length-1;return function(e){var a=e<=0?e=0:e>=1?(e=1,n-1):Math.floor(e*n),o=t[a],r=t[a+1];return(function i(t,n,e,a,o){var r=t*t,i=r*t;return((1-3*t+3*r-i)*n+(4-6*r+3*i)*e+(1+3*t+3*r-3*i)*a+i*o)/6})((e-a/n)*n,a>0?t[a-1]:2*o-r,o,r,a<n-1?t[a+2]:2*r-o)}}));function g5(t,n){n||(n=[]);var e,a=t?Math.min(n.length,t.length):0,o=n.slice();return function(r){for(e=0;e<a;++e)o[e]=t[e]*(1-r)+n[e]*r;return o}}function p5(t,n){var e,a=n?n.length:0,o=t?Math.min(a,t.length):0,r=new Array(o),i=new Array(a);for(e=0;e<o;++e)r[e]=M5(t[e],n[e]);for(;e<a;++e)i[e]=n[e];return function(t){for(e=0;e<o;++e)i[e]=r[e](t);return i}}function b5(t,n){var e=new Date;return t=+t,n=+n,function(a){return e.setTime(t*(1-a)+n*a),e}}function u5(t,n){return t=+t,n=+n,function(e){return t*(1-e)+n*e}}function f5(t,n){var e,a={},o={};for(e in null!==t&&"object"==typeof t||(t={}),null!==n&&"object"==typeof n||(n={}),n)e in t?a[e]=M5(t[e],n[e]):o[e]=n[e];return function(t){for(e in a)o[e]=a[e](t);return o}}var h5=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,_5=new RegExp(h5.source,"g");function C5(t,n){var e,a,o,r=h5.lastIndex=_5.lastIndex=0,i=-1,c=[],s=[];for(t+="",n+="";(e=h5.exec(t))&&(a=_5.exec(n));)(o=a.index)>r&&(o=n.slice(r,o),c[i]?c[i]+=o:c[++i]=o),(e=e[0])===(a=a[0])?c[i]?c[i]+=a:c[++i]=a:(c[++i]=null,s.push({i:i,x:u5(e,a)})),r=_5.lastIndex;return r<n.length&&(o=n.slice(r),c[i]?c[i]+=o:c[++i]=o),c.length<2?s[0]?(function l(t){return function(n){return t(n)+""}})(s[0].x):(function m(t){return function(){return t}})(n):(n=s.length,function(t){for(var e,a=0;a<n;++a)c[(e=s[a]).i]=e.x(t);return c.join("")})}function M5(t,n){var e,a=typeof n;return null==n||"boolean"===a?o5(n):("number"===a?u5:"string"===a?(e=W2(n))?(n=e,s5):C5:n instanceof W2?s5:n instanceof Date?b5:(function o(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)})(n)?g5:Array.isArray(n)?p5:"function"!=typeof n.valueOf&&"function"!=typeof n.toString||isNaN(n)?f5:u5)(t,n)}function O5(t,n){return t=+t,n=+n,function(e){return Math.round(t*(1-e)+n*e)}}var P5,x5,y5,k5,v5=180/Math.PI,w5={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function S5(t,n,e,a,o,r){var i,c,s;return(i=Math.sqrt(t*t+n*n))&&(t/=i,n/=i),(s=t*e+n*a)&&(e-=t*s,a-=n*s),(c=Math.sqrt(e*e+a*a))&&(e/=c,a/=c,s/=c),t*a<n*e&&(t=-t,n=-n,s=-s,i=-i),{translateX:o,translateY:r,rotate:Math.atan2(n,t)*v5,skewX:Math.atan(s)*v5,scaleX:i,scaleY:c}}function E5(t,n,e,a){function o(t){return t.length?t.pop()+" ":""}return function(r,i){var c=[],s=[];return r=t(r),i=t(i),(function l(t,a,o,r,i,c){if(t!==o||a!==r){var s=i.push("translate(",null,n,null,e);c.push({i:s-4,x:u5(t,o)},{i:s-2,x:u5(a,r)})}else(o||r)&&i.push("translate("+o+n+r+e)})(r.translateX,r.translateY,i.translateX,i.translateY,c,s),(function m(t,n,e,r){t!==n?(t-n>180?n+=360:n-t>180&&(t+=360),r.push({i:e.push(o(e)+"rotate(",null,a)-2,x:u5(t,n)})):n&&e.push(o(e)+"rotate("+n+a)})(r.rotate,i.rotate,c,s),(function d(t,n,e,r){t!==n?r.push({i:e.push(o(e)+"skewX(",null,a)-2,x:u5(t,n)}):n&&e.push(o(e)+"skewX("+n+a)})(r.skewX,i.skewX,c,s),(function g(t,n,e,a,r,i){if(t!==e||n!==a){var c=r.push(o(r)+"scale(",null,",",null,")");i.push({i:c-4,x:u5(t,e)},{i:c-2,x:u5(n,a)})}else 1===e&&1===a||r.push(o(r)+"scale("+e+","+a+")")})(r.scaleX,r.scaleY,i.scaleX,i.scaleY,c,s),r=i=null,function(t){for(var n,e=-1,a=s.length;++e<a;)c[(n=s[e]).i]=n.x(t);return c.join("")}}}var A5,z5,R5=E5((function T5(t){return"none"===t?w5:(P5||(P5=document.createElement("DIV"),x5=document.documentElement,y5=document.defaultView),P5.style.transform=t,t=y5.getComputedStyle(x5.appendChild(P5),null).getPropertyValue("transform"),x5.removeChild(P5),S5(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))}),"px, ","px)","deg)"),D5=E5((function I5(t){return null==t?w5:(k5||(k5=document.createElementNS("http://www.w3.org/2000/svg","g")),k5.setAttribute("transform",t),(t=k5.transform.baseVal.consolidate())?S5((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):w5)}),", ",")",")"),N5=(function L5(t){return function(n,e){var a=t((n=n5(n)).h,(e=n5(e)).h),o=i5(n.s,e.s),r=i5(n.l,e.l),i=i5(n.opacity,e.opacity);return function(t){return n.h=a(t),n.s=o(t),n.l=r(t),n.opacity=i(t),n+""}}})((function F5(t,n){var e=n-t;return e?r5(t,e>180||e<-180?e-360*Math.round(e/360):e):o5(isNaN(t)?n:t)})),H5=0,B5=0,V5=0,j5=0,U5=0,W5=0,G5="object"==typeof performance&&performance.now?performance:Date,Y5="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function q5(){return U5||(Y5(Z5),U5=G5.now()+W5)}function Z5(){U5=0}function X5(){this._call=this._time=this._next=null}function J5(t,n,e){var a=new X5;return a.restart(t,n,e),a}function Q5(){U5=(j5=G5.now())+W5,H5=B5=0;try{!(function t(){q5(),++H5;for(var t,n=A5;n;)(t=U5-n._time)>=0&&n._call.call(null,t),n=n._next;--H5})()}finally{H5=0,(function n(){for(var t,n,e=A5,a=1/0;e;)e._call?(a>e._time&&(a=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:A5=n);z5=t,$5(a)})(),U5=0}}function K5(){var t=G5.now(),n=t-j5;n>1e3&&(W5-=n,j5=t)}function $5(t){H5||(B5&&(B5=clearTimeout(B5)),t-U5>24?(t<1/0&&(B5=setTimeout(Q5,t-G5.now()-W5)),V5&&(V5=clearInterval(V5))):(V5||(j5=G5.now(),V5=setInterval(K5,1e3)),H5=1,Y5(Q5)))}function t4(t,n,e){var a=new X5;return a.restart((function(e){a.stop(),t(e+n)}),n=null==n?0:+n,e),a}X5.prototype=J5.prototype={constructor:X5,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?q5():+e)+(null==n?0:+n),this._next||z5===this||(z5?z5._next=this:A5=this,z5=this),this._call=t,this._time=e,$5()},stop:function(){this._call&&(this._call=null,this._time=1/0,$5())}};var n4=S0("start","end","cancel","interrupt"),e4=[];function a4(t,n,e,a,o,r){var i=t.__transition;if(i){if(e in i)return}else t.__transition={};!(function c(t,n,e){var a,o=t.__transition;function r(s){var l,m,d,g;if(1!==e.state)return c();for(l in o)if((g=o[l]).name===e.name){if(3===g.state)return t4(r);4===g.state?(g.state=6,g.timer.stop(),g.on.call("interrupt",t,t.__data__,g.index,g.group),delete o[l]):+l<n&&(g.state=6,g.timer.stop(),g.on.call("cancel",t,t.__data__,g.index,g.group),delete o[l])}if(t4((function(){3===e.state&&(e.state=4,e.timer.restart(i,e.delay,e.time),i(s))})),e.state=2,e.on.call("start",t,t.__data__,e.index,e.group),2===e.state){for(e.state=3,a=new Array(d=e.tween.length),l=0,m=-1;l<d;++l)(g=e.tween[l].value.call(t,t.__data__,e.index,e.group))&&(a[++m]=g);a.length=m+1}}function i(n){for(var o=n<e.duration?e.ease.call(null,n/e.duration):(e.timer.restart(c),e.state=5,1),r=-1,i=a.length;++r<i;)a[r].call(t,o);5===e.state&&(e.on.call("end",t,t.__data__,e.index,e.group),c())}function c(){for(var a in e.state=6,e.timer.stop(),delete o[n],o)return;delete t.__transition}o[n]=e,e.timer=J5((function s(t){e.state=1,e.timer.restart(r,e.delay,e.time),e.delay<=t&&r(t-e.delay)}),0,e.time)})(t,e,{name:n,index:a,group:o,on:n4,tween:e4,time:r.time,delay:r.delay,duration:r.duration,ease:r.ease,timer:null,state:0})}function o4(t,n){var e=i4(t,n);if(e.state>0)throw new Error("too late; already scheduled");return e}function r4(t,n){var e=i4(t,n);if(e.state>3)throw new Error("too late; already running");return e}function i4(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function c4(t,n){var e,a,o,r=t.__transition,i=!0;if(r){for(o in n=null==n?null:n+"",r)(e=r[o]).name===n?(a=e.state>2&&e.state<5,e.state=6,e.timer.stop(),e.on.call(a?"interrupt":"cancel",t,t.__data__,e.index,e.group),delete r[o]):i=!1;i&&delete t.__transition}}function s4(t,n){var e,a;return function(){var o=r4(this,t),r=o.tween;if(r!==e)for(var i=0,c=(a=e=r).length;i<c;++i)if(a[i].name===n){(a=a.slice()).splice(i,1);break}o.tween=a}}function l4(t,n,e){var a,o;if("function"!=typeof e)throw new Error;return function(){var r=r4(this,t),i=r.tween;if(i!==a){o=(a=i).slice();for(var c={name:n,value:e},s=0,l=o.length;s<l;++s)if(o[s].name===n){o[s]=c;break}s===l&&o.push(c)}r.tween=o}}function m4(t,n,e){var a=t._id;return t.each((function(){var t=r4(this,a);(t.value||(t.value={}))[n]=e.apply(this,arguments)})),function(t){return i4(t,a).value[n]}}function d4(t,n){var e;return("number"==typeof n?u5:n instanceof W2?s5:(e=W2(n))?(n=e,s5):C5)(t,n)}function g4(t){return function(){this.removeAttribute(t)}}function p4(t){return function(){this.removeAttributeNS(t.space,t.local)}}function b4(t,n,e){var a,o,r=e+"";return function(){var i=this.getAttribute(t);return i===r?null:i===a?o:o=n(a=i,e)}}function u4(t,n,e){var a,o,r=e+"";return function(){var i=this.getAttributeNS(t.space,t.local);return i===r?null:i===a?o:o=n(a=i,e)}}function f4(t,n,e){var a,o,r;return function(){var i,c,s=e(this);if(null!=s)return(i=this.getAttribute(t))===(c=s+"")?null:i===a&&c===o?r:(o=c,r=n(a=i,s));this.removeAttribute(t)}}function h4(t,n,e){var a,o,r;return function(){var i,c,s=e(this);if(null!=s)return(i=this.getAttributeNS(t.space,t.local))===(c=s+"")?null:i===a&&c===o?r:(o=c,r=n(a=i,s));this.removeAttributeNS(t.space,t.local)}}function _4(t,n){return function(e){this.setAttribute(t,n.call(this,e))}}function C4(t,n){return function(e){this.setAttributeNS(t.space,t.local,n.call(this,e))}}function M4(t,n){var e,a;function o(){var o=n.apply(this,arguments);return o!==a&&(e=(a=o)&&C4(t,o)),e}return o._value=n,o}function O4(t,n){var e,a;function o(){var o=n.apply(this,arguments);return o!==a&&(e=(a=o)&&_4(t,o)),e}return o._value=n,o}function P4(t,n){return function(){o4(this,t).delay=+n.apply(this,arguments)}}function x4(t,n){return n=+n,function(){o4(this,t).delay=n}}function y4(t,n){return function(){r4(this,t).duration=+n.apply(this,arguments)}}function k4(t,n){return n=+n,function(){r4(this,t).duration=n}}function v4(t,n){if("function"!=typeof n)throw new Error;return function(){r4(this,t).ease=n}}function w4(t,n,e){var a,o,r=(function i(t){return(t+"").trim().split(/^|\s+/).every((function(t){var n=t.indexOf(".");return n>=0&&(t=t.slice(0,n)),!t||"start"===t}))})(n)?o4:r4;return function(){var i=r(this,t),c=i.on;c!==a&&(o=(a=c).copy()).on(n,e),i.on=o}}var S4=V1.prototype.constructor;function E4(t){return function(){this.style.removeProperty(t)}}function A4(t,n,e){return function(a){this.style.setProperty(t,n.call(this,a),e)}}function z4(t,n,e){var a,o;function r(){var r=n.apply(this,arguments);return r!==o&&(a=(o=r)&&A4(t,r,e)),a}return r._value=n,r}function R4(t){return function(n){this.textContent=t.call(this,n)}}function T4(t){var n,e;function a(){var a=t.apply(this,arguments);return a!==e&&(n=(e=a)&&R4(a)),n}return a._value=t,a}var D4=0;function I4(t,n,e,a){this._groups=t,this._parents=n,this._name=e,this._id=a}function N4(){return++D4}var F4=V1.prototype;I4.prototype={constructor:I4,select:function L4(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=B0(t));for(var a=this._groups,o=a.length,r=new Array(o),i=0;i<o;++i)for(var c,s,l=a[i],m=l.length,d=r[i]=new Array(m),g=0;g<m;++g)(c=l[g])&&(s=t.call(c,c.__data__,g,l))&&("__data__"in c&&(s.__data__=c.__data__),d[g]=s,a4(d[g],n,e,g,d,i4(c,e)));return new I4(r,this._parents,n,e)},selectAll:function H4(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=j0(t));for(var a=this._groups,o=a.length,r=[],i=[],c=0;c<o;++c)for(var s,l=a[c],m=l.length,d=0;d<m;++d)if(s=l[d]){for(var g,p=t.call(s,s.__data__,d,l),b=i4(s,e),u=0,f=p.length;u<f;++u)(g=p[u])&&a4(g,n,e,u,p,b);r.push(p),i.push(s)}return new I4(r,i,n,e)},filter:function B4(t){"function"!=typeof t&&(t=U0(t));for(var n=this._groups,e=n.length,a=new Array(e),o=0;o<e;++o)for(var r,i=n[o],c=i.length,s=a[o]=[],l=0;l<c;++l)(r=i[l])&&t.call(r,r.__data__,l,i)&&s.push(r);return new I4(a,this._parents,this._name,this._id)},merge:function V4(t){if(t._id!==this._id)throw new Error;for(var n=this._groups,e=t._groups,a=n.length,o=Math.min(a,e.length),r=new Array(a),i=0;i<o;++i)for(var c,s=n[i],l=e[i],m=s.length,d=r[i]=new Array(m),g=0;g<m;++g)(c=s[g]||l[g])&&(d[g]=c);for(;i<a;++i)r[i]=n[i];return new I4(r,this._parents,this._name,this._id)},selection:function j4(){return new S4(this._groups,this._parents)},transition:function U4(){for(var t=this._name,n=this._id,e=N4(),a=this._groups,o=a.length,r=0;r<o;++r)for(var i,c=a[r],s=c.length,l=0;l<s;++l)if(i=c[l]){var m=i4(i,n);a4(i,t,e,l,c,{time:m.time+m.delay+m.duration,delay:0,duration:m.duration,ease:m.ease})}return new I4(a,this._parents,t,e)},call:F4.call,nodes:F4.nodes,node:F4.node,size:F4.size,empty:F4.empty,each:F4.each,on:function W4(t,n){var e=this._id;return arguments.length<2?i4(this.node(),e).on.on(t):this.each(w4(e,t,n))},attr:function G4(t,n){var e=I0(t),a="transform"===e?D5:d4;return this.attrTween(t,"function"==typeof n?(e.local?h4:f4)(e,a,m4(this,"attr."+t,n)):null==n?(e.local?p4:g4)(e):(e.local?u4:b4)(e,a,n))},attrTween:function Y4(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var a=I0(t);return this.tween(e,(a.local?M4:O4)(a,n))},style:function q4(t,n,e){var a="transform"==(t+="")?R5:d4;return null==n?this.styleTween(t,(function o(t,n){var e,a,o;return function(){var r=r1(this,t),i=(this.style.removeProperty(t),r1(this,t));return r===i?null:r===e&&i===a?o:o=n(e=r,a=i)}})(t,a)).on("end.style."+t,E4(t)):"function"==typeof n?this.styleTween(t,(function i(t,n,e){var a,o,r;return function(){var i=r1(this,t),c=e(this),s=c+"";return null==c&&(this.style.removeProperty(t),s=c=r1(this,t)),i===s?null:i===a&&s===o?r:(o=s,r=n(a=i,c))}})(t,a,m4(this,"style."+t,n))).each((function r(t,n){var e,a,o,r,i="style."+n,c="end."+i;return function(){var s=r4(this,t),l=s.on,m=null==s.value[i]?r||(r=E4(n)):void 0;l===e&&o===m||(a=(e=l).copy()).on(c,o=m),s.on=a}})(this._id,t)):this.styleTween(t,(function c(t,n,e){var a,o,r=e+"";return function(){var i=r1(this,t);return i===r?null:i===a?o:o=n(a=i,e)}})(t,a,n),e).on("end.style."+t,null)},styleTween:function Z4(t,n,e){var a="style."+(t+="");if(arguments.length<2)return(a=this.tween(a))&&a._value;if(null==n)return this.tween(a,null);if("function"!=typeof n)throw new Error;return this.tween(a,z4(t,n,null==e?"":e))},text:function X4(t){return this.tween("text","function"==typeof t?(function n(t){return function(){var n=t(this);this.textContent=null==n?"":n}})(m4(this,"text",t)):(function e(t){return function(){this.textContent=t}})(null==t?"":t+""))},textTween:function J4(t){var n="text";if(arguments.length<1)return(n=this.tween(n))&&n._value;if(null==t)return this.tween(n,null);if("function"!=typeof t)throw new Error;return this.tween(n,T4(t))},remove:function Q4(){return this.on("end.remove",(function t(n){return function(){var t=this.parentNode;for(var e in this.__transition)if(+e!==n)return;t&&t.removeChild(this)}})(this._id))},tween:function K4(t,n){var e=this._id;if(t+="",arguments.length<2){for(var a,o=i4(this.node(),e).tween,r=0,i=o.length;r<i;++r)if((a=o[r]).name===t)return a.value;return null}return this.each((null==n?s4:l4)(e,t,n))},delay:function $4(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?P4:x4)(n,t)):i4(this.node(),n).delay},duration:function t3(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?y4:k4)(n,t)):i4(this.node(),n).duration},ease:function n3(t){var n=this._id;return arguments.length?this.each(v4(n,t)):i4(this.node(),n).ease},end:function e3(){var t,n,e=this,a=e._id,o=e.size();return new Promise((function(r,i){var c={value:i},s={value:function(){0==--o&&r()}};e.each((function(){var e=r4(this,a),o=e.on;o!==t&&((n=(t=o).copy())._.cancel.push(c),n._.interrupt.push(c),n._.end.push(s)),e.on=n}))}))}};var a3={time:null,delay:0,duration:250,ease:function o3(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}};function r3(t,n){for(var e;!(e=t.__transition)||!(e=e[n]);)if(!(t=t.parentNode))return a3.time=q5(),a3;return e}function i3(t){return function(){return t}}function c3(t,n,e){this.target=t,this.type=n,this.selection=e}function s3(){A1.stopImmediatePropagation()}function l3(){A1.preventDefault(),A1.stopImmediatePropagation()}V1.prototype.interrupt=function m3(t){return this.each((function(){c4(this,t)}))},V1.prototype.transition=function d3(t){var n,e;t instanceof I4?(n=t._id,t=t._name):(n=N4(),(e=a3).time=q5(),t=null==t?null:t+"");for(var a=this._groups,o=a.length,r=0;r<o;++r)for(var i,c=a[r],s=c.length,l=0;l<s;++l)(i=c[l])&&a4(i,t,n,l,c,e||r3(i,n));return new I4(a,this._parents,t,n)};var g3={name:"drag"},p3={name:"space"},b3={name:"handle"},u3={name:"center"};function f3(t){return[+t[0],+t[1]]}function h3(t){return[f3(t[0]),f3(t[1])]}function _3(t){return function(n){return(function e(t,n,a){arguments.length<3&&(a=n,n=U1().changedTouches);for(var o,r=0,i=n?n.length:0;r<i;++r)if((o=n[r]).identifier===a)return W1(t,o);return null})(n,A1.touches,t)}}var C3={name:"x",handles:["w","e"].map(v3),input:function(t,n){return null==t?null:[[+t[0],n[0][1]],[+t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},M3={name:"y",handles:["n","s"].map(v3),input:function(t,n){return null==t?null:[[n[0][0],+t[0]],[n[1][0],+t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},O3={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},P3={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},x3={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},y3={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},k3={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function v3(t){return{type:t}}function w3(){return!A1.ctrlKey&&!A1.button}function S3(){var t=this.ownerSVGElement||this;return t.hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function E3(){return navigator.maxTouchPoints||"ontouchstart"in this}function A3(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function z3(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}var R3=Math.PI,T3=2*R3,D3=1e-6,I3=T3-D3;function N3(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function F3(){return new N3}N3.prototype=F3.prototype={constructor:N3,moveTo:function(t,n){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,n){this._+="L"+(this._x1=+t)+","+(this._y1=+n)},quadraticCurveTo:function(t,n,e,a){this._+="Q"+ +t+","+ +n+","+(this._x1=+e)+","+(this._y1=+a)},bezierCurveTo:function(t,n,e,a,o,r){this._+="C"+ +t+","+ +n+","+ +e+","+ +a+","+(this._x1=+o)+","+(this._y1=+r)},arcTo:function(t,n,e,a,o){var r=this._x1,i=this._y1,c=(e=+e)-(t=+t),s=(a=+a)-(n=+n),l=r-t,m=i-n,d=l*l+m*m;if((o=+o)<0)throw new Error("negative radius: "+o);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=n);else if(d>D3)if(Math.abs(m*c-s*l)>D3&&o){var g=e-r,p=a-i,b=c*c+s*s,u=g*g+p*p,f=Math.sqrt(b),h=Math.sqrt(d),_=o*Math.tan((R3-Math.acos((b+d-u)/(2*f*h)))/2),C=_/h,M=_/f;Math.abs(C-1)>D3&&(this._+="L"+(t+C*l)+","+(n+C*m)),this._+="A"+o+","+o+",0,0,"+ +(m*g>l*p)+","+(this._x1=t+M*c)+","+(this._y1=n+M*s)}else this._+="L"+(this._x1=t)+","+(this._y1=n)},arc:function(t,n,e,a,o,r){t=+t,n=+n,r=!!r;var i=(e=+e)*Math.cos(a),c=e*Math.sin(a),s=t+i,l=n+c,m=1^r,d=r?a-o:o-a;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+s+","+l:(Math.abs(this._x1-s)>D3||Math.abs(this._y1-l)>D3)&&(this._+="L"+s+","+l),e&&(d<0&&(d=d%T3+T3),d>I3?this._+="A"+e+","+e+",0,1,"+m+","+(t-i)+","+(n-c)+"A"+e+","+e+",0,1,"+m+","+(this._x1=s)+","+(this._y1=l):d>D3&&(this._+="A"+e+","+e+",0,"+ +(d>=R3)+","+m+","+(this._x1=t+e*Math.cos(o))+","+(this._y1=n+e*Math.sin(o))))},rect:function(t,n,e,a){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)+"h"+ +e+"v"+ +a+"h"+-e+"Z"},toString:function(){return this._}};var L3="$";function H3(){}function B3(t,n){var e=new H3;if(t instanceof H3)t.each((function(t,n){e.set(n,t)}));else if(Array.isArray(t)){var a,o=-1,r=t.length;if(null==n)for(;++o<r;)e.set(o,t[o]);else for(;++o<r;)e.set(n(a=t[o],o,t),a)}else if(t)for(var i in t)e.set(i,t[i]);return e}function V3(){}H3.prototype=B3.prototype={constructor:H3,has:function(t){return L3+t in this},get:function(t){return this[L3+t]},set:function(t,n){return this[L3+t]=n,this},remove:function(t){var n=L3+t;return n in this&&delete this[n]},clear:function(){for(var t in this)t[0]===L3&&delete this[t]},keys:function(){var t=[];for(var n in this)n[0]===L3&&t.push(n.slice(1));return t},values:function(){var t=[];for(var n in this)n[0]===L3&&t.push(this[n]);return t},entries:function(){var t=[];for(var n in this)n[0]===L3&&t.push({key:n.slice(1),value:this[n]});return t},size:function(){var t=0;for(var n in this)n[0]===L3&&++t;return t},empty:function(){for(var t in this)if(t[0]===L3)return!1;return!0},each:function(t){for(var n in this)n[0]===L3&&t(this[n],n.slice(1),this)}};var j3=B3.prototype;function U3(t,n){if((e=(t=n?t.toExponential(n-1):t.toExponential()).indexOf("e"))<0)return null;var e,a=t.slice(0,e);return[a.length>1?a[0]+a.slice(2):a,+t.slice(e+1)]}function W3(t){return(t=U3(Math.abs(t)))?t[1]:NaN}V3.prototype={constructor:V3,has:j3.has,add:function(t){return this[L3+(t+="")]=t,this},remove:j3.remove,clear:j3.clear,values:j3.keys,size:j3.size,empty:j3.empty,each:j3.each};var G3,Y3=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function q3(t){if(!(n=Y3.exec(t)))throw new Error("invalid format: "+t);var n;return new Z3({fill:n[1],align:n[2],sign:n[3],symbol:n[4],zero:n[5],width:n[6],comma:n[7],precision:n[8]&&n[8].slice(1),trim:n[9],type:n[10]})}function Z3(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function X3(t,n){var e=U3(t,n);if(!e)return t+"";var a=e[0],o=e[1];return o<0?"0."+new Array(-o).join("0")+a:a.length>o+1?a.slice(0,o+1)+"."+a.slice(o+1):a+new Array(o-a.length+2).join("0")}q3.prototype=Z3.prototype,Z3.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var J3={"%":function(t,n){return(100*t).toFixed(n)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,n){return t.toExponential(n)},f:function(t,n){return t.toFixed(n)},g:function(t,n){return t.toPrecision(n)},o:function(t){return Math.round(t).toString(8)},p:function(t,n){return X3(100*t,n)},r:X3,s:function Q3(t,n){var e=U3(t,n);if(!e)return t+"";var a=e[0],o=e[1],r=o-(G3=3*Math.max(-8,Math.min(8,Math.floor(o/3))))+1,i=a.length;return r===i?a:r>i?a+new Array(r-i+1).join("0"):r>0?a.slice(0,r)+"."+a.slice(r):"0."+new Array(1-r).join("0")+U3(t,Math.max(0,n+r-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}};function K3(t){return t}var $3,t6,n6,e6=Array.prototype.map,a6=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function o6(t,n){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(n).domain(t)}return this}!(function r6(t){$3=(function n(t){var n=void 0===t.grouping||void 0===t.thousands?K3:(function e(t,n){return function(e,a){for(var o=e.length,r=[],i=0,c=t[0],s=0;o>0&&c>0&&(s+c+1>a&&(c=Math.max(1,a-s)),r.push(e.substring(o-=c,o+c)),!((s+=c+1)>a));)c=t[i=(i+1)%t.length];return r.reverse().join(n)}})(e6.call(t.grouping,Number),t.thousands+""),a=void 0===t.currency?"":t.currency[0]+"",o=void 0===t.currency?"":t.currency[1]+"",r=void 0===t.decimal?".":t.decimal+"",i=void 0===t.numerals?K3:(function c(t){return function(n){return n.replace(/[0-9]/g,(function(n){return t[+n]}))}})(e6.call(t.numerals,String)),s=void 0===t.percent?"%":t.percent+"",l=void 0===t.minus?"-":t.minus+"",m=void 0===t.nan?"NaN":t.nan+"";function d(t){var e=(t=q3(t)).fill,c=t.align,d=t.sign,g=t.symbol,p=t.zero,b=t.width,u=t.comma,f=t.precision,h=t.trim,_=t.type;"n"===_?(u=!0,_="g"):J3[_]||(void 0===f&&(f=12),h=!0,_="g"),(p||"0"===e&&"="===c)&&(p=!0,e="0",c="=");var C="$"===g?a:"#"===g&&/[boxX]/.test(_)?"0"+_.toLowerCase():"",M="$"===g?o:/[%p]/.test(_)?s:"",O=J3[_],P=/[defgprs%]/.test(_);function x(t){var a,o,s,g=C,x=M;if("c"===_)x=O(t)+x,t="";else{var y=(t=+t)<0||1/t<0;if(t=isNaN(t)?m:O(Math.abs(t),f),h&&(t=(function k(t){t:for(var n,e=t.length,a=1,o=-1;a<e;++a)switch(t[a]){case".":o=n=a;break;case"0":0===o&&(o=a),n=a;break;default:if(!+t[a])break t;o>0&&(o=0)}return o>0?t.slice(0,o)+t.slice(n+1):t})(t)),y&&0==+t&&"+"!==d&&(y=!1),g=(y?"("===d?d:l:"-"===d||"("===d?"":d)+g,x=("s"===_?a6[8+G3/3]:"")+x+(y&&"("===d?")":""),P)for(a=-1,o=t.length;++a<o;)if(48>(s=t.charCodeAt(a))||s>57){x=(46===s?r+t.slice(a+1):t.slice(a))+x,t=t.slice(0,a);break}}u&&!p&&(t=n(t,1/0));var v=g.length+t.length+x.length,w=v<b?new Array(b-v+1).join(e):"";switch(u&&p&&(t=n(w+t,w.length?b-x.length:1/0),w=""),c){case"<":t=g+t+x+w;break;case"=":t=g+w+t+x;break;case"^":t=w.slice(0,v=w.length>>1)+g+t+x+w.slice(v);break;default:t=w+g+t+x}return i(t)}return f=void 0===f?6:/[gprs]/.test(_)?Math.max(1,Math.min(21,f)):Math.max(0,Math.min(20,f)),x.toString=function(){return t+""},x}return{format:d,formatPrefix:function g(t,n){var e=d(((t=q3(t)).type="f",t)),a=3*Math.max(-8,Math.min(8,Math.floor(W3(n)/3))),o=Math.pow(10,-a),r=a6[8+a/3];return function(t){return e(o*t)+r}}}})(t),t6=$3.format,n6=$3.formatPrefix})({decimal:".",thousands:",",grouping:[3],currency:["$",""],minus:"-"});var i6=Array.prototype,c6=i6.map,s6=i6.slice,l6={name:"implicit"};function m6(){var t=B3(),n=[],e=[],a=l6;function o(o){var r=o+"",i=t.get(r);if(!i){if(a!==l6)return a;t.set(r,i=n.push(o))}return e[(i-1)%e.length]}return o.domain=function(e){if(!arguments.length)return n.slice();n=[],t=B3();for(var a,r,i=-1,c=e.length;++i<c;)t.has(r=(a=e[i])+"")||t.set(r,n.push(a));return o},o.range=function(t){return arguments.length?(e=s6.call(t),o):e.slice()},o.unknown=function(t){return arguments.length?(a=t,o):a},o.copy=function(){return m6(n,e).unknown(a)},o6.apply(o,arguments),o}function d6(){var t,n,e=m6().unknown(void 0),a=e.domain,o=e.range,r=[0,1],i=!1,c=0,s=0,l=.5;function m(){var e=a().length,m=r[1]<r[0],d=r[m-0],g=r[1-m];t=(g-d)/Math.max(1,e-c+2*s),i&&(t=Math.floor(t)),d+=(g-d-t*(e-c))*l,n=t*(1-c),i&&(d=Math.round(d),n=Math.round(n));var p=l0(e).map((function(n){return d+t*n}));return o(m?p.reverse():p)}return delete e.unknown,e.domain=function(t){return arguments.length?(a(t),m()):a()},e.range=function(t){return arguments.length?(r=[+t[0],+t[1]],m()):r.slice()},e.rangeRound=function(t){return r=[+t[0],+t[1]],i=!0,m()},e.bandwidth=function(){return n},e.step=function(){return t},e.round=function(t){return arguments.length?(i=!!t,m()):i},e.padding=function(t){return arguments.length?(c=Math.min(1,s=+t),m()):c},e.paddingInner=function(t){return arguments.length?(c=Math.min(1,t),m()):c},e.paddingOuter=function(t){return arguments.length?(s=+t,m()):s},e.align=function(t){return arguments.length?(l=Math.max(0,Math.min(1,t)),m()):l},e.copy=function(){return d6(a(),r).round(i).paddingInner(c).paddingOuter(s).align(l)},o6.apply(m(),arguments)}function g6(t){var n=t.copy;return t.padding=t.paddingOuter,delete t.paddingInner,delete t.paddingOuter,t.copy=function(){return g6(n())},t}function p6(){return g6(d6.apply(null,arguments).paddingInner(1))}function b6(t){return+t}var u6=[0,1];function f6(t){return t}function h6(t,n){return(n-=t=+t)?function(e){return(e-t)/n}:(function e(t){return function(){return t}})(isNaN(n)?NaN:.5)}function _6(t){var n,e=t[0],a=t[t.length-1];return e>a&&(n=e,e=a,a=n),function(t){return Math.max(e,Math.min(a,t))}}function C6(t,n,e){var a=t[0],o=t[1],r=n[0],i=n[1];return o<a?(a=h6(o,a),r=e(i,r)):(a=h6(a,o),r=e(r,i)),function(t){return r(a(t))}}function M6(t,n,e){var a=Math.min(t.length,n.length)-1,o=new Array(a),r=new Array(a),i=-1;for(t[a]<t[0]&&(t=t.slice().reverse(),n=n.slice().reverse());++i<a;)o[i]=h6(t[i],t[i+1]),r[i]=e(n[i],n[i+1]);return function(n){var e=o0(t,n,1,a)-1;return r[e](o[e](n))}}function O6(t,n){return n.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown())}function P6(){var t,n,e,a,o,r,i=u6,c=u6,s=M5,l=f6;function m(){return a=Math.min(i.length,c.length)>2?M6:C6,o=r=null,d}function d(n){return isNaN(n=+n)?e:(o||(o=a(i.map(t),c,s)))(t(l(n)))}return d.invert=function(e){return l(n((r||(r=a(c,i.map(t),u5)))(e)))},d.domain=function(t){return arguments.length?(i=c6.call(t,b6),l===f6||(l=_6(i)),m()):i.slice()},d.range=function(t){return arguments.length?(c=s6.call(t),m()):c.slice()},d.rangeRound=function(t){return c=s6.call(t),s=O5,m()},d.clamp=function(t){return arguments.length?(l=t?_6(i):f6,d):l!==f6},d.interpolate=function(t){return arguments.length?(s=t,m()):s},d.unknown=function(t){return arguments.length?(e=t,d):e},function(e,a){return t=e,n=a,m()}}function x6(t,n){return P6()(t,n)}function y6(t){var n=t.domain;return t.ticks=function(t){var e=n();return p0(e[0],e[e.length-1],null==t?10:t)},t.tickFormat=function(t,e){var a=n();return(function o(t,n,e,a){var o,r=u0(t,n,e);switch((a=q3(null==a?",f":a)).type){case"s":var i=Math.max(Math.abs(t),Math.abs(n));return null!=a.precision||isNaN(o=(function c(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(W3(n)/3)))-W3(Math.abs(t)))})(r,i))||(a.precision=o),n6(a,i);case"":case"e":case"g":case"p":case"r":null!=a.precision||isNaN(o=(function s(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,W3(n)-W3(t))+1})(r,Math.max(Math.abs(t),Math.abs(n))))||(a.precision=o-("e"===a.type));break;case"f":case"%":null!=a.precision||isNaN(o=(function l(t){return Math.max(0,-W3(Math.abs(t)))})(r))||(a.precision=o-2*("%"===a.type))}return t6(a)})(a[0],a[a.length-1],null==t?10:t,e)},t.nice=function(e){null==e&&(e=10);var a,o=n(),r=0,i=o.length-1,c=o[r],s=o[i];return s<c&&(a=c,c=s,s=a,a=r,r=i,i=a),(a=b0(c,s,e))>0?a=b0(c=Math.floor(c/a)*a,s=Math.ceil(s/a)*a,e):a<0&&(a=b0(c=Math.ceil(c*a)/a,s=Math.floor(s*a)/a,e)),a>0?(o[r]=Math.floor(c/a)*a,o[i]=Math.ceil(s/a)*a,n(o)):a<0&&(o[r]=Math.ceil(c*a)/a,o[i]=Math.floor(s*a)/a,n(o)),t},t}function k6(){var t=x6(f6,f6);return t.copy=function(){return O6(t,k6())},o6.apply(t,arguments),y6(t)}function v6(t,n){var e,a=0,o=(t=t.slice()).length-1,r=t[a],i=t[o];return i<r&&(e=a,a=o,o=e,e=r,r=i,i=e),t[a]=n.floor(r),t[o]=n.ceil(i),t}function w6(t){return Math.log(t)}function S6(t){return Math.exp(t)}function E6(t){return-Math.log(-t)}function A6(t){return-Math.exp(-t)}function z6(t){return isFinite(t)?+("1e"+t):t<0?0:t}function R6(t){return function(n){return-t(-n)}}function T6(t){var n,e,a=t(w6,S6),o=a.domain,r=10;function i(){return n=(function i(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(n){return Math.log(n)/t})})(r),e=(function c(t){return 10===t?z6:t===Math.E?Math.exp:function(n){return Math.pow(t,n)}})(r),o()[0]<0?(n=R6(n),e=R6(e),t(E6,A6)):t(w6,S6),a}return a.base=function(t){return arguments.length?(r=+t,i()):r},a.domain=function(t){return arguments.length?(o(t),i()):o()},a.ticks=function(t){var a,i=o(),c=i[0],s=i[i.length-1];(a=s<c)&&(g=c,c=s,s=g);var l,m,d,g=n(c),p=n(s),b=null==t?10:+t,u=[];if(!(r%1)&&p-g<b){if(g=Math.round(g)-1,p=Math.round(p)+1,c>0){for(;g<p;++g)for(m=1,l=e(g);m<r;++m)if(!((d=l*m)<c)){if(d>s)break;u.push(d)}}else for(;g<p;++g)for(m=r-1,l=e(g);m>=1;--m)if(!((d=l*m)<c)){if(d>s)break;u.push(d)}}else u=p0(g,p,Math.min(p-g,b)).map(e);return a?u.reverse():u},a.tickFormat=function(t,o){if(null==o&&(o=10===r?".0e":","),"function"!=typeof o&&(o=t6(o)),t===1/0)return o;null==t&&(t=10);var i=Math.max(1,r*t/a.ticks().length);return function(t){var a=t/e(Math.round(n(t)));return a*r<r-.5&&(a*=r),a<=i?o(t):""}},a.nice=function(){return o(v6(o(),{floor:function(t){return e(Math.floor(n(t)))},ceil:function(t){return e(Math.ceil(n(t)))}}))},a}function D6(){var t=T6(P6()).domain([1,10]);return t.copy=function(){return O6(t,D6()).base(t.base())},o6.apply(t,arguments),t}var I6=new Date,N6=new Date;function F6(t,n,e,a){function o(n){return t(n=0===arguments.length?new Date:new Date(+n)),n}return o.floor=function(n){return t(n=new Date(+n)),n},o.ceil=function(e){return t(e=new Date(e-1)),n(e,1),t(e),e},o.round=function(t){var n=o(t),e=o.ceil(t);return t-n<e-t?n:e},o.offset=function(t,e){return n(t=new Date(+t),null==e?1:Math.floor(e)),t},o.range=function(e,a,r){var i,c=[];if(e=o.ceil(e),r=null==r?1:Math.floor(r),!(e<a&&r>0))return c;do{c.push(i=new Date(+e)),n(e,r),t(e)}while(i<e&&e<a);return c},o.filter=function(e){return F6((function(n){if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)}),(function(t,a){if(t>=t)if(a<0)for(;++a<=0;)for(;n(t,-1),!e(t););else for(;--a>=0;)for(;n(t,1),!e(t););}))},e&&(o.count=function(n,a){return I6.setTime(+n),N6.setTime(+a),t(I6),t(N6),Math.floor(e(I6,N6))},o.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?o.filter(a?function(n){return a(n)%t==0}:function(n){return o.count(0,n)%t==0}):o:null}),o}var L6=F6((function(){}),(function(t,n){t.setTime(+t+n)}),(function(t,n){return n-t}));L6.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?F6((function(n){n.setTime(Math.floor(n/t)*t)}),(function(n,e){n.setTime(+n+e*t)}),(function(n,e){return(e-n)/t})):L6:null};var H6=1e3,B6=6e4,V6=36e5,j6=864e5,U6=6048e5,W6=F6((function(t){t.setTime(t-t.getMilliseconds())}),(function(t,n){t.setTime(+t+n*H6)}),(function(t,n){return(n-t)/H6}),(function(t){return t.getUTCSeconds()})),G6=F6((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*H6)}),(function(t,n){t.setTime(+t+n*B6)}),(function(t,n){return(n-t)/B6}),(function(t){return t.getMinutes()})),Y6=F6((function(t){t.setTime(t-t.getMilliseconds()-t.getSeconds()*H6-t.getMinutes()*B6)}),(function(t,n){t.setTime(+t+n*V6)}),(function(t,n){return(n-t)/V6}),(function(t){return t.getHours()})),q6=F6((function(t){t.setHours(0,0,0,0)}),(function(t,n){t.setDate(t.getDate()+n)}),(function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*B6)/j6}),(function(t){return t.getDate()-1}));function Z6(t){return F6((function(n){n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)}),(function(t,n){t.setDate(t.getDate()+7*n)}),(function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*B6)/U6}))}var X6=Z6(0),J6=Z6(1);Z6(2),Z6(3);var Q6=Z6(4);Z6(5),Z6(6);var K6=F6((function(t){t.setDate(1),t.setHours(0,0,0,0)}),(function(t,n){t.setMonth(t.getMonth()+n)}),(function(t,n){return n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())}),(function(t){return t.getMonth()})),$6=F6((function(t){t.setMonth(0,1),t.setHours(0,0,0,0)}),(function(t,n){t.setFullYear(t.getFullYear()+n)}),(function(t,n){return n.getFullYear()-t.getFullYear()}),(function(t){return t.getFullYear()}));$6.every=function(t){return isFinite(t=Math.floor(t))&&t>0?F6((function(n){n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)}),(function(n,e){n.setFullYear(n.getFullYear()+e*t)})):null};var t7=F6((function(t){t.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCDate(t.getUTCDate()+n)}),(function(t,n){return(n-t)/j6}),(function(t){return t.getUTCDate()-1}));function n7(t){return F6((function(n){n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCDate(t.getUTCDate()+7*n)}),(function(t,n){return(n-t)/U6}))}var e7=n7(0),a7=n7(1);n7(2),n7(3);var o7=n7(4);n7(5),n7(6);var r7=F6((function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),(function(t,n){t.setUTCFullYear(t.getUTCFullYear()+n)}),(function(t,n){return n.getUTCFullYear()-t.getUTCFullYear()}),(function(t){return t.getUTCFullYear()}));function i7(t){if(0<=t.y&&t.y<100){var n=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return n.setFullYear(t.y),n}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function c7(t){if(0<=t.y&&t.y<100){var n=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return n.setUTCFullYear(t.y),n}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function s7(t,n,e){return{y:t,m:n,d:e,H:0,M:0,S:0,L:0}}r7.every=function(t){return isFinite(t=Math.floor(t))&&t>0?F6((function(n){n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)}),(function(n,e){n.setUTCFullYear(n.getUTCFullYear()+e*t)})):null};var l7,m7,d7={"-":"",_:" ",0:"0"},g7=/^\s*\d+/,p7=/^%/,b7=/[\\^$*+?|[\]().{}]/g;function u7(t,n,e){var a=t<0?"-":"",o=(a?-t:t)+"",r=o.length;return a+(r<e?new Array(e-r+1).join(n)+o:o)}function f7(t){return t.replace(b7,"\\$&")}function h7(t){return new RegExp("^(?:"+t.map(f7).join("|")+")","i")}function _7(t){for(var n={},e=-1,a=t.length;++e<a;)n[t[e].toLowerCase()]=e;return n}function C7(t,n,e){var a=g7.exec(n.slice(e,e+1));return a?(t.w=+a[0],e+a[0].length):-1}function M7(t,n,e){var a=g7.exec(n.slice(e,e+1));return a?(t.u=+a[0],e+a[0].length):-1}function O7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.U=+a[0],e+a[0].length):-1}function P7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.V=+a[0],e+a[0].length):-1}function x7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.W=+a[0],e+a[0].length):-1}function y7(t,n,e){var a=g7.exec(n.slice(e,e+4));return a?(t.y=+a[0],e+a[0].length):-1}function k7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.y=+a[0]+(+a[0]>68?1900:2e3),e+a[0].length):-1}function v7(t,n,e){var a=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return a?(t.Z=a[1]?0:-(a[2]+(a[3]||"00")),e+a[0].length):-1}function w7(t,n,e){var a=g7.exec(n.slice(e,e+1));return a?(t.q=3*a[0]-3,e+a[0].length):-1}function S7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.m=a[0]-1,e+a[0].length):-1}function E7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.d=+a[0],e+a[0].length):-1}function A7(t,n,e){var a=g7.exec(n.slice(e,e+3));return a?(t.m=0,t.d=+a[0],e+a[0].length):-1}function z7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.H=+a[0],e+a[0].length):-1}function R7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.M=+a[0],e+a[0].length):-1}function T7(t,n,e){var a=g7.exec(n.slice(e,e+2));return a?(t.S=+a[0],e+a[0].length):-1}function D7(t,n,e){var a=g7.exec(n.slice(e,e+3));return a?(t.L=+a[0],e+a[0].length):-1}function I7(t,n,e){var a=g7.exec(n.slice(e,e+6));return a?(t.L=Math.floor(a[0]/1e3),e+a[0].length):-1}function N7(t,n,e){var a=p7.exec(n.slice(e,e+1));return a?e+a[0].length:-1}function F7(t,n,e){var a=g7.exec(n.slice(e));return a?(t.Q=+a[0],e+a[0].length):-1}function L7(t,n,e){var a=g7.exec(n.slice(e));return a?(t.s=+a[0],e+a[0].length):-1}function H7(t,n){return u7(t.getDate(),n,2)}function B7(t,n){return u7(t.getHours(),n,2)}function V7(t,n){return u7(t.getHours()%12||12,n,2)}function j7(t,n){return u7(1+q6.count($6(t),t),n,3)}function U7(t,n){return u7(t.getMilliseconds(),n,3)}function W7(t,n){return U7(t,n)+"000"}function G7(t,n){return u7(t.getMonth()+1,n,2)}function Y7(t,n){return u7(t.getMinutes(),n,2)}function q7(t,n){return u7(t.getSeconds(),n,2)}function Z7(t){var n=t.getDay();return 0===n?7:n}function X7(t,n){return u7(X6.count($6(t)-1,t),n,2)}function J7(t,n){var e=t.getDay();return t=e>=4||0===e?Q6(t):Q6.ceil(t),u7(Q6.count($6(t),t)+(4===$6(t).getDay()),n,2)}function Q7(t){return t.getDay()}function K7(t,n){return u7(J6.count($6(t)-1,t),n,2)}function $7(t,n){return u7(t.getFullYear()%100,n,2)}function t8(t,n){return u7(t.getFullYear()%1e4,n,4)}function n8(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+u7(n/60|0,"0",2)+u7(n%60,"0",2)}function e8(t,n){return u7(t.getUTCDate(),n,2)}function a8(t,n){return u7(t.getUTCHours(),n,2)}function o8(t,n){return u7(t.getUTCHours()%12||12,n,2)}function r8(t,n){return u7(1+t7.count(r7(t),t),n,3)}function i8(t,n){return u7(t.getUTCMilliseconds(),n,3)}function c8(t,n){return i8(t,n)+"000"}function s8(t,n){return u7(t.getUTCMonth()+1,n,2)}function l8(t,n){return u7(t.getUTCMinutes(),n,2)}function m8(t,n){return u7(t.getUTCSeconds(),n,2)}function d8(t){var n=t.getUTCDay();return 0===n?7:n}function g8(t,n){return u7(e7.count(r7(t)-1,t),n,2)}function p8(t,n){var e=t.getUTCDay();return t=e>=4||0===e?o7(t):o7.ceil(t),u7(o7.count(r7(t),t)+(4===r7(t).getUTCDay()),n,2)}function b8(t){return t.getUTCDay()}function u8(t,n){return u7(a7.count(r7(t)-1,t),n,2)}function f8(t,n){return u7(t.getUTCFullYear()%100,n,2)}function h8(t,n){return u7(t.getUTCFullYear()%1e4,n,4)}function _8(){return"+0000"}function C8(){return"%"}function M8(t){return+t}function O8(t){return Math.floor(+t/1e3)}!(function P8(t){l7=(function n(t){var n=t.dateTime,e=t.date,a=t.time,o=t.periods,r=t.days,i=t.shortDays,c=t.months,s=t.shortMonths,l=h7(o),m=_7(o),d=h7(r),g=_7(r),p=h7(i),b=_7(i),u=h7(c),f=_7(c),h=h7(s),_=_7(s),C={a:function M(t){return i[t.getDay()]},A:function O(t){return r[t.getDay()]},b:function P(t){return s[t.getMonth()]},B:function x(t){return c[t.getMonth()]},c:null,d:H7,e:H7,f:W7,H:B7,I:V7,j:j7,L:U7,m:G7,M:Y7,p:function y(t){return o[+(t.getHours()>=12)]},q:function k(t){return 1+~~(t.getMonth()/3)},Q:M8,s:O8,S:q7,u:Z7,U:X7,V:J7,w:Q7,W:K7,x:null,X:null,y:$7,Y:t8,Z:n8,"%":C8},v={a:function w(t){return i[t.getUTCDay()]},A:function S(t){return r[t.getUTCDay()]},b:function E(t){return s[t.getUTCMonth()]},B:function A(t){return c[t.getUTCMonth()]},c:null,d:e8,e:e8,f:c8,H:a8,I:o8,j:r8,L:i8,m:s8,M:l8,p:function z(t){return o[+(t.getUTCHours()>=12)]},q:function R(t){return 1+~~(t.getUTCMonth()/3)},Q:M8,s:O8,S:m8,u:d8,U:g8,V:p8,w:b8,W:u8,x:null,X:null,y:f8,Y:h8,Z:_8,"%":C8},T={a:function D(t,n,e){var a=p.exec(n.slice(e));return a?(t.w=b[a[0].toLowerCase()],e+a[0].length):-1},A:function I(t,n,e){var a=d.exec(n.slice(e));return a?(t.w=g[a[0].toLowerCase()],e+a[0].length):-1},b:function N(t,n,e){var a=h.exec(n.slice(e));return a?(t.m=_[a[0].toLowerCase()],e+a[0].length):-1},B:function F(t,n,e){var a=u.exec(n.slice(e));return a?(t.m=f[a[0].toLowerCase()],e+a[0].length):-1},c:function L(t,e,a){return W(t,n,e,a)},d:E7,e:E7,f:I7,H:z7,I:z7,j:A7,L:D7,m:S7,M:R7,p:function H(t,n,e){var a=l.exec(n.slice(e));return a?(t.p=m[a[0].toLowerCase()],e+a[0].length):-1},q:w7,Q:F7,s:L7,S:T7,u:M7,U:O7,V:P7,w:C7,W:x7,x:function B(t,n,a){return W(t,e,n,a)},X:function V(t,n,e){return W(t,a,n,e)},y:k7,Y:y7,Z:v7,"%":N7};function j(t,n){return function(e){var a,o,r,i=[],c=-1,s=0,l=t.length;for(e instanceof Date||(e=new Date(+e));++c<l;)37===t.charCodeAt(c)&&(i.push(t.slice(s,c)),null!=(o=d7[a=t.charAt(++c)])?a=t.charAt(++c):o="e"===a?" ":"0",(r=n[a])&&(a=r(e,o)),i.push(a),s=c+1);return i.push(t.slice(s,c)),i.join("")}}function U(t,n){return function(e){var a,o,r=s7(1900,void 0,1);if(W(r,t,e+="",0)!=e.length)return null;if("Q"in r)return new Date(r.Q);if("s"in r)return new Date(1e3*r.s+("L"in r?r.L:0));if(n&&!("Z"in r)&&(r.Z=0),"p"in r&&(r.H=r.H%12+12*r.p),void 0===r.m&&(r.m="q"in r?r.q:0),"V"in r){if(r.V<1||r.V>53)return null;"w"in r||(r.w=1),"Z"in r?(o=(a=c7(s7(r.y,0,1))).getUTCDay(),a=o>4||0===o?a7.ceil(a):a7(a),a=t7.offset(a,7*(r.V-1)),r.y=a.getUTCFullYear(),r.m=a.getUTCMonth(),r.d=a.getUTCDate()+(r.w+6)%7):(o=(a=i7(s7(r.y,0,1))).getDay(),a=o>4||0===o?J6.ceil(a):J6(a),a=q6.offset(a,7*(r.V-1)),r.y=a.getFullYear(),r.m=a.getMonth(),r.d=a.getDate()+(r.w+6)%7)}else("W"in r||"U"in r)&&("w"in r||(r.w="u"in r?r.u%7:"W"in r?1:0),o="Z"in r?c7(s7(r.y,0,1)).getUTCDay():i7(s7(r.y,0,1)).getDay(),r.m=0,r.d="W"in r?(r.w+6)%7+7*r.W-(o+5)%7:r.w+7*r.U-(o+6)%7);return"Z"in r?(r.H+=r.Z/100|0,r.M+=r.Z%100,c7(r)):i7(r)}}function W(t,n,e,a){for(var o,r,i=0,c=n.length,s=e.length;i<c;){if(a>=s)return-1;if(37===(o=n.charCodeAt(i++))){if(o=n.charAt(i++),!(r=T[o in d7?n.charAt(i++):o])||(a=r(t,e,a))<0)return-1}else if(o!=e.charCodeAt(a++))return-1}return a}return C.x=j(e,C),C.X=j(a,C),C.c=j(n,C),v.x=j(e,v),v.X=j(a,v),v.c=j(n,v),{format:function(t){var n=j(t+="",C);return n.toString=function(){return t},n},parse:function(t){var n=U(t+="",!1);return n.toString=function(){return t},n},utcFormat:function(t){var n=j(t+="",v);return n.toString=function(){return t},n},utcParse:function(t){var n=U(t+="",!0);return n.toString=function(){return t},n}}})(t),m7=l7.format})({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var x8=31536e6;function y8(t){return new Date(t)}function k8(t){return t instanceof Date?+t:+new Date(+t)}function v8(t,n,e,a,o,r,i,c,s){var l=x6(f6,f6),m=l.invert,d=l.domain,g=s(".%L"),p=s(":%S"),b=s("%I:%M"),u=s("%I %p"),f=s("%a %d"),h=s("%b %d"),_=s("%B"),C=s("%Y"),M=[[i,1,1e3],[i,5,5e3],[i,15,15e3],[i,30,3e4],[r,1,6e4],[r,5,3e5],[r,15,9e5],[r,30,18e5],[o,1,36e5],[o,3,108e5],[o,6,216e5],[o,12,432e5],[a,1,864e5],[a,2,1728e5],[e,1,6048e5],[n,1,2592e6],[n,3,7776e6],[t,1,x8]];function O(c){return(i(c)<c?g:r(c)<c?p:o(c)<c?b:a(c)<c?u:n(c)<c?e(c)<c?f:h:t(c)<c?_:C)(c)}function P(n,e,a,o){if(null==n&&(n=10),"number"==typeof n){var r=Math.abs(a-e)/n,i=a0((function(t){return t[2]})).right(M,r);i===M.length?(o=u0(e/x8,a/x8,n),n=t):i?(o=(i=M[r/M[i-1][2]<M[i][2]/r?i-1:i])[1],n=i[0]):(o=Math.max(u0(e,a,n),1),n=c)}return null==o?n:n.every(o)}return l.invert=function(t){return new Date(m(t))},l.domain=function(t){return arguments.length?d(c6.call(t,k8)):d().map(y8)},l.ticks=function(t,n){var e,a=d(),o=a[0],r=a[a.length-1],i=r<o;return i&&(e=o,o=r,r=e),e=(e=P(t,o,r,n))?e.range(o,r+1):[],i?e.reverse():e},l.tickFormat=function(t,n){return null==n?O:s(n)},l.nice=function(t,n){var e=d();return(t=P(t,e[0],e[e.length-1],n))?d(v6(e,t)):l},l.copy=function(){return O6(l,v8(t,n,e,a,o,r,i,c,s))},l}function w8(){return o6.apply(v8($6,K6,X6,q6,Y6,G6,W6,L6,m7).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)}function S8(t){for(var n=t.length/6|0,e=new Array(n),a=0;a<n;)e[a]="#"+t.slice(6*a,6*++a);return e}function E8(t){return l5(t[t.length-1])}var A8=E8(new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(S8)),z8=E8(new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(S8)),R8=E8(new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(S8));function T8(t){return function n(){return t}}function D8(t){this._context=t}function I8(t){return new D8(t)}function N8(t){return t[0]}function F8(t){return t[1]}function L8(){var t=N8,n=F8,e=T8(!0),a=null,o=I8,r=null;function i(i){var c,s,l,m=i.length,d=!1;for(null==a&&(r=o(l=F3())),c=0;c<=m;++c)!(c<m&&e(s=i[c],c,i))===d&&((d=!d)?r.lineStart():r.lineEnd()),d&&r.point(+t(s,c,i),+n(s,c,i));if(l)return r=null,l+""||null}return i.x=function(n){return arguments.length?(t="function"==typeof n?n:T8(+n),i):t},i.y=function(t){return arguments.length?(n="function"==typeof t?t:T8(+t),i):n},i.defined=function(t){return arguments.length?(e="function"==typeof t?t:T8(!!t),i):e},i.curve=function(t){return arguments.length?(o=t,null!=a&&(r=o(a)),i):o},i.context=function(t){return arguments.length?(null==t?a=r=null:r=o(a=t),i):a},i}function H8(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function B8(t,n){this._context=t,this._k=(1-n)/6}function V8(t,n){this._context=t,this._alpha=n}D8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}},B8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:H8(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:H8(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}},V8.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,a=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+a*a,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:!(function o(t,n,e){var a=t._x1,o=t._y1,r=t._x2,i=t._y2;if(t._l01_a>1e-12){var c=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,s=3*t._l01_a*(t._l01_a+t._l12_a);a=(a*c-t._x0*t._l12_2a+t._x2*t._l01_2a)/s,o=(o*c-t._y0*t._l12_2a+t._y2*t._l01_2a)/s}if(t._l23_a>1e-12){var l=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,m=3*t._l23_a*(t._l23_a+t._l12_a);r=(r*l+t._x1*t._l23_2a-n*t._l12_2a)/m,i=(i*l+t._y1*t._l23_2a-e*t._l12_2a)/m}t._context.bezierCurveTo(a,o,r,i,t._x2,t._y2)})(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var j8=(function t(n){function e(t){return n?new V8(t,n):new B8(t,0)}return e.alpha=function(n){return t(+n)},e})(.5);const U8=t6(".2~e"),W8=t6("~"),G8=t6(",~");function Y8(t){if(0===t)return"0";const n=Math.abs(t);return n>=1e5||n<.001?U8(t):W8(t)}const q8={formatTick:Y8,formatShort:Y8,formatReadable:t=>G8(t)},Z8=36e5,X8=864e5,J8=31536e6,Q8=t6(".4~");function K8(t){if(0===t)return"0";let n=Math.sign(t)>0?"":"-";const e=Math.abs(t);return n+=e<1e3?`${Q8(e)} ms`:e<6e4?`${Q8(e/1e3)} sec`:e<Z8?`${Q8(e/6e4)} min`:e<X8?`${Q8(e/Z8)} hr`:e<J8?`${Q8(e/X8)} day`:`${Q8(e/J8)} yr`,n}const $8={formatTick:K8,formatShort:K8,formatReadable:K8},t9=w8().tickFormat();let n9;const e9={formatTick:t=>t9(new Date(t)),formatShort:t=>new Date(t).toLocaleString(n9,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"}),formatReadable:t=>new Date(t).toLocaleString(n9,{year:"numeric",month:"short",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric",timeZoneName:"short",fractionalSecondDigits:3})};function a9(t){switch(t){case j$.LINEAR:return new o9;case j$.LOG10:return new r9;case j$.TIME:return new i9;default:throw new RangeError(`ScaleType ${t} not supported.`)}}class o9{constructor(){this.defaultFormatter=q8}transform(t,n,e){const[a,o]=t,r=o-a,[i,c]=n;return 0===r?i:(c-i)/r*(e-a)+i}forward(t,n,e){return this.transform(t,n,e)}reverse(t,n,e){return this.transform(n,t,e)}niceDomain(t){let[n,e]=t;if(e<n)throw new Error("Unexpected input: min is larger than max");if(e===n)return 0===n?[-1,1]:n<0?[2*n,0]:[0,2*n];const a=k6(),o=.05*(e-n+Number.EPSILON),[r,i]=a.domain([n-o,e+o]).nice().domain();return[r,i]}ticks(t,n){return k6().domain(t).ticks(n)}isSafeNumber(t){return Number.isFinite(t)}}class r9{constructor(){this.defaultFormatter=q8}transform(t){return Math.log10(t>0?t:Number.MIN_VALUE)}untransform(t){return Math.exp(t/Math.LOG10E)}forward(t,n,e){if(e<=0)return n[0];const[a,o]=t,[r,i]=n,c=this.transform(a),s=this.transform(o)-c,l=i-r;return e=this.transform(e),l/(s+Number.EPSILON)*(e-c)+r}reverse(t,n,e){const[a,o]=t,[r,i]=n,c=this.transform(a),s=this.transform(o);return this.untransform((s-c)/(i-r+Number.EPSILON)*(e-r)+c)}niceDomain(t){const[n,e]=t;if(n>e)throw new Error("Unexpected input: min is larger than max");const a=Math.max(n,Number.MIN_VALUE),o=Math.max(e,Number.MIN_VALUE);return e<=0?[Number.MIN_VALUE,1]:[Math.max(Number.MIN_VALUE,.5*a),2*o]}ticks(t,n){const e=t[0]<=0?Number.MIN_VALUE:t[0],a=t[1]<=0?Number.MIN_VALUE:t[1],o=D6().domain([e,a]).ticks(n);return o.length?o:t}isSafeNumber(t){return Number.isFinite(t)&&t>0}}class i9{constructor(){this.scale=w8(),this.defaultFormatter=e9}forward(t,n,e){return this.scale.domain(t).range(n)(e)}reverse(t,n,e){return this.scale.domain(t).range(n).invert(e).getTime()}niceDomain(t){const[n,e]=this.scale.domain(t).nice().domain();return[n.getTime(),e.getTime()]}ticks(t,n){return this.scale.domain(t).ticks(n).map((t=>t.getTime()))}isSafeNumber(t){return Number.isFinite(t)}}const c9=Boolean(self.hasOwnProperty("document")&&document.createElement("canvas").getContext("webgl2"));function s9(){return self.hasOwnProperty("OffscreenCanvas")}function l9(t,n){if(t.length!==n.length)return!1;for(let e=0;e<t.length;e++)if(t[e]!==n[e])return!1;return!0}class m9{constructor(){this.xScale=a9(j$.LINEAR),this.yScale=a9(j$.LINEAR),this.domContainerRect={x:0,width:1,y:0,height:1},this.lastUpdated=0,this.currentViewBoxRect={x:0,width:1,y:0,height:1}}getUpdateIdentifier(){return this.lastUpdated}updateIdentifier(){this.lastUpdated++}isYAxisPointedDown(){return!0}setXScale(t){this.xScale=t,this.updateIdentifier()}setYScale(t){this.yScale=t,this.updateIdentifier()}getCurrentViewBoxRect(){return this.currentViewBoxRect}setViewBoxRect(t){this.currentViewBoxRect=t,this.updateIdentifier()}setDomContainerRect(t){this.domContainerRect=t,this.updateIdentifier()}transformDataToUiCoord(t,n){const e=t,a=(function o(t){return{x:[t.x,t.x+t.width],y:[t.y,t.y+t.height]}})(this.currentViewBoxRect);return[this.xScale.forward(a.x,[e.x,e.x+e.width],n[0]),this.yScale.forward(a.y,this.isYAxisPointedDown()?[e.y+e.height,e.y]:[e.y,e.y+e.height],n[1])]}}function d9(t,n,e,a){const{color:o,visible:r,opacity:i}=a;let c=t;if(c){if(!r)return c.style.display="none",c}else{if(!r)return null;c=n()}return c=e(c),c.style.display="",c.style.stroke=o,c.style.opacity=String(null!=i?i:1),c}class g9{constructor(t){this.svg=t}flush(){}onResize(t){}destroyObject(t){this.svg.removeChild(t.dom)}createPathDString(t){if(!t.length)return"";const n=new Array(t.length/2);n[0]=`M${t[0]},${t[1]}`;for(let e=1;e<t.length/2;e++)n[e]=`L${t[2*e]},${t[2*e+1]}`;return n.join("")}createOrUpdateLineObject(t,n,e){const a=d9(null==t?void 0:t.dom,(()=>{const t=document.createElementNS("http://www.w3.org/2000/svg","path");t.style.fill="none";const e=this.createPathDString(n);return t.setAttribute("d",e),this.svg.appendChild(t),t}),(e=>{if(!(null==t?void 0:t.data)||!l9(n,null==t?void 0:t.data)){const t=this.createPathDString(n);e.setAttribute("d",t)}return e}),e);return null===a?null:(a.style.strokeWidth=String(e.width),{dom:a,data:n})}createOrUpdateTriangleObject(t,n,e){const{size:a,color:o}=e,r=a*Math.sqrt(3)/2,i=new Float32Array([n.x-a/2,n.y+r/3,n.x+a/2,n.y+r/3,n.x,n.y-2*r/3]),c=d9(null==t?void 0:t.dom,(()=>{const t=document.createElementNS("http://www.w3.org/2000/svg","path");t.classList.add("triangle"),t.style.fill="none";const n=this.createPathDString(i);return t.setAttribute("d",n+"Z"),this.svg.appendChild(t),t}),(t=>{const n=this.createPathDString(i);return t.setAttribute("d",n+"Z"),t}),e);return null===c?null:(c.style.fill=o,{dom:c,data:i})}createOrUpdateCircleObject(t,n,e){const{color:a,radius:o}=e,r=d9(null==t?void 0:t.dom,(()=>{const t=document.createElementNS("http://www.w3.org/2000/svg","circle");return t.style.fill=a,t.setAttribute("cx",String(n.x)),t.setAttribute("cy",String(n.y)),t.setAttribute("r",String(o)),this.svg.appendChild(t),t}),(t=>(t.style.fill=a,t.setAttribute("cx",String(n.x)),t.setAttribute("cy",String(n.y)),t.setAttribute("r",String(o)),t)),e);return null===r?null:{dom:r,data:n}}createOrUpdateTrapezoidObject(t,n,e,a){if(n.y!==e.y)throw new RangeError("Input error: start.y != end.y.");const{altitude:o,color:r}=a,i=2/Math.sqrt(3)*o,c=new Float32Array([n.x-i/2,n.y+o/2,n.x,n.y-o/2,e.x,e.y-o/2,e.x+i/2,e.y+o/2]),s=d9(null==t?void 0:t.dom,(()=>{const t=document.createElementNS("http://www.w3.org/2000/svg","path");t.classList.add("trapezoid"),t.style.fill="none";const n=this.createPathDString(c);return t.setAttribute("d",n+"Z"),this.svg.appendChild(t),t}),(t=>{const n=this.createPathDString(c);return t.setAttribute("d",n+"Z"),t}),a);return null===s?null:(s.style.fill=r,{dom:s,data:c})}}const p9=100,b9=1e3,u9=1001,f9=1002,h9=1003,_9=1006,C9=1008,M9=1012,O9=1014,P9=1015,x9=1016,y9=1020,k9=1022,v9=1023,w9=1026,S9=1027,E9=2300,A9=2301,z9=2302,R9=2400,T9=2401,D9=2402,I9=3e3,N9=7680,F9=35044,L9=35048,H9="300 es";function B9(){}Object.assign(B9.prototype,{addEventListener:function(t,n){void 0===this._listeners&&(this._listeners={});const e=this._listeners;void 0===e[t]&&(e[t]=[]),-1===e[t].indexOf(n)&&e[t].push(n)},hasEventListener:function(t,n){if(void 0===this._listeners)return!1;const e=this._listeners;return void 0!==e[t]&&-1!==e[t].indexOf(n)},removeEventListener:function(t,n){if(void 0===this._listeners)return;const e=this._listeners[t];if(void 0!==e){const t=e.indexOf(n);-1!==t&&e.splice(t,1)}},dispatchEvent:function(t){if(void 0===this._listeners)return;const n=this._listeners[t.type];if(void 0!==n){t.target=this;const e=n.slice(0);for(let n=0,a=e.length;n<a;n++)e[n].call(this,t)}}});const V9=[];for(let t=0;t<256;t++)V9[t]=(t<16?"0":"")+t.toString(16);let j9=1234567;const U9={DEG2RAD:Math.PI/180,RAD2DEG:180/Math.PI,generateUUID:function(){const t=4294967295*Math.random()|0,n=4294967295*Math.random()|0,e=4294967295*Math.random()|0,a=4294967295*Math.random()|0;return(V9[255&t]+V9[t>>8&255]+V9[t>>16&255]+V9[t>>24&255]+"-"+V9[255&n]+V9[n>>8&255]+"-"+V9[n>>16&15|64]+V9[n>>24&255]+"-"+V9[63&e|128]+V9[e>>8&255]+"-"+V9[e>>16&255]+V9[e>>24&255]+V9[255&a]+V9[a>>8&255]+V9[a>>16&255]+V9[a>>24&255]).toUpperCase()},clamp:function(t,n,e){return Math.max(n,Math.min(e,t))},euclideanModulo:function(t,n){return(t%n+n)%n},mapLinear:function(t,n,e,a,o){return a+(t-n)*(o-a)/(e-n)},lerp:function(t,n,e){return(1-e)*t+e*n},damp:function(t,n,e,a){return U9.lerp(t,n,1-Math.exp(-e*a))},pingpong:function(t,n=1){return n-Math.abs(U9.euclideanModulo(t,2*n)-n)},smoothstep:function(t,n,e){return t<=n?0:t>=e?1:(t=(t-n)/(e-n))*t*(3-2*t)},smootherstep:function(t,n,e){return t<=n?0:t>=e?1:(t=(t-n)/(e-n))*t*t*(t*(6*t-15)+10)},randInt:function(t,n){return t+Math.floor(Math.random()*(n-t+1))},randFloat:function(t,n){return t+Math.random()*(n-t)},randFloatSpread:function(t){return t*(.5-Math.random())},seededRandom:function(t){return void 0!==t&&(j9=t%2147483647),j9=16807*j9%2147483647,(j9-1)/2147483646},degToRad:function(t){return t*U9.DEG2RAD},radToDeg:function(t){return t*U9.RAD2DEG},isPowerOfTwo:function(t){return 0==(t&t-1)&&0!==t},ceilPowerOfTwo:function(t){return Math.pow(2,Math.ceil(Math.log(t)/Math.LN2))},floorPowerOfTwo:function(t){return Math.pow(2,Math.floor(Math.log(t)/Math.LN2))},setQuaternionFromProperEuler:function(t,n,e,a,o){const r=Math.cos,i=Math.sin,c=r(e/2),s=i(e/2),l=r((n+a)/2),m=i((n+a)/2),d=r((n-a)/2),g=i((n-a)/2),p=r((a-n)/2),b=i((a-n)/2);switch(o){case"XYX":t.set(c*m,s*d,s*g,c*l);break;case"YZY":t.set(s*g,c*m,s*d,c*l);break;case"ZXZ":t.set(s*d,s*g,c*m,c*l);break;case"XZX":t.set(c*m,s*b,s*p,c*l);break;case"YXY":t.set(s*p,c*m,s*b,c*l);break;case"ZYZ":t.set(s*b,s*p,c*m,c*l);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+o)}}};class W9{constructor(t=0,n=0){Object.defineProperty(this,"isVector2",{value:!0}),this.x=t,this.y=n}get width(){return this.x}set width(t){this.x=t}get height(){return this.y}set height(t){this.y=t}set(t,n){return this.x=t,this.y=n,this}setScalar(t){return this.x=t,this.y=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setComponent(t,n){switch(t){case 0:this.x=n;break;case 1:this.y=n;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y)}copy(t){return this.x=t.x,this.y=t.y,this}add(t,n){return void 0!==n?(console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,n)):(this.x+=t.x,this.y+=t.y,this)}addScalar(t){return this.x+=t,this.y+=t,this}addVectors(t,n){return this.x=t.x+n.x,this.y=t.y+n.y,this}addScaledVector(t,n){return this.x+=t.x*n,this.y+=t.y*n,this}sub(t,n){return void 0!==n?(console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,n)):(this.x-=t.x,this.y-=t.y,this)}subScalar(t){return this.x-=t,this.y-=t,this}subVectors(t,n){return this.x=t.x-n.x,this.y=t.y-n.y,this}multiply(t){return this.x*=t.x,this.y*=t.y,this}multiplyScalar(t){return this.x*=t,this.y*=t,this}divide(t){return this.x/=t.x,this.y/=t.y,this}divideScalar(t){return this.multiplyScalar(1/t)}applyMatrix3(t){const n=this.x,e=this.y,a=t.elements;return this.x=a[0]*n+a[3]*e+a[6],this.y=a[1]*n+a[4]*e+a[7],this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this}clamp(t,n){return this.x=Math.max(t.x,Math.min(n.x,this.x)),this.y=Math.max(t.y,Math.min(n.y,this.y)),this}clampScalar(t,n){return this.x=Math.max(t,Math.min(n,this.x)),this.y=Math.max(t,Math.min(n,this.y)),this}clampLength(t,n){const e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(t,Math.min(n,e)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(t){return this.x*t.x+this.y*t.y}cross(t){return this.x*t.y-this.y*t.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const n=this.x-t.x,e=this.y-t.y;return n*n+e*e}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,n){return this.x+=(t.x-this.x)*n,this.y+=(t.y-this.y)*n,this}lerpVectors(t,n,e){return this.x=t.x+(n.x-t.x)*e,this.y=t.y+(n.y-t.y)*e,this}equals(t){return t.x===this.x&&t.y===this.y}fromArray(t,n=0){return this.x=t[n],this.y=t[n+1],this}toArray(t=[],n=0){return t[n]=this.x,t[n+1]=this.y,t}fromBufferAttribute(t,n,e){return void 0!==e&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(n),this.y=t.getY(n),this}rotateAround(t,n){const e=Math.cos(n),a=Math.sin(n),o=this.x-t.x,r=this.y-t.y;return this.x=o*e-r*a+t.x,this.y=o*a+r*e+t.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}}class G9{constructor(){Object.defineProperty(this,"isMatrix3",{value:!0}),this.elements=[1,0,0,0,1,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}set(t,n,e,a,o,r,i,c,s){const l=this.elements;return l[0]=t,l[1]=a,l[2]=i,l[3]=n,l[4]=o,l[5]=c,l[6]=e,l[7]=r,l[8]=s,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}clone(){return(new this.constructor).fromArray(this.elements)}copy(t){const n=this.elements,e=t.elements;return n[0]=e[0],n[1]=e[1],n[2]=e[2],n[3]=e[3],n[4]=e[4],n[5]=e[5],n[6]=e[6],n[7]=e[7],n[8]=e[8],this}extractBasis(t,n,e){return t.setFromMatrix3Column(this,0),n.setFromMatrix3Column(this,1),e.setFromMatrix3Column(this,2),this}setFromMatrix4(t){const n=t.elements;return this.set(n[0],n[4],n[8],n[1],n[5],n[9],n[2],n[6],n[10]),this}multiply(t){return this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,n){const e=t.elements,a=n.elements,o=this.elements,r=e[0],i=e[3],c=e[6],s=e[1],l=e[4],m=e[7],d=e[2],g=e[5],p=e[8],b=a[0],u=a[3],f=a[6],h=a[1],_=a[4],C=a[7],M=a[2],O=a[5],P=a[8];return o[0]=r*b+i*h+c*M,o[3]=r*u+i*_+c*O,o[6]=r*f+i*C+c*P,o[1]=s*b+l*h+m*M,o[4]=s*u+l*_+m*O,o[7]=s*f+l*C+m*P,o[2]=d*b+g*h+p*M,o[5]=d*u+g*_+p*O,o[8]=d*f+g*C+p*P,this}multiplyScalar(t){const n=this.elements;return n[0]*=t,n[3]*=t,n[6]*=t,n[1]*=t,n[4]*=t,n[7]*=t,n[2]*=t,n[5]*=t,n[8]*=t,this}determinant(){const t=this.elements,n=t[0],e=t[1],a=t[2],o=t[3],r=t[4],i=t[5],c=t[6],s=t[7],l=t[8];return n*r*l-n*i*s-e*o*l+e*i*c+a*o*s-a*r*c}invert(){const t=this.elements,n=t[0],e=t[1],a=t[2],o=t[3],r=t[4],i=t[5],c=t[6],s=t[7],l=t[8],m=l*r-i*s,d=i*c-l*o,g=s*o-r*c,p=n*m+e*d+a*g;if(0===p)return this.set(0,0,0,0,0,0,0,0,0);const b=1/p;return t[0]=m*b,t[1]=(a*s-l*e)*b,t[2]=(i*e-a*r)*b,t[3]=d*b,t[4]=(l*n-a*c)*b,t[5]=(a*o-i*n)*b,t[6]=g*b,t[7]=(e*c-s*n)*b,t[8]=(r*n-e*o)*b,this}transpose(){let t;const n=this.elements;return t=n[1],n[1]=n[3],n[3]=t,t=n[2],n[2]=n[6],n[6]=t,t=n[5],n[5]=n[7],n[7]=t,this}getNormalMatrix(t){return this.setFromMatrix4(t).copy(this).invert().transpose()}transposeIntoArray(t){const n=this.elements;return t[0]=n[0],t[1]=n[3],t[2]=n[6],t[3]=n[1],t[4]=n[4],t[5]=n[7],t[6]=n[2],t[7]=n[5],t[8]=n[8],this}setUvTransform(t,n,e,a,o,r,i){const c=Math.cos(o),s=Math.sin(o);return this.set(e*c,e*s,-e*(c*r+s*i)+r+t,-a*s,a*c,-a*(-s*r+c*i)+i+n,0,0,1),this}scale(t,n){const e=this.elements;return e[0]*=t,e[3]*=t,e[6]*=t,e[1]*=n,e[4]*=n,e[7]*=n,this}rotate(t){const n=Math.cos(t),e=Math.sin(t),a=this.elements,o=a[0],r=a[3],i=a[6],c=a[1],s=a[4],l=a[7];return a[0]=n*o+e*c,a[3]=n*r+e*s,a[6]=n*i+e*l,a[1]=-e*o+n*c,a[4]=-e*r+n*s,a[7]=-e*i+n*l,this}translate(t,n){const e=this.elements;return e[0]+=t*e[2],e[3]+=t*e[5],e[6]+=t*e[8],e[1]+=n*e[2],e[4]+=n*e[5],e[7]+=n*e[8],this}equals(t){const n=this.elements,e=t.elements;for(let t=0;t<9;t++)if(n[t]!==e[t])return!1;return!0}fromArray(t,n=0){for(let e=0;e<9;e++)this.elements[e]=t[e+n];return this}toArray(t=[],n=0){const e=this.elements;return t[n]=e[0],t[n+1]=e[1],t[n+2]=e[2],t[n+3]=e[3],t[n+4]=e[4],t[n+5]=e[5],t[n+6]=e[6],t[n+7]=e[7],t[n+8]=e[8],t}}let Y9;const q9={getDataURL:function(t){if(/^data:/i.test(t.src))return t.src;if("undefined"==typeof HTMLCanvasElement)return t.src;let n;if(t instanceof HTMLCanvasElement)n=t;else{void 0===Y9&&(Y9=document.createElementNS("http://www.w3.org/1999/xhtml","canvas")),Y9.width=t.width,Y9.height=t.height;const e=Y9.getContext("2d");t instanceof ImageData?e.putImageData(t,0,0):e.drawImage(t,0,0,t.width,t.height),n=Y9}return n.width>2048||n.height>2048?n.toDataURL("image/jpeg",.6):n.toDataURL("image/png")}};let Z9=0;function X9(t=X9.DEFAULT_IMAGE,n=X9.DEFAULT_MAPPING,e=1001,a=1001,o=1006,r=1008,i=1023,c=1009,s=1,l=3e3){Object.defineProperty(this,"id",{value:Z9++}),this.uuid=U9.generateUUID(),this.name="",this.image=t,this.mipmaps=[],this.mapping=n,this.wrapS=e,this.wrapT=a,this.magFilter=o,this.minFilter=r,this.anisotropy=s,this.format=i,this.internalFormat=null,this.type=c,this.offset=new W9(0,0),this.repeat=new W9(1,1),this.center=new W9(0,0),this.rotation=0,this.matrixAutoUpdate=!0,this.matrix=new G9,this.generateMipmaps=!0,this.premultiplyAlpha=!1,this.flipY=!0,this.unpackAlignment=4,this.encoding=l,this.version=0,this.onUpdate=null}function J9(t){return"undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap?q9.getDataURL(t):t.data?{data:Array.prototype.slice.call(t.data),width:t.width,height:t.height,type:t.data.constructor.name}:(console.warn("THREE.Texture: Unable to serialize Texture."),{})}X9.DEFAULT_IMAGE=void 0,X9.DEFAULT_MAPPING=300,X9.prototype=Object.assign(Object.create(B9.prototype),{constructor:X9,isTexture:!0,updateMatrix:function(){this.matrix.setUvTransform(this.offset.x,this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)},clone:function(){return(new this.constructor).copy(this)},copy:function(t){return this.name=t.name,this.image=t.image,this.mipmaps=t.mipmaps.slice(0),this.mapping=t.mapping,this.wrapS=t.wrapS,this.wrapT=t.wrapT,this.magFilter=t.magFilter,this.minFilter=t.minFilter,this.anisotropy=t.anisotropy,this.format=t.format,this.internalFormat=t.internalFormat,this.type=t.type,this.offset.copy(t.offset),this.repeat.copy(t.repeat),this.center.copy(t.center),this.rotation=t.rotation,this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrix.copy(t.matrix),this.generateMipmaps=t.generateMipmaps,this.premultiplyAlpha=t.premultiplyAlpha,this.flipY=t.flipY,this.unpackAlignment=t.unpackAlignment,this.encoding=t.encoding,this},toJSON:function(t){const n=void 0===t||"string"==typeof t;if(!n&&void 0!==t.textures[this.uuid])return t.textures[this.uuid];const e={metadata:{version:4.5,type:"Texture",generator:"Texture.toJSON"},uuid:this.uuid,name:this.name,mapping:this.mapping,repeat:[this.repeat.x,this.repeat.y],offset:[this.offset.x,this.offset.y],center:[this.center.x,this.center.y],rotation:this.rotation,wrap:[this.wrapS,this.wrapT],format:this.format,type:this.type,encoding:this.encoding,minFilter:this.minFilter,magFilter:this.magFilter,anisotropy:this.anisotropy,flipY:this.flipY,premultiplyAlpha:this.premultiplyAlpha,unpackAlignment:this.unpackAlignment};if(void 0!==this.image){const a=this.image;if(void 0===a.uuid&&(a.uuid=U9.generateUUID()),!n&&void 0===t.images[a.uuid]){let n;if(Array.isArray(a)){n=[];for(let t=0,e=a.length;t<e;t++)n.push(J9(a[t].isDataTexture?a[t].image:a[t]))}else n=J9(a);t.images[a.uuid]={uuid:a.uuid,url:n}}e.image=a.uuid}return n||(t.textures[this.uuid]=e),e},dispose:function(){this.dispatchEvent({type:"dispose"})},transformUv:function(t){if(300!==this.mapping)return t;if(t.applyMatrix3(this.matrix),t.x<0||t.x>1)switch(this.wrapS){case b9:t.x=t.x-Math.floor(t.x);break;case u9:t.x=t.x<0?0:1;break;case f9:t.x=1===Math.abs(Math.floor(t.x)%2)?Math.ceil(t.x)-t.x:t.x-Math.floor(t.x)}if(t.y<0||t.y>1)switch(this.wrapT){case b9:t.y=t.y-Math.floor(t.y);break;case u9:t.y=t.y<0?0:1;break;case f9:t.y=1===Math.abs(Math.floor(t.y)%2)?Math.ceil(t.y)-t.y:t.y-Math.floor(t.y)}return this.flipY&&(t.y=1-t.y),t}}),Object.defineProperty(X9.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}});class Q9{constructor(t=0,n=0,e=0,a=1){Object.defineProperty(this,"isVector4",{value:!0}),this.x=t,this.y=n,this.z=e,this.w=a}get width(){return this.z}set width(t){this.z=t}get height(){return this.w}set height(t){this.w=t}set(t,n,e,a){return this.x=t,this.y=n,this.z=e,this.w=a,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this.w=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setW(t){return this.w=t,this}setComponent(t,n){switch(t){case 0:this.x=n;break;case 1:this.y=n;break;case 2:this.z=n;break;case 3:this.w=n;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this.w=void 0!==t.w?t.w:1,this}add(t,n){return void 0!==n?(console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,n)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this.w+=t,this}addVectors(t,n){return this.x=t.x+n.x,this.y=t.y+n.y,this.z=t.z+n.z,this.w=t.w+n.w,this}addScaledVector(t,n){return this.x+=t.x*n,this.y+=t.y*n,this.z+=t.z*n,this.w+=t.w*n,this}sub(t,n){return void 0!==n?(console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,n)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this.w-=t,this}subVectors(t,n){return this.x=t.x-n.x,this.y=t.y-n.y,this.z=t.z-n.z,this.w=t.w-n.w,this}multiply(t){return this.x*=t.x,this.y*=t.y,this.z*=t.z,this.w*=t.w,this}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this}applyMatrix4(t){const n=this.x,e=this.y,a=this.z,o=this.w,r=t.elements;return this.x=r[0]*n+r[4]*e+r[8]*a+r[12]*o,this.y=r[1]*n+r[5]*e+r[9]*a+r[13]*o,this.z=r[2]*n+r[6]*e+r[10]*a+r[14]*o,this.w=r[3]*n+r[7]*e+r[11]*a+r[15]*o,this}divideScalar(t){return this.multiplyScalar(1/t)}setAxisAngleFromQuaternion(t){this.w=2*Math.acos(t.w);const n=Math.sqrt(1-t.w*t.w);return n<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=t.x/n,this.y=t.y/n,this.z=t.z/n),this}setAxisAngleFromRotationMatrix(t){let n,e,a,o;const r=.01,i=.1,c=t.elements,s=c[0],l=c[4],m=c[8],d=c[1],g=c[5],p=c[9],b=c[2],u=c[6],f=c[10];if(Math.abs(l-d)<r&&Math.abs(m-b)<r&&Math.abs(p-u)<r){if(Math.abs(l+d)<i&&Math.abs(m+b)<i&&Math.abs(p+u)<i&&Math.abs(s+g+f-3)<i)return this.set(1,0,0,0),this;n=Math.PI;const t=(s+1)/2,c=(g+1)/2,h=(f+1)/2,_=(l+d)/4,C=(m+b)/4,M=(p+u)/4;return t>c&&t>h?t<r?(e=0,a=.707106781,o=.707106781):(e=Math.sqrt(t),a=_/e,o=C/e):c>h?c<r?(e=.707106781,a=0,o=.707106781):(a=Math.sqrt(c),e=_/a,o=M/a):h<r?(e=.707106781,a=.707106781,o=0):(o=Math.sqrt(h),e=C/o,a=M/o),this.set(e,a,o,n),this}let h=Math.sqrt((u-p)*(u-p)+(m-b)*(m-b)+(d-l)*(d-l));return Math.abs(h)<.001&&(h=1),this.x=(u-p)/h,this.y=(m-b)/h,this.z=(d-l)/h,this.w=Math.acos((s+g+f-1)/2),this}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this.w=Math.min(this.w,t.w),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this.w=Math.max(this.w,t.w),this}clamp(t,n){return this.x=Math.max(t.x,Math.min(n.x,this.x)),this.y=Math.max(t.y,Math.min(n.y,this.y)),this.z=Math.max(t.z,Math.min(n.z,this.z)),this.w=Math.max(t.w,Math.min(n.w,this.w)),this}clampScalar(t,n){return this.x=Math.max(t,Math.min(n,this.x)),this.y=Math.max(t,Math.min(n,this.y)),this.z=Math.max(t,Math.min(n,this.z)),this.w=Math.max(t,Math.min(n,this.w)),this}clampLength(t,n){const e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(t,Math.min(n,e)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this.w=this.w<0?Math.ceil(this.w):Math.floor(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z+this.w*t.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,n){return this.x+=(t.x-this.x)*n,this.y+=(t.y-this.y)*n,this.z+=(t.z-this.z)*n,this.w+=(t.w-this.w)*n,this}lerpVectors(t,n,e){return this.x=t.x+(n.x-t.x)*e,this.y=t.y+(n.y-t.y)*e,this.z=t.z+(n.z-t.z)*e,this.w=t.w+(n.w-t.w)*e,this}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z&&t.w===this.w}fromArray(t,n=0){return this.x=t[n],this.y=t[n+1],this.z=t[n+2],this.w=t[n+3],this}toArray(t=[],n=0){return t[n]=this.x,t[n+1]=this.y,t[n+2]=this.z,t[n+3]=this.w,t}fromBufferAttribute(t,n,e){return void 0!==e&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(n),this.y=t.getY(n),this.z=t.getZ(n),this.w=t.getW(n),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}}class K9 extends B9{constructor(t,n,e){super(),Object.defineProperty(this,"isWebGLRenderTarget",{value:!0}),this.width=t,this.height=n,this.scissor=new Q9(0,0,t,n),this.scissorTest=!1,this.viewport=new Q9(0,0,t,n),this.texture=new X9(void 0,(e=e||{}).mapping,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,e.anisotropy,e.encoding),this.texture.image={},this.texture.image.width=t,this.texture.image.height=n,this.texture.generateMipmaps=void 0!==e.generateMipmaps&&e.generateMipmaps,this.texture.minFilter=void 0!==e.minFilter?e.minFilter:_9,this.depthBuffer=void 0===e.depthBuffer||e.depthBuffer,this.stencilBuffer=void 0!==e.stencilBuffer&&e.stencilBuffer,this.depthTexture=void 0!==e.depthTexture?e.depthTexture:null}setSize(t,n){this.width===t&&this.height===n||(this.width=t,this.height=n,this.texture.image.width=t,this.texture.image.height=n,this.dispose()),this.viewport.set(0,0,t,n),this.scissor.set(0,0,t,n)}clone(){return(new this.constructor).copy(this)}copy(t){return this.width=t.width,this.height=t.height,this.viewport.copy(t.viewport),this.texture=t.texture.clone(),this.depthBuffer=t.depthBuffer,this.stencilBuffer=t.stencilBuffer,this.depthTexture=t.depthTexture,this}dispose(){this.dispatchEvent({type:"dispose"})}}class $9{constructor(t=0,n=0,e=0,a=1){Object.defineProperty(this,"isQuaternion",{value:!0}),this._x=t,this._y=n,this._z=e,this._w=a}static slerp(t,n,e,a){return e.copy(t).slerp(n,a)}static slerpFlat(t,n,e,a,o,r,i){let c=e[a+0],s=e[a+1],l=e[a+2],m=e[a+3];const d=o[r+0],g=o[r+1],p=o[r+2],b=o[r+3];if(m!==b||c!==d||s!==g||l!==p){let t=1-i;const n=c*d+s*g+l*p+m*b,e=n>=0?1:-1,a=1-n*n;if(a>Number.EPSILON){const o=Math.sqrt(a),r=Math.atan2(o,n*e);t=Math.sin(t*r)/o,i=Math.sin(i*r)/o}const o=i*e;if(c=c*t+d*o,s=s*t+g*o,l=l*t+p*o,m=m*t+b*o,t===1-i){const t=1/Math.sqrt(c*c+s*s+l*l+m*m);c*=t,s*=t,l*=t,m*=t}}t[n]=c,t[n+1]=s,t[n+2]=l,t[n+3]=m}static multiplyQuaternionsFlat(t,n,e,a,o,r){const i=e[a],c=e[a+1],s=e[a+2],l=e[a+3],m=o[r],d=o[r+1],g=o[r+2],p=o[r+3];return t[n]=i*p+l*m+c*g-s*d,t[n+1]=c*p+l*d+s*m-i*g,t[n+2]=s*p+l*g+i*d-c*m,t[n+3]=l*p-i*m-c*d-s*g,t}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get w(){return this._w}set w(t){this._w=t,this._onChangeCallback()}set(t,n,e,a){return this._x=t,this._y=n,this._z=e,this._w=a,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(t){return this._x=t.x,this._y=t.y,this._z=t.z,this._w=t.w,this._onChangeCallback(),this}setFromEuler(t,n){if(!t||!t.isEuler)throw new Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");const e=t._x,a=t._y,o=t._z,r=t._order,i=Math.cos,c=Math.sin,s=i(e/2),l=i(a/2),m=i(o/2),d=c(e/2),g=c(a/2),p=c(o/2);switch(r){case"XYZ":this._x=d*l*m+s*g*p,this._y=s*g*m-d*l*p,this._z=s*l*p+d*g*m,this._w=s*l*m-d*g*p;break;case"YXZ":this._x=d*l*m+s*g*p,this._y=s*g*m-d*l*p,this._z=s*l*p-d*g*m,this._w=s*l*m+d*g*p;break;case"ZXY":this._x=d*l*m-s*g*p,this._y=s*g*m+d*l*p,this._z=s*l*p+d*g*m,this._w=s*l*m-d*g*p;break;case"ZYX":this._x=d*l*m-s*g*p,this._y=s*g*m+d*l*p,this._z=s*l*p-d*g*m,this._w=s*l*m+d*g*p;break;case"YZX":this._x=d*l*m+s*g*p,this._y=s*g*m+d*l*p,this._z=s*l*p-d*g*m,this._w=s*l*m-d*g*p;break;case"XZY":this._x=d*l*m-s*g*p,this._y=s*g*m-d*l*p,this._z=s*l*p+d*g*m,this._w=s*l*m+d*g*p;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+r)}return!1!==n&&this._onChangeCallback(),this}setFromAxisAngle(t,n){const e=n/2,a=Math.sin(e);return this._x=t.x*a,this._y=t.y*a,this._z=t.z*a,this._w=Math.cos(e),this._onChangeCallback(),this}setFromRotationMatrix(t){const n=t.elements,e=n[0],a=n[4],o=n[8],r=n[1],i=n[5],c=n[9],s=n[2],l=n[6],m=n[10],d=e+i+m;if(d>0){const t=.5/Math.sqrt(d+1);this._w=.25/t,this._x=(l-c)*t,this._y=(o-s)*t,this._z=(r-a)*t}else if(e>i&&e>m){const t=2*Math.sqrt(1+e-i-m);this._w=(l-c)/t,this._x=.25*t,this._y=(a+r)/t,this._z=(o+s)/t}else if(i>m){const t=2*Math.sqrt(1+i-e-m);this._w=(o-s)/t,this._x=(a+r)/t,this._y=.25*t,this._z=(c+l)/t}else{const t=2*Math.sqrt(1+m-e-i);this._w=(r-a)/t,this._x=(o+s)/t,this._y=(c+l)/t,this._z=.25*t}return this._onChangeCallback(),this}setFromUnitVectors(t,n){let e=t.dot(n)+1;return e<1e-6?(e=0,Math.abs(t.x)>Math.abs(t.z)?(this._x=-t.y,this._y=t.x,this._z=0,this._w=e):(this._x=0,this._y=-t.z,this._z=t.y,this._w=e)):(this._x=t.y*n.z-t.z*n.y,this._y=t.z*n.x-t.x*n.z,this._z=t.x*n.y-t.y*n.x,this._w=e),this.normalize()}angleTo(t){return 2*Math.acos(Math.abs(U9.clamp(this.dot(t),-1,1)))}rotateTowards(t,n){const e=this.angleTo(t);if(0===e)return this;const a=Math.min(1,n/e);return this.slerp(t,a),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(t){return this._x*t._x+this._y*t._y+this._z*t._z+this._w*t._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let t=this.length();return 0===t?(this._x=0,this._y=0,this._z=0,this._w=1):(t=1/t,this._x=this._x*t,this._y=this._y*t,this._z=this._z*t,this._w=this._w*t),this._onChangeCallback(),this}multiply(t,n){return void 0!==n?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(t,n)):this.multiplyQuaternions(this,t)}premultiply(t){return this.multiplyQuaternions(t,this)}multiplyQuaternions(t,n){const e=t._x,a=t._y,o=t._z,r=t._w,i=n._x,c=n._y,s=n._z,l=n._w;return this._x=e*l+r*i+a*s-o*c,this._y=a*l+r*c+o*i-e*s,this._z=o*l+r*s+e*c-a*i,this._w=r*l-e*i-a*c-o*s,this._onChangeCallback(),this}slerp(t,n){if(0===n)return this;if(1===n)return this.copy(t);const e=this._x,a=this._y,o=this._z,r=this._w;let i=r*t._w+e*t._x+a*t._y+o*t._z;if(i<0?(this._w=-t._w,this._x=-t._x,this._y=-t._y,this._z=-t._z,i=-i):this.copy(t),i>=1)return this._w=r,this._x=e,this._y=a,this._z=o,this;const c=1-i*i;if(c<=Number.EPSILON){const t=1-n;return this._w=t*r+n*this._w,this._x=t*e+n*this._x,this._y=t*a+n*this._y,this._z=t*o+n*this._z,this.normalize(),this._onChangeCallback(),this}const s=Math.sqrt(c),l=Math.atan2(s,i),m=Math.sin((1-n)*l)/s,d=Math.sin(n*l)/s;return this._w=r*m+this._w*d,this._x=e*m+this._x*d,this._y=a*m+this._y*d,this._z=o*m+this._z*d,this._onChangeCallback(),this}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._w===this._w}fromArray(t,n=0){return this._x=t[n],this._y=t[n+1],this._z=t[n+2],this._w=t[n+3],this._onChangeCallback(),this}toArray(t=[],n=0){return t[n]=this._x,t[n+1]=this._y,t[n+2]=this._z,t[n+3]=this._w,t}fromBufferAttribute(t,n){return this._x=t.getX(n),this._y=t.getY(n),this._z=t.getZ(n),this._w=t.getW(n),this}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}class ttt{constructor(t=0,n=0,e=0){Object.defineProperty(this,"isVector3",{value:!0}),this.x=t,this.y=n,this.z=e}set(t,n,e){return void 0===e&&(e=this.z),this.x=t,this.y=n,this.z=e,this}setScalar(t){return this.x=t,this.y=t,this.z=t,this}setX(t){return this.x=t,this}setY(t){return this.y=t,this}setZ(t){return this.z=t,this}setComponent(t,n){switch(t){case 0:this.x=n;break;case 1:this.y=n;break;case 2:this.z=n;break;default:throw new Error("index is out of range: "+t)}return this}getComponent(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+t)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(t){return this.x=t.x,this.y=t.y,this.z=t.z,this}add(t,n){return void 0!==n?(console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(t,n)):(this.x+=t.x,this.y+=t.y,this.z+=t.z,this)}addScalar(t){return this.x+=t,this.y+=t,this.z+=t,this}addVectors(t,n){return this.x=t.x+n.x,this.y=t.y+n.y,this.z=t.z+n.z,this}addScaledVector(t,n){return this.x+=t.x*n,this.y+=t.y*n,this.z+=t.z*n,this}sub(t,n){return void 0!==n?(console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(t,n)):(this.x-=t.x,this.y-=t.y,this.z-=t.z,this)}subScalar(t){return this.x-=t,this.y-=t,this.z-=t,this}subVectors(t,n){return this.x=t.x-n.x,this.y=t.y-n.y,this.z=t.z-n.z,this}multiply(t,n){return void 0!==n?(console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(t,n)):(this.x*=t.x,this.y*=t.y,this.z*=t.z,this)}multiplyScalar(t){return this.x*=t,this.y*=t,this.z*=t,this}multiplyVectors(t,n){return this.x=t.x*n.x,this.y=t.y*n.y,this.z=t.z*n.z,this}applyEuler(t){return t&&t.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order."),this.applyQuaternion(ett.setFromEuler(t))}applyAxisAngle(t,n){return this.applyQuaternion(ett.setFromAxisAngle(t,n))}applyMatrix3(t){const n=this.x,e=this.y,a=this.z,o=t.elements;return this.x=o[0]*n+o[3]*e+o[6]*a,this.y=o[1]*n+o[4]*e+o[7]*a,this.z=o[2]*n+o[5]*e+o[8]*a,this}applyNormalMatrix(t){return this.applyMatrix3(t).normalize()}applyMatrix4(t){const n=this.x,e=this.y,a=this.z,o=t.elements,r=1/(o[3]*n+o[7]*e+o[11]*a+o[15]);return this.x=(o[0]*n+o[4]*e+o[8]*a+o[12])*r,this.y=(o[1]*n+o[5]*e+o[9]*a+o[13])*r,this.z=(o[2]*n+o[6]*e+o[10]*a+o[14])*r,this}applyQuaternion(t){const n=this.x,e=this.y,a=this.z,o=t.x,r=t.y,i=t.z,c=t.w,s=c*n+r*a-i*e,l=c*e+i*n-o*a,m=c*a+o*e-r*n,d=-o*n-r*e-i*a;return this.x=s*c+d*-o+l*-i-m*-r,this.y=l*c+d*-r+m*-o-s*-i,this.z=m*c+d*-i+s*-r-l*-o,this}project(t){return this.applyMatrix4(t.matrixWorldInverse).applyMatrix4(t.projectionMatrix)}unproject(t){return this.applyMatrix4(t.projectionMatrixInverse).applyMatrix4(t.matrixWorld)}transformDirection(t){const n=this.x,e=this.y,a=this.z,o=t.elements;return this.x=o[0]*n+o[4]*e+o[8]*a,this.y=o[1]*n+o[5]*e+o[9]*a,this.z=o[2]*n+o[6]*e+o[10]*a,this.normalize()}divide(t){return this.x/=t.x,this.y/=t.y,this.z/=t.z,this}divideScalar(t){return this.multiplyScalar(1/t)}min(t){return this.x=Math.min(this.x,t.x),this.y=Math.min(this.y,t.y),this.z=Math.min(this.z,t.z),this}max(t){return this.x=Math.max(this.x,t.x),this.y=Math.max(this.y,t.y),this.z=Math.max(this.z,t.z),this}clamp(t,n){return this.x=Math.max(t.x,Math.min(n.x,this.x)),this.y=Math.max(t.y,Math.min(n.y,this.y)),this.z=Math.max(t.z,Math.min(n.z,this.z)),this}clampScalar(t,n){return this.x=Math.max(t,Math.min(n,this.x)),this.y=Math.max(t,Math.min(n,this.y)),this.z=Math.max(t,Math.min(n,this.z)),this}clampLength(t,n){const e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(t,Math.min(n,e)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=this.x<0?Math.ceil(this.x):Math.floor(this.x),this.y=this.y<0?Math.ceil(this.y):Math.floor(this.y),this.z=this.z<0?Math.ceil(this.z):Math.floor(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(t){return this.x*t.x+this.y*t.y+this.z*t.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(t){return this.normalize().multiplyScalar(t)}lerp(t,n){return this.x+=(t.x-this.x)*n,this.y+=(t.y-this.y)*n,this.z+=(t.z-this.z)*n,this}lerpVectors(t,n,e){return this.x=t.x+(n.x-t.x)*e,this.y=t.y+(n.y-t.y)*e,this.z=t.z+(n.z-t.z)*e,this}cross(t,n){return void 0!==n?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(t,n)):this.crossVectors(this,t)}crossVectors(t,n){const e=t.x,a=t.y,o=t.z,r=n.x,i=n.y,c=n.z;return this.x=a*c-o*i,this.y=o*r-e*c,this.z=e*i-a*r,this}projectOnVector(t){const n=t.lengthSq();if(0===n)return this.set(0,0,0);const e=t.dot(this)/n;return this.copy(t).multiplyScalar(e)}projectOnPlane(t){return ntt.copy(this).projectOnVector(t),this.sub(ntt)}reflect(t){return this.sub(ntt.copy(t).multiplyScalar(2*this.dot(t)))}angleTo(t){const n=Math.sqrt(this.lengthSq()*t.lengthSq());if(0===n)return Math.PI/2;const e=this.dot(t)/n;return Math.acos(U9.clamp(e,-1,1))}distanceTo(t){return Math.sqrt(this.distanceToSquared(t))}distanceToSquared(t){const n=this.x-t.x,e=this.y-t.y,a=this.z-t.z;return n*n+e*e+a*a}manhattanDistanceTo(t){return Math.abs(this.x-t.x)+Math.abs(this.y-t.y)+Math.abs(this.z-t.z)}setFromSpherical(t){return this.setFromSphericalCoords(t.radius,t.phi,t.theta)}setFromSphericalCoords(t,n,e){const a=Math.sin(n)*t;return this.x=a*Math.sin(e),this.y=Math.cos(n)*t,this.z=a*Math.cos(e),this}setFromCylindrical(t){return this.setFromCylindricalCoords(t.radius,t.theta,t.y)}setFromCylindricalCoords(t,n,e){return this.x=t*Math.sin(n),this.y=e,this.z=t*Math.cos(n),this}setFromMatrixPosition(t){const n=t.elements;return this.x=n[12],this.y=n[13],this.z=n[14],this}setFromMatrixScale(t){const n=this.setFromMatrixColumn(t,0).length(),e=this.setFromMatrixColumn(t,1).length(),a=this.setFromMatrixColumn(t,2).length();return this.x=n,this.y=e,this.z=a,this}setFromMatrixColumn(t,n){return this.fromArray(t.elements,4*n)}setFromMatrix3Column(t,n){return this.fromArray(t.elements,3*n)}equals(t){return t.x===this.x&&t.y===this.y&&t.z===this.z}fromArray(t,n=0){return this.x=t[n],this.y=t[n+1],this.z=t[n+2],this}toArray(t=[],n=0){return t[n]=this.x,t[n+1]=this.y,t[n+2]=this.z,t}fromBufferAttribute(t,n,e){return void 0!==e&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute()."),this.x=t.getX(n),this.y=t.getY(n),this.z=t.getZ(n),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}}const ntt=new ttt,ett=new $9;class att{constructor(t,n){Object.defineProperty(this,"isBox3",{value:!0}),this.min=void 0!==t?t:new ttt(1/0,1/0,1/0),this.max=void 0!==n?n:new ttt(-1/0,-1/0,-1/0)}set(t,n){return this.min.copy(t),this.max.copy(n),this}setFromArray(t){let n=1/0,e=1/0,a=1/0,o=-1/0,r=-1/0,i=-1/0;for(let c=0,s=t.length;c<s;c+=3){const s=t[c],l=t[c+1],m=t[c+2];s<n&&(n=s),l<e&&(e=l),m<a&&(a=m),s>o&&(o=s),l>r&&(r=l),m>i&&(i=m)}return this.min.set(n,e,a),this.max.set(o,r,i),this}setFromBufferAttribute(t){let n=1/0,e=1/0,a=1/0,o=-1/0,r=-1/0,i=-1/0;for(let c=0,s=t.count;c<s;c++){const s=t.getX(c),l=t.getY(c),m=t.getZ(c);s<n&&(n=s),l<e&&(e=l),m<a&&(a=m),s>o&&(o=s),l>r&&(r=l),m>i&&(i=m)}return this.min.set(n,e,a),this.max.set(o,r,i),this}setFromPoints(t){this.makeEmpty();for(let n=0,e=t.length;n<e;n++)this.expandByPoint(t[n]);return this}setFromCenterAndSize(t,n){const e=itt.copy(n).multiplyScalar(.5);return this.min.copy(t).sub(e),this.max.copy(t).add(e),this}setFromObject(t){return this.makeEmpty(),this.expandByObject(t)}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=this.min.z=1/0,this.max.x=this.max.y=this.max.z=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z}getCenter(t){return void 0===t&&(console.warn("THREE.Box3: .getCenter() target is now required"),t=new ttt),this.isEmpty()?t.set(0,0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return void 0===t&&(console.warn("THREE.Box3: .getSize() target is now required"),t=new ttt),this.isEmpty()?t.set(0,0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}expandByObject(t){t.updateWorldMatrix(!1,!1);const n=t.geometry;void 0!==n&&(null===n.boundingBox&&n.computeBoundingBox(),ctt.copy(n.boundingBox),ctt.applyMatrix4(t.matrixWorld),this.union(ctt));const e=t.children;for(let t=0,n=e.length;t<n;t++)this.expandByObject(e[t]);return this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y||t.z<this.min.z||t.z>this.max.z)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y&&this.min.z<=t.min.z&&t.max.z<=this.max.z}getParameter(t,n){return void 0===n&&(console.warn("THREE.Box3: .getParameter() target is now required"),n=new ttt),n.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y),(t.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y||t.max.z<this.min.z||t.min.z>this.max.z)}intersectsSphere(t){return this.clampPoint(t.center,itt),itt.distanceToSquared(t.center)<=t.radius*t.radius}intersectsPlane(t){let n,e;return t.normal.x>0?(n=t.normal.x*this.min.x,e=t.normal.x*this.max.x):(n=t.normal.x*this.max.x,e=t.normal.x*this.min.x),t.normal.y>0?(n+=t.normal.y*this.min.y,e+=t.normal.y*this.max.y):(n+=t.normal.y*this.max.y,e+=t.normal.y*this.min.y),t.normal.z>0?(n+=t.normal.z*this.min.z,e+=t.normal.z*this.max.z):(n+=t.normal.z*this.max.z,e+=t.normal.z*this.min.z),n<=-t.constant&&e>=-t.constant}intersectsTriangle(t){if(this.isEmpty())return!1;this.getCenter(btt),utt.subVectors(this.max,btt),stt.subVectors(t.a,btt),ltt.subVectors(t.b,btt),mtt.subVectors(t.c,btt),dtt.subVectors(ltt,stt),gtt.subVectors(mtt,ltt),ptt.subVectors(stt,mtt);let n=[0,-dtt.z,dtt.y,0,-gtt.z,gtt.y,0,-ptt.z,ptt.y,dtt.z,0,-dtt.x,gtt.z,0,-gtt.x,ptt.z,0,-ptt.x,-dtt.y,dtt.x,0,-gtt.y,gtt.x,0,-ptt.y,ptt.x,0];return!!ott(n,stt,ltt,mtt,utt)&&(n=[1,0,0,0,1,0,0,0,1],!!ott(n,stt,ltt,mtt,utt)&&(ftt.crossVectors(dtt,gtt),n=[ftt.x,ftt.y,ftt.z],ott(n,stt,ltt,mtt,utt)))}clampPoint(t,n){return void 0===n&&(console.warn("THREE.Box3: .clampPoint() target is now required"),n=new ttt),n.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return itt.copy(t).clamp(this.min,this.max).sub(t).length()}getBoundingSphere(t){return void 0===t&&console.error("THREE.Box3: .getBoundingSphere() target is now required"),this.getCenter(t.center),t.radius=.5*this.getSize(itt).length(),t}intersect(t){return this.min.max(t.min),this.max.min(t.max),this.isEmpty()&&this.makeEmpty(),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}applyMatrix4(t){return this.isEmpty()||(rtt[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(t),rtt[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(t),rtt[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(t),rtt[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(t),rtt[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(t),rtt[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(t),rtt[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(t),rtt[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(t),this.setFromPoints(rtt)),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}function ott(t,n,e,a,o){for(let r=0,i=t.length-3;r<=i;r+=3){htt.fromArray(t,r);const i=o.x*Math.abs(htt.x)+o.y*Math.abs(htt.y)+o.z*Math.abs(htt.z),c=n.dot(htt),s=e.dot(htt),l=a.dot(htt);if(Math.max(-Math.max(c,s,l),Math.min(c,s,l))>i)return!1}return!0}const rtt=[new ttt,new ttt,new ttt,new ttt,new ttt,new ttt,new ttt,new ttt],itt=new ttt,ctt=new att,stt=new ttt,ltt=new ttt,mtt=new ttt,dtt=new ttt,gtt=new ttt,ptt=new ttt,btt=new ttt,utt=new ttt,ftt=new ttt,htt=new ttt,_tt=new att;class Ctt{constructor(t,n){this.center=void 0!==t?t:new ttt,this.radius=void 0!==n?n:-1}set(t,n){return this.center.copy(t),this.radius=n,this}setFromPoints(t,n){const e=this.center;void 0!==n?e.copy(n):_tt.setFromPoints(t).getCenter(e);let a=0;for(let n=0,o=t.length;n<o;n++)a=Math.max(a,e.distanceToSquared(t[n]));return this.radius=Math.sqrt(a),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.center.copy(t.center),this.radius=t.radius,this}isEmpty(){return this.radius<0}makeEmpty(){return this.center.set(0,0,0),this.radius=-1,this}containsPoint(t){return t.distanceToSquared(this.center)<=this.radius*this.radius}distanceToPoint(t){return t.distanceTo(this.center)-this.radius}intersectsSphere(t){const n=this.radius+t.radius;return t.center.distanceToSquared(this.center)<=n*n}intersectsBox(t){return t.intersectsSphere(this)}intersectsPlane(t){return Math.abs(t.distanceToPoint(this.center))<=this.radius}clampPoint(t,n){const e=this.center.distanceToSquared(t);return void 0===n&&(console.warn("THREE.Sphere: .clampPoint() target is now required"),n=new ttt),n.copy(t),e>this.radius*this.radius&&(n.sub(this.center).normalize(),n.multiplyScalar(this.radius).add(this.center)),n}getBoundingBox(t){return void 0===t&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),t=new att),this.isEmpty()?(t.makeEmpty(),t):(t.set(this.center,this.center),t.expandByScalar(this.radius),t)}applyMatrix4(t){return this.center.applyMatrix4(t),this.radius=this.radius*t.getMaxScaleOnAxis(),this}translate(t){return this.center.add(t),this}equals(t){return t.center.equals(this.center)&&t.radius===this.radius}}const Mtt=new ttt,Ott=new ttt,Ptt=new ttt,xtt=new ttt,ytt=new ttt,ktt=new ttt,vtt=new ttt;class wtt{constructor(t,n){this.origin=void 0!==t?t:new ttt,this.direction=void 0!==n?n:new ttt(0,0,-1)}set(t,n){return this.origin.copy(t),this.direction.copy(n),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.origin.copy(t.origin),this.direction.copy(t.direction),this}at(t,n){return void 0===n&&(console.warn("THREE.Ray: .at() target is now required"),n=new ttt),n.copy(this.direction).multiplyScalar(t).add(this.origin)}lookAt(t){return this.direction.copy(t).sub(this.origin).normalize(),this}recast(t){return this.origin.copy(this.at(t,Mtt)),this}closestPointToPoint(t,n){void 0===n&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),n=new ttt),n.subVectors(t,this.origin);const e=n.dot(this.direction);return e<0?n.copy(this.origin):n.copy(this.direction).multiplyScalar(e).add(this.origin)}distanceToPoint(t){return Math.sqrt(this.distanceSqToPoint(t))}distanceSqToPoint(t){const n=Mtt.subVectors(t,this.origin).dot(this.direction);return n<0?this.origin.distanceToSquared(t):(Mtt.copy(this.direction).multiplyScalar(n).add(this.origin),Mtt.distanceToSquared(t))}distanceSqToSegment(t,n,e,a){Ott.copy(t).add(n).multiplyScalar(.5),Ptt.copy(n).sub(t).normalize(),xtt.copy(this.origin).sub(Ott);const o=.5*t.distanceTo(n),r=-this.direction.dot(Ptt),i=xtt.dot(this.direction),c=-xtt.dot(Ptt),s=xtt.lengthSq(),l=Math.abs(1-r*r);let m,d,g,p;if(l>0)if(m=r*c-i,d=r*i-c,p=o*l,m>=0)if(d>=-p)if(d<=p){const t=1/l;m*=t,d*=t,g=m*(m+r*d+2*i)+d*(r*m+d+2*c)+s}else d=o,m=Math.max(0,-(r*d+i)),g=-m*m+d*(d+2*c)+s;else d=-o,m=Math.max(0,-(r*d+i)),g=-m*m+d*(d+2*c)+s;else d<=-p?(m=Math.max(0,-(-r*o+i)),d=m>0?-o:Math.min(Math.max(-o,-c),o),g=-m*m+d*(d+2*c)+s):d<=p?(m=0,d=Math.min(Math.max(-o,-c),o),g=d*(d+2*c)+s):(m=Math.max(0,-(r*o+i)),d=m>0?o:Math.min(Math.max(-o,-c),o),g=-m*m+d*(d+2*c)+s);else d=r>0?-o:o,m=Math.max(0,-(r*d+i)),g=-m*m+d*(d+2*c)+s;return e&&e.copy(this.direction).multiplyScalar(m).add(this.origin),a&&a.copy(Ptt).multiplyScalar(d).add(Ott),g}intersectSphere(t,n){Mtt.subVectors(t.center,this.origin);const e=Mtt.dot(this.direction),a=Mtt.dot(Mtt)-e*e,o=t.radius*t.radius;if(a>o)return null;const r=Math.sqrt(o-a),i=e-r,c=e+r;return i<0&&c<0?null:this.at(i<0?c:i,n)}intersectsSphere(t){return this.distanceSqToPoint(t.center)<=t.radius*t.radius}distanceToPlane(t){const n=t.normal.dot(this.direction);if(0===n)return 0===t.distanceToPoint(this.origin)?0:null;const e=-(this.origin.dot(t.normal)+t.constant)/n;return e>=0?e:null}intersectPlane(t,n){const e=this.distanceToPlane(t);return null===e?null:this.at(e,n)}intersectsPlane(t){const n=t.distanceToPoint(this.origin);return 0===n||t.normal.dot(this.direction)*n<0}intersectBox(t,n){let e,a,o,r,i,c;const s=1/this.direction.x,l=1/this.direction.y,m=1/this.direction.z,d=this.origin;return s>=0?(e=(t.min.x-d.x)*s,a=(t.max.x-d.x)*s):(e=(t.max.x-d.x)*s,a=(t.min.x-d.x)*s),l>=0?(o=(t.min.y-d.y)*l,r=(t.max.y-d.y)*l):(o=(t.max.y-d.y)*l,r=(t.min.y-d.y)*l),e>r||o>a?null:((o>e||e!=e)&&(e=o),(r<a||a!=a)&&(a=r),m>=0?(i=(t.min.z-d.z)*m,c=(t.max.z-d.z)*m):(i=(t.max.z-d.z)*m,c=(t.min.z-d.z)*m),e>c||i>a?null:((i>e||e!=e)&&(e=i),(c<a||a!=a)&&(a=c),a<0?null:this.at(e>=0?e:a,n)))}intersectsBox(t){return null!==this.intersectBox(t,Mtt)}intersectTriangle(t,n,e,a,o){ytt.subVectors(n,t),ktt.subVectors(e,t),vtt.crossVectors(ytt,ktt);let r,i=this.direction.dot(vtt);if(i>0){if(a)return null;r=1}else{if(!(i<0))return null;r=-1,i=-i}xtt.subVectors(this.origin,t);const c=r*this.direction.dot(ktt.crossVectors(xtt,ktt));if(c<0)return null;const s=r*this.direction.dot(ytt.cross(xtt));if(s<0)return null;if(c+s>i)return null;const l=-r*xtt.dot(vtt);return l<0?null:this.at(l/i,o)}applyMatrix4(t){return this.origin.applyMatrix4(t),this.direction.transformDirection(t),this}equals(t){return t.origin.equals(this.origin)&&t.direction.equals(this.direction)}}class Stt{constructor(){Object.defineProperty(this,"isMatrix4",{value:!0}),this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],arguments.length>0&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}set(t,n,e,a,o,r,i,c,s,l,m,d,g,p,b,u){const f=this.elements;return f[0]=t,f[4]=n,f[8]=e,f[12]=a,f[1]=o,f[5]=r,f[9]=i,f[13]=c,f[2]=s,f[6]=l,f[10]=m,f[14]=d,f[3]=g,f[7]=p,f[11]=b,f[15]=u,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return(new Stt).fromArray(this.elements)}copy(t){const n=this.elements,e=t.elements;return n[0]=e[0],n[1]=e[1],n[2]=e[2],n[3]=e[3],n[4]=e[4],n[5]=e[5],n[6]=e[6],n[7]=e[7],n[8]=e[8],n[9]=e[9],n[10]=e[10],n[11]=e[11],n[12]=e[12],n[13]=e[13],n[14]=e[14],n[15]=e[15],this}copyPosition(t){const n=this.elements,e=t.elements;return n[12]=e[12],n[13]=e[13],n[14]=e[14],this}setFromMatrix3(t){const n=t.elements;return this.set(n[0],n[3],n[6],0,n[1],n[4],n[7],0,n[2],n[5],n[8],0,0,0,0,1),this}extractBasis(t,n,e){return t.setFromMatrixColumn(this,0),n.setFromMatrixColumn(this,1),e.setFromMatrixColumn(this,2),this}makeBasis(t,n,e){return this.set(t.x,n.x,e.x,0,t.y,n.y,e.y,0,t.z,n.z,e.z,0,0,0,0,1),this}extractRotation(t){const n=this.elements,e=t.elements,a=1/Ett.setFromMatrixColumn(t,0).length(),o=1/Ett.setFromMatrixColumn(t,1).length(),r=1/Ett.setFromMatrixColumn(t,2).length();return n[0]=e[0]*a,n[1]=e[1]*a,n[2]=e[2]*a,n[3]=0,n[4]=e[4]*o,n[5]=e[5]*o,n[6]=e[6]*o,n[7]=0,n[8]=e[8]*r,n[9]=e[9]*r,n[10]=e[10]*r,n[11]=0,n[12]=0,n[13]=0,n[14]=0,n[15]=1,this}makeRotationFromEuler(t){t&&t.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");const n=this.elements,e=t.x,a=t.y,o=t.z,r=Math.cos(e),i=Math.sin(e),c=Math.cos(a),s=Math.sin(a),l=Math.cos(o),m=Math.sin(o);if("XYZ"===t.order){const t=r*l,e=r*m,a=i*l,o=i*m;n[0]=c*l,n[4]=-c*m,n[8]=s,n[1]=e+a*s,n[5]=t-o*s,n[9]=-i*c,n[2]=o-t*s,n[6]=a+e*s,n[10]=r*c}else if("YXZ"===t.order){const t=c*l,e=c*m,a=s*l,o=s*m;n[0]=t+o*i,n[4]=a*i-e,n[8]=r*s,n[1]=r*m,n[5]=r*l,n[9]=-i,n[2]=e*i-a,n[6]=o+t*i,n[10]=r*c}else if("ZXY"===t.order){const t=c*l,e=c*m,a=s*l,o=s*m;n[0]=t-o*i,n[4]=-r*m,n[8]=a+e*i,n[1]=e+a*i,n[5]=r*l,n[9]=o-t*i,n[2]=-r*s,n[6]=i,n[10]=r*c}else if("ZYX"===t.order){const t=r*l,e=r*m,a=i*l,o=i*m;n[0]=c*l,n[4]=a*s-e,n[8]=t*s+o,n[1]=c*m,n[5]=o*s+t,n[9]=e*s-a,n[2]=-s,n[6]=i*c,n[10]=r*c}else if("YZX"===t.order){const t=r*c,e=r*s,a=i*c,o=i*s;n[0]=c*l,n[4]=o-t*m,n[8]=a*m+e,n[1]=m,n[5]=r*l,n[9]=-i*l,n[2]=-s*l,n[6]=e*m+a,n[10]=t-o*m}else if("XZY"===t.order){const t=r*c,e=r*s,a=i*c,o=i*s;n[0]=c*l,n[4]=-m,n[8]=s*l,n[1]=t*m+o,n[5]=r*l,n[9]=e*m-a,n[2]=a*m-e,n[6]=i*l,n[10]=o*m+t}return n[3]=0,n[7]=0,n[11]=0,n[12]=0,n[13]=0,n[14]=0,n[15]=1,this}makeRotationFromQuaternion(t){return this.compose(ztt,t,Rtt)}lookAt(t,n,e){const a=this.elements;return Itt.subVectors(t,n),0===Itt.lengthSq()&&(Itt.z=1),Itt.normalize(),Ttt.crossVectors(e,Itt),0===Ttt.lengthSq()&&(1===Math.abs(e.z)?Itt.x+=1e-4:Itt.z+=1e-4,Itt.normalize(),Ttt.crossVectors(e,Itt)),Ttt.normalize(),Dtt.crossVectors(Itt,Ttt),a[0]=Ttt.x,a[4]=Dtt.x,a[8]=Itt.x,a[1]=Ttt.y,a[5]=Dtt.y,a[9]=Itt.y,a[2]=Ttt.z,a[6]=Dtt.z,a[10]=Itt.z,this}multiply(t,n){return void 0!==n?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),this.multiplyMatrices(t,n)):this.multiplyMatrices(this,t)}premultiply(t){return this.multiplyMatrices(t,this)}multiplyMatrices(t,n){const e=t.elements,a=n.elements,o=this.elements,r=e[0],i=e[4],c=e[8],s=e[12],l=e[1],m=e[5],d=e[9],g=e[13],p=e[2],b=e[6],u=e[10],f=e[14],h=e[3],_=e[7],C=e[11],M=e[15],O=a[0],P=a[4],x=a[8],y=a[12],k=a[1],v=a[5],w=a[9],S=a[13],E=a[2],A=a[6],z=a[10],R=a[14],T=a[3],D=a[7],I=a[11],N=a[15];return o[0]=r*O+i*k+c*E+s*T,o[4]=r*P+i*v+c*A+s*D,o[8]=r*x+i*w+c*z+s*I,o[12]=r*y+i*S+c*R+s*N,o[1]=l*O+m*k+d*E+g*T,o[5]=l*P+m*v+d*A+g*D,o[9]=l*x+m*w+d*z+g*I,o[13]=l*y+m*S+d*R+g*N,o[2]=p*O+b*k+u*E+f*T,o[6]=p*P+b*v+u*A+f*D,o[10]=p*x+b*w+u*z+f*I,o[14]=p*y+b*S+u*R+f*N,o[3]=h*O+_*k+C*E+M*T,o[7]=h*P+_*v+C*A+M*D,o[11]=h*x+_*w+C*z+M*I,o[15]=h*y+_*S+C*R+M*N,this}multiplyScalar(t){const n=this.elements;return n[0]*=t,n[4]*=t,n[8]*=t,n[12]*=t,n[1]*=t,n[5]*=t,n[9]*=t,n[13]*=t,n[2]*=t,n[6]*=t,n[10]*=t,n[14]*=t,n[3]*=t,n[7]*=t,n[11]*=t,n[15]*=t,this}determinant(){const t=this.elements,n=t[0],e=t[4],a=t[8],o=t[12],r=t[1],i=t[5],c=t[9],s=t[13],l=t[2],m=t[6],d=t[10],g=t[14];return t[3]*(+o*c*m-a*s*m-o*i*d+e*s*d+a*i*g-e*c*g)+t[7]*(+n*c*g-n*s*d+o*r*d-a*r*g+a*s*l-o*c*l)+t[11]*(+n*s*m-n*i*g-o*r*m+e*r*g+o*i*l-e*s*l)+t[15]*(-a*i*l-n*c*m+n*i*d+a*r*m-e*r*d+e*c*l)}transpose(){const t=this.elements;let n;return n=t[1],t[1]=t[4],t[4]=n,n=t[2],t[2]=t[8],t[8]=n,n=t[6],t[6]=t[9],t[9]=n,n=t[3],t[3]=t[12],t[12]=n,n=t[7],t[7]=t[13],t[13]=n,n=t[11],t[11]=t[14],t[14]=n,this}setPosition(t,n,e){const a=this.elements;return t.isVector3?(a[12]=t.x,a[13]=t.y,a[14]=t.z):(a[12]=t,a[13]=n,a[14]=e),this}invert(){const t=this.elements,n=t[0],e=t[1],a=t[2],o=t[3],r=t[4],i=t[5],c=t[6],s=t[7],l=t[8],m=t[9],d=t[10],g=t[11],p=t[12],b=t[13],u=t[14],f=t[15],h=m*u*s-b*d*s+b*c*g-i*u*g-m*c*f+i*d*f,_=p*d*s-l*u*s-p*c*g+r*u*g+l*c*f-r*d*f,C=l*b*s-p*m*s+p*i*g-r*b*g-l*i*f+r*m*f,M=p*m*c-l*b*c-p*i*d+r*b*d+l*i*u-r*m*u,O=n*h+e*_+a*C+o*M;if(0===O)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);const P=1/O;return t[0]=h*P,t[1]=(b*d*o-m*u*o-b*a*g+e*u*g+m*a*f-e*d*f)*P,t[2]=(i*u*o-b*c*o+b*a*s-e*u*s-i*a*f+e*c*f)*P,t[3]=(m*c*o-i*d*o-m*a*s+e*d*s+i*a*g-e*c*g)*P,t[4]=_*P,t[5]=(l*u*o-p*d*o+p*a*g-n*u*g-l*a*f+n*d*f)*P,t[6]=(p*c*o-r*u*o-p*a*s+n*u*s+r*a*f-n*c*f)*P,t[7]=(r*d*o-l*c*o+l*a*s-n*d*s-r*a*g+n*c*g)*P,t[8]=C*P,t[9]=(p*m*o-l*b*o-p*e*g+n*b*g+l*e*f-n*m*f)*P,t[10]=(r*b*o-p*i*o+p*e*s-n*b*s-r*e*f+n*i*f)*P,t[11]=(l*i*o-r*m*o-l*e*s+n*m*s+r*e*g-n*i*g)*P,t[12]=M*P,t[13]=(l*b*a-p*m*a+p*e*d-n*b*d-l*e*u+n*m*u)*P,t[14]=(p*i*a-r*b*a-p*e*c+n*b*c+r*e*u-n*i*u)*P,t[15]=(r*m*a-l*i*a+l*e*c-n*m*c-r*e*d+n*i*d)*P,this}scale(t){const n=this.elements,e=t.x,a=t.y,o=t.z;return n[0]*=e,n[4]*=a,n[8]*=o,n[1]*=e,n[5]*=a,n[9]*=o,n[2]*=e,n[6]*=a,n[10]*=o,n[3]*=e,n[7]*=a,n[11]*=o,this}getMaxScaleOnAxis(){const t=this.elements;return Math.sqrt(Math.max(t[0]*t[0]+t[1]*t[1]+t[2]*t[2],t[4]*t[4]+t[5]*t[5]+t[6]*t[6],t[8]*t[8]+t[9]*t[9]+t[10]*t[10]))}makeTranslation(t,n,e){return this.set(1,0,0,t,0,1,0,n,0,0,1,e,0,0,0,1),this}makeRotationX(t){const n=Math.cos(t),e=Math.sin(t);return this.set(1,0,0,0,0,n,-e,0,0,e,n,0,0,0,0,1),this}makeRotationY(t){const n=Math.cos(t),e=Math.sin(t);return this.set(n,0,e,0,0,1,0,0,-e,0,n,0,0,0,0,1),this}makeRotationZ(t){const n=Math.cos(t),e=Math.sin(t);return this.set(n,-e,0,0,e,n,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(t,n){const e=Math.cos(n),a=Math.sin(n),o=1-e,r=t.x,i=t.y,c=t.z,s=o*r,l=o*i;return this.set(s*r+e,s*i-a*c,s*c+a*i,0,s*i+a*c,l*i+e,l*c-a*r,0,s*c-a*i,l*c+a*r,o*c*c+e,0,0,0,0,1),this}makeScale(t,n,e){return this.set(t,0,0,0,0,n,0,0,0,0,e,0,0,0,0,1),this}makeShear(t,n,e){return this.set(1,n,e,0,t,1,e,0,t,n,1,0,0,0,0,1),this}compose(t,n,e){const a=this.elements,o=n._x,r=n._y,i=n._z,c=n._w,s=o+o,l=r+r,m=i+i,d=o*s,g=o*l,p=o*m,b=r*l,u=r*m,f=i*m,h=c*s,_=c*l,C=c*m,M=e.x,O=e.y,P=e.z;return a[0]=(1-(b+f))*M,a[1]=(g+C)*M,a[2]=(p-_)*M,a[3]=0,a[4]=(g-C)*O,a[5]=(1-(d+f))*O,a[6]=(u+h)*O,a[7]=0,a[8]=(p+_)*P,a[9]=(u-h)*P,a[10]=(1-(d+b))*P,a[11]=0,a[12]=t.x,a[13]=t.y,a[14]=t.z,a[15]=1,this}decompose(t,n,e){const a=this.elements;let o=Ett.set(a[0],a[1],a[2]).length();const r=Ett.set(a[4],a[5],a[6]).length(),i=Ett.set(a[8],a[9],a[10]).length();this.determinant()<0&&(o=-o),t.x=a[12],t.y=a[13],t.z=a[14],Att.copy(this);const c=1/o,s=1/r,l=1/i;return Att.elements[0]*=c,Att.elements[1]*=c,Att.elements[2]*=c,Att.elements[4]*=s,Att.elements[5]*=s,Att.elements[6]*=s,Att.elements[8]*=l,Att.elements[9]*=l,Att.elements[10]*=l,n.setFromRotationMatrix(Att),e.x=o,e.y=r,e.z=i,this}makePerspective(t,n,e,a,o,r){void 0===r&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");const i=this.elements,c=2*o/(e-a),s=(n+t)/(n-t),l=(e+a)/(e-a),m=-(r+o)/(r-o),d=-2*r*o/(r-o);return i[0]=2*o/(n-t),i[4]=0,i[8]=s,i[12]=0,i[1]=0,i[5]=c,i[9]=l,i[13]=0,i[2]=0,i[6]=0,i[10]=m,i[14]=d,i[3]=0,i[7]=0,i[11]=-1,i[15]=0,this}makeOrthographic(t,n,e,a,o,r){const i=this.elements,c=1/(n-t),s=1/(e-a),l=1/(r-o),m=(n+t)*c,d=(e+a)*s,g=(r+o)*l;return i[0]=2*c,i[4]=0,i[8]=0,i[12]=-m,i[1]=0,i[5]=2*s,i[9]=0,i[13]=-d,i[2]=0,i[6]=0,i[10]=-2*l,i[14]=-g,i[3]=0,i[7]=0,i[11]=0,i[15]=1,this}equals(t){const n=this.elements,e=t.elements;for(let t=0;t<16;t++)if(n[t]!==e[t])return!1;return!0}fromArray(t,n=0){for(let e=0;e<16;e++)this.elements[e]=t[e+n];return this}toArray(t=[],n=0){const e=this.elements;return t[n]=e[0],t[n+1]=e[1],t[n+2]=e[2],t[n+3]=e[3],t[n+4]=e[4],t[n+5]=e[5],t[n+6]=e[6],t[n+7]=e[7],t[n+8]=e[8],t[n+9]=e[9],t[n+10]=e[10],t[n+11]=e[11],t[n+12]=e[12],t[n+13]=e[13],t[n+14]=e[14],t[n+15]=e[15],t}}const Ett=new ttt,Att=new Stt,ztt=new ttt(0,0,0),Rtt=new ttt(1,1,1),Ttt=new ttt,Dtt=new ttt,Itt=new ttt;class Ntt{constructor(t=0,n=0,e=0,a=Ntt.DefaultOrder){Object.defineProperty(this,"isEuler",{value:!0}),this._x=t,this._y=n,this._z=e,this._order=a}get x(){return this._x}set x(t){this._x=t,this._onChangeCallback()}get y(){return this._y}set y(t){this._y=t,this._onChangeCallback()}get z(){return this._z}set z(t){this._z=t,this._onChangeCallback()}get order(){return this._order}set order(t){this._order=t,this._onChangeCallback()}set(t,n,e,a){return this._x=t,this._y=n,this._z=e,this._order=a||this._order,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(t){return this._x=t._x,this._y=t._y,this._z=t._z,this._order=t._order,this._onChangeCallback(),this}setFromRotationMatrix(t,n,e){const a=U9.clamp,o=t.elements,r=o[0],i=o[4],c=o[8],s=o[1],l=o[5],m=o[9],d=o[2],g=o[6],p=o[10];switch(n=n||this._order){case"XYZ":this._y=Math.asin(a(c,-1,1)),Math.abs(c)<.9999999?(this._x=Math.atan2(-m,p),this._z=Math.atan2(-i,r)):(this._x=Math.atan2(g,l),this._z=0);break;case"YXZ":this._x=Math.asin(-a(m,-1,1)),Math.abs(m)<.9999999?(this._y=Math.atan2(c,p),this._z=Math.atan2(s,l)):(this._y=Math.atan2(-d,r),this._z=0);break;case"ZXY":this._x=Math.asin(a(g,-1,1)),Math.abs(g)<.9999999?(this._y=Math.atan2(-d,p),this._z=Math.atan2(-i,l)):(this._y=0,this._z=Math.atan2(s,r));break;case"ZYX":this._y=Math.asin(-a(d,-1,1)),Math.abs(d)<.9999999?(this._x=Math.atan2(g,p),this._z=Math.atan2(s,r)):(this._x=0,this._z=Math.atan2(-i,l));break;case"YZX":this._z=Math.asin(a(s,-1,1)),Math.abs(s)<.9999999?(this._x=Math.atan2(-m,l),this._y=Math.atan2(-d,r)):(this._x=0,this._y=Math.atan2(c,p));break;case"XZY":this._z=Math.asin(-a(i,-1,1)),Math.abs(i)<.9999999?(this._x=Math.atan2(g,l),this._y=Math.atan2(c,r)):(this._x=Math.atan2(-m,p),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+n)}return this._order=n,!1!==e&&this._onChangeCallback(),this}setFromQuaternion(t,n,e){return Ftt.makeRotationFromQuaternion(t),this.setFromRotationMatrix(Ftt,n,e)}setFromVector3(t,n){return this.set(t.x,t.y,t.z,n||this._order)}reorder(t){return Ltt.setFromEuler(this),this.setFromQuaternion(Ltt,t)}equals(t){return t._x===this._x&&t._y===this._y&&t._z===this._z&&t._order===this._order}fromArray(t){return this._x=t[0],this._y=t[1],this._z=t[2],void 0!==t[3]&&(this._order=t[3]),this._onChangeCallback(),this}toArray(t=[],n=0){return t[n]=this._x,t[n+1]=this._y,t[n+2]=this._z,t[n+3]=this._order,t}toVector3(t){return t?t.set(this._x,this._y,this._z):new ttt(this._x,this._y,this._z)}_onChange(t){return this._onChangeCallback=t,this}_onChangeCallback(){}}Ntt.DefaultOrder="XYZ",Ntt.RotationOrders=["XYZ","YZX","ZXY","XZY","YXZ","ZYX"];const Ftt=new Stt,Ltt=new $9;class Htt{constructor(){this.mask=1}set(t){this.mask=1<<t|0}enable(t){this.mask|=1<<t|0}enableAll(){this.mask=-1}toggle(t){this.mask^=1<<t|0}disable(t){this.mask&=~(1<<t|0)}disableAll(){this.mask=0}test(t){return 0!=(this.mask&t.mask)}}let Btt=0;const Vtt=new ttt,jtt=new $9,Utt=new Stt,Wtt=new ttt,Gtt=new ttt,Ytt=new ttt,qtt=new $9,Ztt=new ttt(1,0,0),Xtt=new ttt(0,1,0),Jtt=new ttt(0,0,1),Qtt={type:"added"},Ktt={type:"removed"};function $tt(){Object.defineProperty(this,"id",{value:Btt++}),this.uuid=U9.generateUUID(),this.name="",this.type="Object3D",this.parent=null,this.children=[],this.up=$tt.DefaultUp.clone();const t=new ttt,n=new Ntt,e=new $9,a=new ttt(1,1,1);n._onChange((function o(){e.setFromEuler(n,!1)})),e._onChange((function r(){n.setFromQuaternion(e,void 0,!1)})),Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:t},rotation:{configurable:!0,enumerable:!0,value:n},quaternion:{configurable:!0,enumerable:!0,value:e},scale:{configurable:!0,enumerable:!0,value:a},modelViewMatrix:{value:new Stt},normalMatrix:{value:new G9}}),this.matrix=new Stt,this.matrixWorld=new Stt,this.matrixAutoUpdate=$tt.DefaultMatrixAutoUpdate,this.matrixWorldNeedsUpdate=!1,this.layers=new Htt,this.visible=!0,this.castShadow=!1,this.receiveShadow=!1,this.frustumCulled=!0,this.renderOrder=0,this.animations=[],this.userData={}}$tt.DefaultUp=new ttt(0,1,0),$tt.DefaultMatrixAutoUpdate=!0,$tt.prototype=Object.assign(Object.create(B9.prototype),{constructor:$tt,isObject3D:!0,onBeforeRender:function(){},onAfterRender:function(){},applyMatrix4:function(t){this.matrixAutoUpdate&&this.updateMatrix(),this.matrix.premultiply(t),this.matrix.decompose(this.position,this.quaternion,this.scale)},applyQuaternion:function(t){return this.quaternion.premultiply(t),this},setRotationFromAxisAngle:function(t,n){this.quaternion.setFromAxisAngle(t,n)},setRotationFromEuler:function(t){this.quaternion.setFromEuler(t,!0)},setRotationFromMatrix:function(t){this.quaternion.setFromRotationMatrix(t)},setRotationFromQuaternion:function(t){this.quaternion.copy(t)},rotateOnAxis:function(t,n){return jtt.setFromAxisAngle(t,n),this.quaternion.multiply(jtt),this},rotateOnWorldAxis:function(t,n){return jtt.setFromAxisAngle(t,n),this.quaternion.premultiply(jtt),this},rotateX:function(t){return this.rotateOnAxis(Ztt,t)},rotateY:function(t){return this.rotateOnAxis(Xtt,t)},rotateZ:function(t){return this.rotateOnAxis(Jtt,t)},translateOnAxis:function(t,n){return Vtt.copy(t).applyQuaternion(this.quaternion),this.position.add(Vtt.multiplyScalar(n)),this},translateX:function(t){return this.translateOnAxis(Ztt,t)},translateY:function(t){return this.translateOnAxis(Xtt,t)},translateZ:function(t){return this.translateOnAxis(Jtt,t)},localToWorld:function(t){return t.applyMatrix4(this.matrixWorld)},worldToLocal:function(t){return t.applyMatrix4(Utt.copy(this.matrixWorld).invert())},lookAt:function(t,n,e){t.isVector3?Wtt.copy(t):Wtt.set(t,n,e);const a=this.parent;this.updateWorldMatrix(!0,!1),Gtt.setFromMatrixPosition(this.matrixWorld),this.isCamera||this.isLight?Utt.lookAt(Gtt,Wtt,this.up):Utt.lookAt(Wtt,Gtt,this.up),this.quaternion.setFromRotationMatrix(Utt),a&&(Utt.extractRotation(a.matrixWorld),jtt.setFromRotationMatrix(Utt),this.quaternion.premultiply(jtt.invert()))},add:function(t){if(arguments.length>1){for(let t=0;t<arguments.length;t++)this.add(arguments[t]);return this}return t===this?(console.error("THREE.Object3D.add: object can't be added as a child of itself.",t),this):(t&&t.isObject3D?(null!==t.parent&&t.parent.remove(t),t.parent=this,this.children.push(t),t.dispatchEvent(Qtt)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",t),this)},remove:function(t){if(arguments.length>1){for(let t=0;t<arguments.length;t++)this.remove(arguments[t]);return this}const n=this.children.indexOf(t);return-1!==n&&(t.parent=null,this.children.splice(n,1),t.dispatchEvent(Ktt)),this},clear:function(){for(let t=0;t<this.children.length;t++){const n=this.children[t];n.parent=null,n.dispatchEvent(Ktt)}return this.children.length=0,this},attach:function(t){return this.updateWorldMatrix(!0,!1),Utt.copy(this.matrixWorld).invert(),null!==t.parent&&(t.parent.updateWorldMatrix(!0,!1),Utt.multiply(t.parent.matrixWorld)),t.applyMatrix4(Utt),t.updateWorldMatrix(!1,!1),this.add(t),this},getObjectById:function(t){return this.getObjectByProperty("id",t)},getObjectByName:function(t){return this.getObjectByProperty("name",t)},getObjectByProperty:function(t,n){if(this[t]===n)return this;for(let e=0,a=this.children.length;e<a;e++){const a=this.children[e].getObjectByProperty(t,n);if(void 0!==a)return a}},getWorldPosition:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldPosition() target is now required"),t=new ttt),this.updateWorldMatrix(!0,!1),t.setFromMatrixPosition(this.matrixWorld)},getWorldQuaternion:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldQuaternion() target is now required"),t=new $9),this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Gtt,t,Ytt),t},getWorldScale:function(t){return void 0===t&&(console.warn("THREE.Object3D: .getWorldScale() target is now required"),t=new ttt),this.updateWorldMatrix(!0,!1),this.matrixWorld.decompose(Gtt,qtt,t),t},getWorldDirection:function(t){void 0===t&&(console.warn("THREE.Object3D: .getWorldDirection() target is now required"),t=new ttt),this.updateWorldMatrix(!0,!1);const n=this.matrixWorld.elements;return t.set(n[8],n[9],n[10]).normalize()},raycast:function(){},traverse:function(t){t(this);const n=this.children;for(let e=0,a=n.length;e<a;e++)n[e].traverse(t)},traverseVisible:function(t){if(!1===this.visible)return;t(this);const n=this.children;for(let e=0,a=n.length;e<a;e++)n[e].traverseVisible(t)},traverseAncestors:function(t){const n=this.parent;null!==n&&(t(n),n.traverseAncestors(t))},updateMatrix:function(){this.matrix.compose(this.position,this.quaternion,this.scale),this.matrixWorldNeedsUpdate=!0},updateMatrixWorld:function(t){this.matrixAutoUpdate&&this.updateMatrix(),(this.matrixWorldNeedsUpdate||t)&&(null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,t=!0);const n=this.children;for(let e=0,a=n.length;e<a;e++)n[e].updateMatrixWorld(t)},updateWorldMatrix:function(t,n){const e=this.parent;if(!0===t&&null!==e&&e.updateWorldMatrix(!0,!1),this.matrixAutoUpdate&&this.updateMatrix(),null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),!0===n){const t=this.children;for(let n=0,e=t.length;n<e;n++)t[n].updateWorldMatrix(!1,!0)}},toJSON:function(t){const n=void 0===t||"string"==typeof t,e={};n&&(t={geometries:{},materials:{},textures:{},images:{},shapes:{},skeletons:{},animations:{}},e.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});const a={};function o(n,e){return void 0===n[e.uuid]&&(n[e.uuid]=e.toJSON(t)),e.uuid}if(a.uuid=this.uuid,a.type=this.type,""!==this.name&&(a.name=this.name),!0===this.castShadow&&(a.castShadow=!0),!0===this.receiveShadow&&(a.receiveShadow=!0),!1===this.visible&&(a.visible=!1),!1===this.frustumCulled&&(a.frustumCulled=!1),0!==this.renderOrder&&(a.renderOrder=this.renderOrder),"{}"!==JSON.stringify(this.userData)&&(a.userData=this.userData),a.layers=this.layers.mask,a.matrix=this.matrix.toArray(),!1===this.matrixAutoUpdate&&(a.matrixAutoUpdate=!1),this.isInstancedMesh&&(a.type="InstancedMesh",a.count=this.count,a.instanceMatrix=this.instanceMatrix.toJSON()),this.isMesh||this.isLine||this.isPoints){a.geometry=o(t.geometries,this.geometry);const n=this.geometry.parameters;if(void 0!==n&&void 0!==n.shapes){const e=n.shapes;if(Array.isArray(e))for(let n=0,a=e.length;n<a;n++)o(t.shapes,e[n]);else o(t.shapes,e)}}if(this.isSkinnedMesh&&(a.bindMode=this.bindMode,a.bindMatrix=this.bindMatrix.toArray(),void 0!==this.skeleton&&(o(t.skeletons,this.skeleton),a.skeleton=this.skeleton.uuid)),void 0!==this.material)if(Array.isArray(this.material)){const n=[];for(let e=0,a=this.material.length;e<a;e++)n.push(o(t.materials,this.material[e]));a.material=n}else a.material=o(t.materials,this.material);if(this.children.length>0){a.children=[];for(let n=0;n<this.children.length;n++)a.children.push(this.children[n].toJSON(t).object)}if(this.animations.length>0){a.animations=[];for(let n=0;n<this.animations.length;n++)a.animations.push(o(t.animations,this.animations[n]))}if(n){const n=r(t.geometries),a=r(t.materials),o=r(t.textures),i=r(t.images),c=r(t.shapes),s=r(t.skeletons),l=r(t.animations);n.length>0&&(e.geometries=n),a.length>0&&(e.materials=a),o.length>0&&(e.textures=o),i.length>0&&(e.images=i),c.length>0&&(e.shapes=c),s.length>0&&(e.skeletons=s),l.length>0&&(e.animations=l)}return e.object=a,e;function r(t){const n=[];for(const e in t){const a=t[e];delete a.metadata,n.push(a)}return n}},clone:function(t){return(new this.constructor).copy(this,t)},copy:function(t,n=!0){if(this.name=t.name,this.up.copy(t.up),this.position.copy(t.position),this.rotation.order=t.rotation.order,this.quaternion.copy(t.quaternion),this.scale.copy(t.scale),this.matrix.copy(t.matrix),this.matrixWorld.copy(t.matrixWorld),this.matrixAutoUpdate=t.matrixAutoUpdate,this.matrixWorldNeedsUpdate=t.matrixWorldNeedsUpdate,this.layers.mask=t.layers.mask,this.visible=t.visible,this.castShadow=t.castShadow,this.receiveShadow=t.receiveShadow,this.frustumCulled=t.frustumCulled,this.renderOrder=t.renderOrder,this.userData=JSON.parse(JSON.stringify(t.userData)),!0===n)for(let n=0;n<t.children.length;n++)this.add(t.children[n].clone());return this}});const tnt=new ttt,nnt=new ttt,ent=new G9;class ant{constructor(t,n){Object.defineProperty(this,"isPlane",{value:!0}),this.normal=void 0!==t?t:new ttt(1,0,0),this.constant=void 0!==n?n:0}set(t,n){return this.normal.copy(t),this.constant=n,this}setComponents(t,n,e,a){return this.normal.set(t,n,e),this.constant=a,this}setFromNormalAndCoplanarPoint(t,n){return this.normal.copy(t),this.constant=-n.dot(this.normal),this}setFromCoplanarPoints(t,n,e){const a=tnt.subVectors(e,n).cross(nnt.subVectors(t,n)).normalize();return this.setFromNormalAndCoplanarPoint(a,t),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.normal.copy(t.normal),this.constant=t.constant,this}normalize(){const t=1/this.normal.length();return this.normal.multiplyScalar(t),this.constant*=t,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(t){return this.normal.dot(t)+this.constant}distanceToSphere(t){return this.distanceToPoint(t.center)-t.radius}projectPoint(t,n){return void 0===n&&(console.warn("THREE.Plane: .projectPoint() target is now required"),n=new ttt),n.copy(this.normal).multiplyScalar(-this.distanceToPoint(t)).add(t)}intersectLine(t,n){void 0===n&&(console.warn("THREE.Plane: .intersectLine() target is now required"),n=new ttt);const e=t.delta(tnt),a=this.normal.dot(e);if(0===a)return 0===this.distanceToPoint(t.start)?n.copy(t.start):void 0;const o=-(t.start.dot(this.normal)+this.constant)/a;return o<0||o>1?void 0:n.copy(e).multiplyScalar(o).add(t.start)}intersectsLine(t){const n=this.distanceToPoint(t.start),e=this.distanceToPoint(t.end);return n<0&&e>0||e<0&&n>0}intersectsBox(t){return t.intersectsPlane(this)}intersectsSphere(t){return t.intersectsPlane(this)}coplanarPoint(t){return void 0===t&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),t=new ttt),t.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(t,n){const e=n||ent.getNormalMatrix(t),a=this.coplanarPoint(tnt).applyMatrix4(t),o=this.normal.applyMatrix3(e).normalize();return this.constant=-a.dot(o),this}translate(t){return this.constant-=t.dot(this.normal),this}equals(t){return t.normal.equals(this.normal)&&t.constant===this.constant}}const ont=new ttt,rnt=new ttt,int=new ttt,cnt=new ttt,snt=new ttt,lnt=new ttt,mnt=new ttt,dnt=new ttt,gnt=new ttt,pnt=new ttt;class bnt{constructor(t,n,e){this.a=void 0!==t?t:new ttt,this.b=void 0!==n?n:new ttt,this.c=void 0!==e?e:new ttt}static getNormal(t,n,e,a){void 0===a&&(console.warn("THREE.Triangle: .getNormal() target is now required"),a=new ttt),a.subVectors(e,n),ont.subVectors(t,n),a.cross(ont);const o=a.lengthSq();return o>0?a.multiplyScalar(1/Math.sqrt(o)):a.set(0,0,0)}static getBarycoord(t,n,e,a,o){ont.subVectors(a,n),rnt.subVectors(e,n),int.subVectors(t,n);const r=ont.dot(ont),i=ont.dot(rnt),c=ont.dot(int),s=rnt.dot(rnt),l=rnt.dot(int),m=r*s-i*i;if(void 0===o&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),o=new ttt),0===m)return o.set(-2,-1,-1);const d=1/m,g=(s*c-i*l)*d,p=(r*l-i*c)*d;return o.set(1-g-p,p,g)}static containsPoint(t,n,e,a){return this.getBarycoord(t,n,e,a,cnt),cnt.x>=0&&cnt.y>=0&&cnt.x+cnt.y<=1}static getUV(t,n,e,a,o,r,i,c){return this.getBarycoord(t,n,e,a,cnt),c.set(0,0),c.addScaledVector(o,cnt.x),c.addScaledVector(r,cnt.y),c.addScaledVector(i,cnt.z),c}static isFrontFacing(t,n,e,a){return ont.subVectors(e,n),rnt.subVectors(t,n),ont.cross(rnt).dot(a)<0}set(t,n,e){return this.a.copy(t),this.b.copy(n),this.c.copy(e),this}setFromPointsAndIndices(t,n,e,a){return this.a.copy(t[n]),this.b.copy(t[e]),this.c.copy(t[a]),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.a.copy(t.a),this.b.copy(t.b),this.c.copy(t.c),this}getArea(){return ont.subVectors(this.c,this.b),rnt.subVectors(this.a,this.b),.5*ont.cross(rnt).length()}getMidpoint(t){return void 0===t&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),t=new ttt),t.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(t){return bnt.getNormal(this.a,this.b,this.c,t)}getPlane(t){return void 0===t&&(console.warn("THREE.Triangle: .getPlane() target is now required"),t=new ant),t.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(t,n){return bnt.getBarycoord(t,this.a,this.b,this.c,n)}getUV(t,n,e,a,o){return bnt.getUV(t,this.a,this.b,this.c,n,e,a,o)}containsPoint(t){return bnt.containsPoint(t,this.a,this.b,this.c)}isFrontFacing(t){return bnt.isFrontFacing(this.a,this.b,this.c,t)}intersectsBox(t){return t.intersectsTriangle(this)}closestPointToPoint(t,n){void 0===n&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),n=new ttt);const e=this.a,a=this.b,o=this.c;let r,i;snt.subVectors(a,e),lnt.subVectors(o,e),dnt.subVectors(t,e);const c=snt.dot(dnt),s=lnt.dot(dnt);if(c<=0&&s<=0)return n.copy(e);gnt.subVectors(t,a);const l=snt.dot(gnt),m=lnt.dot(gnt);if(l>=0&&m<=l)return n.copy(a);const d=c*m-l*s;if(d<=0&&c>=0&&l<=0)return r=c/(c-l),n.copy(e).addScaledVector(snt,r);pnt.subVectors(t,o);const g=snt.dot(pnt),p=lnt.dot(pnt);if(p>=0&&g<=p)return n.copy(o);const b=g*s-c*p;if(b<=0&&s>=0&&p<=0)return i=s/(s-p),n.copy(e).addScaledVector(lnt,i);const u=l*p-g*m;if(u<=0&&m-l>=0&&g-p>=0)return mnt.subVectors(o,a),i=(m-l)/(m-l+(g-p)),n.copy(a).addScaledVector(mnt,i);const f=1/(u+b+d);return r=b*f,i=d*f,n.copy(e).addScaledVector(snt,r).addScaledVector(lnt,i)}equals(t){return t.a.equals(this.a)&&t.b.equals(this.b)&&t.c.equals(this.c)}}const unt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},fnt={h:0,s:0,l:0},hnt={h:0,s:0,l:0};function _nt(t,n,e){return e<0&&(e+=1),e>1&&(e-=1),e<1/6?t+6*(n-t)*e:e<.5?n:e<2/3?t+6*(n-t)*(2/3-e):t}function Cnt(t){return t<.04045?.0773993808*t:Math.pow(.9478672986*t+.0521327014,2.4)}function Mnt(t){return t<.0031308?12.92*t:1.055*Math.pow(t,.41666)-.055}class Ont{constructor(t,n,e){return Object.defineProperty(this,"isColor",{value:!0}),void 0===n&&void 0===e?this.set(t):this.setRGB(t,n,e)}set(t){return t&&t.isColor?this.copy(t):"number"==typeof t?this.setHex(t):"string"==typeof t&&this.setStyle(t),this}setScalar(t){return this.r=t,this.g=t,this.b=t,this}setHex(t){return t=Math.floor(t),this.r=(t>>16&255)/255,this.g=(t>>8&255)/255,this.b=(255&t)/255,this}setRGB(t,n,e){return this.r=t,this.g=n,this.b=e,this}setHSL(t,n,e){if(t=U9.euclideanModulo(t,1),n=U9.clamp(n,0,1),e=U9.clamp(e,0,1),0===n)this.r=this.g=this.b=e;else{const a=e<=.5?e*(1+n):e+n-e*n,o=2*e-a;this.r=_nt(o,a,t+1/3),this.g=_nt(o,a,t),this.b=_nt(o,a,t-1/3)}return this}setStyle(t){function n(n){void 0!==n&&parseFloat(n)<1&&console.warn("THREE.Color: Alpha component of "+t+" will be ignored.")}let e;if(e=/^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(t)){let t;const a=e[2];switch(e[1]){case"rgb":case"rgba":if(t=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(255,parseInt(t[1],10))/255,this.g=Math.min(255,parseInt(t[2],10))/255,this.b=Math.min(255,parseInt(t[3],10))/255,n(t[4]),this;if(t=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a))return this.r=Math.min(100,parseInt(t[1],10))/100,this.g=Math.min(100,parseInt(t[2],10))/100,this.b=Math.min(100,parseInt(t[3],10))/100,n(t[4]),this;break;case"hsl":case"hsla":if(t=/^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(a)){const e=parseFloat(t[1])/360,a=parseInt(t[2],10)/100,o=parseInt(t[3],10)/100;return n(t[4]),this.setHSL(e,a,o)}}}else if(e=/^\#([A-Fa-f\d]+)$/.exec(t)){const t=e[1],n=t.length;if(3===n)return this.r=parseInt(t.charAt(0)+t.charAt(0),16)/255,this.g=parseInt(t.charAt(1)+t.charAt(1),16)/255,this.b=parseInt(t.charAt(2)+t.charAt(2),16)/255,this;if(6===n)return this.r=parseInt(t.charAt(0)+t.charAt(1),16)/255,this.g=parseInt(t.charAt(2)+t.charAt(3),16)/255,this.b=parseInt(t.charAt(4)+t.charAt(5),16)/255,this}return t&&t.length>0?this.setColorName(t):this}setColorName(t){const n=unt[t];return void 0!==n?this.setHex(n):console.warn("THREE.Color: Unknown color "+t),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(t){return this.r=t.r,this.g=t.g,this.b=t.b,this}copyGammaToLinear(t,n=2){return this.r=Math.pow(t.r,n),this.g=Math.pow(t.g,n),this.b=Math.pow(t.b,n),this}copyLinearToGamma(t,n=2){const e=n>0?1/n:1;return this.r=Math.pow(t.r,e),this.g=Math.pow(t.g,e),this.b=Math.pow(t.b,e),this}convertGammaToLinear(t){return this.copyGammaToLinear(this,t),this}convertLinearToGamma(t){return this.copyLinearToGamma(this,t),this}copySRGBToLinear(t){return this.r=Cnt(t.r),this.g=Cnt(t.g),this.b=Cnt(t.b),this}copyLinearToSRGB(t){return this.r=Mnt(t.r),this.g=Mnt(t.g),this.b=Mnt(t.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0}getHexString(){return("000000"+this.getHex().toString(16)).slice(-6)}getHSL(t){void 0===t&&(console.warn("THREE.Color: .getHSL() target is now required"),t={h:0,s:0,l:0});const n=this.r,e=this.g,a=this.b,o=Math.max(n,e,a),r=Math.min(n,e,a);let i,c;const s=(r+o)/2;if(r===o)i=0,c=0;else{const t=o-r;switch(c=s<=.5?t/(o+r):t/(2-o-r),o){case n:i=(e-a)/t+(e<a?6:0);break;case e:i=(a-n)/t+2;break;case a:i=(n-e)/t+4}i/=6}return t.h=i,t.s=c,t.l=s,t}getStyle(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"}offsetHSL(t,n,e){return this.getHSL(fnt),fnt.h+=t,fnt.s+=n,fnt.l+=e,this.setHSL(fnt.h,fnt.s,fnt.l),this}add(t){return this.r+=t.r,this.g+=t.g,this.b+=t.b,this}addColors(t,n){return this.r=t.r+n.r,this.g=t.g+n.g,this.b=t.b+n.b,this}addScalar(t){return this.r+=t,this.g+=t,this.b+=t,this}sub(t){return this.r=Math.max(0,this.r-t.r),this.g=Math.max(0,this.g-t.g),this.b=Math.max(0,this.b-t.b),this}multiply(t){return this.r*=t.r,this.g*=t.g,this.b*=t.b,this}multiplyScalar(t){return this.r*=t,this.g*=t,this.b*=t,this}lerp(t,n){return this.r+=(t.r-this.r)*n,this.g+=(t.g-this.g)*n,this.b+=(t.b-this.b)*n,this}lerpColors(t,n,e){return this.r=t.r+(n.r-t.r)*e,this.g=t.g+(n.g-t.g)*e,this.b=t.b+(n.b-t.b)*e,this}lerpHSL(t,n){this.getHSL(fnt),t.getHSL(hnt);const e=U9.lerp(fnt.h,hnt.h,n),a=U9.lerp(fnt.s,hnt.s,n),o=U9.lerp(fnt.l,hnt.l,n);return this.setHSL(e,a,o),this}equals(t){return t.r===this.r&&t.g===this.g&&t.b===this.b}fromArray(t,n=0){return this.r=t[n],this.g=t[n+1],this.b=t[n+2],this}toArray(t=[],n=0){return t[n]=this.r,t[n+1]=this.g,t[n+2]=this.b,t}fromBufferAttribute(t,n){return this.r=t.getX(n),this.g=t.getY(n),this.b=t.getZ(n),!0===t.normalized&&(this.r/=255,this.g/=255,this.b/=255),this}toJSON(){return this.getHex()}}Ont.NAMES=unt,Ont.prototype.r=1,Ont.prototype.g=1,Ont.prototype.b=1;class Pnt{constructor(t,n,e,a,o,r=0){this.a=t,this.b=n,this.c=e,this.normal=a&&a.isVector3?a:new ttt,this.vertexNormals=Array.isArray(a)?a:[],this.color=o&&o.isColor?o:new Ont,this.vertexColors=Array.isArray(o)?o:[],this.materialIndex=r}clone(){return(new this.constructor).copy(this)}copy(t){this.a=t.a,this.b=t.b,this.c=t.c,this.normal.copy(t.normal),this.color.copy(t.color),this.materialIndex=t.materialIndex;for(let n=0,e=t.vertexNormals.length;n<e;n++)this.vertexNormals[n]=t.vertexNormals[n].clone();for(let n=0,e=t.vertexColors.length;n<e;n++)this.vertexColors[n]=t.vertexColors[n].clone();return this}}let xnt=0;function ynt(){Object.defineProperty(this,"id",{value:xnt++}),this.uuid=U9.generateUUID(),this.name="",this.type="Material",this.fog=!0,this.blending=1,this.side=0,this.flatShading=!1,this.vertexColors=!1,this.opacity=1,this.transparent=!1,this.blendSrc=204,this.blendDst=205,this.blendEquation=p9,this.blendSrcAlpha=null,this.blendDstAlpha=null,this.blendEquationAlpha=null,this.depthFunc=3,this.depthTest=!0,this.depthWrite=!0,this.stencilWriteMask=255,this.stencilFunc=519,this.stencilRef=0,this.stencilFuncMask=255,this.stencilFail=N9,this.stencilZFail=N9,this.stencilZPass=N9,this.stencilWrite=!1,this.clippingPlanes=null,this.clipIntersection=!1,this.clipShadows=!1,this.shadowSide=null,this.colorWrite=!0,this.precision=null,this.polygonOffset=!1,this.polygonOffsetFactor=0,this.polygonOffsetUnits=0,this.dithering=!1,this.alphaTest=0,this.premultipliedAlpha=!1,this.visible=!0,this.toneMapped=!0,this.userData={},this.version=0}function knt(t){ynt.call(this),this.type="MeshBasicMaterial",this.color=new Ont(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.setValues(t)}ynt.prototype=Object.assign(Object.create(B9.prototype),{constructor:ynt,isMaterial:!0,onBeforeCompile:function(){},customProgramCacheKey:function(){return this.onBeforeCompile.toString()},setValues:function(t){if(void 0!==t)for(const n in t){const e=t[n];if(void 0===e){console.warn("THREE.Material: '"+n+"' parameter is undefined.");continue}if("shading"===n){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===e;continue}const a=this[n];void 0!==a?a&&a.isColor?a.set(e):a&&a.isVector3&&e&&e.isVector3?a.copy(e):this[n]=e:console.warn("THREE."+this.type+": '"+n+"' is not a property of this material.")}},toJSON:function(t){const n=void 0===t||"string"==typeof t;n&&(t={textures:{},images:{}});const e={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};function a(t){const n=[];for(const e in t){const a=t[e];delete a.metadata,n.push(a)}return n}if(e.uuid=this.uuid,e.type=this.type,""!==this.name&&(e.name=this.name),this.color&&this.color.isColor&&(e.color=this.color.getHex()),void 0!==this.roughness&&(e.roughness=this.roughness),void 0!==this.metalness&&(e.metalness=this.metalness),this.sheen&&this.sheen.isColor&&(e.sheen=this.sheen.getHex()),this.emissive&&this.emissive.isColor&&(e.emissive=this.emissive.getHex()),this.emissiveIntensity&&1!==this.emissiveIntensity&&(e.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(e.specular=this.specular.getHex()),void 0!==this.shininess&&(e.shininess=this.shininess),void 0!==this.clearcoat&&(e.clearcoat=this.clearcoat),void 0!==this.clearcoatRoughness&&(e.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(e.clearcoatMap=this.clearcoatMap.toJSON(t).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(e.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(t).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(e.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(t).uuid,e.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.map&&this.map.isTexture&&(e.map=this.map.toJSON(t).uuid),this.matcap&&this.matcap.isTexture&&(e.matcap=this.matcap.toJSON(t).uuid),this.alphaMap&&this.alphaMap.isTexture&&(e.alphaMap=this.alphaMap.toJSON(t).uuid),this.lightMap&&this.lightMap.isTexture&&(e.lightMap=this.lightMap.toJSON(t).uuid),this.aoMap&&this.aoMap.isTexture&&(e.aoMap=this.aoMap.toJSON(t).uuid,e.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(e.bumpMap=this.bumpMap.toJSON(t).uuid,e.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(e.normalMap=this.normalMap.toJSON(t).uuid,e.normalMapType=this.normalMapType,e.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(e.displacementMap=this.displacementMap.toJSON(t).uuid,e.displacementScale=this.displacementScale,e.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(e.roughnessMap=this.roughnessMap.toJSON(t).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(e.metalnessMap=this.metalnessMap.toJSON(t).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(e.emissiveMap=this.emissiveMap.toJSON(t).uuid),this.specularMap&&this.specularMap.isTexture&&(e.specularMap=this.specularMap.toJSON(t).uuid),this.envMap&&this.envMap.isTexture&&(e.envMap=this.envMap.toJSON(t).uuid,e.reflectivity=this.reflectivity,e.refractionRatio=this.refractionRatio,void 0!==this.combine&&(e.combine=this.combine),void 0!==this.envMapIntensity&&(e.envMapIntensity=this.envMapIntensity)),this.gradientMap&&this.gradientMap.isTexture&&(e.gradientMap=this.gradientMap.toJSON(t).uuid),void 0!==this.size&&(e.size=this.size),void 0!==this.sizeAttenuation&&(e.sizeAttenuation=this.sizeAttenuation),1!==this.blending&&(e.blending=this.blending),!0===this.flatShading&&(e.flatShading=this.flatShading),0!==this.side&&(e.side=this.side),this.vertexColors&&(e.vertexColors=!0),this.opacity<1&&(e.opacity=this.opacity),!0===this.transparent&&(e.transparent=this.transparent),e.depthFunc=this.depthFunc,e.depthTest=this.depthTest,e.depthWrite=this.depthWrite,e.stencilWrite=this.stencilWrite,e.stencilWriteMask=this.stencilWriteMask,e.stencilFunc=this.stencilFunc,e.stencilRef=this.stencilRef,e.stencilFuncMask=this.stencilFuncMask,e.stencilFail=this.stencilFail,e.stencilZFail=this.stencilZFail,e.stencilZPass=this.stencilZPass,this.rotation&&0!==this.rotation&&(e.rotation=this.rotation),!0===this.polygonOffset&&(e.polygonOffset=!0),0!==this.polygonOffsetFactor&&(e.polygonOffsetFactor=this.polygonOffsetFactor),0!==this.polygonOffsetUnits&&(e.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth&&1!==this.linewidth&&(e.linewidth=this.linewidth),void 0!==this.dashSize&&(e.dashSize=this.dashSize),void 0!==this.gapSize&&(e.gapSize=this.gapSize),void 0!==this.scale&&(e.scale=this.scale),!0===this.dithering&&(e.dithering=!0),this.alphaTest>0&&(e.alphaTest=this.alphaTest),!0===this.premultipliedAlpha&&(e.premultipliedAlpha=this.premultipliedAlpha),!0===this.wireframe&&(e.wireframe=this.wireframe),this.wireframeLinewidth>1&&(e.wireframeLinewidth=this.wireframeLinewidth),"round"!==this.wireframeLinecap&&(e.wireframeLinecap=this.wireframeLinecap),"round"!==this.wireframeLinejoin&&(e.wireframeLinejoin=this.wireframeLinejoin),!0===this.morphTargets&&(e.morphTargets=!0),!0===this.morphNormals&&(e.morphNormals=!0),!0===this.skinning&&(e.skinning=!0),!1===this.visible&&(e.visible=!1),!1===this.toneMapped&&(e.toneMapped=!1),"{}"!==JSON.stringify(this.userData)&&(e.userData=this.userData),n){const n=a(t.textures),o=a(t.images);n.length>0&&(e.textures=n),o.length>0&&(e.images=o)}return e},clone:function(){return(new this.constructor).copy(this)},copy:function(t){this.name=t.name,this.fog=t.fog,this.blending=t.blending,this.side=t.side,this.flatShading=t.flatShading,this.vertexColors=t.vertexColors,this.opacity=t.opacity,this.transparent=t.transparent,this.blendSrc=t.blendSrc,this.blendDst=t.blendDst,this.blendEquation=t.blendEquation,this.blendSrcAlpha=t.blendSrcAlpha,this.blendDstAlpha=t.blendDstAlpha,this.blendEquationAlpha=t.blendEquationAlpha,this.depthFunc=t.depthFunc,this.depthTest=t.depthTest,this.depthWrite=t.depthWrite,this.stencilWriteMask=t.stencilWriteMask,this.stencilFunc=t.stencilFunc,this.stencilRef=t.stencilRef,this.stencilFuncMask=t.stencilFuncMask,this.stencilFail=t.stencilFail,this.stencilZFail=t.stencilZFail,this.stencilZPass=t.stencilZPass,this.stencilWrite=t.stencilWrite;const n=t.clippingPlanes;let e=null;if(null!==n){const t=n.length;e=new Array(t);for(let a=0;a!==t;++a)e[a]=n[a].clone()}return this.clippingPlanes=e,this.clipIntersection=t.clipIntersection,this.clipShadows=t.clipShadows,this.shadowSide=t.shadowSide,this.colorWrite=t.colorWrite,this.precision=t.precision,this.polygonOffset=t.polygonOffset,this.polygonOffsetFactor=t.polygonOffsetFactor,this.polygonOffsetUnits=t.polygonOffsetUnits,this.dithering=t.dithering,this.alphaTest=t.alphaTest,this.premultipliedAlpha=t.premultipliedAlpha,this.visible=t.visible,this.toneMapped=t.toneMapped,this.userData=JSON.parse(JSON.stringify(t.userData)),this},dispose:function(){this.dispatchEvent({type:"dispose"})}}),Object.defineProperty(ynt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),(knt.prototype=Object.create(ynt.prototype)).constructor=knt,knt.prototype.isMeshBasicMaterial=!0,knt.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this};const vnt=new ttt,wnt=new W9;function Snt(t,n,e){if(Array.isArray(t))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="",this.array=t,this.itemSize=n,this.count=void 0!==t?t.length/n:0,this.normalized=!0===e,this.usage=F9,this.updateRange={offset:0,count:-1},this.version=0}function Ent(t,n,e){Snt.call(this,new Int8Array(t),n,e)}function Ant(t,n,e){Snt.call(this,new Uint8Array(t),n,e)}function znt(t,n,e){Snt.call(this,new Uint8ClampedArray(t),n,e)}function Rnt(t,n,e){Snt.call(this,new Int16Array(t),n,e)}function Tnt(t,n,e){Snt.call(this,new Uint16Array(t),n,e)}function Dnt(t,n,e){Snt.call(this,new Int32Array(t),n,e)}function Int(t,n,e){Snt.call(this,new Uint32Array(t),n,e)}function Nnt(t,n,e){Snt.call(this,new Uint16Array(t),n,e)}function Fnt(t,n,e){Snt.call(this,new Float32Array(t),n,e)}function Lnt(t,n,e){Snt.call(this,new Float64Array(t),n,e)}function Hnt(t){if(0===t.length)return-1/0;let n=t[0];for(let e=1,a=t.length;e<a;++e)t[e]>n&&(n=t[e]);return n}Object.defineProperty(Snt.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(Snt.prototype,{isBufferAttribute:!0,onUploadCallback:function(){},setUsage:function(t){return this.usage=t,this},copy:function(t){return this.name=t.name,this.array=new t.array.constructor(t.array),this.itemSize=t.itemSize,this.count=t.count,this.normalized=t.normalized,this.usage=t.usage,this},copyAt:function(t,n,e){t*=this.itemSize,e*=n.itemSize;for(let a=0,o=this.itemSize;a<o;a++)this.array[t+a]=n.array[e+a];return this},copyArray:function(t){return this.array.set(t),this},copyColorsArray:function(t){const n=this.array;let e=0;for(let a=0,o=t.length;a<o;a++){let o=t[a];void 0===o&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",a),o=new Ont),n[e++]=o.r,n[e++]=o.g,n[e++]=o.b}return this},copyVector2sArray:function(t){const n=this.array;let e=0;for(let a=0,o=t.length;a<o;a++){let o=t[a];void 0===o&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",a),o=new W9),n[e++]=o.x,n[e++]=o.y}return this},copyVector3sArray:function(t){const n=this.array;let e=0;for(let a=0,o=t.length;a<o;a++){let o=t[a];void 0===o&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",a),o=new ttt),n[e++]=o.x,n[e++]=o.y,n[e++]=o.z}return this},copyVector4sArray:function(t){const n=this.array;let e=0;for(let a=0,o=t.length;a<o;a++){let o=t[a];void 0===o&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",a),o=new Q9),n[e++]=o.x,n[e++]=o.y,n[e++]=o.z,n[e++]=o.w}return this},applyMatrix3:function(t){if(2===this.itemSize)for(let n=0,e=this.count;n<e;n++)wnt.fromBufferAttribute(this,n),wnt.applyMatrix3(t),this.setXY(n,wnt.x,wnt.y);else if(3===this.itemSize)for(let n=0,e=this.count;n<e;n++)vnt.fromBufferAttribute(this,n),vnt.applyMatrix3(t),this.setXYZ(n,vnt.x,vnt.y,vnt.z);return this},applyMatrix4:function(t){for(let n=0,e=this.count;n<e;n++)vnt.x=this.getX(n),vnt.y=this.getY(n),vnt.z=this.getZ(n),vnt.applyMatrix4(t),this.setXYZ(n,vnt.x,vnt.y,vnt.z);return this},applyNormalMatrix:function(t){for(let n=0,e=this.count;n<e;n++)vnt.x=this.getX(n),vnt.y=this.getY(n),vnt.z=this.getZ(n),vnt.applyNormalMatrix(t),this.setXYZ(n,vnt.x,vnt.y,vnt.z);return this},transformDirection:function(t){for(let n=0,e=this.count;n<e;n++)vnt.x=this.getX(n),vnt.y=this.getY(n),vnt.z=this.getZ(n),vnt.transformDirection(t),this.setXYZ(n,vnt.x,vnt.y,vnt.z);return this},set:function(t,n=0){return this.array.set(t,n),this},getX:function(t){return this.array[t*this.itemSize]},setX:function(t,n){return this.array[t*this.itemSize]=n,this},getY:function(t){return this.array[t*this.itemSize+1]},setY:function(t,n){return this.array[t*this.itemSize+1]=n,this},getZ:function(t){return this.array[t*this.itemSize+2]},setZ:function(t,n){return this.array[t*this.itemSize+2]=n,this},getW:function(t){return this.array[t*this.itemSize+3]},setW:function(t,n){return this.array[t*this.itemSize+3]=n,this},setXY:function(t,n,e){return this.array[0+(t*=this.itemSize)]=n,this.array[t+1]=e,this},setXYZ:function(t,n,e,a){return this.array[0+(t*=this.itemSize)]=n,this.array[t+1]=e,this.array[t+2]=a,this},setXYZW:function(t,n,e,a,o){return this.array[0+(t*=this.itemSize)]=n,this.array[t+1]=e,this.array[t+2]=a,this.array[t+3]=o,this},onUpload:function(t){return this.onUploadCallback=t,this},clone:function(){return new this.constructor(this.array,this.itemSize).copy(this)},toJSON:function(){return{itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),normalized:this.normalized}}}),(Ent.prototype=Object.create(Snt.prototype)).constructor=Ent,(Ant.prototype=Object.create(Snt.prototype)).constructor=Ant,(znt.prototype=Object.create(Snt.prototype)).constructor=znt,(Rnt.prototype=Object.create(Snt.prototype)).constructor=Rnt,(Tnt.prototype=Object.create(Snt.prototype)).constructor=Tnt,(Dnt.prototype=Object.create(Snt.prototype)).constructor=Dnt,(Int.prototype=Object.create(Snt.prototype)).constructor=Int,(Nnt.prototype=Object.create(Snt.prototype)).constructor=Nnt,Nnt.prototype.isFloat16BufferAttribute=!0,(Fnt.prototype=Object.create(Snt.prototype)).constructor=Fnt,(Lnt.prototype=Object.create(Snt.prototype)).constructor=Lnt;const Bnt={Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:"undefined"!=typeof Uint8ClampedArray?Uint8ClampedArray:Uint8Array,Int16Array:Int16Array,Uint16Array:Uint16Array,Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,Float64Array:Float64Array};function Vnt(t,n){return new Bnt[t](n)}let jnt=0;const Unt=new Stt,Wnt=new $tt,Gnt=new ttt,Ynt=new att,qnt=new att,Znt=new ttt;function Xnt(){Object.defineProperty(this,"id",{value:jnt++}),this.uuid=U9.generateUUID(),this.name="",this.type="BufferGeometry",this.index=null,this.attributes={},this.morphAttributes={},this.morphTargetsRelative=!1,this.groups=[],this.boundingBox=null,this.boundingSphere=null,this.drawRange={start:0,count:1/0},this.userData={}}Xnt.prototype=Object.assign(Object.create(B9.prototype),{constructor:Xnt,isBufferGeometry:!0,getIndex:function(){return this.index},setIndex:function(t){return this.index=Array.isArray(t)?new(Hnt(t)>65535?Int:Tnt)(t,1):t,this},getAttribute:function(t){return this.attributes[t]},setAttribute:function(t,n){return this.attributes[t]=n,this},deleteAttribute:function(t){return delete this.attributes[t],this},hasAttribute:function(t){return void 0!==this.attributes[t]},addGroup:function(t,n,e=0){this.groups.push({start:t,count:n,materialIndex:e})},clearGroups:function(){this.groups=[]},setDrawRange:function(t,n){this.drawRange.start=t,this.drawRange.count=n},applyMatrix4:function(t){const n=this.attributes.position;void 0!==n&&(n.applyMatrix4(t),n.needsUpdate=!0);const e=this.attributes.normal;if(void 0!==e){const n=(new G9).getNormalMatrix(t);e.applyNormalMatrix(n),e.needsUpdate=!0}const a=this.attributes.tangent;return void 0!==a&&(a.transformDirection(t),a.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this},rotateX:function(t){return Unt.makeRotationX(t),this.applyMatrix4(Unt),this},rotateY:function(t){return Unt.makeRotationY(t),this.applyMatrix4(Unt),this},rotateZ:function(t){return Unt.makeRotationZ(t),this.applyMatrix4(Unt),this},translate:function(t,n,e){return Unt.makeTranslation(t,n,e),this.applyMatrix4(Unt),this},scale:function(t,n,e){return Unt.makeScale(t,n,e),this.applyMatrix4(Unt),this},lookAt:function(t){return Wnt.lookAt(t),Wnt.updateMatrix(),this.applyMatrix4(Wnt.matrix),this},center:function(){return this.computeBoundingBox(),this.boundingBox.getCenter(Gnt).negate(),this.translate(Gnt.x,Gnt.y,Gnt.z),this},setFromPoints:function(t){const n=[];for(let e=0,a=t.length;e<a;e++){const a=t[e];n.push(a.x,a.y,a.z||0)}return this.setAttribute("position",new Fnt(n,3)),this},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new att);const t=this.attributes.position,n=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingBox.set(new ttt(-1/0,-1/0,-1/0),new ttt(1/0,1/0,1/0));if(void 0!==t){if(this.boundingBox.setFromBufferAttribute(t),n)for(let t=0,e=n.length;t<e;t++)Ynt.setFromBufferAttribute(n[t]),this.morphTargetsRelative?(Znt.addVectors(this.boundingBox.min,Ynt.min),this.boundingBox.expandByPoint(Znt),Znt.addVectors(this.boundingBox.max,Ynt.max),this.boundingBox.expandByPoint(Znt)):(this.boundingBox.expandByPoint(Ynt.min),this.boundingBox.expandByPoint(Ynt.max))}else this.boundingBox.makeEmpty();(isNaN(this.boundingBox.min.x)||isNaN(this.boundingBox.min.y)||isNaN(this.boundingBox.min.z))&&console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',this)},computeBoundingSphere:function(){null===this.boundingSphere&&(this.boundingSphere=new Ctt);const t=this.attributes.position,n=this.morphAttributes.position;if(t&&t.isGLBufferAttribute)return console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',this),void this.boundingSphere.set(new ttt,1/0);if(t){const e=this.boundingSphere.center;if(Ynt.setFromBufferAttribute(t),n)for(let t=0,e=n.length;t<e;t++)qnt.setFromBufferAttribute(n[t]),this.morphTargetsRelative?(Znt.addVectors(Ynt.min,qnt.min),Ynt.expandByPoint(Znt),Znt.addVectors(Ynt.max,qnt.max),Ynt.expandByPoint(Znt)):(Ynt.expandByPoint(qnt.min),Ynt.expandByPoint(qnt.max));Ynt.getCenter(e);let a=0;for(let n=0,o=t.count;n<o;n++)Znt.fromBufferAttribute(t,n),a=Math.max(a,e.distanceToSquared(Znt));if(n)for(let o=0,r=n.length;o<r;o++){const r=n[o],i=this.morphTargetsRelative;for(let n=0,o=r.count;n<o;n++)Znt.fromBufferAttribute(r,n),i&&(Gnt.fromBufferAttribute(t,n),Znt.add(Gnt)),a=Math.max(a,e.distanceToSquared(Znt))}this.boundingSphere.radius=Math.sqrt(a),isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',this)}},computeFaceNormals:function(){},computeTangents:function(){const t=this.index,n=this.attributes;if(null===t||void 0===n.position||void 0===n.normal||void 0===n.uv)return void console.error("THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)");const e=t.array,a=n.position.array,o=n.normal.array,r=n.uv.array,i=a.length/3;void 0===n.tangent&&this.setAttribute("tangent",new Snt(new Float32Array(4*i),4));const c=n.tangent.array,s=[],l=[];for(let t=0;t<i;t++)s[t]=new ttt,l[t]=new ttt;const m=new ttt,d=new ttt,g=new ttt,p=new W9,b=new W9,u=new W9,f=new ttt,h=new ttt;function _(t,n,e){m.fromArray(a,3*t),d.fromArray(a,3*n),g.fromArray(a,3*e),p.fromArray(r,2*t),b.fromArray(r,2*n),u.fromArray(r,2*e),d.sub(m),g.sub(m),b.sub(p),u.sub(p);const o=1/(b.x*u.y-u.x*b.y);isFinite(o)&&(f.copy(d).multiplyScalar(u.y).addScaledVector(g,-b.y).multiplyScalar(o),h.copy(g).multiplyScalar(b.x).addScaledVector(d,-u.x).multiplyScalar(o),s[t].add(f),s[n].add(f),s[e].add(f),l[t].add(h),l[n].add(h),l[e].add(h))}let C=this.groups;0===C.length&&(C=[{start:0,count:e.length}]);for(let t=0,n=C.length;t<n;++t){const n=C[t],a=n.start;for(let t=a,o=a+n.count;t<o;t+=3)_(e[t+0],e[t+1],e[t+2])}const M=new ttt,O=new ttt,P=new ttt,x=new ttt;function y(t){P.fromArray(o,3*t),x.copy(P);const n=s[t];M.copy(n),M.sub(P.multiplyScalar(P.dot(n))).normalize(),O.crossVectors(x,n);const e=O.dot(l[t])<0?-1:1;c[4*t]=M.x,c[4*t+1]=M.y,c[4*t+2]=M.z,c[4*t+3]=e}for(let t=0,n=C.length;t<n;++t){const n=C[t],a=n.start;for(let t=a,o=a+n.count;t<o;t+=3)y(e[t+0]),y(e[t+1]),y(e[t+2])}},computeVertexNormals:function(){const t=this.index,n=this.getAttribute("position");if(void 0!==n){let e=this.getAttribute("normal");if(void 0===e)e=new Snt(new Float32Array(3*n.count),3),this.setAttribute("normal",e);else for(let t=0,n=e.count;t<n;t++)e.setXYZ(t,0,0,0);const a=new ttt,o=new ttt,r=new ttt,i=new ttt,c=new ttt,s=new ttt,l=new ttt,m=new ttt;if(t)for(let d=0,g=t.count;d<g;d+=3){const g=t.getX(d+0),p=t.getX(d+1),b=t.getX(d+2);a.fromBufferAttribute(n,g),o.fromBufferAttribute(n,p),r.fromBufferAttribute(n,b),l.subVectors(r,o),m.subVectors(a,o),l.cross(m),i.fromBufferAttribute(e,g),c.fromBufferAttribute(e,p),s.fromBufferAttribute(e,b),i.add(l),c.add(l),s.add(l),e.setXYZ(g,i.x,i.y,i.z),e.setXYZ(p,c.x,c.y,c.z),e.setXYZ(b,s.x,s.y,s.z)}else for(let t=0,i=n.count;t<i;t+=3)a.fromBufferAttribute(n,t+0),o.fromBufferAttribute(n,t+1),r.fromBufferAttribute(n,t+2),l.subVectors(r,o),m.subVectors(a,o),l.cross(m),e.setXYZ(t+0,l.x,l.y,l.z),e.setXYZ(t+1,l.x,l.y,l.z),e.setXYZ(t+2,l.x,l.y,l.z);this.normalizeNormals(),e.needsUpdate=!0}},merge:function(t,n){if(!t||!t.isBufferGeometry)return void console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",t);void 0===n&&(n=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));const e=this.attributes;for(const a in e){if(void 0===t.attributes[a])continue;const o=e[a].array,r=t.attributes[a],i=r.array,c=r.itemSize*n,s=Math.min(i.length,o.length-c);for(let t=0,n=c;t<s;t++,n++)o[n]=i[t]}return this},normalizeNormals:function(){const t=this.attributes.normal;for(let n=0,e=t.count;n<e;n++)Znt.fromBufferAttribute(t,n),Znt.normalize(),t.setXYZ(n,Znt.x,Znt.y,Znt.z)},toNonIndexed:function(){function t(t,n){const e=t.array,a=t.itemSize,o=t.normalized,r=new e.constructor(n.length*a);let i=0,c=0;for(let t=0,o=n.length;t<o;t++){i=n[t]*a;for(let t=0;t<a;t++)r[c++]=e[i++]}return new Snt(r,a,o)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed."),this;const n=new Xnt,e=this.index.array,a=this.attributes;for(const o in a){const r=t(a[o],e);n.setAttribute(o,r)}const o=this.morphAttributes;for(const a in o){const r=[],i=o[a];for(let n=0,a=i.length;n<a;n++){const a=t(i[n],e);r.push(a)}n.morphAttributes[a]=r}n.morphTargetsRelative=this.morphTargetsRelative;const r=this.groups;for(let t=0,e=r.length;t<e;t++){const e=r[t];n.addGroup(e.start,e.count,e.materialIndex)}return n},toJSON:function(){const t={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};if(t.uuid=this.uuid,t.type=this.type,""!==this.name&&(t.name=this.name),Object.keys(this.userData).length>0&&(t.userData=this.userData),void 0!==this.parameters){const n=this.parameters;for(const e in n)void 0!==n[e]&&(t[e]=n[e]);return t}t.data={attributes:{}};const n=this.index;null!==n&&(t.data.index={type:n.array.constructor.name,array:Array.prototype.slice.call(n.array)});const e=this.attributes;for(const n in e){const a=e[n],o=a.toJSON(t.data);""!==a.name&&(o.name=a.name),t.data.attributes[n]=o}const a={};let o=!1;for(const n in this.morphAttributes){const e=this.morphAttributes[n],r=[];for(let n=0,a=e.length;n<a;n++){const a=e[n],o=a.toJSON(t.data);""!==a.name&&(o.name=a.name),r.push(o)}r.length>0&&(a[n]=r,o=!0)}o&&(t.data.morphAttributes=a,t.data.morphTargetsRelative=this.morphTargetsRelative);const r=this.groups;r.length>0&&(t.data.groups=JSON.parse(JSON.stringify(r)));const i=this.boundingSphere;return null!==i&&(t.data.boundingSphere={center:i.center.toArray(),radius:i.radius}),t},clone:function(){return(new Xnt).copy(this)},copy:function(t){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const n={};this.name=t.name;const e=t.index;null!==e&&this.setIndex(e.clone(n));const a=t.attributes;for(const t in a)this.setAttribute(t,a[t].clone(n));const o=t.morphAttributes;for(const t in o){const e=[],a=o[t];for(let t=0,o=a.length;t<o;t++)e.push(a[t].clone(n));this.morphAttributes[t]=e}this.morphTargetsRelative=t.morphTargetsRelative;const r=t.groups;for(let t=0,n=r.length;t<n;t++){const n=r[t];this.addGroup(n.start,n.count,n.materialIndex)}const i=t.boundingBox;null!==i&&(this.boundingBox=i.clone());const c=t.boundingSphere;return null!==c&&(this.boundingSphere=c.clone()),this.drawRange.start=t.drawRange.start,this.drawRange.count=t.drawRange.count,this.userData=t.userData,this},dispose:function(){this.dispatchEvent({type:"dispose"})}});const Jnt=new Stt,Qnt=new wtt,Knt=new Ctt,$nt=new ttt,tet=new ttt,net=new ttt,eet=new ttt,aet=new ttt,oet=new ttt,ret=new ttt,iet=new ttt,cet=new ttt,set=new W9,met=new W9,det=new W9,get=new ttt,pet=new ttt;function bet(t=new Xnt,n=new knt){$tt.call(this),this.type="Mesh",this.geometry=t,this.material=n,this.updateMorphTargets()}function uet(t,n,e,a,o,r,i,c,s,l,m,d){$nt.fromBufferAttribute(o,l),tet.fromBufferAttribute(o,m),net.fromBufferAttribute(o,d);const g=t.morphTargetInfluences;if(n.morphTargets&&r&&g){ret.set(0,0,0),iet.set(0,0,0),cet.set(0,0,0);for(let t=0,n=r.length;t<n;t++){const n=g[t],e=r[t];0!==n&&(eet.fromBufferAttribute(e,l),aet.fromBufferAttribute(e,m),oet.fromBufferAttribute(e,d),i?(ret.addScaledVector(eet,n),iet.addScaledVector(aet,n),cet.addScaledVector(oet,n)):(ret.addScaledVector(eet.sub($nt),n),iet.addScaledVector(aet.sub(tet),n),cet.addScaledVector(oet.sub(net),n)))}$nt.add(ret),tet.add(iet),net.add(cet)}t.isSkinnedMesh&&(t.boneTransform(l,$nt),t.boneTransform(m,tet),t.boneTransform(d,net));const p=(function b(t,n,e,a,o,r,i,c){let s;if(s=1===n.side?a.intersectTriangle(i,r,o,!0,c):a.intersectTriangle(o,r,i,2!==n.side,c),null===s)return null;pet.copy(c),pet.applyMatrix4(t.matrixWorld);const l=e.ray.origin.distanceTo(pet);return l<e.near||l>e.far?null:{distance:l,point:pet.clone(),object:t}})(t,n,e,a,$nt,tet,net,get);if(p){c&&(set.fromBufferAttribute(c,l),met.fromBufferAttribute(c,m),det.fromBufferAttribute(c,d),p.uv=bnt.getUV(get,$nt,tet,net,set,met,det,new W9)),s&&(set.fromBufferAttribute(s,l),met.fromBufferAttribute(s,m),det.fromBufferAttribute(s,d),p.uv2=bnt.getUV(get,$nt,tet,net,set,met,det,new W9));const t=new Pnt(l,m,d);bnt.getNormal($nt,tet,net,t.normal),p.face=t}return p}bet.prototype=Object.assign(Object.create($tt.prototype),{constructor:bet,isMesh:!0,copy:function(t){return $tt.prototype.copy.call(this,t),void 0!==t.morphTargetInfluences&&(this.morphTargetInfluences=t.morphTargetInfluences.slice()),void 0!==t.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},t.morphTargetDictionary)),this.material=t.material,this.geometry=t.geometry,this},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const n=t.morphAttributes,e=Object.keys(n);if(e.length>0){const t=n[e[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let n=0,e=t.length;n<e;n++){const e=t[n].name||String(n);this.morphTargetInfluences.push(0),this.morphTargetDictionary[e]=n}}}}else{const n=t.morphTargets;void 0!==n&&n.length>0&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}},raycast:function(t,n){const e=this.geometry,a=this.material,o=this.matrixWorld;if(void 0===a)return;if(null===e.boundingSphere&&e.computeBoundingSphere(),Knt.copy(e.boundingSphere),Knt.applyMatrix4(o),!1===t.ray.intersectsSphere(Knt))return;if(Jnt.copy(o).invert(),Qnt.copy(t.ray).applyMatrix4(Jnt),null!==e.boundingBox&&!1===Qnt.intersectsBox(e.boundingBox))return;let r;if(e.isBufferGeometry){const o=e.index,i=e.attributes.position,c=e.morphAttributes.position,s=e.morphTargetsRelative,l=e.attributes.uv,m=e.attributes.uv2,d=e.groups,g=e.drawRange;if(null!==o)if(Array.isArray(a))for(let e=0,p=d.length;e<p;e++){const p=d[e],b=a[p.materialIndex];for(let e=Math.max(p.start,g.start),a=Math.min(p.start+p.count,g.start+g.count);e<a;e+=3){const a=o.getX(e),d=o.getX(e+1),g=o.getX(e+2);r=uet(this,b,t,Qnt,i,c,s,l,m,a,d,g),r&&(r.faceIndex=Math.floor(e/3),r.face.materialIndex=p.materialIndex,n.push(r))}}else for(let e=Math.max(0,g.start),d=Math.min(o.count,g.start+g.count);e<d;e+=3){const d=o.getX(e),g=o.getX(e+1),p=o.getX(e+2);r=uet(this,a,t,Qnt,i,c,s,l,m,d,g,p),r&&(r.faceIndex=Math.floor(e/3),n.push(r))}else if(void 0!==i)if(Array.isArray(a))for(let e=0,o=d.length;e<o;e++){const o=d[e],p=a[o.materialIndex];for(let e=Math.max(o.start,g.start),a=Math.min(o.start+o.count,g.start+g.count);e<a;e+=3)r=uet(this,p,t,Qnt,i,c,s,l,m,e,e+1,e+2),r&&(r.faceIndex=Math.floor(e/3),r.face.materialIndex=o.materialIndex,n.push(r))}else for(let e=Math.max(0,g.start),o=Math.min(i.count,g.start+g.count);e<o;e+=3)r=uet(this,a,t,Qnt,i,c,s,l,m,e,e+1,e+2),r&&(r.faceIndex=Math.floor(e/3),n.push(r))}else e.isGeometry&&console.error("THREE.Mesh.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")}});class fet extends Xnt{constructor(t=1,n=1,e=1,a=1,o=1,r=1){super(),this.type="BoxGeometry",this.parameters={width:t,height:n,depth:e,widthSegments:a,heightSegments:o,depthSegments:r};const i=this;a=Math.floor(a),o=Math.floor(o),r=Math.floor(r);const c=[],s=[],l=[],m=[];let d=0,g=0;function p(t,n,e,a,o,r,p,b,u,f,h){const _=r/u,C=p/f,M=r/2,O=p/2,P=b/2,x=u+1,y=f+1;let k=0,v=0;const w=new ttt;for(let r=0;r<y;r++){const i=r*C-O;for(let c=0;c<x;c++)w[t]=(c*_-M)*a,w[n]=i*o,w[e]=P,s.push(w.x,w.y,w.z),w[t]=0,w[n]=0,w[e]=b>0?1:-1,l.push(w.x,w.y,w.z),m.push(c/u),m.push(1-r/f),k+=1}for(let t=0;t<f;t++)for(let n=0;n<u;n++){const e=d+n+x*(t+1),a=d+(n+1)+x*(t+1),o=d+(n+1)+x*t;c.push(d+n+x*t,e,o),c.push(e,a,o),v+=6}i.addGroup(g,v,h),g+=v,d+=k}p("z","y","x",-1,-1,e,n,t,r,o,0),p("z","y","x",1,-1,e,n,-t,r,o,1),p("x","z","y",1,1,t,e,n,a,r,2),p("x","z","y",1,-1,t,e,-n,a,r,3),p("x","y","z",1,-1,t,n,e,a,o,4),p("x","y","z",-1,-1,t,n,-e,a,o,5),this.setIndex(c),this.setAttribute("position",new Fnt(s,3)),this.setAttribute("normal",new Fnt(l,3)),this.setAttribute("uv",new Fnt(m,2))}}function het(t){const n={};for(const e in t){n[e]={};for(const a in t[e]){const o=t[e][a];n[e][a]=o&&(o.isColor||o.isMatrix3||o.isMatrix4||o.isVector2||o.isVector3||o.isVector4||o.isTexture)?o.clone():Array.isArray(o)?o.slice():o}}return n}function _et(t){const n={};for(let e=0;e<t.length;e++){const a=het(t[e]);for(const t in a)n[t]=a[t]}return n}const Cet={clone:het,merge:_et};function Met(t){ynt.call(this),this.type="ShaderMaterial",this.defines={},this.uniforms={},this.vertexShader="void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",this.fragmentShader="void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}",this.linewidth=1,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.lights=!1,this.clipping=!1,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.extensions={derivatives:!1,fragDepth:!1,drawBuffers:!1,shaderTextureLOD:!1},this.defaultAttributeValues={color:[1,1,1],uv:[0,0],uv2:[0,0]},this.index0AttributeName=void 0,this.uniformsNeedUpdate=!1,this.glslVersion=null,void 0!==t&&(void 0!==t.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),this.setValues(t))}function Oet(){$tt.call(this),this.type="Camera",this.matrixWorldInverse=new Stt,this.projectionMatrix=new Stt,this.projectionMatrixInverse=new Stt}function Pet(t=50,n=1,e=.1,a=2e3){Oet.call(this),this.type="PerspectiveCamera",this.fov=t,this.zoom=1,this.near=e,this.far=a,this.focus=10,this.aspect=n,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}(Met.prototype=Object.create(ynt.prototype)).constructor=Met,Met.prototype.isShaderMaterial=!0,Met.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.fragmentShader=t.fragmentShader,this.vertexShader=t.vertexShader,this.uniforms=het(t.uniforms),this.defines=Object.assign({},t.defines),this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.lights=t.lights,this.clipping=t.clipping,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this.extensions=Object.assign({},t.extensions),this.glslVersion=t.glslVersion,this},Met.prototype.toJSON=function(t){const n=ynt.prototype.toJSON.call(this,t);n.glslVersion=this.glslVersion,n.uniforms={};for(const e in this.uniforms){const a=this.uniforms[e].value;n.uniforms[e]=a&&a.isTexture?{type:"t",value:a.toJSON(t).uuid}:a&&a.isColor?{type:"c",value:a.getHex()}:a&&a.isVector2?{type:"v2",value:a.toArray()}:a&&a.isVector3?{type:"v3",value:a.toArray()}:a&&a.isVector4?{type:"v4",value:a.toArray()}:a&&a.isMatrix3?{type:"m3",value:a.toArray()}:a&&a.isMatrix4?{type:"m4",value:a.toArray()}:{value:a}}Object.keys(this.defines).length>0&&(n.defines=this.defines),n.vertexShader=this.vertexShader,n.fragmentShader=this.fragmentShader;const e={};for(const t in this.extensions)!0===this.extensions[t]&&(e[t]=!0);return Object.keys(e).length>0&&(n.extensions=e),n},Oet.prototype=Object.assign(Object.create($tt.prototype),{constructor:Oet,isCamera:!0,copy:function(t,n){return $tt.prototype.copy.call(this,t,n),this.matrixWorldInverse.copy(t.matrixWorldInverse),this.projectionMatrix.copy(t.projectionMatrix),this.projectionMatrixInverse.copy(t.projectionMatrixInverse),this},getWorldDirection:function(t){void 0===t&&(console.warn("THREE.Camera: .getWorldDirection() target is now required"),t=new ttt),this.updateWorldMatrix(!0,!1);const n=this.matrixWorld.elements;return t.set(-n[8],-n[9],-n[10]).normalize()},updateMatrixWorld:function(t){$tt.prototype.updateMatrixWorld.call(this,t),this.matrixWorldInverse.copy(this.matrixWorld).invert()},updateWorldMatrix:function(t,n){$tt.prototype.updateWorldMatrix.call(this,t,n),this.matrixWorldInverse.copy(this.matrixWorld).invert()},clone:function(){return(new this.constructor).copy(this)}}),Pet.prototype=Object.assign(Object.create(Oet.prototype),{constructor:Pet,isPerspectiveCamera:!0,copy:function(t,n){return Oet.prototype.copy.call(this,t,n),this.fov=t.fov,this.zoom=t.zoom,this.near=t.near,this.far=t.far,this.focus=t.focus,this.aspect=t.aspect,this.view=null===t.view?null:Object.assign({},t.view),this.filmGauge=t.filmGauge,this.filmOffset=t.filmOffset,this},setFocalLength:function(t){const n=.5*this.getFilmHeight()/t;this.fov=2*U9.RAD2DEG*Math.atan(n),this.updateProjectionMatrix()},getFocalLength:function(){const t=Math.tan(.5*U9.DEG2RAD*this.fov);return.5*this.getFilmHeight()/t},getEffectiveFOV:function(){return 2*U9.RAD2DEG*Math.atan(Math.tan(.5*U9.DEG2RAD*this.fov)/this.zoom)},getFilmWidth:function(){return this.filmGauge*Math.min(this.aspect,1)},getFilmHeight:function(){return this.filmGauge/Math.max(this.aspect,1)},setViewOffset:function(t,n,e,a,o,r){this.aspect=t/n,null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=n,this.view.offsetX=e,this.view.offsetY=a,this.view.width=o,this.view.height=r,this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()},updateProjectionMatrix:function(){const t=this.near;let n=t*Math.tan(.5*U9.DEG2RAD*this.fov)/this.zoom,e=2*n,a=this.aspect*e,o=-.5*a;const r=this.view;if(null!==this.view&&this.view.enabled){const t=r.fullWidth,i=r.fullHeight;o+=r.offsetX*a/t,n-=r.offsetY*e/i,a*=r.width/t,e*=r.height/i}const i=this.filmOffset;0!==i&&(o+=t*i/this.getFilmWidth()),this.projectionMatrix.makePerspective(o,o+a,n,n-e,t,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()},toJSON:function(t){const n=$tt.prototype.toJSON.call(this,t);return n.object.fov=this.fov,n.object.zoom=this.zoom,n.object.near=this.near,n.object.far=this.far,n.object.focus=this.focus,n.object.aspect=this.aspect,null!==this.view&&(n.object.view=Object.assign({},this.view)),n.object.filmGauge=this.filmGauge,n.object.filmOffset=this.filmOffset,n}});const xet=90;function yet(t,n,e){if($tt.call(this),this.type="CubeCamera",!0!==e.isWebGLCubeRenderTarget)return void console.error("THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.");this.renderTarget=e;const a=new Pet(xet,1,t,n);a.layers=this.layers,a.up.set(0,-1,0),a.lookAt(new ttt(1,0,0)),this.add(a);const o=new Pet(xet,1,t,n);o.layers=this.layers,o.up.set(0,-1,0),o.lookAt(new ttt(-1,0,0)),this.add(o);const r=new Pet(xet,1,t,n);r.layers=this.layers,r.up.set(0,0,1),r.lookAt(new ttt(0,1,0)),this.add(r);const i=new Pet(xet,1,t,n);i.layers=this.layers,i.up.set(0,0,-1),i.lookAt(new ttt(0,-1,0)),this.add(i);const c=new Pet(xet,1,t,n);c.layers=this.layers,c.up.set(0,-1,0),c.lookAt(new ttt(0,0,1)),this.add(c);const s=new Pet(xet,1,t,n);s.layers=this.layers,s.up.set(0,-1,0),s.lookAt(new ttt(0,0,-1)),this.add(s),this.update=function(t,n){null===this.parent&&this.updateMatrixWorld();const l=t.xr.enabled,m=t.getRenderTarget();t.xr.enabled=!1;const d=e.texture.generateMipmaps;e.texture.generateMipmaps=!1,t.setRenderTarget(e,0),t.render(n,a),t.setRenderTarget(e,1),t.render(n,o),t.setRenderTarget(e,2),t.render(n,r),t.setRenderTarget(e,3),t.render(n,i),t.setRenderTarget(e,4),t.render(n,c),e.texture.generateMipmaps=d,t.setRenderTarget(e,5),t.render(n,s),t.setRenderTarget(m),t.xr.enabled=l}}function ket(t,n,e,a,o,r,i,c,s,l){X9.call(this,t=void 0!==t?t:[],n=void 0!==n?n:301,e,a,o,r,i=void 0!==i?i:k9,c,s,l),this.flipY=!1,this._needsFlipEnvMap=!0}(yet.prototype=Object.create($tt.prototype)).constructor=yet,(ket.prototype=Object.create(X9.prototype)).constructor=ket,ket.prototype.isCubeTexture=!0,Object.defineProperty(ket.prototype,"images",{get:function(){return this.image},set:function(t){this.image=t}});class vet extends K9{constructor(t,n,e){Number.isInteger(n)&&(console.warn("THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )"),n=e),super(t,t,n),Object.defineProperty(this,"isWebGLCubeRenderTarget",{value:!0}),this.texture=new ket(void 0,(n=n||{}).mapping,n.wrapS,n.wrapT,n.magFilter,n.minFilter,n.format,n.type,n.anisotropy,n.encoding),this.texture._needsFlipEnvMap=!1}fromEquirectangularTexture(t,n){this.texture.type=n.type,this.texture.format=v9,this.texture.encoding=n.encoding,this.texture.generateMipmaps=n.generateMipmaps,this.texture.minFilter=n.minFilter,this.texture.magFilter=n.magFilter;const e=new fet(5,5,5),a=new Met({name:"CubemapFromEquirect",uniforms:het({tEquirect:{value:null}}),vertexShader:"\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t\t}\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t\t#include <begin_vertex>\n\t\t\t\t\t#include <project_vertex>\n\n\t\t\t\t}\n\t\t\t",fragmentShader:"\n\n\t\t\t\tuniform sampler2D tEquirect;\n\n\t\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t\t#include <common>\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t\t}\n\t\t\t",side:1,blending:0});a.uniforms.tEquirect.value=n;const o=new bet(e,a),r=n.minFilter;return n.minFilter===C9&&(n.minFilter=_9),new yet(1,10,this).update(t,o),n.minFilter=r,o.geometry.dispose(),o.material.dispose(),this}clear(t,n,e,a){const o=t.getRenderTarget();for(let o=0;o<6;o++)t.setRenderTarget(this,o),t.clear(n,e,a);t.setRenderTarget(o)}}function wet(t,n,e,a,o,r,i,c,s,l,m,d){X9.call(this,null,r,i,c,s,l,a,o,m,d),this.image={data:t||null,width:n||1,height:e||1},this.magFilter=void 0!==s?s:h9,this.minFilter=void 0!==l?l:h9,this.generateMipmaps=!1,this.flipY=!1,this.unpackAlignment=1,this.needsUpdate=!0}(wet.prototype=Object.create(X9.prototype)).constructor=wet,wet.prototype.isDataTexture=!0;const Eet=new Ctt,Aet=new ttt;class zet{constructor(t,n,e,a,o,r){this.planes=[void 0!==t?t:new ant,void 0!==n?n:new ant,void 0!==e?e:new ant,void 0!==a?a:new ant,void 0!==o?o:new ant,void 0!==r?r:new ant]}set(t,n,e,a,o,r){const i=this.planes;return i[0].copy(t),i[1].copy(n),i[2].copy(e),i[3].copy(a),i[4].copy(o),i[5].copy(r),this}clone(){return(new this.constructor).copy(this)}copy(t){const n=this.planes;for(let e=0;e<6;e++)n[e].copy(t.planes[e]);return this}setFromProjectionMatrix(t){const n=this.planes,e=t.elements,a=e[0],o=e[1],r=e[2],i=e[3],c=e[4],s=e[5],l=e[6],m=e[7],d=e[8],g=e[9],p=e[10],b=e[11],u=e[12],f=e[13],h=e[14],_=e[15];return n[0].setComponents(i-a,m-c,b-d,_-u).normalize(),n[1].setComponents(i+a,m+c,b+d,_+u).normalize(),n[2].setComponents(i+o,m+s,b+g,_+f).normalize(),n[3].setComponents(i-o,m-s,b-g,_-f).normalize(),n[4].setComponents(i-r,m-l,b-p,_-h).normalize(),n[5].setComponents(i+r,m+l,b+p,_+h).normalize(),this}intersectsObject(t){const n=t.geometry;return null===n.boundingSphere&&n.computeBoundingSphere(),Eet.copy(n.boundingSphere).applyMatrix4(t.matrixWorld),this.intersectsSphere(Eet)}intersectsSprite(t){return Eet.center.set(0,0,0),Eet.radius=.7071067811865476,Eet.applyMatrix4(t.matrixWorld),this.intersectsSphere(Eet)}intersectsSphere(t){const n=this.planes,e=t.center,a=-t.radius;for(let t=0;t<6;t++)if(n[t].distanceToPoint(e)<a)return!1;return!0}intersectsBox(t){const n=this.planes;for(let e=0;e<6;e++){const a=n[e];if(Aet.x=a.normal.x>0?t.max.x:t.min.x,Aet.y=a.normal.y>0?t.max.y:t.min.y,Aet.z=a.normal.z>0?t.max.z:t.min.z,a.distanceToPoint(Aet)<0)return!1}return!0}containsPoint(t){const n=this.planes;for(let e=0;e<6;e++)if(n[e].distanceToPoint(t)<0)return!1;return!0}}function Ret(){let t=null,n=!1,e=null,a=null;function o(n,r){e(n,r),a=t.requestAnimationFrame(o)}return{start:function(){!0!==n&&null!==e&&(a=t.requestAnimationFrame(o),n=!0)},stop:function(){t.cancelAnimationFrame(a),n=!1},setAnimationLoop:function(t){e=t},setContext:function(n){t=n}}}function Tet(t,n){const e=n.isWebGL2,a=new WeakMap;return{get:function o(t){return t.isInterleavedBufferAttribute&&(t=t.data),a.get(t)},remove:function r(n){n.isInterleavedBufferAttribute&&(n=n.data);const e=a.get(n);e&&(t.deleteBuffer(e.buffer),a.delete(n))},update:function i(n,o){if(n.isGLBufferAttribute){const t=a.get(n);return void((!t||t.version<n.version)&&a.set(n,{buffer:n.buffer,type:n.type,bytesPerElement:n.elementSize,version:n.version}))}n.isInterleavedBufferAttribute&&(n=n.data);const r=a.get(n);void 0===r?a.set(n,(function i(n,a){const o=n.array,r=n.usage,i=t.createBuffer();t.bindBuffer(a,i),t.bufferData(a,o,r),n.onUploadCallback();let c=5126;return o instanceof Float32Array?c=5126:o instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):o instanceof Uint16Array?n.isFloat16BufferAttribute?e?c=5131:console.warn("THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2."):c=5123:o instanceof Int16Array?c=5122:o instanceof Uint32Array?c=5125:o instanceof Int32Array?c=5124:o instanceof Int8Array?c=5120:o instanceof Uint8Array&&(c=5121),{buffer:i,type:c,bytesPerElement:o.BYTES_PER_ELEMENT,version:n.version}})(n,o)):r.version<n.version&&((function c(n,a,o){const r=a.array,i=a.updateRange;t.bindBuffer(o,n),-1===i.count?t.bufferSubData(o,0,r):(e?t.bufferSubData(o,i.offset*r.BYTES_PER_ELEMENT,r,i.offset,i.count):t.bufferSubData(o,i.offset*r.BYTES_PER_ELEMENT,r.subarray(i.offset,i.offset+i.count)),i.count=-1)})(r.buffer,n,o),r.version=n.version)}}}class Det extends Xnt{constructor(t=1,n=1,e=1,a=1){super(),this.type="PlaneGeometry",this.parameters={width:t,height:n,widthSegments:e,heightSegments:a};const o=t/2,r=n/2,i=Math.floor(e),c=Math.floor(a),s=i+1,l=c+1,m=t/i,d=n/c,g=[],p=[],b=[],u=[];for(let t=0;t<l;t++){const n=t*d-r;for(let e=0;e<s;e++)p.push(e*m-o,-n,0),b.push(0,0,1),u.push(e/i),u.push(1-t/c)}for(let t=0;t<c;t++)for(let n=0;n<i;n++){const e=n+s*(t+1),a=n+1+s*(t+1),o=n+1+s*t;g.push(n+s*t,e,o),g.push(e,a,o)}this.setIndex(g),this.setAttribute("position",new Fnt(p,3)),this.setAttribute("normal",new Fnt(b,3)),this.setAttribute("uv",new Fnt(u,2))}}const Iet={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif",aomap_pars_fragment:"#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif",begin_vertex:"vec3 transformed = vec3( position );",beginnormal_vertex:"vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif",bsdfs:"vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + viewDir );\n\tfloat dotNL = saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss = F * brdf.x + brdf.y;\n\tfloat Ess = brdf.x + brdf.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha = 1.0 / roughness;\n\tfloat cos2h = NoH * NoH;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N = geometry.normal;\n\tvec3 V = geometry.viewDir;\n\tvec3 H = normalize( V + L );\n\tfloat dotNH = saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\n}\n#endif",bumpmap_pars_fragment:"#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif",clipping_planes_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif",color_fragment:"#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif",color_pars_fragment:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif",color_vertex:"#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor.xyz *= color.xyz;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif",common:"#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}",cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 );\n\t\tvec2 f = fract( uv );\n\t\tuv += 0.5 - f;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\tvec3 tl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x += texelSize;\n\t\tvec3 tr = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.y += texelSize;\n\t\tvec3 br = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x -= texelSize;\n\t\tvec3 bl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tvec3 tm = mix( tl, tr, f.x );\n\t\tvec3 bm = mix( bl, br, f.x );\n\t\treturn mix( tm, bm, f.y );\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), m0, cubeUV_maxMipLevel );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif",defaultnormal_vertex:"vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif",displacementmap_pars_vertex:"#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif",displacementmap_vertex:"#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif",emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor = linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat D = max( maxRange / maxRGB, 1.0 );\n\tD = clamp( floor( D ) / 255.0, 0.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value ) {\n\tvec3 Xp_Y_XYZp = cLogLuvM * value.rgb;\n\tXp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract( Le );\n\tvResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}",envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifndef ENVMAP_TYPE_CUBE_UV\n\t\tenvColor = envMapTexelToLinear( envColor );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif",envmap_common_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform int maxMipLevel;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif",envmap_pars_fragment:"#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif",envmap_pars_vertex:"#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif",envmap_physical_pars_fragment:"#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( -viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif",envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tfogDepth = - mvPosition.z;\n#endif",fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif",gradientmap_pars_fragment:"#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn texture2D( gradientMap, coord ).rgb;\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\treflectedLight.indirectDiffuse += PI * lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n#endif",lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif",lights_pars_begin:"uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif",lights_toon_fragment:"ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;",lights_toon_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)",lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)",lights_physical_fragment:"PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.specularRoughness = max( roughnessFactor, 0.0525 );material.specularRoughness += geometryRoughness;\nmaterial.specularRoughness = min( material.specularRoughness, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheen;\n#endif",lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat specularRoughness;\n\tvec3 specularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *= PI;\n\t\t#endif\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL = ccDotNV;\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\tfloat clearcoatInv = 1.0 - clearcoatDHR;\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}",lights_fragment_begin:"\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\tirradiance += getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif",lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\n\t#endif\n#endif",lights_fragment_end:"#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif",logdepthbuf_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif",logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif",logdepthbuf_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif",map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif",map_particle_pars_fragment:"#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",metalnessmap_fragment:"float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif",metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifndef USE_MORPHNORMALS\n\t\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\t\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif",morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t#endif\n#endif",normal_fragment_begin:"#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent = bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;",normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( -vViewPosition, normal, mapN );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif",normalmap_pars_fragment:"#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\t\tmat3 tsn = mat3( S, T, N );\n\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif",clearcoat_normal_fragment_begin:"#ifdef CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN );\n\t#endif\n#endif",clearcoat_pars_fragment:"#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",packing:"vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ));\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);\n}\nvec2 unpackRGBATo2Half( vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}",premultiplied_alpha_fragment:"#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif",roughnessmap_fragment:"float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif",roughnessmap_pars_fragment:"#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif",shadowmap_pars_fragment:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ), \n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif",shadowmap_pars_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif",shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}",skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif",skinning_pars_vertex:"#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif",specularmap_pars_fragment:"#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif",tonemapping_fragment:"#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }",transmissionmap_fragment:"#ifdef USE_TRANSMISSIONMAP\n\ttotalTransmission *= texture2D( transmissionMap, vUv ).r;\n#endif",transmissionmap_pars_fragment:"#ifdef USE_TRANSMISSIONMAP\n\tuniform sampler2D transmissionMap;\n#endif",uv_pars_fragment:"#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif",uv2_pars_fragment:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif",uv2_pars_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif",worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}",cube_frag:"#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",cube_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}",depth_frag:"#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#endif\n}",depth_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}",distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}",distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}",equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tvec4 texColor = texture2D( tEquirect, sampleUV );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}",equirect_vert:"varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}",meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshbasic_vert:"#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}",meshlambert_frag:"uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshlambert_vert:"#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t\tmatcapColor = matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor = vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#ifndef FLAT_SHADED\n\t\tvNormal = normalize( transformedNormal );\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}",meshtoon_frag:"#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshtoon_vert:"#define TOON\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSMISSION\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSMISSION\n\tuniform float transmission;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <transmissionmap_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#ifdef TRANSMISSION\n\t\tfloat totalTransmission = transmission;\n\t#endif\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <transmissionmap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSMISSION\n\t\tdiffuseColor.a *= mix( saturate( 1. - totalTransmission + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) ), 1.0, metalness );\n\t#endif\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}",meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",normal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}",normal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}",points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}",points_vert:"uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}",shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",shadow_vert:"#include <common>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}",sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}",sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}"},Net={common:{diffuse:{value:new Ont(15658734)},opacity:{value:1},map:{value:null},uvTransform:{value:new G9},uv2Transform:{value:new G9},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},aomap:{aoMap:{value:null},aoMapIntensity:{value:1}},lightmap:{lightMap:{value:null},lightMapIntensity:{value:1}},emissivemap:{emissiveMap:{value:null}},bumpmap:{bumpMap:{value:null},bumpScale:{value:1}},normalmap:{normalMap:{value:null},normalScale:{value:new W9(1,1)}},displacementmap:{displacementMap:{value:null},displacementScale:{value:1},displacementBias:{value:0}},roughnessmap:{roughnessMap:{value:null}},metalnessmap:{metalnessMap:{value:null}},gradientmap:{gradientMap:{value:null}},fog:{fogDensity:{value:25e-5},fogNear:{value:1},fogFar:{value:2e3},fogColor:{value:new Ont(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{}}},directionalLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{}}},spotLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{}}},pointLightShadows:{value:[],properties:{shadowBias:{},shadowNormalBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}},ltc_1:{value:null},ltc_2:{value:null}},points:{diffuse:{value:new Ont(15658734)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},alphaMap:{value:null},uvTransform:{value:new G9}},sprite:{diffuse:{value:new Ont(15658734)},opacity:{value:1},center:{value:new W9(.5,.5)},rotation:{value:0},map:{value:null},alphaMap:{value:null},uvTransform:{value:new G9}}},Fet={basic:{uniforms:_et([Net.common,Net.specularmap,Net.envmap,Net.aomap,Net.lightmap,Net.fog]),vertexShader:Iet.meshbasic_vert,fragmentShader:Iet.meshbasic_frag},lambert:{uniforms:_et([Net.common,Net.specularmap,Net.envmap,Net.aomap,Net.lightmap,Net.emissivemap,Net.fog,Net.lights,{emissive:{value:new Ont(0)}}]),vertexShader:Iet.meshlambert_vert,fragmentShader:Iet.meshlambert_frag},phong:{uniforms:_et([Net.common,Net.specularmap,Net.envmap,Net.aomap,Net.lightmap,Net.emissivemap,Net.bumpmap,Net.normalmap,Net.displacementmap,Net.fog,Net.lights,{emissive:{value:new Ont(0)},specular:{value:new Ont(1118481)},shininess:{value:30}}]),vertexShader:Iet.meshphong_vert,fragmentShader:Iet.meshphong_frag},standard:{uniforms:_et([Net.common,Net.envmap,Net.aomap,Net.lightmap,Net.emissivemap,Net.bumpmap,Net.normalmap,Net.displacementmap,Net.roughnessmap,Net.metalnessmap,Net.fog,Net.lights,{emissive:{value:new Ont(0)},roughness:{value:1},metalness:{value:0},envMapIntensity:{value:1}}]),vertexShader:Iet.meshphysical_vert,fragmentShader:Iet.meshphysical_frag},toon:{uniforms:_et([Net.common,Net.aomap,Net.lightmap,Net.emissivemap,Net.bumpmap,Net.normalmap,Net.displacementmap,Net.gradientmap,Net.fog,Net.lights,{emissive:{value:new Ont(0)}}]),vertexShader:Iet.meshtoon_vert,fragmentShader:Iet.meshtoon_frag},matcap:{uniforms:_et([Net.common,Net.bumpmap,Net.normalmap,Net.displacementmap,Net.fog,{matcap:{value:null}}]),vertexShader:Iet.meshmatcap_vert,fragmentShader:Iet.meshmatcap_frag},points:{uniforms:_et([Net.points,Net.fog]),vertexShader:Iet.points_vert,fragmentShader:Iet.points_frag},dashed:{uniforms:_et([Net.common,Net.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:Iet.linedashed_vert,fragmentShader:Iet.linedashed_frag},depth:{uniforms:_et([Net.common,Net.displacementmap]),vertexShader:Iet.depth_vert,fragmentShader:Iet.depth_frag},normal:{uniforms:_et([Net.common,Net.bumpmap,Net.normalmap,Net.displacementmap,{opacity:{value:1}}]),vertexShader:Iet.normal_vert,fragmentShader:Iet.normal_frag},sprite:{uniforms:_et([Net.sprite,Net.fog]),vertexShader:Iet.sprite_vert,fragmentShader:Iet.sprite_frag},background:{uniforms:{uvTransform:{value:new G9},t2D:{value:null}},vertexShader:Iet.background_vert,fragmentShader:Iet.background_frag},cube:{uniforms:_et([Net.envmap,{opacity:{value:1}}]),vertexShader:Iet.cube_vert,fragmentShader:Iet.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:Iet.equirect_vert,fragmentShader:Iet.equirect_frag},distanceRGBA:{uniforms:_et([Net.common,Net.displacementmap,{referencePosition:{value:new ttt},nearDistance:{value:1},farDistance:{value:1e3}}]),vertexShader:Iet.distanceRGBA_vert,fragmentShader:Iet.distanceRGBA_frag},shadow:{uniforms:_et([Net.lights,Net.fog,{color:{value:new Ont(0)},opacity:{value:1}}]),vertexShader:Iet.shadow_vert,fragmentShader:Iet.shadow_frag}};function Let(t,n,e,a,o){const r=new Ont(0);let i,c,s=0,l=null,m=0,d=null;function g(t,n){e.buffers.color.setClear(t.r,t.g,t.b,n,o)}return{getClearColor:function(){return r},setClearColor:function(t,n=1){r.set(t),s=n,g(r,s)},getClearAlpha:function(){return s},setClearAlpha:function(t){s=t,g(r,s)},render:function p(e,o,b,u){let f=!0===o.isScene?o.background:null;f&&f.isTexture&&(f=n.get(f));const h=t.xr,_=h.getSession&&h.getSession();_&&"additive"===_.environmentBlendMode&&(f=null),null===f?g(r,s):f&&f.isColor&&(g(f,1),u=!0),(t.autoClear||u)&&t.clear(t.autoClearColor,t.autoClearDepth,t.autoClearStencil),f&&(f.isCubeTexture||f.isWebGLCubeRenderTarget||306===f.mapping)?(void 0===c&&(c=new bet(new fet(1,1,1),new Met({name:"BackgroundCubeMaterial",uniforms:het(Fet.cube.uniforms),vertexShader:Fet.cube.vertexShader,fragmentShader:Fet.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),c.geometry.deleteAttribute("normal"),c.geometry.deleteAttribute("uv"),c.onBeforeRender=function(t,n,e){this.matrixWorld.copyPosition(e.matrixWorld)},Object.defineProperty(c.material,"envMap",{get:function(){return this.uniforms.envMap.value}}),a.update(c)),f.isWebGLCubeRenderTarget&&(f=f.texture),c.material.uniforms.envMap.value=f,c.material.uniforms.flipEnvMap.value=f.isCubeTexture&&f._needsFlipEnvMap?-1:1,l===f&&m===f.version&&d===t.toneMapping||(c.material.needsUpdate=!0,l=f,m=f.version,d=t.toneMapping),e.unshift(c,c.geometry,c.material,0,0,null)):f&&f.isTexture&&(void 0===i&&(i=new bet(new Det(2,2),new Met({name:"BackgroundMaterial",uniforms:het(Fet.background.uniforms),vertexShader:Fet.background.vertexShader,fragmentShader:Fet.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,fog:!1})),i.geometry.deleteAttribute("normal"),Object.defineProperty(i.material,"map",{get:function(){return this.uniforms.t2D.value}}),a.update(i)),i.material.uniforms.t2D.value=f,!0===f.matrixAutoUpdate&&f.updateMatrix(),i.material.uniforms.uvTransform.value.copy(f.matrix),l===f&&m===f.version&&d===t.toneMapping||(i.material.needsUpdate=!0,l=f,m=f.version,d=t.toneMapping),e.unshift(i,i.geometry,i.material,0,0,null))}}}function Het(t,n,e,a){const o=t.getParameter(34921),r=a.isWebGL2?null:n.get("OES_vertex_array_object"),i=a.isWebGL2||null!==r,c={},s=g(null);let l=s;function m(n){return a.isWebGL2?t.bindVertexArray(n):r.bindVertexArrayOES(n)}function d(n){return a.isWebGL2?t.deleteVertexArray(n):r.deleteVertexArrayOES(n)}function g(t){const n=[],e=[],a=[];for(let t=0;t<o;t++)n[t]=0,e[t]=0,a[t]=0;return{geometry:null,program:null,wireframe:!1,newAttributes:n,enabledAttributes:e,attributeDivisors:a,object:t,attributes:{},index:null}}function p(){const t=l.newAttributes;for(let n=0,e=t.length;n<e;n++)t[n]=0}function b(t){u(t,0)}function u(e,o){const r=l.enabledAttributes,i=l.attributeDivisors;l.newAttributes[e]=1,0===r[e]&&(t.enableVertexAttribArray(e),r[e]=1),i[e]!==o&&((a.isWebGL2?t:n.get("ANGLE_instanced_arrays"))[a.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](e,o),i[e]=o)}function f(){const n=l.newAttributes,e=l.enabledAttributes;for(let a=0,o=e.length;a<o;a++)e[a]!==n[a]&&(t.disableVertexAttribArray(a),e[a]=0)}function h(n,e,o,r,i,c){!0!==a.isWebGL2||5124!==o&&5125!==o?t.vertexAttribPointer(n,e,o,r,i,c):t.vertexAttribIPointer(n,e,o,i,c)}function _(){C(),l!==s&&(l=s,m(l.object))}function C(){s.geometry=null,s.program=null,s.wireframe=!1}return{setup:function M(o,s,d,_,C){let M=!1;if(i){const n=(function O(n,e,o){const i=!0===o.wireframe;let s=c[n.id];void 0===s&&(s={},c[n.id]=s);let l=s[e.id];void 0===l&&(l={},s[e.id]=l);let m=l[i];return void 0===m&&(m=g((function d(){return a.isWebGL2?t.createVertexArray():r.createVertexArrayOES()})()),l[i]=m),m})(_,d,s);l!==n&&(l=n,m(l.object)),M=(function P(t,n){const e=l.attributes,a=t.attributes;let o=0;for(const t in a){const n=e[t],r=a[t];if(void 0===n)return!0;if(n.attribute!==r)return!0;if(n.data!==r.data)return!0;o++}return l.attributesNum!==o||l.index!==n})(_,C),M&&(function x(t,n){const e={},a=t.attributes;let o=0;for(const t in a){const n=a[t],r={};r.attribute=n,n.data&&(r.data=n.data),e[t]=r,o++}l.attributes=e,l.attributesNum=o,l.index=n})(_,C)}else{const t=!0===s.wireframe;l.geometry===_.id&&l.program===d.id&&l.wireframe===t||(l.geometry=_.id,l.program=d.id,l.wireframe=t,M=!0)}!0===o.isInstancedMesh&&(M=!0),null!==C&&e.update(C,34963),M&&((function y(o,r,i,c){if(!1===a.isWebGL2&&(o.isInstancedMesh||c.isInstancedBufferGeometry)&&null===n.get("ANGLE_instanced_arrays"))return;p();const s=c.attributes,l=i.getAttributes(),m=r.defaultAttributeValues;for(const n in l){const a=l[n];if(a>=0){const r=s[n];if(void 0!==r){const n=r.normalized,o=r.itemSize,i=e.get(r);if(void 0===i)continue;const s=i.buffer,l=i.type,m=i.bytesPerElement;if(r.isInterleavedBufferAttribute){const e=r.data,i=e.stride,d=r.offset;e&&e.isInstancedInterleavedBuffer?(u(a,e.meshPerAttribute),void 0===c._maxInstanceCount&&(c._maxInstanceCount=e.meshPerAttribute*e.count)):b(a),t.bindBuffer(34962,s),h(a,o,l,n,i*m,d*m)}else r.isInstancedBufferAttribute?(u(a,r.meshPerAttribute),void 0===c._maxInstanceCount&&(c._maxInstanceCount=r.meshPerAttribute*r.count)):b(a),t.bindBuffer(34962,s),h(a,o,l,n,0,0)}else if("instanceMatrix"===n){const n=e.get(o.instanceMatrix);if(void 0===n)continue;const r=n.buffer,i=n.type;u(a+0,1),u(a+1,1),u(a+2,1),u(a+3,1),t.bindBuffer(34962,r),t.vertexAttribPointer(a+0,4,i,!1,64,0),t.vertexAttribPointer(a+1,4,i,!1,64,16),t.vertexAttribPointer(a+2,4,i,!1,64,32),t.vertexAttribPointer(a+3,4,i,!1,64,48)}else if("instanceColor"===n){const n=e.get(o.instanceColor);if(void 0===n)continue;const r=n.buffer,i=n.type;u(a,1),t.bindBuffer(34962,r),t.vertexAttribPointer(a,3,i,!1,12,0)}else if(void 0!==m){const e=m[n];if(void 0!==e)switch(e.length){case 2:t.vertexAttrib2fv(a,e);break;case 3:t.vertexAttrib3fv(a,e);break;case 4:t.vertexAttrib4fv(a,e);break;default:t.vertexAttrib1fv(a,e)}}}}f()})(o,s,d,_),null!==C&&t.bindBuffer(34963,e.get(C).buffer))},reset:_,resetDefaultState:C,dispose:function O(){_();for(const t in c){const n=c[t];for(const t in n){const e=n[t];for(const t in e)d(e[t].object),delete e[t];delete n[t]}delete c[t]}},releaseStatesOfGeometry:function P(t){if(void 0===c[t.id])return;const n=c[t.id];for(const t in n){const e=n[t];for(const t in e)d(e[t].object),delete e[t];delete n[t]}delete c[t.id]},releaseStatesOfProgram:function x(t){for(const n in c){const e=c[n];if(void 0===e[t.id])continue;const a=e[t.id];for(const t in a)d(a[t].object),delete a[t];delete e[t.id]}},initAttributes:p,enableAttribute:b,disableUnusedAttributes:f}}function Bet(t,n,e,a){const o=a.isWebGL2;let r;this.setMode=function i(t){r=t},this.render=function c(n,a){t.drawArrays(r,n,a),e.update(a,r,1)},this.renderInstances=function s(a,i,c){if(0===c)return;let s,l;if(o)s=t,l="drawArraysInstanced";else if(s=n.get("ANGLE_instanced_arrays"),l="drawArraysInstancedANGLE",null===s)return void console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");s[l](r,a,i,c),e.update(i,r,c)}}function Vet(t,n,e){let a;function o(n){if("highp"===n){if(t.getShaderPrecisionFormat(35633,36338).precision>0&&t.getShaderPrecisionFormat(35632,36338).precision>0)return"highp";n="mediump"}return"mediump"===n&&t.getShaderPrecisionFormat(35633,36337).precision>0&&t.getShaderPrecisionFormat(35632,36337).precision>0?"mediump":"lowp"}const r="undefined"!=typeof WebGL2RenderingContext&&t instanceof WebGL2RenderingContext||"undefined"!=typeof WebGL2ComputeRenderingContext&&t instanceof WebGL2ComputeRenderingContext;let i=void 0!==e.precision?e.precision:"highp";const c=o(i);c!==i&&(console.warn("THREE.WebGLRenderer:",i,"not supported, using",c,"instead."),i=c);const s=!0===e.logarithmicDepthBuffer,l=t.getParameter(34930),m=t.getParameter(35660),d=t.getParameter(3379),g=t.getParameter(34076),p=t.getParameter(34921),b=t.getParameter(36347),u=t.getParameter(36348),f=t.getParameter(36349),h=m>0,_=r||!!n.get("OES_texture_float");return{isWebGL2:r,getMaxAnisotropy:function C(){if(void 0!==a)return a;const e=n.get("EXT_texture_filter_anisotropic");return a=null!==e?t.getParameter(e.MAX_TEXTURE_MAX_ANISOTROPY_EXT):0,a},getMaxPrecision:o,precision:i,logarithmicDepthBuffer:s,maxTextures:l,maxVertexTextures:m,maxTextureSize:d,maxCubemapSize:g,maxAttributes:p,maxVertexUniforms:b,maxVaryings:u,maxFragmentUniforms:f,vertexTextures:h,floatFragmentTextures:_,floatVertexTextures:h&&_,maxSamples:r?t.getParameter(36183):0}}function jet(t){const n=this;let e=null,a=0,o=!1,r=!1;const i=new ant,c=new G9,s={value:null,needsUpdate:!1};function l(){s.value!==e&&(s.value=e,s.needsUpdate=a>0),n.numPlanes=a,n.numIntersection=0}function m(t,e,a,o){const r=null!==t?t.length:0;let l=null;if(0!==r){if(l=s.value,!0!==o||null===l){const n=a+4*r,o=e.matrixWorldInverse;c.getNormalMatrix(o),(null===l||l.length<n)&&(l=new Float32Array(n));for(let n=0,e=a;n!==r;++n,e+=4)i.copy(t[n]).applyMatrix4(o,c),i.normal.toArray(l,e),l[e+3]=i.constant}s.value=l,s.needsUpdate=!0}return n.numPlanes=r,n.numIntersection=0,l}this.uniform=s,this.numPlanes=0,this.numIntersection=0,this.init=function(t,n,r){const i=0!==t.length||n||0!==a||o;return o=n,e=m(t,r,0),a=t.length,i},this.beginShadows=function(){r=!0,m(null)},this.endShadows=function(){r=!1,l()},this.setState=function(n,i,c){const d=n.clippingPlanes,g=n.clipIntersection,p=n.clipShadows,b=t.get(n);if(!o||null===d||0===d.length||r&&!p)r?m(null):l();else{const t=r?0:a,n=4*t;let o=b.clippingState||null;s.value=o,o=m(d,i,n,c);for(let t=0;t!==n;++t)o[t]=e[t];b.clippingState=o,this.numIntersection=g?this.numPlanes:0,this.numPlanes+=t}}}function Uet(t){let n=new WeakMap;function e(t,n){return 303===n?t.mapping=301:304===n&&(t.mapping=302),t}function a(t){const e=t.target;e.removeEventListener("dispose",a);const o=n.get(e);void 0!==o&&(n.delete(e),o.dispose())}return{get:function o(r){if(r&&r.isTexture){const o=r.mapping;if(303===o||304===o){if(n.has(r))return e(n.get(r).texture,r.mapping);{const o=r.image;if(o&&o.height>0){const i=t.getRenderList(),c=t.getRenderTarget(),s=new vet(o.height/2);return s.fromEquirectangularTexture(t,r),n.set(r,s),t.setRenderTarget(c),t.setRenderList(i),r.addEventListener("dispose",a),e(s.texture,r.mapping)}return null}}}return r},dispose:function r(){n=new WeakMap}}}function Wet(t){const n={};function e(e){if(void 0!==n[e])return n[e];let a;switch(e){case"WEBGL_depth_texture":a=t.getExtension("WEBGL_depth_texture")||t.getExtension("MOZ_WEBGL_depth_texture")||t.getExtension("WEBKIT_WEBGL_depth_texture");break;case"EXT_texture_filter_anisotropic":a=t.getExtension("EXT_texture_filter_anisotropic")||t.getExtension("MOZ_EXT_texture_filter_anisotropic")||t.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case"WEBGL_compressed_texture_s3tc":a=t.getExtension("WEBGL_compressed_texture_s3tc")||t.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||t.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case"WEBGL_compressed_texture_pvrtc":a=t.getExtension("WEBGL_compressed_texture_pvrtc")||t.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:a=t.getExtension(e)}return n[e]=a,a}return{has:function(t){return null!==e(t)},init:function(t){t.isWebGL2?e("EXT_color_buffer_float"):(e("WEBGL_depth_texture"),e("OES_texture_float"),e("OES_texture_half_float"),e("OES_texture_half_float_linear"),e("OES_standard_derivatives"),e("OES_element_index_uint"),e("OES_vertex_array_object"),e("ANGLE_instanced_arrays")),e("OES_texture_float_linear"),e("EXT_color_buffer_half_float")},get:function(t){const n=e(t);return null===n&&console.warn("THREE.WebGLRenderer: "+t+" extension not supported."),n}}}function Get(t,n,e,a){const o={},r=new WeakMap;function i(t){const c=t.target;null!==c.index&&n.remove(c.index);for(const t in c.attributes)n.remove(c.attributes[t]);c.removeEventListener("dispose",i),delete o[c.id];const s=r.get(c);s&&(n.remove(s),r.delete(c)),a.releaseStatesOfGeometry(c),!0===c.isInstancedBufferGeometry&&delete c._maxInstanceCount,e.memory.geometries--}function c(t){const e=[],a=t.index,o=t.attributes.position;let i=0;if(null!==a){const t=a.array;i=a.version;for(let n=0,a=t.length;n<a;n+=3){const a=t[n+0],o=t[n+1],r=t[n+2];e.push(a,o,o,r,r,a)}}else{i=o.version;for(let t=0,n=o.array.length/3-1;t<n;t+=3){const n=t+0,a=t+1,o=t+2;e.push(n,a,a,o,o,n)}}const c=new(Hnt(e)>65535?Int:Tnt)(e,1);c.version=i;const s=r.get(t);s&&n.remove(s),r.set(t,c)}return{get:function s(t,n){return!0===o[n.id]||(n.addEventListener("dispose",i),o[n.id]=!0,e.memory.geometries++),n},update:function l(t){const e=t.attributes;for(const t in e)n.update(e[t],34962);const a=t.morphAttributes;for(const t in a){const e=a[t];for(let t=0,a=e.length;t<a;t++)n.update(e[t],34962)}},getWireframeAttribute:function m(t){const n=r.get(t);if(n){const e=t.index;null!==e&&n.version<e.version&&c(t)}else c(t);return r.get(t)}}}function Yet(t,n,e,a){const o=a.isWebGL2;let r,i,c;this.setMode=function s(t){r=t},this.setIndex=function l(t){i=t.type,c=t.bytesPerElement},this.render=function m(n,a){t.drawElements(r,a,i,n*c),e.update(a,r,1)},this.renderInstances=function d(a,s,l){if(0===l)return;let m,d;if(o)m=t,d="drawElementsInstanced";else if(m=n.get("ANGLE_instanced_arrays"),d="drawElementsInstancedANGLE",null===m)return void console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");m[d](r,s,i,a*c,l),e.update(s,r,l)}}function qet(t){const n={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:n,programs:null,autoReset:!0,reset:function e(){n.frame++,n.calls=0,n.triangles=0,n.points=0,n.lines=0},update:function a(t,e,o){switch(n.calls++,e){case 4:n.triangles+=o*(t/3);break;case 1:n.lines+=o*(t/2);break;case 3:n.lines+=o*(t-1);break;case 2:n.lines+=o*t;break;case 0:n.points+=o*t;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",e)}}}}function Zet(t,n){return t[0]-n[0]}function Xet(t,n){return Math.abs(n[1])-Math.abs(t[1])}function Jet(t){const n={},e=new Float32Array(8),a=[];for(let t=0;t<8;t++)a[t]=[t,0];return{update:function o(r,i,c,s){const l=r.morphTargetInfluences,m=void 0===l?0:l.length;let d=n[i.id];if(void 0===d){d=[];for(let t=0;t<m;t++)d[t]=[t,0];n[i.id]=d}for(let t=0;t<m;t++){const n=d[t];n[0]=t,n[1]=l[t]}d.sort(Xet);for(let t=0;t<8;t++)t<m&&d[t][1]?(a[t][0]=d[t][0],a[t][1]=d[t][1]):(a[t][0]=Number.MAX_SAFE_INTEGER,a[t][1]=0);a.sort(Zet);const g=c.morphTargets&&i.morphAttributes.position,p=c.morphNormals&&i.morphAttributes.normal;let b=0;for(let t=0;t<8;t++){const n=a[t],o=n[0],r=n[1];o!==Number.MAX_SAFE_INTEGER&&r?(g&&i.getAttribute("morphTarget"+t)!==g[o]&&i.setAttribute("morphTarget"+t,g[o]),p&&i.getAttribute("morphNormal"+t)!==p[o]&&i.setAttribute("morphNormal"+t,p[o]),e[t]=r,b+=r):(g&&!0===i.hasAttribute("morphTarget"+t)&&i.deleteAttribute("morphTarget"+t),p&&!0===i.hasAttribute("morphNormal"+t)&&i.deleteAttribute("morphNormal"+t),e[t]=0)}const u=i.morphTargetsRelative?1:1-b;s.getUniforms().setValue(t,"morphTargetBaseInfluence",u),s.getUniforms().setValue(t,"morphTargetInfluences",e)}}}function Qet(t,n,e,a){let o=new WeakMap;function r(t){const n=t.target;n.removeEventListener("dispose",r),e.remove(n.instanceMatrix),null!==n.instanceColor&&e.remove(n.instanceColor)}return{update:function i(t){const i=a.render.frame,c=n.get(t,t.geometry);return o.get(c)!==i&&(n.update(c),o.set(c,i)),t.isInstancedMesh&&(!1===t.hasEventListener("dispose",r)&&t.addEventListener("dispose",r),e.update(t.instanceMatrix,34962),null!==t.instanceColor&&e.update(t.instanceColor,34962)),c},dispose:function c(){o=new WeakMap}}}function Ket(t=null,n=1,e=1,a=1){X9.call(this,null),this.image={data:t,width:n,height:e,depth:a},this.magFilter=h9,this.minFilter=h9,this.wrapR=u9,this.generateMipmaps=!1,this.flipY=!1,this.needsUpdate=!0}function $et(t=null,n=1,e=1,a=1){X9.call(this,null),this.image={data:t,width:n,height:e,depth:a},this.magFilter=h9,this.minFilter=h9,this.wrapR=u9,this.generateMipmaps=!1,this.flipY=!1,this.needsUpdate=!0}Fet.physical={uniforms:_et([Fet.standard.uniforms,{clearcoat:{value:0},clearcoatMap:{value:null},clearcoatRoughness:{value:0},clearcoatRoughnessMap:{value:null},clearcoatNormalScale:{value:new W9(1,1)},clearcoatNormalMap:{value:null},sheen:{value:new Ont(0)},transmission:{value:0},transmissionMap:{value:null}}]),vertexShader:Iet.meshphysical_vert,fragmentShader:Iet.meshphysical_frag},(Ket.prototype=Object.create(X9.prototype)).constructor=Ket,Ket.prototype.isDataTexture2DArray=!0,($et.prototype=Object.create(X9.prototype)).constructor=$et,$et.prototype.isDataTexture3D=!0;const tat=new X9,nat=new Ket,eat=new $et,aat=new ket,oat=[],rat=[],iat=new Float32Array(16),cat=new Float32Array(9),sat=new Float32Array(4);function lat(t,n,e){const a=t[0];if(a<=0||a>0)return t;const o=n*e;let r=oat[o];if(void 0===r&&(r=new Float32Array(o),oat[o]=r),0!==n){a.toArray(r,0);for(let a=1,o=0;a!==n;++a)o+=e,t[a].toArray(r,o)}return r}function mat(t,n){if(t.length!==n.length)return!1;for(let e=0,a=t.length;e<a;e++)if(t[e]!==n[e])return!1;return!0}function dat(t,n){for(let e=0,a=n.length;e<a;e++)t[e]=n[e]}function gat(t,n){let e=rat[n];void 0===e&&(e=new Int32Array(n),rat[n]=e);for(let a=0;a!==n;++a)e[a]=t.allocateTextureUnit();return e}function pat(t,n){const e=this.cache;e[0]!==n&&(t.uniform1f(this.addr,n),e[0]=n)}function bat(t,n){const e=this.cache;if(void 0!==n.x)e[0]===n.x&&e[1]===n.y||(t.uniform2f(this.addr,n.x,n.y),e[0]=n.x,e[1]=n.y);else{if(mat(e,n))return;t.uniform2fv(this.addr,n),dat(e,n)}}function uat(t,n){const e=this.cache;if(void 0!==n.x)e[0]===n.x&&e[1]===n.y&&e[2]===n.z||(t.uniform3f(this.addr,n.x,n.y,n.z),e[0]=n.x,e[1]=n.y,e[2]=n.z);else if(void 0!==n.r)e[0]===n.r&&e[1]===n.g&&e[2]===n.b||(t.uniform3f(this.addr,n.r,n.g,n.b),e[0]=n.r,e[1]=n.g,e[2]=n.b);else{if(mat(e,n))return;t.uniform3fv(this.addr,n),dat(e,n)}}function fat(t,n){const e=this.cache;if(void 0!==n.x)e[0]===n.x&&e[1]===n.y&&e[2]===n.z&&e[3]===n.w||(t.uniform4f(this.addr,n.x,n.y,n.z,n.w),e[0]=n.x,e[1]=n.y,e[2]=n.z,e[3]=n.w);else{if(mat(e,n))return;t.uniform4fv(this.addr,n),dat(e,n)}}function hat(t,n){const e=this.cache,a=n.elements;if(void 0===a){if(mat(e,n))return;t.uniformMatrix2fv(this.addr,!1,n),dat(e,n)}else{if(mat(e,a))return;sat.set(a),t.uniformMatrix2fv(this.addr,!1,sat),dat(e,a)}}function _at(t,n){const e=this.cache,a=n.elements;if(void 0===a){if(mat(e,n))return;t.uniformMatrix3fv(this.addr,!1,n),dat(e,n)}else{if(mat(e,a))return;cat.set(a),t.uniformMatrix3fv(this.addr,!1,cat),dat(e,a)}}function Cat(t,n){const e=this.cache,a=n.elements;if(void 0===a){if(mat(e,n))return;t.uniformMatrix4fv(this.addr,!1,n),dat(e,n)}else{if(mat(e,a))return;iat.set(a),t.uniformMatrix4fv(this.addr,!1,iat),dat(e,a)}}function Mat(t,n,e){const a=this.cache,o=e.allocateTextureUnit();a[0]!==o&&(t.uniform1i(this.addr,o),a[0]=o),e.safeSetTexture2D(n||tat,o)}function Oat(t,n,e){const a=this.cache,o=e.allocateTextureUnit();a[0]!==o&&(t.uniform1i(this.addr,o),a[0]=o),e.setTexture2DArray(n||nat,o)}function Pat(t,n,e){const a=this.cache,o=e.allocateTextureUnit();a[0]!==o&&(t.uniform1i(this.addr,o),a[0]=o),e.setTexture3D(n||eat,o)}function xat(t,n,e){const a=this.cache,o=e.allocateTextureUnit();a[0]!==o&&(t.uniform1i(this.addr,o),a[0]=o),e.safeSetTextureCube(n||aat,o)}function yat(t,n){const e=this.cache;e[0]!==n&&(t.uniform1i(this.addr,n),e[0]=n)}function kat(t,n){const e=this.cache;mat(e,n)||(t.uniform2iv(this.addr,n),dat(e,n))}function vat(t,n){const e=this.cache;mat(e,n)||(t.uniform3iv(this.addr,n),dat(e,n))}function wat(t,n){const e=this.cache;mat(e,n)||(t.uniform4iv(this.addr,n),dat(e,n))}function Sat(t,n){const e=this.cache;e[0]!==n&&(t.uniform1ui(this.addr,n),e[0]=n)}function Eat(t,n){t.uniform1fv(this.addr,n)}function Aat(t,n){t.uniform1iv(this.addr,n)}function zat(t,n){t.uniform2iv(this.addr,n)}function Rat(t,n){t.uniform3iv(this.addr,n)}function Tat(t,n){t.uniform4iv(this.addr,n)}function Dat(t,n){const e=lat(n,this.size,2);t.uniform2fv(this.addr,e)}function Iat(t,n){const e=lat(n,this.size,3);t.uniform3fv(this.addr,e)}function Nat(t,n){const e=lat(n,this.size,4);t.uniform4fv(this.addr,e)}function Fat(t,n){const e=lat(n,this.size,4);t.uniformMatrix2fv(this.addr,!1,e)}function Lat(t,n){const e=lat(n,this.size,9);t.uniformMatrix3fv(this.addr,!1,e)}function Hat(t,n){const e=lat(n,this.size,16);t.uniformMatrix4fv(this.addr,!1,e)}function Bat(t,n,e){const a=n.length,o=gat(e,a);t.uniform1iv(this.addr,o);for(let t=0;t!==a;++t)e.safeSetTexture2D(n[t]||tat,o[t])}function Vat(t,n,e){const a=n.length,o=gat(e,a);t.uniform1iv(this.addr,o);for(let t=0;t!==a;++t)e.safeSetTextureCube(n[t]||aat,o[t])}function jat(t,n,e){this.id=t,this.addr=e,this.cache=[],this.setValue=(function a(t){switch(t){case 5126:return pat;case 35664:return bat;case 35665:return uat;case 35666:return fat;case 35674:return hat;case 35675:return _at;case 35676:return Cat;case 5124:case 35670:return yat;case 35667:case 35671:return kat;case 35668:case 35672:return vat;case 35669:case 35673:return wat;case 5125:return Sat;case 35678:case 36198:case 36298:case 36306:case 35682:return Mat;case 35679:case 36299:case 36307:return Pat;case 35680:case 36300:case 36308:case 36293:return xat;case 36289:case 36303:case 36311:case 36292:return Oat}})(n.type)}function Uat(t,n,e){this.id=t,this.addr=e,this.cache=[],this.size=n.size,this.setValue=(function a(t){switch(t){case 5126:return Eat;case 35664:return Dat;case 35665:return Iat;case 35666:return Nat;case 35674:return Fat;case 35675:return Lat;case 35676:return Hat;case 5124:case 35670:return Aat;case 35667:case 35671:return zat;case 35668:case 35672:return Rat;case 35669:case 35673:return Tat;case 35678:case 36198:case 36298:case 36306:case 35682:return Bat;case 35680:case 36300:case 36308:case 36293:return Vat}})(n.type)}function Wat(t){this.id=t,this.seq=[],this.map={}}Uat.prototype.updateCache=function(t){const n=this.cache;t instanceof Float32Array&&n.length!==t.length&&(this.cache=new Float32Array(t.length)),dat(n,t)},Wat.prototype.setValue=function(t,n,e){const a=this.seq;for(let o=0,r=a.length;o!==r;++o){const r=a[o];r.setValue(t,n[r.id],e)}};const Gat=/(\w+)(\])?(\[|\.)?/g;function Yat(t,n){t.seq.push(n),t.map[n.id]=n}function qat(t,n,e){const a=t.name,o=a.length;for(Gat.lastIndex=0;;){const r=Gat.exec(a),i=Gat.lastIndex;let c=r[1];const s=r[3];if("]"===r[2]&&(c|=0),void 0===s||"["===s&&i+2===o){Yat(e,void 0===s?new jat(c,t,n):new Uat(c,t,n));break}{let t=e.map[c];void 0===t&&(t=new Wat(c),Yat(e,t)),e=t}}}function Zat(t,n){this.seq=[],this.map={};const e=t.getProgramParameter(n,35718);for(let a=0;a<e;++a){const e=t.getActiveUniform(n,a);qat(e,t.getUniformLocation(n,e.name),this)}}function Xat(t,n,e){const a=t.createShader(n);return t.shaderSource(a,e),t.compileShader(a),a}Zat.prototype.setValue=function(t,n,e,a){const o=this.map[n];void 0!==o&&o.setValue(t,e,a)},Zat.prototype.setOptional=function(t,n,e){const a=n[e];void 0!==a&&this.setValue(t,e,a)},Zat.upload=function(t,n,e,a){for(let o=0,r=n.length;o!==r;++o){const r=n[o],i=e[r.id];!1!==i.needsUpdate&&r.setValue(t,i.value,a)}},Zat.seqWithValue=function(t,n){const e=[];for(let a=0,o=t.length;a!==o;++a){const o=t[a];o.id in n&&e.push(o)}return e};let Jat=0;function Qat(t){switch(t){case I9:return["Linear","( value )"];case 3001:return["sRGB","( value )"];case 3002:return["RGBE","( value )"];case 3004:return["RGBM","( value, 7.0 )"];case 3005:return["RGBM","( value, 16.0 )"];case 3006:return["RGBD","( value, 256.0 )"];case 3007:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case 3003:return["LogLuv","( value )"];default:return console.warn("THREE.WebGLProgram: Unsupported encoding:",t),["Linear","( value )"]}}function Kat(t,n,e){const a=t.getShaderParameter(n,35713),o=t.getShaderInfoLog(n).trim();return a&&""===o?"":"THREE.WebGLShader: gl.getShaderInfoLog() "+e+"\n"+o+(function r(t){const n=t.split("\n");for(let t=0;t<n.length;t++)n[t]=t+1+": "+n[t];return n.join("\n")})(t.getShaderSource(n))}function $at(t,n){const e=Qat(n);return"vec4 "+t+"( vec4 value ) { return "+e[0]+"ToLinear"+e[1]+"; }"}function tot(t,n){const e=Qat(n);return"vec4 "+t+"( vec4 value ) { return LinearTo"+e[0]+e[1]+"; }"}function not(t,n){let e;switch(n){case 1:e="Linear";break;case 2:e="Reinhard";break;case 3:e="OptimizedCineon";break;case 4:e="ACESFilmic";break;case 5:e="Custom";break;default:console.warn("THREE.WebGLProgram: Unsupported toneMapping:",n),e="Linear"}return"vec3 "+t+"( vec3 color ) { return "+e+"ToneMapping( color ); }"}function eot(t){return""!==t}function aot(t,n){return t.replace(/NUM_DIR_LIGHTS/g,n.numDirLights).replace(/NUM_SPOT_LIGHTS/g,n.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,n.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,n.numPointLights).replace(/NUM_HEMI_LIGHTS/g,n.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,n.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,n.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,n.numPointLightShadows)}function oot(t,n){return t.replace(/NUM_CLIPPING_PLANES/g,n.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,n.numClippingPlanes-n.numClipIntersection)}const rot=/^[ \t]*#include +<([\w\d./]+)>/gm;function iot(t){return t.replace(rot,cot)}function cot(t,n){const e=Iet[n];if(void 0===e)throw new Error("Can not resolve #include <"+n+">");return iot(e)}const sot=/#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g,lot=/#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;function mot(t){return t.replace(lot,got).replace(sot,dot)}function dot(t,n,e,a){return console.warn("WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead."),got(0,n,e,a)}function got(t,n,e,a){let o="";for(let t=parseInt(n);t<parseInt(e);t++)o+=a.replace(/\[\s*i\s*\]/g,"[ "+t+" ]").replace(/UNROLLED_LOOP_INDEX/g,t);return o}function pot(t){let n="precision "+t.precision+" float;\nprecision "+t.precision+" int;";return"highp"===t.precision?n+="\n#define HIGH_PRECISION":"mediump"===t.precision?n+="\n#define MEDIUM_PRECISION":"lowp"===t.precision&&(n+="\n#define LOW_PRECISION"),n}function bot(t,n,e,a){const o=t.getContext(),r=e.defines;let i=e.vertexShader,c=e.fragmentShader;const s=(function l(t){let n="SHADOWMAP_TYPE_BASIC";return 1===t.shadowMapType?n="SHADOWMAP_TYPE_PCF":2===t.shadowMapType?n="SHADOWMAP_TYPE_PCF_SOFT":3===t.shadowMapType&&(n="SHADOWMAP_TYPE_VSM"),n})(e),m=(function d(t){let n="ENVMAP_TYPE_CUBE";if(t.envMap)switch(t.envMapMode){case 301:case 302:n="ENVMAP_TYPE_CUBE";break;case 306:case 307:n="ENVMAP_TYPE_CUBE_UV"}return n})(e),g=(function p(t){let n="ENVMAP_MODE_REFLECTION";if(t.envMap)switch(t.envMapMode){case 302:case 307:n="ENVMAP_MODE_REFRACTION"}return n})(e),b=(function u(t){let n="ENVMAP_BLENDING_NONE";if(t.envMap)switch(t.combine){case 0:n="ENVMAP_BLENDING_MULTIPLY";break;case 1:n="ENVMAP_BLENDING_MIX";break;case 2:n="ENVMAP_BLENDING_ADD"}return n})(e),f=t.gammaFactor>0?t.gammaFactor:1,h=e.isWebGL2?"":(function _(t){return[t.extensionDerivatives||t.envMapCubeUV||t.bumpMap||t.tangentSpaceNormalMap||t.clearcoatNormalMap||t.flatShading||"physical"===t.shaderID?"#extension GL_OES_standard_derivatives : enable":"",(t.extensionFragDepth||t.logarithmicDepthBuffer)&&t.rendererExtensionFragDepth?"#extension GL_EXT_frag_depth : enable":"",t.extensionDrawBuffers&&t.rendererExtensionDrawBuffers?"#extension GL_EXT_draw_buffers : require":"",(t.extensionShaderTextureLOD||t.envMap)&&t.rendererExtensionShaderTextureLod?"#extension GL_EXT_shader_texture_lod : enable":""].filter(eot).join("\n")})(e),C=(function M(t){const n=[];for(const e in t){const a=t[e];!1!==a&&n.push("#define "+e+" "+a)}return n.join("\n")})(r),O=o.createProgram();let P,x,y=e.glslVersion?"#version "+e.glslVersion+"\n":"";e.isRawShaderMaterial?(P=[C].filter(eot).join("\n"),P.length>0&&(P+="\n"),x=[h,C].filter(eot).join("\n"),x.length>0&&(x+="\n")):(P=[pot(e),"#define SHADER_NAME "+e.shaderName,C,e.instancing?"#define USE_INSTANCING":"",e.instancingColor?"#define USE_INSTANCING_COLOR":"",e.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+f,"#define MAX_BONES "+e.maxBones,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+g:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.displacementMap&&e.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors?"#define USE_COLOR":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.flatShading?"#define FLAT_SHADED":"",e.skinning?"#define USE_SKINNING":"",e.useVertexTexture?"#define BONE_TEXTURE":"",e.morphTargets?"#define USE_MORPHTARGETS":"",e.morphNormals&&!1===e.flatShading?"#define USE_MORPHNORMALS":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+s:"",e.sizeAttenuation?"#define USE_SIZEATTENUATION":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;","uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;","#ifdef USE_INSTANCING","\tattribute mat4 instanceMatrix;","#endif","#ifdef USE_INSTANCING_COLOR","\tattribute vec3 instanceColor;","#endif","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#ifdef USE_COLOR","\tattribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS","\tattribute vec3 morphTarget0;","\tattribute vec3 morphTarget1;","\tattribute vec3 morphTarget2;","\tattribute vec3 morphTarget3;","\t#ifdef USE_MORPHNORMALS","\t\tattribute vec3 morphNormal0;","\t\tattribute vec3 morphNormal1;","\t\tattribute vec3 morphNormal2;","\t\tattribute vec3 morphNormal3;","\t#else","\t\tattribute vec3 morphTarget4;","\t\tattribute vec3 morphTarget5;","\t\tattribute vec3 morphTarget6;","\t\tattribute vec3 morphTarget7;","\t#endif","#endif","#ifdef USE_SKINNING","\tattribute vec4 skinIndex;","\tattribute vec4 skinWeight;","#endif","\n"].filter(eot).join("\n"),x=[h,pot(e),"#define SHADER_NAME "+e.shaderName,C,e.alphaTest?"#define ALPHATEST "+e.alphaTest+(e.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+f,e.useFog&&e.fog?"#define USE_FOG":"",e.useFog&&e.fogExp2?"#define FOG_EXP2":"",e.map?"#define USE_MAP":"",e.matcap?"#define USE_MATCAP":"",e.envMap?"#define USE_ENVMAP":"",e.envMap?"#define "+m:"",e.envMap?"#define "+g:"",e.envMap?"#define "+b:"",e.lightMap?"#define USE_LIGHTMAP":"",e.aoMap?"#define USE_AOMAP":"",e.emissiveMap?"#define USE_EMISSIVEMAP":"",e.bumpMap?"#define USE_BUMPMAP":"",e.normalMap?"#define USE_NORMALMAP":"",e.normalMap&&e.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",e.normalMap&&e.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",e.clearcoatMap?"#define USE_CLEARCOATMAP":"",e.clearcoatRoughnessMap?"#define USE_CLEARCOAT_ROUGHNESSMAP":"",e.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",e.specularMap?"#define USE_SPECULARMAP":"",e.roughnessMap?"#define USE_ROUGHNESSMAP":"",e.metalnessMap?"#define USE_METALNESSMAP":"",e.alphaMap?"#define USE_ALPHAMAP":"",e.sheen?"#define USE_SHEEN":"",e.transmissionMap?"#define USE_TRANSMISSIONMAP":"",e.vertexTangents?"#define USE_TANGENT":"",e.vertexColors||e.instancingColor?"#define USE_COLOR":"",e.vertexUvs?"#define USE_UV":"",e.uvsVertexOnly?"#define UVS_VERTEX_ONLY":"",e.gradientMap?"#define USE_GRADIENTMAP":"",e.flatShading?"#define FLAT_SHADED":"",e.doubleSided?"#define DOUBLE_SIDED":"",e.flipSided?"#define FLIP_SIDED":"",e.shadowMapEnabled?"#define USE_SHADOWMAP":"",e.shadowMapEnabled?"#define "+s:"",e.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",e.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",e.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",e.logarithmicDepthBuffer&&e.rendererExtensionFragDepth?"#define USE_LOGDEPTHBUF_EXT":"",(e.extensionShaderTextureLOD||e.envMap)&&e.rendererExtensionShaderTextureLod?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;","uniform bool isOrthographic;",0!==e.toneMapping?"#define TONE_MAPPING":"",0!==e.toneMapping?Iet.tonemapping_pars_fragment:"",0!==e.toneMapping?not("toneMapping",e.toneMapping):"",e.dithering?"#define DITHERING":"",Iet.encodings_pars_fragment,e.map?$at("mapTexelToLinear",e.mapEncoding):"",e.matcap?$at("matcapTexelToLinear",e.matcapEncoding):"",e.envMap?$at("envMapTexelToLinear",e.envMapEncoding):"",e.emissiveMap?$at("emissiveMapTexelToLinear",e.emissiveMapEncoding):"",e.lightMap?$at("lightMapTexelToLinear",e.lightMapEncoding):"",tot("linearToOutputTexel",e.outputEncoding),e.depthPacking?"#define DEPTH_PACKING "+e.depthPacking:"","\n"].filter(eot).join("\n")),i=iot(i),i=aot(i,e),i=oot(i,e),c=iot(c),c=aot(c,e),c=oot(c,e),i=mot(i),c=mot(c),e.isWebGL2&&!0!==e.isRawShaderMaterial&&(y="#version 300 es\n",P=["#define attribute in","#define varying out","#define texture2D texture"].join("\n")+"\n"+P,x=["#define varying in",e.glslVersion===H9?"":"out highp vec4 pc_fragColor;",e.glslVersion===H9?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth","#define texture2D texture","#define textureCube texture","#define texture2DProj textureProj","#define texture2DLodEXT textureLod","#define texture2DProjLodEXT textureProjLod","#define textureCubeLodEXT textureLod","#define texture2DGradEXT textureGrad","#define texture2DProjGradEXT textureProjGrad","#define textureCubeGradEXT textureGrad"].join("\n")+"\n"+x);const k=y+x+c,v=Xat(o,35633,y+P+i),w=Xat(o,35632,k);if(o.attachShader(O,v),o.attachShader(O,w),void 0!==e.index0AttributeName?o.bindAttribLocation(O,0,e.index0AttributeName):!0===e.morphTargets&&o.bindAttribLocation(O,0,"position"),o.linkProgram(O),t.debug.checkShaderErrors){const t=o.getProgramInfoLog(O).trim(),n=o.getShaderInfoLog(v).trim(),e=o.getShaderInfoLog(w).trim();let a=!0,r=!0;if(!1===o.getProgramParameter(O,35714)){a=!1;const n=Kat(o,v,"vertex"),e=Kat(o,w,"fragment");console.error("THREE.WebGLProgram: shader error: ",o.getError(),"35715",o.getProgramParameter(O,35715),"gl.getProgramInfoLog",t,n,e)}else""!==t?console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",t):""!==n&&""!==e||(r=!1);r&&(this.diagnostics={runnable:a,programLog:t,vertexShader:{log:n,prefix:P},fragmentShader:{log:e,prefix:x}})}let S,E;return o.deleteShader(v),o.deleteShader(w),this.getUniforms=function(){return void 0===S&&(S=new Zat(o,O)),S},this.getAttributes=function(){return void 0===E&&(E=(function t(n,e){const a={},o=n.getProgramParameter(e,35721);for(let t=0;t<o;t++){const o=n.getActiveAttrib(e,t).name;a[o]=n.getAttribLocation(e,o)}return a})(o,O)),E},this.destroy=function(){a.releaseStatesOfProgram(this),o.deleteProgram(O),this.program=void 0},this.name=e.shaderName,this.id=Jat++,this.cacheKey=n,this.usedTimes=1,this.program=O,this.vertexShader=v,this.fragmentShader=w,this}function uot(t,n,e,a,o,r){const i=[],c=a.isWebGL2,s=a.logarithmicDepthBuffer,l=a.floatVertexTextures,m=a.maxVertexUniforms,d=a.vertexTextures;let g=a.precision;const p={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"toon",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},b=["precision","isWebGL2","supportsVertexTextures","outputEncoding","instancing","instancingColor","map","mapEncoding","matcap","matcapEncoding","envMap","envMapMode","envMapEncoding","envMapCubeUV","lightMap","lightMapEncoding","aoMap","emissiveMap","emissiveMapEncoding","bumpMap","normalMap","objectSpaceNormalMap","tangentSpaceNormalMap","clearcoatMap","clearcoatRoughnessMap","clearcoatNormalMap","displacementMap","specularMap","roughnessMap","metalnessMap","gradientMap","alphaMap","combine","vertexColors","vertexTangents","vertexUvs","uvsVertexOnly","fog","useFog","fogExp2","flatShading","sizeAttenuation","logarithmicDepthBuffer","skinning","maxBones","useVertexTexture","morphTargets","morphNormals","maxMorphTargets","maxMorphNormals","premultipliedAlpha","numDirLights","numPointLights","numSpotLights","numHemiLights","numRectAreaLights","numDirLightShadows","numPointLightShadows","numSpotLightShadows","shadowMapEnabled","shadowMapType","toneMapping","physicallyCorrectLights","alphaTest","doubleSided","flipSided","numClippingPlanes","numClipIntersection","depthPacking","dithering","sheen","transmissionMap"];function u(t){let n;return t&&t.isTexture?n=t.encoding:t&&t.isWebGLRenderTarget?(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),n=t.texture.encoding):n=I9,n}return{getParameters:function f(o,i,b,h,_){const C=h.fog,M=n.get(o.envMap||(o.isMeshStandardMaterial?h.environment:null)),O=p[o.type],P=_.isSkinnedMesh?(function x(t){const n=t.skeleton.bones;if(l)return 1024;{const t=Math.floor((m-20)/4),e=Math.min(t,n.length);return e<n.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+n.length+" bones. This GPU supports "+e+"."),0):e}})(_):0;let y,k;if(null!==o.precision&&(g=a.getMaxPrecision(o.precision),g!==o.precision&&console.warn("THREE.WebGLProgram.getParameters:",o.precision,"not supported, using",g,"instead.")),O){const t=Fet[O];y=t.vertexShader,k=t.fragmentShader}else y=o.vertexShader,k=o.fragmentShader;const v=t.getRenderTarget();return{isWebGL2:c,shaderID:O,shaderName:o.type,vertexShader:y,fragmentShader:k,defines:o.defines,isRawShaderMaterial:!0===o.isRawShaderMaterial,glslVersion:o.glslVersion,precision:g,instancing:!0===_.isInstancedMesh,instancingColor:!0===_.isInstancedMesh&&null!==_.instanceColor,supportsVertexTextures:d,outputEncoding:null!==v?u(v.texture):t.outputEncoding,map:!!o.map,mapEncoding:u(o.map),matcap:!!o.matcap,matcapEncoding:u(o.matcap),envMap:!!M,envMapMode:M&&M.mapping,envMapEncoding:u(M),envMapCubeUV:!!M&&(306===M.mapping||307===M.mapping),lightMap:!!o.lightMap,lightMapEncoding:u(o.lightMap),aoMap:!!o.aoMap,emissiveMap:!!o.emissiveMap,emissiveMapEncoding:u(o.emissiveMap),bumpMap:!!o.bumpMap,normalMap:!!o.normalMap,objectSpaceNormalMap:1===o.normalMapType,tangentSpaceNormalMap:0===o.normalMapType,clearcoatMap:!!o.clearcoatMap,clearcoatRoughnessMap:!!o.clearcoatRoughnessMap,clearcoatNormalMap:!!o.clearcoatNormalMap,displacementMap:!!o.displacementMap,roughnessMap:!!o.roughnessMap,metalnessMap:!!o.metalnessMap,specularMap:!!o.specularMap,alphaMap:!!o.alphaMap,gradientMap:!!o.gradientMap,sheen:!!o.sheen,transmissionMap:!!o.transmissionMap,combine:o.combine,vertexTangents:o.normalMap&&o.vertexTangents,vertexColors:o.vertexColors,vertexUvs:!!(o.map||o.bumpMap||o.normalMap||o.specularMap||o.alphaMap||o.emissiveMap||o.roughnessMap||o.metalnessMap||o.clearcoatMap||o.clearcoatRoughnessMap||o.clearcoatNormalMap||o.displacementMap||o.transmissionMap),uvsVertexOnly:!(o.map||o.bumpMap||o.normalMap||o.specularMap||o.alphaMap||o.emissiveMap||o.roughnessMap||o.metalnessMap||o.clearcoatNormalMap||o.transmissionMap||!o.displacementMap),fog:!!C,useFog:o.fog,fogExp2:C&&C.isFogExp2,flatShading:o.flatShading,sizeAttenuation:o.sizeAttenuation,logarithmicDepthBuffer:s,skinning:o.skinning&&P>0,maxBones:P,useVertexTexture:l,morphTargets:o.morphTargets,morphNormals:o.morphNormals,maxMorphTargets:t.maxMorphTargets,maxMorphNormals:t.maxMorphNormals,numDirLights:i.directional.length,numPointLights:i.point.length,numSpotLights:i.spot.length,numRectAreaLights:i.rectArea.length,numHemiLights:i.hemi.length,numDirLightShadows:i.directionalShadowMap.length,numPointLightShadows:i.pointShadowMap.length,numSpotLightShadows:i.spotShadowMap.length,numClippingPlanes:r.numPlanes,numClipIntersection:r.numIntersection,dithering:o.dithering,shadowMapEnabled:t.shadowMap.enabled&&b.length>0,shadowMapType:t.shadowMap.type,toneMapping:o.toneMapped?t.toneMapping:0,physicallyCorrectLights:t.physicallyCorrectLights,premultipliedAlpha:o.premultipliedAlpha,alphaTest:o.alphaTest,doubleSided:2===o.side,flipSided:1===o.side,depthPacking:void 0!==o.depthPacking&&o.depthPacking,index0AttributeName:o.index0AttributeName,extensionDerivatives:o.extensions&&o.extensions.derivatives,extensionFragDepth:o.extensions&&o.extensions.fragDepth,extensionDrawBuffers:o.extensions&&o.extensions.drawBuffers,extensionShaderTextureLOD:o.extensions&&o.extensions.shaderTextureLOD,rendererExtensionFragDepth:c||e.has("EXT_frag_depth"),rendererExtensionDrawBuffers:c||e.has("WEBGL_draw_buffers"),rendererExtensionShaderTextureLod:c||e.has("EXT_shader_texture_lod"),customProgramCacheKey:o.customProgramCacheKey()}},getProgramCacheKey:function h(n){const e=[];if(n.shaderID?e.push(n.shaderID):(e.push(n.fragmentShader),e.push(n.vertexShader)),void 0!==n.defines)for(const t in n.defines)e.push(t),e.push(n.defines[t]);if(!1===n.isRawShaderMaterial){for(let t=0;t<b.length;t++)e.push(n[b[t]]);e.push(t.outputEncoding),e.push(t.gammaFactor)}return e.push(n.customProgramCacheKey),e.join()},getUniforms:function _(t){const n=p[t.type];let e;return e=n?Cet.clone(Fet[n].uniforms):t.uniforms,e},acquireProgram:function C(n,e){let a;for(let t=0,n=i.length;t<n;t++){const n=i[t];if(n.cacheKey===e){a=n,++a.usedTimes;break}}return void 0===a&&(a=new bot(t,e,n,o),i.push(a)),a},releaseProgram:function M(t){if(0==--t.usedTimes){const n=i.indexOf(t);i[n]=i[i.length-1],i.pop(),t.destroy()}},programs:i}}function fot(){let t=new WeakMap;return{get:function n(e){let a=t.get(e);return void 0===a&&(a={},t.set(e,a)),a},remove:function e(n){t.delete(n)},update:function a(n,e,o){t.get(n)[e]=o},dispose:function o(){t=new WeakMap}}}function hot(t,n){return t.groupOrder!==n.groupOrder?t.groupOrder-n.groupOrder:t.renderOrder!==n.renderOrder?t.renderOrder-n.renderOrder:t.program!==n.program?t.program.id-n.program.id:t.material.id!==n.material.id?t.material.id-n.material.id:t.z!==n.z?t.z-n.z:t.id-n.id}function _ot(t,n){return t.groupOrder!==n.groupOrder?t.groupOrder-n.groupOrder:t.renderOrder!==n.renderOrder?t.renderOrder-n.renderOrder:t.z!==n.z?n.z-t.z:t.id-n.id}function Cot(t){const n=[];let e=0;const a=[],o=[],r={id:-1};function i(a,o,i,c,s,l){let m=n[e];const d=t.get(i);return void 0===m?(m={id:a.id,object:a,geometry:o,material:i,program:d.program||r,groupOrder:c,renderOrder:a.renderOrder,z:s,group:l},n[e]=m):(m.id=a.id,m.object=a,m.geometry=o,m.material=i,m.program=d.program||r,m.groupOrder=c,m.renderOrder=a.renderOrder,m.z=s,m.group=l),e++,m}return{opaque:a,transparent:o,init:function c(){e=0,a.length=0,o.length=0},push:function s(t,n,e,r,c,l){const m=i(t,n,e,r,c,l);(!0===e.transparent?o:a).push(m)},unshift:function l(t,n,e,r,c,s){const l=i(t,n,e,r,c,s);(!0===e.transparent?o:a).unshift(l)},finish:function m(){for(let t=e,a=n.length;t<a;t++){const e=n[t];if(null===e.id)break;e.id=null,e.object=null,e.geometry=null,e.material=null,e.program=null,e.group=null}},sort:function d(t,n){a.length>1&&a.sort(t||hot),o.length>1&&o.sort(n||_ot)}}}function Mot(t){let n=new WeakMap;return{get:function e(a,o){const r=n.get(a);let i;return void 0===r?(i=new Cot(t),n.set(a,new WeakMap),n.get(a).set(o,i)):(i=r.get(o),void 0===i&&(i=new Cot(t),r.set(o,i))),i},dispose:function a(){n=new WeakMap}}}function Oot(){const t={};return{get:function(n){if(void 0!==t[n.id])return t[n.id];let e;switch(n.type){case"DirectionalLight":e={direction:new ttt,color:new Ont};break;case"SpotLight":e={position:new ttt,direction:new ttt,color:new Ont,distance:0,coneCos:0,penumbraCos:0,decay:0};break;case"PointLight":e={position:new ttt,color:new Ont,distance:0,decay:0};break;case"HemisphereLight":e={direction:new ttt,skyColor:new Ont,groundColor:new Ont};break;case"RectAreaLight":e={color:new Ont,position:new ttt,halfWidth:new ttt,halfHeight:new ttt}}return t[n.id]=e,e}}}let Pot=0;function xot(t,n){return(n.castShadow?1:0)-(t.castShadow?1:0)}function yot(t,n){const e=new Oot,a=(function o(){const t={};return{get:function(n){if(void 0!==t[n.id])return t[n.id];let e;switch(n.type){case"DirectionalLight":case"SpotLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new W9};break;case"PointLight":e={shadowBias:0,shadowNormalBias:0,shadowRadius:1,shadowMapSize:new W9,shadowCameraNear:1,shadowCameraFar:1e3}}return t[n.id]=e,e}}})(),r={version:0,hash:{directionalLength:-1,pointLength:-1,spotLength:-1,rectAreaLength:-1,hemiLength:-1,numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},ambient:[0,0,0],probe:[],directional:[],directionalShadow:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadow:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],rectAreaLTC1:null,rectAreaLTC2:null,point:[],pointShadow:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[]};for(let t=0;t<9;t++)r.probe.push(new ttt);const i=new ttt,c=new Stt,s=new Stt;return{setup:function l(o){let i=0,c=0,s=0;for(let t=0;t<9;t++)r.probe[t].set(0,0,0);let l=0,m=0,d=0,g=0,p=0,b=0,u=0,f=0;o.sort(xot);for(let t=0,n=o.length;t<n;t++){const n=o[t],h=n.color,_=n.intensity,C=n.distance,M=n.shadow&&n.shadow.map?n.shadow.map.texture:null;if(n.isAmbientLight)i+=h.r*_,c+=h.g*_,s+=h.b*_;else if(n.isLightProbe)for(let t=0;t<9;t++)r.probe[t].addScaledVector(n.sh.coefficients[t],_);else if(n.isDirectionalLight){const t=e.get(n);if(t.color.copy(n.color).multiplyScalar(n.intensity),n.castShadow){const t=n.shadow,e=a.get(n);e.shadowBias=t.bias,e.shadowNormalBias=t.normalBias,e.shadowRadius=t.radius,e.shadowMapSize=t.mapSize,r.directionalShadow[l]=e,r.directionalShadowMap[l]=M,r.directionalShadowMatrix[l]=n.shadow.matrix,b++}r.directional[l]=t,l++}else if(n.isSpotLight){const t=e.get(n);if(t.position.setFromMatrixPosition(n.matrixWorld),t.color.copy(h).multiplyScalar(_),t.distance=C,t.coneCos=Math.cos(n.angle),t.penumbraCos=Math.cos(n.angle*(1-n.penumbra)),t.decay=n.decay,n.castShadow){const t=n.shadow,e=a.get(n);e.shadowBias=t.bias,e.shadowNormalBias=t.normalBias,e.shadowRadius=t.radius,e.shadowMapSize=t.mapSize,r.spotShadow[d]=e,r.spotShadowMap[d]=M,r.spotShadowMatrix[d]=n.shadow.matrix,f++}r.spot[d]=t,d++}else if(n.isRectAreaLight){const t=e.get(n);t.color.copy(h).multiplyScalar(_),t.halfWidth.set(.5*n.width,0,0),t.halfHeight.set(0,.5*n.height,0),r.rectArea[g]=t,g++}else if(n.isPointLight){const t=e.get(n);if(t.color.copy(n.color).multiplyScalar(n.intensity),t.distance=n.distance,t.decay=n.decay,n.castShadow){const t=n.shadow,e=a.get(n);e.shadowBias=t.bias,e.shadowNormalBias=t.normalBias,e.shadowRadius=t.radius,e.shadowMapSize=t.mapSize,e.shadowCameraNear=t.camera.near,e.shadowCameraFar=t.camera.far,r.pointShadow[m]=e,r.pointShadowMap[m]=M,r.pointShadowMatrix[m]=n.shadow.matrix,u++}r.point[m]=t,m++}else if(n.isHemisphereLight){const t=e.get(n);t.skyColor.copy(n.color).multiplyScalar(_),t.groundColor.copy(n.groundColor).multiplyScalar(_),r.hemi[p]=t,p++}}g>0&&(n.isWebGL2||!0===t.has("OES_texture_float_linear")?(r.rectAreaLTC1=Net.LTC_FLOAT_1,r.rectAreaLTC2=Net.LTC_FLOAT_2):!0===t.has("OES_texture_half_float_linear")?(r.rectAreaLTC1=Net.LTC_HALF_1,r.rectAreaLTC2=Net.LTC_HALF_2):console.error("THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.")),r.ambient[0]=i,r.ambient[1]=c,r.ambient[2]=s;const h=r.hash;h.directionalLength===l&&h.pointLength===m&&h.spotLength===d&&h.rectAreaLength===g&&h.hemiLength===p&&h.numDirectionalShadows===b&&h.numPointShadows===u&&h.numSpotShadows===f||(r.directional.length=l,r.spot.length=d,r.rectArea.length=g,r.point.length=m,r.hemi.length=p,r.directionalShadow.length=b,r.directionalShadowMap.length=b,r.pointShadow.length=u,r.pointShadowMap.length=u,r.spotShadow.length=f,r.spotShadowMap.length=f,r.directionalShadowMatrix.length=b,r.pointShadowMatrix.length=u,r.spotShadowMatrix.length=f,h.directionalLength=l,h.pointLength=m,h.spotLength=d,h.rectAreaLength=g,h.hemiLength=p,h.numDirectionalShadows=b,h.numPointShadows=u,h.numSpotShadows=f,r.version=Pot++)},setupView:function m(t,n){let e=0,a=0,o=0,l=0,m=0;const d=n.matrixWorldInverse;for(let n=0,g=t.length;n<g;n++){const g=t[n];if(g.isDirectionalLight){const t=r.directional[e];t.direction.setFromMatrixPosition(g.matrixWorld),i.setFromMatrixPosition(g.target.matrixWorld),t.direction.sub(i),t.direction.transformDirection(d),e++}else if(g.isSpotLight){const t=r.spot[o];t.position.setFromMatrixPosition(g.matrixWorld),t.position.applyMatrix4(d),t.direction.setFromMatrixPosition(g.matrixWorld),i.setFromMatrixPosition(g.target.matrixWorld),t.direction.sub(i),t.direction.transformDirection(d),o++}else if(g.isRectAreaLight){const t=r.rectArea[l];t.position.setFromMatrixPosition(g.matrixWorld),t.position.applyMatrix4(d),s.identity(),c.copy(g.matrixWorld),c.premultiply(d),s.extractRotation(c),t.halfWidth.set(.5*g.width,0,0),t.halfHeight.set(0,.5*g.height,0),t.halfWidth.applyMatrix4(s),t.halfHeight.applyMatrix4(s),l++}else if(g.isPointLight){const t=r.point[a];t.position.setFromMatrixPosition(g.matrixWorld),t.position.applyMatrix4(d),a++}else if(g.isHemisphereLight){const t=r.hemi[m];t.direction.setFromMatrixPosition(g.matrixWorld),t.direction.transformDirection(d),t.direction.normalize(),m++}}},state:r}}function kot(t,n){const e=new yot(t,n),a=[],o=[];return{init:function r(){a.length=0,o.length=0},state:{lightsArray:a,shadowsArray:o,lights:e},setupLights:function i(){e.setup(a)},setupLightsView:function c(t){e.setupView(a,t)},pushLight:function s(t){a.push(t)},pushShadow:function l(t){o.push(t)}}}function vot(t,n){let e=new WeakMap;return{get:function a(o,r=0){let i;return!1===e.has(o)?(i=new kot(t,n),e.set(o,[]),e.get(o).push(i)):r>=e.get(o).length?(i=new kot(t,n),e.get(o).push(i)):i=e.get(o)[r],i},dispose:function o(){e=new WeakMap}}}function wot(t){ynt.call(this),this.type="MeshDepthMaterial",this.depthPacking=3200,this.skinning=!1,this.morphTargets=!1,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.setValues(t)}function Sot(t){ynt.call(this),this.type="MeshDistanceMaterial",this.referencePosition=new ttt,this.nearDistance=1,this.farDistance=1e3,this.skinning=!1,this.morphTargets=!1,this.map=null,this.alphaMap=null,this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.fog=!1,this.setValues(t)}function Eot(t,n,e){let a=new zet;const o=new W9,r=new W9,i=new Q9,c=[],s=[],l={},m={0:1,1:0,2:2},d=new Met({defines:{SAMPLE_RATE:2/8,HALF_SAMPLE_RATE:1/8},uniforms:{shadow_pass:{value:null},resolution:{value:new W9},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position = vec4( position, 1.0 );\n}",fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy ) / resolution ) );\n\tfor ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, i ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean * HALF_SAMPLE_RATE;\n\tsquared_mean = squared_mean * HALF_SAMPLE_RATE;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}"}),g=d.clone();g.defines.HORIZONTAL_PASS=1;const p=new Xnt;p.setAttribute("position",new Snt(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));const b=new bet(p,d),u=this;function f(e,a){const o=n.update(b);d.uniforms.shadow_pass.value=e.map.texture,d.uniforms.resolution.value=e.mapSize,d.uniforms.radius.value=e.radius,t.setRenderTarget(e.mapPass),t.clear(),t.renderBufferDirect(a,null,o,d,b,null),g.uniforms.shadow_pass.value=e.mapPass.texture,g.uniforms.resolution.value=e.mapSize,g.uniforms.radius.value=e.radius,t.setRenderTarget(e.map),t.clear(),t.renderBufferDirect(a,null,o,g,b,null)}function h(t,n,e){const a=t<<0|n<<1|e<<2;let o=c[a];return void 0===o&&(o=new wot({depthPacking:3201,morphTargets:t,skinning:n}),c[a]=o),o}function _(t,n,e){const a=t<<0|n<<1|e<<2;let o=s[a];return void 0===o&&(o=new Sot({morphTargets:t,skinning:n}),s[a]=o),o}function C(n,e,a,o,r,i,c){let s=null,d=h,g=n.customDepthMaterial;if(!0===o.isPointLight&&(d=_,g=n.customDistanceMaterial),void 0===g){let t=!1;!0===a.morphTargets&&(t=e.morphAttributes&&e.morphAttributes.position&&e.morphAttributes.position.length>0);let o=!1;!0===n.isSkinnedMesh&&(!0===a.skinning?o=!0:console.warn("THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:",n)),s=d(t,o,!0===n.isInstancedMesh)}else s=g;if(t.localClippingEnabled&&!0===a.clipShadows&&0!==a.clippingPlanes.length){const t=s.uuid,n=a.uuid;let e=l[t];void 0===e&&(e={},l[t]=e);let o=e[n];void 0===o&&(o=s.clone(),e[n]=o),s=o}return s.visible=a.visible,s.wireframe=a.wireframe,s.side=3===c?null!==a.shadowSide?a.shadowSide:a.side:null!==a.shadowSide?a.shadowSide:m[a.side],s.clipShadows=a.clipShadows,s.clippingPlanes=a.clippingPlanes,s.clipIntersection=a.clipIntersection,s.wireframeLinewidth=a.wireframeLinewidth,s.linewidth=a.linewidth,!0===o.isPointLight&&!0===s.isMeshDistanceMaterial&&(s.referencePosition.setFromMatrixPosition(o.matrixWorld),s.nearDistance=r,s.farDistance=i),s}function M(e,o,r,i,c){if(!1===e.visible)return;if(e.layers.test(o.layers)&&(e.isMesh||e.isLine||e.isPoints)&&(e.castShadow||e.receiveShadow&&3===c)&&(!e.frustumCulled||a.intersectsObject(e))){e.modelViewMatrix.multiplyMatrices(r.matrixWorldInverse,e.matrixWorld);const a=n.update(e),o=e.material;if(Array.isArray(o)){const n=a.groups;for(let s=0,l=n.length;s<l;s++){const l=n[s],m=o[l.materialIndex];if(m&&m.visible){const n=C(e,a,m,i,r.near,r.far,c);t.renderBufferDirect(r,null,a,n,e,l)}}}else if(o.visible){const n=C(e,a,o,i,r.near,r.far,c);t.renderBufferDirect(r,null,a,n,e,null)}}const s=e.children;for(let t=0,n=s.length;t<n;t++)M(s[t],o,r,i,c)}this.enabled=!1,this.autoUpdate=!0,this.needsUpdate=!1,this.type=1,this.render=function(n,c,s){if(!1===u.enabled)return;if(!1===u.autoUpdate&&!1===u.needsUpdate)return;if(0===n.length)return;const l=t.getRenderTarget(),m=t.getActiveCubeFace(),d=t.getActiveMipmapLevel(),g=t.state;g.setBlending(0),g.buffers.color.setClear(1,1,1,1),g.buffers.depth.setTest(!0),g.setScissorTest(!1);for(let l=0,m=n.length;l<m;l++){const m=n[l],d=m.shadow;if(void 0===d){console.warn("THREE.WebGLShadowMap:",m,"has no shadow.");continue}if(!1===d.autoUpdate&&!1===d.needsUpdate)continue;o.copy(d.mapSize);const p=d.getFrameExtents();if(o.multiply(p),r.copy(d.mapSize),(o.x>e||o.y>e)&&(o.x>e&&(r.x=Math.floor(e/p.x),o.x=r.x*p.x,d.mapSize.x=r.x),o.y>e&&(r.y=Math.floor(e/p.y),o.y=r.y*p.y,d.mapSize.y=r.y)),null===d.map&&!d.isPointLightShadow&&3===this.type){const t={minFilter:_9,magFilter:_9,format:v9};d.map=new K9(o.x,o.y,t),d.map.texture.name=m.name+".shadowMap",d.mapPass=new K9(o.x,o.y,t),d.camera.updateProjectionMatrix()}null===d.map&&(d.map=new K9(o.x,o.y,{minFilter:h9,magFilter:h9,format:v9}),d.map.texture.name=m.name+".shadowMap",d.camera.updateProjectionMatrix()),t.setRenderTarget(d.map),t.clear();const b=d.getViewportCount();for(let t=0;t<b;t++){const n=d.getViewport(t);i.set(r.x*n.x,r.y*n.y,r.x*n.z,r.y*n.w),g.viewport(i),d.updateMatrices(m,t),a=d.getFrustum(),M(c,s,d.camera,m,this.type)}d.isPointLightShadow||3!==this.type||f(d,s),d.needsUpdate=!1}u.needsUpdate=!1,t.setRenderTarget(l,m,d)}}function Aot(t,n,e){const a=e.isWebGL2,o=new(function r(){let n=!1;const e=new Q9;let a=null;const o=new Q9(0,0,0,0);return{setMask:function(e){a===e||n||(t.colorMask(e,e,e,e),a=e)},setLocked:function(t){n=t},setClear:function(n,a,r,i,c){!0===c&&(n*=i,a*=i,r*=i),e.set(n,a,r,i),!1===o.equals(e)&&(t.clearColor(n,a,r,i),o.copy(e))},reset:function(){n=!1,a=null,o.set(-1,0,0,0)}}}),i=new(function c(){let n=!1,e=null,a=null,o=null;return{setTest:function(t){t?N(2929):F(2929)},setMask:function(a){e===a||n||(t.depthMask(a),e=a)},setFunc:function(n){if(a!==n){if(n)switch(n){case 0:t.depthFunc(512);break;case 1:t.depthFunc(519);break;case 2:t.depthFunc(513);break;case 3:t.depthFunc(515);break;case 4:t.depthFunc(514);break;case 5:t.depthFunc(518);break;case 6:t.depthFunc(516);break;case 7:t.depthFunc(517);break;default:t.depthFunc(515)}else t.depthFunc(515);a=n}},setLocked:function(t){n=t},setClear:function(n){o!==n&&(t.clearDepth(n),o=n)},reset:function(){n=!1,e=null,a=null,o=null}}}),s=new(function l(){let n=!1,e=null,a=null,o=null,r=null,i=null,c=null,s=null,l=null;return{setTest:function(t){n||(t?N(2960):F(2960))},setMask:function(a){e===a||n||(t.stencilMask(a),e=a)},setFunc:function(n,e,i){a===n&&o===e&&r===i||(t.stencilFunc(n,e,i),a=n,o=e,r=i)},setOp:function(n,e,a){i===n&&c===e&&s===a||(t.stencilOp(n,e,a),i=n,c=e,s=a)},setLocked:function(t){n=t},setClear:function(n){l!==n&&(t.clearStencil(n),l=n)},reset:function(){n=!1,e=null,a=null,o=null,r=null,i=null,c=null,s=null,l=null}}});let m={},d=null,g=null,p=null,b=null,u=null,f=null,h=null,_=null,C=null,M=!1,O=null,P=null,x=null,y=null,k=null;const v=t.getParameter(35661);let w=!1,S=0;const E=t.getParameter(7938);-1!==E.indexOf("WebGL")?(S=parseFloat(/^WebGL (\d)/.exec(E)[1]),w=S>=1):-1!==E.indexOf("OpenGL ES")&&(S=parseFloat(/^OpenGL ES (\d)/.exec(E)[1]),w=S>=2);let A=null,z={};const R=new Q9,T=new Q9;function D(n,e,a){const o=new Uint8Array(4),r=t.createTexture();t.bindTexture(n,r),t.texParameteri(n,10241,9728),t.texParameteri(n,10240,9728);for(let n=0;n<a;n++)t.texImage2D(e+n,0,6408,1,1,0,6408,5121,o);return r}const I={};function N(n){!0!==m[n]&&(t.enable(n),m[n]=!0)}function F(n){!1!==m[n]&&(t.disable(n),m[n]=!1)}I[3553]=D(3553,3553,1),I[34067]=D(34067,34069,6),o.setClear(0,0,0,1),i.setClear(1),s.setClear(0),N(2929),i.setFunc(3),V(!1),j(1),N(2884),B(0);const L={[p9]:32774,101:32778,102:32779};if(a)L[103]=32775,L[104]=32776;else{const t=n.get("EXT_blend_minmax");null!==t&&(L[103]=t.MIN_EXT,L[104]=t.MAX_EXT)}const H={200:0,201:1,202:768,204:770,210:776,208:774,206:772,203:769,205:771,209:775,207:773};function B(n,e,a,o,r,i,c,s){if(0!==n){if(g||(N(3042),g=!0),5===n)r=r||e,i=i||a,c=c||o,e===b&&r===h||(t.blendEquationSeparate(L[e],L[r]),b=e,h=r),a===u&&o===f&&i===_&&c===C||(t.blendFuncSeparate(H[a],H[o],H[i],H[c]),u=a,f=o,_=i,C=c),p=n,M=null;else if(n!==p||s!==M){if(b===p9&&h===p9||(t.blendEquation(32774),b=p9,h=p9),s)switch(n){case 1:t.blendFuncSeparate(1,771,1,771);break;case 2:t.blendFunc(1,1);break;case 3:t.blendFuncSeparate(0,0,769,771);break;case 4:t.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",n)}else switch(n){case 1:t.blendFuncSeparate(770,771,1,771);break;case 2:t.blendFunc(770,1);break;case 3:t.blendFunc(0,769);break;case 4:t.blendFunc(0,768);break;default:console.error("THREE.WebGLState: Invalid blending: ",n)}u=null,f=null,_=null,C=null,p=n,M=s}}else g&&(F(3042),g=!1)}function V(n){O!==n&&(t.frontFace(n?2304:2305),O=n)}function j(n){0!==n?(N(2884),n!==P&&t.cullFace(1===n?1029:2===n?1028:1032)):F(2884),P=n}function U(n,e,a){n?(N(32823),y===e&&k===a||(t.polygonOffset(e,a),y=e,k=a)):F(32823)}function W(n){void 0===n&&(n=33984+v-1),A!==n&&(t.activeTexture(n),A=n)}return{buffers:{color:o,depth:i,stencil:s},enable:N,disable:F,useProgram:function G(n){return d!==n&&(t.useProgram(n),d=n,!0)},setBlending:B,setMaterial:function Y(t,n){2===t.side?F(2884):N(2884);let e=1===t.side;n&&(e=!e),V(e),1===t.blending&&!1===t.transparent?B(0):B(t.blending,t.blendEquation,t.blendSrc,t.blendDst,t.blendEquationAlpha,t.blendSrcAlpha,t.blendDstAlpha,t.premultipliedAlpha),i.setFunc(t.depthFunc),i.setTest(t.depthTest),i.setMask(t.depthWrite),o.setMask(t.colorWrite);const a=t.stencilWrite;s.setTest(a),a&&(s.setMask(t.stencilWriteMask),s.setFunc(t.stencilFunc,t.stencilRef,t.stencilFuncMask),s.setOp(t.stencilFail,t.stencilZFail,t.stencilZPass)),U(t.polygonOffset,t.polygonOffsetFactor,t.polygonOffsetUnits)},setFlipSided:V,setCullFace:j,setLineWidth:function q(n){n!==x&&(w&&t.lineWidth(n),x=n)},setPolygonOffset:U,setScissorTest:function Z(t){t?N(3089):F(3089)},activeTexture:W,bindTexture:function X(n,e){null===A&&W();let a=z[A];void 0===a&&(a={type:void 0,texture:void 0},z[A]=a),a.type===n&&a.texture===e||(t.bindTexture(n,e||I[n]),a.type=n,a.texture=e)},unbindTexture:function J(){const n=z[A];void 0!==n&&void 0!==n.type&&(t.bindTexture(n.type,null),n.type=void 0,n.texture=void 0)},compressedTexImage2D:function Q(){try{t.compressedTexImage2D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},texImage2D:function K(){try{t.texImage2D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},texImage3D:function $(){try{t.texImage3D.apply(t,arguments)}catch(t){console.error("THREE.WebGLState:",t)}},scissor:function tt(n){!1===R.equals(n)&&(t.scissor(n.x,n.y,n.z,n.w),R.copy(n))},viewport:function nt(n){!1===T.equals(n)&&(t.viewport(n.x,n.y,n.z,n.w),T.copy(n))},reset:function et(){m={},A=null,z={},d=null,g=null,p=null,b=null,u=null,f=null,h=null,_=null,C=null,M=!1,O=null,P=null,x=null,y=null,k=null,o.reset(),i.reset(),s.reset()}}}function zot(t,n,e,a,o,r,i){const c=o.isWebGL2,s=o.maxTextures,l=o.maxCubemapSize,m=o.maxTextureSize,d=o.maxSamples,g=new WeakMap;let p,b=!1;try{b="undefined"!=typeof OffscreenCanvas&&null!==new OffscreenCanvas(1,1).getContext("2d")}catch(t){}function u(t,n){return b?new OffscreenCanvas(t,n):document.createElementNS("http://www.w3.org/1999/xhtml","canvas")}function f(t,n,e,a){let o=1;if((t.width>a||t.height>a)&&(o=a/Math.max(t.width,t.height)),o<1||!0===n){if("undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof ImageBitmap&&t instanceof ImageBitmap){const a=n?U9.floorPowerOfTwo:Math.floor,r=a(o*t.width),i=a(o*t.height);void 0===p&&(p=u(r,i));const c=e?u(r,i):p;return c.width=r,c.height=i,c.getContext("2d").drawImage(t,0,0,r,i),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+t.width+"x"+t.height+") to ("+r+"x"+i+")."),c}return"data"in t&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+t.width+"x"+t.height+")."),t}return t}function h(t){return U9.isPowerOfTwo(t.width)&&U9.isPowerOfTwo(t.height)}function _(t,n){return t.generateMipmaps&&n&&t.minFilter!==h9&&t.minFilter!==_9}function C(n,e,o,r){t.generateMipmap(n),a.get(e).__maxMipLevel=Math.log(Math.max(o,r))*Math.LOG2E}function M(e,a,o){if(!1===c)return a;if(null!==e){if(void 0!==t[e])return t[e];console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '"+e+"'")}let r=a;return 6403===a&&(5126===o&&(r=33326),5131===o&&(r=33325),5121===o&&(r=33321)),6407===a&&(5126===o&&(r=34837),5131===o&&(r=34843),5121===o&&(r=32849)),6408===a&&(5126===o&&(r=34836),5131===o&&(r=34842),5121===o&&(r=32856)),33325!==r&&33326!==r&&34842!==r&&34836!==r||n.get("EXT_color_buffer_float"),r}function O(t){return t===h9||1004===t||1005===t?9728:9729}function P(n){const e=n.target;e.removeEventListener("dispose",P),(function o(n){const e=a.get(n);void 0!==e.__webglInit&&(t.deleteTexture(e.__webglTexture),a.remove(n))})(e),e.isVideoTexture&&g.delete(e),i.memory.textures--}function x(n){const e=n.target;e.removeEventListener("dispose",x),(function o(n){const e=a.get(n),o=a.get(n.texture);if(n){if(void 0!==o.__webglTexture&&t.deleteTexture(o.__webglTexture),n.depthTexture&&n.depthTexture.dispose(),n.isWebGLCubeRenderTarget)for(let n=0;n<6;n++)t.deleteFramebuffer(e.__webglFramebuffer[n]),e.__webglDepthbuffer&&t.deleteRenderbuffer(e.__webglDepthbuffer[n]);else t.deleteFramebuffer(e.__webglFramebuffer),e.__webglDepthbuffer&&t.deleteRenderbuffer(e.__webglDepthbuffer),e.__webglMultisampledFramebuffer&&t.deleteFramebuffer(e.__webglMultisampledFramebuffer),e.__webglColorRenderbuffer&&t.deleteRenderbuffer(e.__webglColorRenderbuffer),e.__webglDepthRenderbuffer&&t.deleteRenderbuffer(e.__webglDepthRenderbuffer);a.remove(n.texture),a.remove(n)}})(e),i.memory.textures--}let y=0;function k(t,n){const o=a.get(t);if(t.isVideoTexture&&(function r(t){const n=i.render.frame;g.get(t)!==n&&(g.set(t,n),t.update())})(t),t.version>0&&o.__version!==t.version){const e=t.image;if(void 0===e)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");else{if(!1!==e.complete)return void z(o,t,n);console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete")}}e.activeTexture(33984+n),e.bindTexture(3553,o.__webglTexture)}function v(n,o){const i=a.get(n);n.version>0&&i.__version!==n.version?(function s(n,a,o){if(6!==a.image.length)return;A(n,a),e.activeTexture(33984+o),e.bindTexture(34067,n.__webglTexture),t.pixelStorei(37440,a.flipY),t.pixelStorei(37441,a.premultiplyAlpha),t.pixelStorei(3317,a.unpackAlignment);const i=a&&(a.isCompressedTexture||a.image[0].isCompressedTexture),s=a.image[0]&&a.image[0].isDataTexture,m=[];for(let t=0;t<6;t++)m[t]=i||s?s?a.image[t].image:a.image[t]:f(a.image[t],!1,!0,l);const d=m[0],g=h(d)||c,p=r.convert(a.format),b=r.convert(a.type),u=M(a.internalFormat,p,b);let O;if(E(34067,a,g),i){for(let t=0;t<6;t++){O=m[t].mipmaps;for(let n=0;n<O.length;n++){const o=O[n];a.format!==v9&&a.format!==k9?null!==p?e.compressedTexImage2D(34069+t,n,u,o.width,o.height,0,o.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):e.texImage2D(34069+t,n,u,o.width,o.height,0,p,b,o.data)}}n.__maxMipLevel=O.length-1}else{O=a.mipmaps;for(let t=0;t<6;t++)if(s){e.texImage2D(34069+t,0,u,m[t].width,m[t].height,0,p,b,m[t].data);for(let n=0;n<O.length;n++){const a=O[n].image[t].image;e.texImage2D(34069+t,n+1,u,a.width,a.height,0,p,b,a.data)}}else{e.texImage2D(34069+t,0,u,p,b,m[t]);for(let n=0;n<O.length;n++)e.texImage2D(34069+t,n+1,u,p,b,O[n].image[t])}n.__maxMipLevel=O.length}_(a,g)&&C(34067,a,d.width,d.height),n.__version=a.version,a.onUpdate&&a.onUpdate(a)})(i,n,o):(e.activeTexture(33984+o),e.bindTexture(34067,i.__webglTexture))}const w={[b9]:10497,[u9]:33071,[f9]:33648},S={[h9]:9728,1004:9984,1005:9986,[_9]:9729,1007:9985,[C9]:9987};function E(e,r,i){i?(t.texParameteri(e,10242,w[r.wrapS]),t.texParameteri(e,10243,w[r.wrapT]),32879!==e&&35866!==e||t.texParameteri(e,32882,w[r.wrapR]),t.texParameteri(e,10240,S[r.magFilter]),t.texParameteri(e,10241,S[r.minFilter])):(t.texParameteri(e,10242,33071),t.texParameteri(e,10243,33071),32879!==e&&35866!==e||t.texParameteri(e,32882,33071),r.wrapS===u9&&r.wrapT===u9||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),t.texParameteri(e,10240,O(r.magFilter)),t.texParameteri(e,10241,O(r.minFilter)),r.minFilter!==h9&&r.minFilter!==_9&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter."));const s=n.get("EXT_texture_filter_anisotropic");if(s){if(r.type===P9&&null===n.get("OES_texture_float_linear"))return;if(r.type===x9&&null===(c||n.get("OES_texture_half_float_linear")))return;(r.anisotropy>1||a.get(r).__currentAnisotropy)&&(t.texParameterf(e,s.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(r.anisotropy,o.getMaxAnisotropy())),a.get(r).__currentAnisotropy=r.anisotropy)}}function A(n,e){void 0===n.__webglInit&&(n.__webglInit=!0,e.addEventListener("dispose",P),n.__webglTexture=t.createTexture(),i.memory.textures++)}function z(n,a,o){let i=3553;a.isDataTexture2DArray&&(i=35866),a.isDataTexture3D&&(i=32879),A(n,a),e.activeTexture(33984+o),e.bindTexture(i,n.__webglTexture),t.pixelStorei(37440,a.flipY),t.pixelStorei(37441,a.premultiplyAlpha),t.pixelStorei(3317,a.unpackAlignment);const s=(function l(t){return!c&&(t.wrapS!==u9||t.wrapT!==u9||t.minFilter!==h9&&t.minFilter!==_9)})(a)&&!1===h(a.image),d=f(a.image,s,!1,m),g=h(d)||c,p=r.convert(a.format);let b,u=r.convert(a.type),O=M(a.internalFormat,p,u);E(i,a,g);const P=a.mipmaps;if(a.isDepthTexture)O=6402,c?O=a.type===P9?36012:a.type===O9?33190:a.type===y9?35056:33189:a.type===P9&&console.error("WebGLRenderer: Floating point depth texture requires WebGL2."),a.format===w9&&6402===O&&a.type!==M9&&a.type!==O9&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),a.type=M9,u=r.convert(a.type)),a.format===S9&&6402===O&&(O=34041,a.type!==y9&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),a.type=y9,u=r.convert(a.type))),e.texImage2D(3553,0,O,d.width,d.height,0,p,u,null);else if(a.isDataTexture)if(P.length>0&&g){for(let t=0,n=P.length;t<n;t++)b=P[t],e.texImage2D(3553,t,O,b.width,b.height,0,p,u,b.data);a.generateMipmaps=!1,n.__maxMipLevel=P.length-1}else e.texImage2D(3553,0,O,d.width,d.height,0,p,u,d.data),n.__maxMipLevel=0;else if(a.isCompressedTexture){for(let t=0,n=P.length;t<n;t++)b=P[t],a.format!==v9&&a.format!==k9?null!==p?e.compressedTexImage2D(3553,t,O,b.width,b.height,0,b.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):e.texImage2D(3553,t,O,b.width,b.height,0,p,u,b.data);n.__maxMipLevel=P.length-1}else if(a.isDataTexture2DArray)e.texImage3D(35866,0,O,d.width,d.height,d.depth,0,p,u,d.data),n.__maxMipLevel=0;else if(a.isDataTexture3D)e.texImage3D(32879,0,O,d.width,d.height,d.depth,0,p,u,d.data),n.__maxMipLevel=0;else if(P.length>0&&g){for(let t=0,n=P.length;t<n;t++)b=P[t],e.texImage2D(3553,t,O,p,u,b);a.generateMipmaps=!1,n.__maxMipLevel=P.length-1}else e.texImage2D(3553,0,O,p,u,d),n.__maxMipLevel=0;_(a,g)&&C(i,a,d.width,d.height),n.__version=a.version,a.onUpdate&&a.onUpdate(a)}function R(n,o,i,c){const s=r.convert(o.texture.format),l=r.convert(o.texture.type),m=M(o.texture.internalFormat,s,l);e.texImage2D(c,0,m,o.width,o.height,0,s,l,null),t.bindFramebuffer(36160,n),t.framebufferTexture2D(36160,i,c,a.get(o.texture).__webglTexture,0),t.bindFramebuffer(36160,null)}function T(n,e,a){if(t.bindRenderbuffer(36161,n),e.depthBuffer&&!e.stencilBuffer){let o=33189;if(a){const n=e.depthTexture;n&&n.isDepthTexture&&(n.type===P9?o=36012:n.type===O9&&(o=33190));const a=D(e);t.renderbufferStorageMultisample(36161,a,o,e.width,e.height)}else t.renderbufferStorage(36161,o,e.width,e.height);t.framebufferRenderbuffer(36160,36096,36161,n)}else if(e.depthBuffer&&e.stencilBuffer){if(a){const n=D(e);t.renderbufferStorageMultisample(36161,n,35056,e.width,e.height)}else t.renderbufferStorage(36161,34041,e.width,e.height);t.framebufferRenderbuffer(36160,33306,36161,n)}else{const n=r.convert(e.texture.format),o=r.convert(e.texture.type),i=M(e.texture.internalFormat,n,o);if(a){const n=D(e);t.renderbufferStorageMultisample(36161,n,i,e.width,e.height)}else t.renderbufferStorage(36161,i,e.width,e.height)}t.bindRenderbuffer(36161,null)}function D(t){return c&&t.isWebGLMultisampleRenderTarget?Math.min(d,t.samples):0}let I=!1,N=!1;this.allocateTextureUnit=function F(){const t=y;return t>=s&&console.warn("THREE.WebGLTextures: Trying to use "+t+" texture units while this GPU supports only "+s),y+=1,t},this.resetTextureUnits=function L(){y=0},this.setTexture2D=k,this.setTexture2DArray=function H(t,n){const o=a.get(t);t.version>0&&o.__version!==t.version?z(o,t,n):(e.activeTexture(33984+n),e.bindTexture(35866,o.__webglTexture))},this.setTexture3D=function B(t,n){const o=a.get(t);t.version>0&&o.__version!==t.version?z(o,t,n):(e.activeTexture(33984+n),e.bindTexture(32879,o.__webglTexture))},this.setTextureCube=v,this.setupRenderTarget=function V(n){const o=a.get(n),s=a.get(n.texture);n.addEventListener("dispose",x),s.__webglTexture=t.createTexture(),i.memory.textures++;const l=!0===n.isWebGLCubeRenderTarget,m=!0===n.isWebGLMultisampleRenderTarget,d=h(n)||c;if(!c||n.texture.format!==k9||n.texture.type!==P9&&n.texture.type!==x9||(n.texture.format=v9,console.warn("THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.")),l){o.__webglFramebuffer=[];for(let n=0;n<6;n++)o.__webglFramebuffer[n]=t.createFramebuffer()}else if(o.__webglFramebuffer=t.createFramebuffer(),m)if(c){o.__webglMultisampledFramebuffer=t.createFramebuffer(),o.__webglColorRenderbuffer=t.createRenderbuffer(),t.bindRenderbuffer(36161,o.__webglColorRenderbuffer);const e=r.convert(n.texture.format),a=r.convert(n.texture.type),i=M(n.texture.internalFormat,e,a),c=D(n);t.renderbufferStorageMultisample(36161,c,i,n.width,n.height),t.bindFramebuffer(36160,o.__webglMultisampledFramebuffer),t.framebufferRenderbuffer(36160,36064,36161,o.__webglColorRenderbuffer),t.bindRenderbuffer(36161,null),n.depthBuffer&&(o.__webglDepthRenderbuffer=t.createRenderbuffer(),T(o.__webglDepthRenderbuffer,n,!0)),t.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");if(l){e.bindTexture(34067,s.__webglTexture),E(34067,n.texture,d);for(let t=0;t<6;t++)R(o.__webglFramebuffer[t],n,36064,34069+t);_(n.texture,d)&&C(34067,n.texture,n.width,n.height),e.bindTexture(34067,null)}else e.bindTexture(3553,s.__webglTexture),E(3553,n.texture,d),R(o.__webglFramebuffer,n,36064,3553),_(n.texture,d)&&C(3553,n.texture,n.width,n.height),e.bindTexture(3553,null);n.depthBuffer&&(function g(n){const e=a.get(n),o=!0===n.isWebGLCubeRenderTarget;if(n.depthTexture){if(o)throw new Error("target.depthTexture not supported in Cube render targets");!(function r(n,e){if(e&&e.isWebGLCubeRenderTarget)throw new Error("Depth Texture with cube render targets is not supported");if(t.bindFramebuffer(36160,n),!e.depthTexture||!e.depthTexture.isDepthTexture)throw new Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");a.get(e.depthTexture).__webglTexture&&e.depthTexture.image.width===e.width&&e.depthTexture.image.height===e.height||(e.depthTexture.image.width=e.width,e.depthTexture.image.height=e.height,e.depthTexture.needsUpdate=!0),k(e.depthTexture,0);const o=a.get(e.depthTexture).__webglTexture;if(e.depthTexture.format===w9)t.framebufferTexture2D(36160,36096,3553,o,0);else{if(e.depthTexture.format!==S9)throw new Error("Unknown depthTexture format");t.framebufferTexture2D(36160,33306,3553,o,0)}})(e.__webglFramebuffer,n)}else if(o){e.__webglDepthbuffer=[];for(let a=0;a<6;a++)t.bindFramebuffer(36160,e.__webglFramebuffer[a]),e.__webglDepthbuffer[a]=t.createRenderbuffer(),T(e.__webglDepthbuffer[a],n,!1)}else t.bindFramebuffer(36160,e.__webglFramebuffer),e.__webglDepthbuffer=t.createRenderbuffer(),T(e.__webglDepthbuffer,n,!1);t.bindFramebuffer(36160,null)})(n)},this.updateRenderTargetMipmap=function j(t){const n=t.texture;if(_(n,h(t)||c)){const o=t.isWebGLCubeRenderTarget?34067:3553,r=a.get(n).__webglTexture;e.bindTexture(o,r),C(o,n,t.width,t.height),e.bindTexture(o,null)}},this.updateMultisampleRenderTarget=function U(n){if(n.isWebGLMultisampleRenderTarget)if(c){const e=a.get(n);t.bindFramebuffer(36008,e.__webglMultisampledFramebuffer),t.bindFramebuffer(36009,e.__webglFramebuffer);const o=n.width,r=n.height;let i=16384;n.depthBuffer&&(i|=256),n.stencilBuffer&&(i|=1024),t.blitFramebuffer(0,0,o,r,0,0,o,r,i,9728),t.bindFramebuffer(36160,e.__webglMultisampledFramebuffer)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")},this.safeSetTexture2D=function W(t,n){t&&t.isWebGLRenderTarget&&(!1===I&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),I=!0),t=t.texture),k(t,n)},this.safeSetTextureCube=function G(t,n){t&&t.isWebGLCubeRenderTarget&&(!1===N&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),N=!0),t=t.texture),v(t,n)}}function Rot(t,n,e){const a=e.isWebGL2;return{convert:function o(t){let e;if(1009===t)return 5121;if(1017===t)return 32819;if(1018===t)return 32820;if(1019===t)return 33635;if(1010===t)return 5120;if(1011===t)return 5122;if(t===M9)return 5123;if(1013===t)return 5124;if(t===O9)return 5125;if(t===P9)return 5126;if(t===x9)return a?5131:(e=n.get("OES_texture_half_float"),null!==e?e.HALF_FLOAT_OES:null);if(1021===t)return 6406;if(t===k9)return 6407;if(t===v9)return 6408;if(1024===t)return 6409;if(1025===t)return 6410;if(t===w9)return 6402;if(t===S9)return 34041;if(1028===t)return 6403;if(1029===t)return 36244;if(1030===t)return 33319;if(1031===t)return 33320;if(1032===t)return 36248;if(1033===t)return 36249;if(33776===t||33777===t||33778===t||33779===t){if(e=n.get("WEBGL_compressed_texture_s3tc"),null===e)return null;if(33776===t)return e.COMPRESSED_RGB_S3TC_DXT1_EXT;if(33777===t)return e.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(33778===t)return e.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(33779===t)return e.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(35840===t||35841===t||35842===t||35843===t){if(e=n.get("WEBGL_compressed_texture_pvrtc"),null===e)return null;if(35840===t)return e.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(35841===t)return e.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(35842===t)return e.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(35843===t)return e.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(36196===t)return e=n.get("WEBGL_compressed_texture_etc1"),null!==e?e.COMPRESSED_RGB_ETC1_WEBGL:null;if((37492===t||37496===t)&&(e=n.get("WEBGL_compressed_texture_etc"),null!==e)){if(37492===t)return e.COMPRESSED_RGB8_ETC2;if(37496===t)return e.COMPRESSED_RGBA8_ETC2_EAC}return 37808===t||37809===t||37810===t||37811===t||37812===t||37813===t||37814===t||37815===t||37816===t||37817===t||37818===t||37819===t||37820===t||37821===t||37840===t||37841===t||37842===t||37843===t||37844===t||37845===t||37846===t||37847===t||37848===t||37849===t||37850===t||37851===t||37852===t||37853===t?(e=n.get("WEBGL_compressed_texture_astc"),null!==e?t:null):36492===t?(e=n.get("EXT_texture_compression_bptc"),null!==e?t:null):t===y9?a?34042:(e=n.get("WEBGL_depth_texture"),null!==e?e.UNSIGNED_INT_24_8_WEBGL:null):void 0}}}function Tot(t=[]){Pet.call(this),this.cameras=t}function Dot(){$tt.call(this),this.type="Group"}function Iot(){this._targetRay=null,this._grip=null,this._hand=null}function Not(t,n){const e=this;let a=null,o=1,r=null,i="local-floor",c=null;const s=[],l=new Map,m=new Pet;m.layers.enable(1),m.viewport=new Q9;const d=new Pet;d.layers.enable(2),d.viewport=new Q9;const g=[m,d],p=new Tot;p.layers.enable(1),p.layers.enable(2);let b=null,u=null;function f(t){const n=l.get(t.inputSource);n&&n.dispatchEvent({type:t.type,data:t.inputSource})}function h(){l.forEach((function(t,n){t.disconnect(n)})),l.clear(),b=null,u=null,t.setFramebuffer(null),t.setRenderTarget(t.getRenderTarget()),x.stop(),e.isPresenting=!1,e.dispatchEvent({type:"sessionend"})}function _(t){const n=a.inputSources;for(let t=0;t<s.length;t++)l.set(n[t],s[t]);for(let n=0;n<t.removed.length;n++){const e=t.removed[n],a=l.get(e);a&&(a.dispatchEvent({type:"disconnected",data:e}),l.delete(e))}for(let n=0;n<t.added.length;n++){const e=t.added[n],a=l.get(e);a&&a.dispatchEvent({type:"connected",data:e})}}this.enabled=!1,this.isPresenting=!1,this.getController=function(t){let n=s[t];return void 0===n&&(n=new Iot,s[t]=n),n.getTargetRaySpace()},this.getControllerGrip=function(t){let n=s[t];return void 0===n&&(n=new Iot,s[t]=n),n.getGripSpace()},this.getHand=function(t){let n=s[t];return void 0===n&&(n=new Iot,s[t]=n),n.getHandSpace()},this.setFramebufferScaleFactor=function(t){o=t,!0===e.isPresenting&&console.warn("THREE.WebXRManager: Cannot change framebuffer scale while presenting.")},this.setReferenceSpaceType=function(t){i=t,!0===e.isPresenting&&console.warn("THREE.WebXRManager: Cannot change reference space type while presenting.")},this.getReferenceSpace=function(){return r},this.getSession=function(){return a},this.setSession=async function(t){if(a=t,null!==a){a.addEventListener("select",f),a.addEventListener("selectstart",f),a.addEventListener("selectend",f),a.addEventListener("squeeze",f),a.addEventListener("squeezestart",f),a.addEventListener("squeezeend",f),a.addEventListener("end",h),a.addEventListener("inputsourceschange",_);const t=n.getContextAttributes();!0!==t.xrCompatible&&await n.makeXRCompatible();const c=new XRWebGLLayer(a,n,{antialias:t.antialias,alpha:t.alpha,depth:t.depth,stencil:t.stencil,framebufferScaleFactor:o});a.updateRenderState({baseLayer:c}),r=await a.requestReferenceSpace(i),x.setContext(a),x.start(),e.isPresenting=!0,e.dispatchEvent({type:"sessionstart"})}};const C=new ttt,M=new ttt;function O(t,n){null===n?t.matrixWorld.copy(t.matrix):t.matrixWorld.multiplyMatrices(n.matrixWorld,t.matrix),t.matrixWorldInverse.copy(t.matrixWorld).invert()}this.getCamera=function(t){p.near=d.near=m.near=t.near,p.far=d.far=m.far=t.far,b===p.near&&u===p.far||(a.updateRenderState({depthNear:p.near,depthFar:p.far}),b=p.near,u=p.far);const n=t.parent,e=p.cameras;O(p,n);for(let t=0;t<e.length;t++)O(e[t],n);t.matrixWorld.copy(p.matrixWorld),t.matrix.copy(p.matrix),t.matrix.decompose(t.position,t.quaternion,t.scale);const o=t.children;for(let t=0,n=o.length;t<n;t++)o[t].updateMatrixWorld(!0);return 2===e.length?(function r(t,n,e){C.setFromMatrixPosition(n.matrixWorld),M.setFromMatrixPosition(e.matrixWorld);const a=C.distanceTo(M),o=n.projectionMatrix.elements,r=e.projectionMatrix.elements,i=o[14]/(o[10]-1),c=o[14]/(o[10]+1),s=(o[9]+1)/o[5],l=(o[9]-1)/o[5],m=(o[8]-1)/o[0],d=(r[8]+1)/r[0],g=i*m,p=i*d,b=a/(-m+d),u=b*-m;n.matrixWorld.decompose(t.position,t.quaternion,t.scale),t.translateX(u),t.translateZ(b),t.matrixWorld.compose(t.position,t.quaternion,t.scale),t.matrixWorldInverse.copy(t.matrixWorld).invert();const f=i+b,h=c+b;t.projectionMatrix.makePerspective(g-u,p+(a-u),s*c/h*f,l*c/h*f,f,h)})(p,m,d):p.projectionMatrix.copy(m.projectionMatrix),p};let P=null;const x=new Ret;x.setAnimationLoop((function y(n,e){if(c=e.getViewerPose(r),null!==c){const n=c.views,e=a.renderState.baseLayer;t.setFramebuffer(e.framebuffer);let o=!1;n.length!==p.cameras.length&&(p.cameras.length=0,o=!0);for(let t=0;t<n.length;t++){const a=n[t],r=e.getViewport(a),i=g[t];i.matrix.fromArray(a.transform.matrix),i.projectionMatrix.fromArray(a.projectionMatrix),i.viewport.set(r.x,r.y,r.width,r.height),0===t&&p.matrix.copy(i.matrix),!0===o&&p.cameras.push(i)}}const o=a.inputSources;for(let t=0;t<s.length;t++)s[t].update(o[t],e,r);P&&P(n,e)})),this.setAnimationLoop=function(t){P=t},this.dispose=function(){}}function Fot(t){function n(n,e){n.opacity.value=e.opacity,e.color&&n.diffuse.value.copy(e.color),e.emissive&&n.emissive.value.copy(e.emissive).multiplyScalar(e.emissiveIntensity),e.map&&(n.map.value=e.map),e.alphaMap&&(n.alphaMap.value=e.alphaMap),e.specularMap&&(n.specularMap.value=e.specularMap);const a=t.get(e).envMap;if(a){n.envMap.value=a,n.flipEnvMap.value=a.isCubeTexture&&a._needsFlipEnvMap?-1:1,n.reflectivity.value=e.reflectivity,n.refractionRatio.value=e.refractionRatio;const o=t.get(a).__maxMipLevel;void 0!==o&&(n.maxMipLevel.value=o)}let o,r;e.lightMap&&(n.lightMap.value=e.lightMap,n.lightMapIntensity.value=e.lightMapIntensity),e.aoMap&&(n.aoMap.value=e.aoMap,n.aoMapIntensity.value=e.aoMapIntensity),e.map?o=e.map:e.specularMap?o=e.specularMap:e.displacementMap?o=e.displacementMap:e.normalMap?o=e.normalMap:e.bumpMap?o=e.bumpMap:e.roughnessMap?o=e.roughnessMap:e.metalnessMap?o=e.metalnessMap:e.alphaMap?o=e.alphaMap:e.emissiveMap?o=e.emissiveMap:e.clearcoatMap?o=e.clearcoatMap:e.clearcoatNormalMap?o=e.clearcoatNormalMap:e.clearcoatRoughnessMap&&(o=e.clearcoatRoughnessMap),void 0!==o&&(o.isWebGLRenderTarget&&(o=o.texture),!0===o.matrixAutoUpdate&&o.updateMatrix(),n.uvTransform.value.copy(o.matrix)),e.aoMap?r=e.aoMap:e.lightMap&&(r=e.lightMap),void 0!==r&&(r.isWebGLRenderTarget&&(r=r.texture),!0===r.matrixAutoUpdate&&r.updateMatrix(),n.uv2Transform.value.copy(r.matrix))}function e(n,e){n.roughness.value=e.roughness,n.metalness.value=e.metalness,e.roughnessMap&&(n.roughnessMap.value=e.roughnessMap),e.metalnessMap&&(n.metalnessMap.value=e.metalnessMap),e.emissiveMap&&(n.emissiveMap.value=e.emissiveMap),e.bumpMap&&(n.bumpMap.value=e.bumpMap,n.bumpScale.value=e.bumpScale,1===e.side&&(n.bumpScale.value*=-1)),e.normalMap&&(n.normalMap.value=e.normalMap,n.normalScale.value.copy(e.normalScale),1===e.side&&n.normalScale.value.negate()),e.displacementMap&&(n.displacementMap.value=e.displacementMap,n.displacementScale.value=e.displacementScale,n.displacementBias.value=e.displacementBias),t.get(e).envMap&&(n.envMapIntensity.value=e.envMapIntensity)}return{refreshFogUniforms:function a(t,n){t.fogColor.value.copy(n.color),n.isFog?(t.fogNear.value=n.near,t.fogFar.value=n.far):n.isFogExp2&&(t.fogDensity.value=n.density)},refreshMaterialUniforms:function o(t,a,r,i){a.isMeshBasicMaterial?n(t,a):a.isMeshLambertMaterial?(n(t,a),(function c(t,n){n.emissiveMap&&(t.emissiveMap.value=n.emissiveMap)})(t,a)):a.isMeshToonMaterial?(n(t,a),(function s(t,n){n.gradientMap&&(t.gradientMap.value=n.gradientMap),n.emissiveMap&&(t.emissiveMap.value=n.emissiveMap),n.bumpMap&&(t.bumpMap.value=n.bumpMap,t.bumpScale.value=n.bumpScale,1===n.side&&(t.bumpScale.value*=-1)),n.normalMap&&(t.normalMap.value=n.normalMap,t.normalScale.value.copy(n.normalScale),1===n.side&&t.normalScale.value.negate()),n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias)})(t,a)):a.isMeshPhongMaterial?(n(t,a),(function l(t,n){t.specular.value.copy(n.specular),t.shininess.value=Math.max(n.shininess,1e-4),n.emissiveMap&&(t.emissiveMap.value=n.emissiveMap),n.bumpMap&&(t.bumpMap.value=n.bumpMap,t.bumpScale.value=n.bumpScale,1===n.side&&(t.bumpScale.value*=-1)),n.normalMap&&(t.normalMap.value=n.normalMap,t.normalScale.value.copy(n.normalScale),1===n.side&&t.normalScale.value.negate()),n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias)})(t,a)):a.isMeshStandardMaterial?(n(t,a),a.isMeshPhysicalMaterial?(function m(t,n){e(t,n),t.reflectivity.value=n.reflectivity,t.clearcoat.value=n.clearcoat,t.clearcoatRoughness.value=n.clearcoatRoughness,n.sheen&&t.sheen.value.copy(n.sheen),n.clearcoatMap&&(t.clearcoatMap.value=n.clearcoatMap),n.clearcoatRoughnessMap&&(t.clearcoatRoughnessMap.value=n.clearcoatRoughnessMap),n.clearcoatNormalMap&&(t.clearcoatNormalScale.value.copy(n.clearcoatNormalScale),t.clearcoatNormalMap.value=n.clearcoatNormalMap,1===n.side&&t.clearcoatNormalScale.value.negate()),t.transmission.value=n.transmission,n.transmissionMap&&(t.transmissionMap.value=n.transmissionMap)})(t,a):e(t,a)):a.isMeshMatcapMaterial?(n(t,a),(function d(t,n){n.matcap&&(t.matcap.value=n.matcap),n.bumpMap&&(t.bumpMap.value=n.bumpMap,t.bumpScale.value=n.bumpScale,1===n.side&&(t.bumpScale.value*=-1)),n.normalMap&&(t.normalMap.value=n.normalMap,t.normalScale.value.copy(n.normalScale),1===n.side&&t.normalScale.value.negate()),n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias)})(t,a)):a.isMeshDepthMaterial?(n(t,a),(function g(t,n){n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias)})(t,a)):a.isMeshDistanceMaterial?(n(t,a),(function p(t,n){n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias),t.referencePosition.value.copy(n.referencePosition),t.nearDistance.value=n.nearDistance,t.farDistance.value=n.farDistance})(t,a)):a.isMeshNormalMaterial?(n(t,a),(function b(t,n){n.bumpMap&&(t.bumpMap.value=n.bumpMap,t.bumpScale.value=n.bumpScale,1===n.side&&(t.bumpScale.value*=-1)),n.normalMap&&(t.normalMap.value=n.normalMap,t.normalScale.value.copy(n.normalScale),1===n.side&&t.normalScale.value.negate()),n.displacementMap&&(t.displacementMap.value=n.displacementMap,t.displacementScale.value=n.displacementScale,t.displacementBias.value=n.displacementBias)})(t,a)):a.isLineBasicMaterial?((function u(t,n){t.diffuse.value.copy(n.color),t.opacity.value=n.opacity})(t,a),a.isLineDashedMaterial&&(function f(t,n){t.dashSize.value=n.dashSize,t.totalSize.value=n.dashSize+n.gapSize,t.scale.value=n.scale})(t,a)):a.isPointsMaterial?(function h(t,n,e,a){let o;t.diffuse.value.copy(n.color),t.opacity.value=n.opacity,t.size.value=n.size*e,t.scale.value=.5*a,n.map&&(t.map.value=n.map),n.alphaMap&&(t.alphaMap.value=n.alphaMap),n.map?o=n.map:n.alphaMap&&(o=n.alphaMap),void 0!==o&&(!0===o.matrixAutoUpdate&&o.updateMatrix(),t.uvTransform.value.copy(o.matrix))})(t,a,r,i):a.isSpriteMaterial?(function _(t,n){let e;t.diffuse.value.copy(n.color),t.opacity.value=n.opacity,t.rotation.value=n.rotation,n.map&&(t.map.value=n.map),n.alphaMap&&(t.alphaMap.value=n.alphaMap),n.map?e=n.map:n.alphaMap&&(e=n.alphaMap),void 0!==e&&(!0===e.matrixAutoUpdate&&e.updateMatrix(),t.uvTransform.value.copy(e.matrix))})(t,a):a.isShadowMaterial?(t.color.value.copy(a.color),t.opacity.value=a.opacity):a.isShaderMaterial&&(a.uniformsNeedUpdate=!1)}}}function Lot(t){const n=void 0!==(t=t||{}).canvas?t.canvas:(function e(){const t=document.createElementNS("http://www.w3.org/1999/xhtml","canvas");return t.style.display="block",t})(),a=void 0!==t.context?t.context:null,o=void 0!==t.alpha&&t.alpha,r=void 0===t.depth||t.depth,i=void 0===t.stencil||t.stencil,c=void 0!==t.antialias&&t.antialias,s=void 0===t.premultipliedAlpha||t.premultipliedAlpha,l=void 0!==t.preserveDrawingBuffer&&t.preserveDrawingBuffer,m=void 0!==t.powerPreference?t.powerPreference:"default",d=void 0!==t.failIfMajorPerformanceCaveat&&t.failIfMajorPerformanceCaveat;let g=null,p=null;const b=[];this.domElement=n,this.debug={checkShaderErrors:!0},this.autoClear=!0,this.autoClearColor=!0,this.autoClearDepth=!0,this.autoClearStencil=!0,this.sortObjects=!0,this.clippingPlanes=[],this.localClippingEnabled=!1,this.gammaFactor=2,this.outputEncoding=I9,this.physicallyCorrectLights=!1,this.toneMapping=0,this.toneMappingExposure=1,this.maxMorphTargets=8,this.maxMorphNormals=4;const u=this;let f=!1,h=null,_=0,C=0,M=null,O=null,P=-1,x=null;const y=new Q9,k=new Q9;let v=null,w=n.width,S=n.height,E=1,A=null,z=null;const R=new Q9(0,0,w,S),T=new Q9(0,0,w,S);let D=!1;const I=new zet;let N=!1,F=!1;const L=new Stt,H=new ttt,B={background:null,fog:null,environment:null,overrideMaterial:null,isScene:!0};function V(){return null===M?E:1}let j,U,W,G,Y,q,Z,X,J,Q,K,$,tt,nt,et,at,ot,rt,it,ct,st,lt=a;function mt(t,e){for(let a=0;a<t.length;a++){const o=n.getContext(t[a],e);if(null!==o)return o}return null}try{const t={alpha:o,depth:r,stencil:i,antialias:c,premultipliedAlpha:s,preserveDrawingBuffer:l,powerPreference:m,failIfMajorPerformanceCaveat:d};if(n.addEventListener("webglcontextlost",bt,!1),n.addEventListener("webglcontextrestored",ut,!1),null===lt){const n=["webgl2","webgl","experimental-webgl"];if(!0===u.isWebGL1Renderer&&n.shift(),lt=mt(n,t),null===lt)throw mt(n)?new Error("Error creating WebGL context with your selected attributes."):new Error("Error creating WebGL context.")}void 0===lt.getShaderPrecisionFormat&&(lt.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(t){throw console.error("THREE.WebGLRenderer: "+t.message),t}function dt(){j=new Wet(lt),U=new Vet(lt,j,t),j.init(U),ct=new Rot(lt,j,U),W=new Aot(lt,j,U),W.scissor(k.copy(T).multiplyScalar(E).floor()),W.viewport(y.copy(R).multiplyScalar(E).floor()),G=new qet(lt),Y=new fot,q=new zot(lt,j,W,Y,U,ct,G),Z=new Uet(u),X=new Tet(lt,U),st=new Het(lt,j,X,U),J=new Get(lt,X,G,st),Q=new Qet(lt,J,X,G),ot=new Jet(lt),et=new jet(Y),K=new uot(u,Z,j,U,st,et),$=new Fot(Y),tt=new Mot(Y),nt=new vot(j,U),at=new Let(u,Z,W,Q,s),rt=new Bet(lt,j,G,U),it=new Yet(lt,j,G,U),G.programs=K.programs,u.capabilities=U,u.extensions=j,u.properties=Y,u.renderLists=tt,u.state=W,u.info=G}dt();const gt=new Not(u,lt);this.xr=gt;const pt=new Eot(u,Q,U.maxTextureSize);function bt(t){t.preventDefault(),console.log("THREE.WebGLRenderer: Context Lost."),f=!0}function ut(){console.log("THREE.WebGLRenderer: Context Restored."),f=!1,dt()}function ft(t){const n=t.target;n.removeEventListener("dispose",ft),(function e(t){ht(t),Y.remove(t)})(n)}function ht(t){const n=Y.get(t).program;void 0!==n&&K.releaseProgram(n)}this.shadowMap=pt,this.getContext=function(){return lt},this.getContextAttributes=function(){return lt.getContextAttributes()},this.forceContextLoss=function(){const t=j.get("WEBGL_lose_context");t&&t.loseContext()},this.forceContextRestore=function(){const t=j.get("WEBGL_lose_context");t&&t.restoreContext()},this.getPixelRatio=function(){return E},this.setPixelRatio=function(t){void 0!==t&&(E=t,this.setSize(w,S,!1))},this.getSize=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getsize() now requires a Vector2 as an argument"),t=new W9),t.set(w,S)},this.setSize=function(t,e,a){gt.isPresenting?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(w=t,S=e,n.width=Math.floor(t*E),n.height=Math.floor(e*E),!1!==a&&(n.style.width=t+"px",n.style.height=e+"px"),this.setViewport(0,0,t,e))},this.getDrawingBufferSize=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument"),t=new W9),t.set(w*E,S*E).floor()},this.setDrawingBufferSize=function(t,e,a){w=t,S=e,E=a,n.width=Math.floor(t*a),n.height=Math.floor(e*a),this.setViewport(0,0,t,e)},this.getCurrentViewport=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument"),t=new Q9),t.copy(y)},this.getViewport=function(t){return t.copy(R)},this.setViewport=function(t,n,e,a){t.isVector4?R.set(t.x,t.y,t.z,t.w):R.set(t,n,e,a),W.viewport(y.copy(R).multiplyScalar(E).floor())},this.getScissor=function(t){return t.copy(T)},this.setScissor=function(t,n,e,a){t.isVector4?T.set(t.x,t.y,t.z,t.w):T.set(t,n,e,a),W.scissor(k.copy(T).multiplyScalar(E).floor())},this.getScissorTest=function(){return D},this.setScissorTest=function(t){W.setScissorTest(D=t)},this.setOpaqueSort=function(t){A=t},this.setTransparentSort=function(t){z=t},this.getClearColor=function(t){return void 0===t&&(console.warn("WebGLRenderer: .getClearColor() now requires a Color as an argument"),t=new Ont),t.copy(at.getClearColor())},this.setClearColor=function(){at.setClearColor.apply(at,arguments)},this.getClearAlpha=function(){return at.getClearAlpha()},this.setClearAlpha=function(){at.setClearAlpha.apply(at,arguments)},this.clear=function(t,n,e){let a=0;(void 0===t||t)&&(a|=16384),(void 0===n||n)&&(a|=256),(void 0===e||e)&&(a|=1024),lt.clear(a)},this.clearColor=function(){this.clear(!0,!1,!1)},this.clearDepth=function(){this.clear(!1,!0,!1)},this.clearStencil=function(){this.clear(!1,!1,!0)},this.dispose=function(){n.removeEventListener("webglcontextlost",bt,!1),n.removeEventListener("webglcontextrestored",ut,!1),tt.dispose(),nt.dispose(),Y.dispose(),Z.dispose(),Q.dispose(),st.dispose(),gt.dispose(),Ct.stop()},this.renderBufferImmediate=function(t,n){st.initAttributes();const e=Y.get(t);t.hasPositions&&!e.position&&(e.position=lt.createBuffer()),t.hasNormals&&!e.normal&&(e.normal=lt.createBuffer()),t.hasUvs&&!e.uv&&(e.uv=lt.createBuffer()),t.hasColors&&!e.color&&(e.color=lt.createBuffer());const a=n.getAttributes();t.hasPositions&&(lt.bindBuffer(34962,e.position),lt.bufferData(34962,t.positionArray,35048),st.enableAttribute(a.position),lt.vertexAttribPointer(a.position,3,5126,!1,0,0)),t.hasNormals&&(lt.bindBuffer(34962,e.normal),lt.bufferData(34962,t.normalArray,35048),st.enableAttribute(a.normal),lt.vertexAttribPointer(a.normal,3,5126,!1,0,0)),t.hasUvs&&(lt.bindBuffer(34962,e.uv),lt.bufferData(34962,t.uvArray,35048),st.enableAttribute(a.uv),lt.vertexAttribPointer(a.uv,2,5126,!1,0,0)),t.hasColors&&(lt.bindBuffer(34962,e.color),lt.bufferData(34962,t.colorArray,35048),st.enableAttribute(a.color),lt.vertexAttribPointer(a.color,3,5126,!1,0,0)),st.disableUnusedAttributes(),lt.drawArrays(4,0,t.count),t.count=0},this.renderBufferDirect=function(t,n,e,a,o,r){null===n&&(n=B);const i=o.isMesh&&o.matrixWorld.determinant()<0,c=yt(t,n,a,o);W.setMaterial(a,i);let s=e.index;const l=e.attributes.position;if(null===s){if(void 0===l||0===l.count)return}else if(0===s.count)return;let m,d=1;!0===a.wireframe&&(s=J.getWireframeAttribute(e),d=2),(a.morphTargets||a.morphNormals)&&ot.update(o,e,a,c),st.setup(o,a,c,e,s);let g=rt;null!==s&&(m=X.get(s),g=it,g.setIndex(m));const p=null!==s?s.count:l.count,b=e.drawRange.start*d,u=e.drawRange.count*d,f=null!==r?r.start*d:0,h=null!==r?r.count*d:1/0,_=Math.max(b,f),C=Math.min(p,b+u,f+h)-1,M=Math.max(0,C-_+1);if(0!==M){if(o.isMesh)!0===a.wireframe?(W.setLineWidth(a.wireframeLinewidth*V()),g.setMode(1)):g.setMode(4);else if(o.isLine){let t=a.linewidth;void 0===t&&(t=1),W.setLineWidth(t*V()),g.setMode(o.isLineSegments?1:o.isLineLoop?2:3)}else o.isPoints?g.setMode(0):o.isSprite&&g.setMode(4);if(o.isInstancedMesh)g.renderInstances(_,M,o.count);else if(e.isInstancedBufferGeometry){const t=Math.min(e.instanceCount,e._maxInstanceCount);g.renderInstances(_,M,t)}else g.render(_,M)}},this.compile=function(t,n){p=nt.get(t),p.init(),t.traverseVisible((function(t){t.isLight&&t.layers.test(n.layers)&&(p.pushLight(t),t.castShadow&&p.pushShadow(t))})),p.setupLights();const e=new WeakMap;t.traverse((function(n){const a=n.material;if(a)if(Array.isArray(a))for(let o=0;o<a.length;o++){const r=a[o];!1===e.has(r)&&(xt(r,t,n),e.set(r))}else!1===e.has(a)&&(xt(a,t,n),e.set(a))}))};let _t=null;const Ct=new Ret;function Mt(t,n,e,a){if(!1===t.visible)return;if(t.layers.test(n.layers))if(t.isGroup)e=t.renderOrder;else if(t.isLOD)!0===t.autoUpdate&&t.update(n);else if(t.isLight)p.pushLight(t),t.castShadow&&p.pushShadow(t);else if(t.isSprite){if(!t.frustumCulled||I.intersectsSprite(t)){a&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(L);const n=Q.update(t),o=t.material;o.visible&&g.push(t,n,o,e,H.z,null)}}else if(t.isImmediateRenderObject)a&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(L),g.push(t,null,t.material,e,H.z,null);else if((t.isMesh||t.isLine||t.isPoints)&&(t.isSkinnedMesh&&t.skeleton.frame!==G.render.frame&&(t.skeleton.update(),t.skeleton.frame=G.render.frame),!t.frustumCulled||I.intersectsObject(t))){a&&H.setFromMatrixPosition(t.matrixWorld).applyMatrix4(L);const n=Q.update(t),o=t.material;if(Array.isArray(o)){const a=n.groups;for(let r=0,i=a.length;r<i;r++){const i=a[r],c=o[i.materialIndex];c&&c.visible&&g.push(t,n,c,e,H.z,i)}}else o.visible&&g.push(t,n,o,e,H.z,null)}const o=t.children;for(let t=0,r=o.length;t<r;t++)Mt(o[t],n,e,a)}function Ot(t,n,e){const a=!0===n.isScene?n.overrideMaterial:null;for(let o=0,r=t.length;o<r;o++){const r=t[o],i=r.object,c=r.geometry,s=null===a?r.material:a,l=r.group;if(e.isArrayCamera){const t=e.cameras;for(let e=0,a=t.length;e<a;e++){const a=t[e];i.layers.test(a.layers)&&(W.viewport(y.copy(a.viewport)),p.setupLightsView(a),Pt(i,n,a,c,s,l))}}else Pt(i,n,e,c,s,l)}}function Pt(t,n,e,a,o,r){if(t.onBeforeRender(u,n,e,a,o,r),t.modelViewMatrix.multiplyMatrices(e.matrixWorldInverse,t.matrixWorld),t.normalMatrix.getNormalMatrix(t.modelViewMatrix),t.isImmediateRenderObject){const a=yt(e,n,o,t);W.setMaterial(o),st.reset(),(function i(t,n){t.render((function(t){u.renderBufferImmediate(t,n)}))})(t,a)}else u.renderBufferDirect(e,n,a,o,t,r);t.onAfterRender(u,n,e,a,o,r)}function xt(t,n,e){!0!==n.isScene&&(n=B);const a=Y.get(t),o=p.state.lights,r=o.state.version,i=K.getParameters(t,o.state,p.state.shadowsArray,n,e),c=K.getProgramCacheKey(i);let s=a.program,l=!0;if(a.environment=t.isMeshStandardMaterial?n.environment:null,a.fog=n.fog,a.envMap=Z.get(t.envMap||a.environment),void 0===s)t.addEventListener("dispose",ft);else if(s.cacheKey!==c)ht(t);else if(a.lightsStateVersion!==r)l=!1;else{if(void 0!==i.shaderID)return;l=!1}l&&(i.uniforms=K.getUniforms(t),t.onBeforeCompile(i,u),s=K.acquireProgram(i,c),a.program=s,a.uniforms=i.uniforms,a.outputEncoding=i.outputEncoding);const m=a.uniforms;(t.isShaderMaterial||t.isRawShaderMaterial)&&!0!==t.clipping||(a.numClippingPlanes=et.numPlanes,a.numIntersection=et.numIntersection,m.clippingPlanes=et.uniform),a.needsLights=(function d(t){return t.isMeshLambertMaterial||t.isMeshToonMaterial||t.isMeshPhongMaterial||t.isMeshStandardMaterial||t.isShadowMaterial||t.isShaderMaterial&&!0===t.lights})(t),a.lightsStateVersion=r,a.needsLights&&(m.ambientLightColor.value=o.state.ambient,m.lightProbe.value=o.state.probe,m.directionalLights.value=o.state.directional,m.directionalLightShadows.value=o.state.directionalShadow,m.spotLights.value=o.state.spot,m.spotLightShadows.value=o.state.spotShadow,m.rectAreaLights.value=o.state.rectArea,m.ltc_1.value=o.state.rectAreaLTC1,m.ltc_2.value=o.state.rectAreaLTC2,m.pointLights.value=o.state.point,m.pointLightShadows.value=o.state.pointShadow,m.hemisphereLights.value=o.state.hemi,m.directionalShadowMap.value=o.state.directionalShadowMap,m.directionalShadowMatrix.value=o.state.directionalShadowMatrix,m.spotShadowMap.value=o.state.spotShadowMap,m.spotShadowMatrix.value=o.state.spotShadowMatrix,m.pointShadowMap.value=o.state.pointShadowMap,m.pointShadowMatrix.value=o.state.pointShadowMatrix);const g=a.program.getUniforms(),b=Zat.seqWithValue(g.seq,m);a.uniformsList=b}function yt(t,n,e,a){!0!==n.isScene&&(n=B),q.resetTextureUnits();const o=n.fog,r=e.isMeshStandardMaterial?n.environment:null,i=null===M?u.outputEncoding:M.texture.encoding,c=Z.get(e.envMap||r),s=Y.get(e),l=p.state.lights;!0!==N||!0!==F&&t===x||et.setState(e,t,t===x&&e.id===P),e.version===s.__version?e.fog&&s.fog!==o||s.environment!==r||s.needsLights&&s.lightsStateVersion!==l.state.version?xt(e,n,a):void 0===s.numClippingPlanes||s.numClippingPlanes===et.numPlanes&&s.numIntersection===et.numIntersection?(s.outputEncoding!==i||s.envMap!==c)&&xt(e,n,a):xt(e,n,a):(xt(e,n,a),s.__version=e.version);let m=!1,d=!1,g=!1;const b=s.program,f=b.getUniforms(),h=s.uniforms;if(W.useProgram(b.program)&&(m=!0,d=!0,g=!0),e.id!==P&&(P=e.id,d=!0),m||x!==t){if(f.setValue(lt,"projectionMatrix",t.projectionMatrix),U.logarithmicDepthBuffer&&f.setValue(lt,"logDepthBufFC",2/(Math.log(t.far+1)/Math.LN2)),x!==t&&(x=t,d=!0,g=!0),e.isShaderMaterial||e.isMeshPhongMaterial||e.isMeshToonMaterial||e.isMeshStandardMaterial||e.envMap){const n=f.map.cameraPosition;void 0!==n&&n.setValue(lt,H.setFromMatrixPosition(t.matrixWorld))}(e.isMeshPhongMaterial||e.isMeshToonMaterial||e.isMeshLambertMaterial||e.isMeshBasicMaterial||e.isMeshStandardMaterial||e.isShaderMaterial)&&f.setValue(lt,"isOrthographic",!0===t.isOrthographicCamera),(e.isMeshPhongMaterial||e.isMeshToonMaterial||e.isMeshLambertMaterial||e.isMeshBasicMaterial||e.isMeshStandardMaterial||e.isShaderMaterial||e.isShadowMaterial||e.skinning)&&f.setValue(lt,"viewMatrix",t.matrixWorldInverse)}if(e.skinning){f.setOptional(lt,a,"bindMatrix"),f.setOptional(lt,a,"bindMatrixInverse");const t=a.skeleton;if(t){const n=t.bones;if(U.floatVertexTextures){if(null===t.boneTexture){let e=Math.sqrt(4*n.length);e=U9.ceilPowerOfTwo(e),e=Math.max(e,4);const a=new Float32Array(e*e*4);a.set(t.boneMatrices);const o=new wet(a,e,e,v9,P9);t.boneMatrices=a,t.boneTexture=o,t.boneTextureSize=e}f.setValue(lt,"boneTexture",t.boneTexture,q),f.setValue(lt,"boneTextureSize",t.boneTextureSize)}else f.setOptional(lt,t,"boneMatrices")}}return(d||s.receiveShadow!==a.receiveShadow)&&(s.receiveShadow=a.receiveShadow,f.setValue(lt,"receiveShadow",a.receiveShadow)),d&&(f.setValue(lt,"toneMappingExposure",u.toneMappingExposure),s.needsLights&&(function _(t,n){t.ambientLightColor.needsUpdate=n,t.lightProbe.needsUpdate=n,t.directionalLights.needsUpdate=n,t.directionalLightShadows.needsUpdate=n,t.pointLights.needsUpdate=n,t.pointLightShadows.needsUpdate=n,t.spotLights.needsUpdate=n,t.spotLightShadows.needsUpdate=n,t.rectAreaLights.needsUpdate=n,t.hemisphereLights.needsUpdate=n})(h,g),o&&e.fog&&$.refreshFogUniforms(h,o),$.refreshMaterialUniforms(h,e,E,S),Zat.upload(lt,s.uniformsList,h,q)),e.isShaderMaterial&&!0===e.uniformsNeedUpdate&&(Zat.upload(lt,s.uniformsList,h,q),e.uniformsNeedUpdate=!1),e.isSpriteMaterial&&f.setValue(lt,"center",a.center),f.setValue(lt,"modelViewMatrix",a.modelViewMatrix),f.setValue(lt,"normalMatrix",a.normalMatrix),f.setValue(lt,"modelMatrix",a.matrixWorld),b}Ct.setAnimationLoop((function kt(t){gt.isPresenting||_t&&_t(t)})),"undefined"!=typeof window&&Ct.setContext(window),this.setAnimationLoop=function(t){_t=t,gt.setAnimationLoop(t),null===t?Ct.stop():Ct.start()},this.render=function(t,n){let e,a;if(void 0!==arguments[2]&&(console.warn("THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead."),e=arguments[2]),void 0!==arguments[3]&&(console.warn("THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead."),a=arguments[3]),void 0!==n&&!0!==n.isCamera)return void console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.");if(!0===f)return;st.resetDefaultState(),P=-1,x=null,!0===t.autoUpdate&&t.updateMatrixWorld(),null===n.parent&&n.updateMatrixWorld(),!0===gt.enabled&&!0===gt.isPresenting&&(n=gt.getCamera(n)),!0===t.isScene&&t.onBeforeRender(u,t,n,e||M),p=nt.get(t,b.length),p.init(),b.push(p),L.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),I.setFromProjectionMatrix(L),F=this.localClippingEnabled,N=et.init(this.clippingPlanes,F,n),g=tt.get(t,n),g.init(),Mt(t,n,0,u.sortObjects),g.finish(),!0===u.sortObjects&&g.sort(A,z),!0===N&&et.beginShadows();const o=p.state.shadowsArray;pt.render(o,t,n),p.setupLights(),p.setupLightsView(n),!0===N&&et.endShadows(),!0===this.info.autoReset&&this.info.reset(),void 0!==e&&this.setRenderTarget(e),at.render(g,t,n,a);const r=g.opaque,i=g.transparent;r.length>0&&Ot(r,t,n),i.length>0&&Ot(i,t,n),!0===t.isScene&&t.onAfterRender(u,t,n),null!==M&&(q.updateRenderTargetMipmap(M),q.updateMultisampleRenderTarget(M)),W.buffers.depth.setTest(!0),W.buffers.depth.setMask(!0),W.buffers.color.setMask(!0),W.setPolygonOffset(!1),b.pop(),p=b.length>0?b[b.length-1]:null,g=null},this.setFramebuffer=function(t){h!==t&&null===M&&lt.bindFramebuffer(36160,t),h=t},this.getActiveCubeFace=function(){return _},this.getActiveMipmapLevel=function(){return C},this.getRenderList=function(){return g},this.setRenderList=function(t){g=t},this.getRenderTarget=function(){return M},this.setRenderTarget=function(t,n=0,e=0){M=t,_=n,C=e,t&&void 0===Y.get(t).__webglFramebuffer&&q.setupRenderTarget(t);let a=h,o=!1;if(t){const e=Y.get(t).__webglFramebuffer;t.isWebGLCubeRenderTarget?(a=e[n],o=!0):a=t.isWebGLMultisampleRenderTarget?Y.get(t).__webglMultisampledFramebuffer:e,y.copy(t.viewport),k.copy(t.scissor),v=t.scissorTest}else y.copy(R).multiplyScalar(E).floor(),k.copy(T).multiplyScalar(E).floor(),v=D;if(O!==a&&(lt.bindFramebuffer(36160,a),O=a),W.viewport(y),W.scissor(k),W.setScissorTest(v),o){const a=Y.get(t.texture);lt.framebufferTexture2D(36160,36064,34069+n,a.__webglTexture,e)}},this.readRenderTargetPixels=function(t,n,e,a,o,r,i){if(!t||!t.isWebGLRenderTarget)return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.");let c=Y.get(t).__webglFramebuffer;if(t.isWebGLCubeRenderTarget&&void 0!==i&&(c=c[i]),c){let i=!1;c!==O&&(lt.bindFramebuffer(36160,c),i=!0);try{const c=t.texture,s=c.format,l=c.type;if(s!==v9&&ct.convert(s)!==lt.getParameter(35739))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.");const m=l===x9&&(j.has("EXT_color_buffer_half_float")||U.isWebGL2&&j.has("EXT_color_buffer_float"));if(!(1009===l||ct.convert(l)===lt.getParameter(35738)||l===P9&&(U.isWebGL2||j.has("OES_texture_float")||j.has("WEBGL_color_buffer_float"))||m))return void console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.");36053===lt.checkFramebufferStatus(36160)?n>=0&&n<=t.width-a&&e>=0&&e<=t.height-o&&lt.readPixels(n,e,a,o,ct.convert(s),ct.convert(l),r):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.")}finally{i&&lt.bindFramebuffer(36160,O)}}},this.copyFramebufferToTexture=function(t,n,e=0){const a=Math.pow(2,-e),o=Math.floor(n.image.width*a),r=Math.floor(n.image.height*a),i=ct.convert(n.format);q.setTexture2D(n,0),lt.copyTexImage2D(3553,e,i,t.x,t.y,o,r,0),W.unbindTexture()},this.copyTextureToTexture=function(t,n,e,a=0){const o=n.image.width,r=n.image.height,i=ct.convert(e.format),c=ct.convert(e.type);q.setTexture2D(e,0),lt.pixelStorei(37440,e.flipY),lt.pixelStorei(37441,e.premultiplyAlpha),lt.pixelStorei(3317,e.unpackAlignment),n.isDataTexture?lt.texSubImage2D(3553,a,t.x,t.y,o,r,i,c,n.image.data):n.isCompressedTexture?lt.compressedTexSubImage2D(3553,a,t.x,t.y,n.mipmaps[0].width,n.mipmaps[0].height,i,n.mipmaps[0].data):lt.texSubImage2D(3553,a,t.x,t.y,i,c,n.image),0===a&&e.generateMipmaps&&lt.generateMipmap(3553),W.unbindTexture()},this.initTexture=function(t){q.setTexture2D(t,0),W.unbindTexture()},this.resetState=function(){W.reset(),st.reset()},"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function Hot(t){Lot.call(this,t)}(wot.prototype=Object.create(ynt.prototype)).constructor=wot,wot.prototype.isMeshDepthMaterial=!0,wot.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.depthPacking=t.depthPacking,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this},(Sot.prototype=Object.create(ynt.prototype)).constructor=Sot,Sot.prototype.isMeshDistanceMaterial=!0,Sot.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.referencePosition.copy(t.referencePosition),this.nearDistance=t.nearDistance,this.farDistance=t.farDistance,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.map=t.map,this.alphaMap=t.alphaMap,this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this},Tot.prototype=Object.assign(Object.create(Pet.prototype),{constructor:Tot,isArrayCamera:!0}),Dot.prototype=Object.assign(Object.create($tt.prototype),{constructor:Dot,isGroup:!0}),Object.assign(Iot.prototype,{constructor:Iot,getHandSpace:function(){return null===this._hand&&(this._hand=new Dot,this._hand.matrixAutoUpdate=!1,this._hand.visible=!1,this._hand.joints={},this._hand.inputState={pinching:!1}),this._hand},getTargetRaySpace:function(){return null===this._targetRay&&(this._targetRay=new Dot,this._targetRay.matrixAutoUpdate=!1,this._targetRay.visible=!1),this._targetRay},getGripSpace:function(){return null===this._grip&&(this._grip=new Dot,this._grip.matrixAutoUpdate=!1,this._grip.visible=!1),this._grip},dispatchEvent:function(t){return null!==this._targetRay&&this._targetRay.dispatchEvent(t),null!==this._grip&&this._grip.dispatchEvent(t),null!==this._hand&&this._hand.dispatchEvent(t),this},disconnect:function(t){return this.dispatchEvent({type:"disconnected",data:t}),null!==this._targetRay&&(this._targetRay.visible=!1),null!==this._grip&&(this._grip.visible=!1),null!==this._hand&&(this._hand.visible=!1),this},update:function(t,n,e){let a=null,o=null,r=null;const i=this._targetRay,c=this._grip,s=this._hand;if(t&&"visible-blurred"!==n.session.visibilityState)if(s&&t.hand){r=!0;for(const a of t.hand.values()){const t=n.getJointPose(a,e);if(void 0===s.joints[a.jointName]){const t=new Dot;t.matrixAutoUpdate=!1,t.visible=!1,s.joints[a.jointName]=t,s.add(t)}const o=s.joints[a.jointName];null!==t&&(o.matrix.fromArray(t.transform.matrix),o.matrix.decompose(o.position,o.rotation,o.scale),o.jointRadius=t.radius),o.visible=null!==t}const a=s.joints["index-finger-tip"].position.distanceTo(s.joints["thumb-tip"].position),o=.02,i=.005;s.inputState.pinching&&a>o+i?(s.inputState.pinching=!1,this.dispatchEvent({type:"pinchend",handedness:t.handedness,target:this})):!s.inputState.pinching&&a<=o-i&&(s.inputState.pinching=!0,this.dispatchEvent({type:"pinchstart",handedness:t.handedness,target:this}))}else null!==i&&(a=n.getPose(t.targetRaySpace,e),null!==a&&(i.matrix.fromArray(a.transform.matrix),i.matrix.decompose(i.position,i.rotation,i.scale))),null!==c&&t.gripSpace&&(o=n.getPose(t.gripSpace,e),null!==o&&(c.matrix.fromArray(o.transform.matrix),c.matrix.decompose(c.position,c.rotation,c.scale)));return null!==i&&(i.visible=null!==a),null!==c&&(c.visible=null!==o),null!==s&&(s.visible=null!==r),this}}),Object.assign(Not.prototype,B9.prototype),Hot.prototype=Object.assign(Object.create(Lot.prototype),{constructor:Hot,isWebGL1Renderer:!0});class Bot extends $tt{constructor(){super(),Object.defineProperty(this,"isScene",{value:!0}),this.type="Scene",this.background=null,this.environment=null,this.fog=null,this.overrideMaterial=null,this.autoUpdate=!0,"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}copy(t,n){return super.copy(t,n),null!==t.background&&(this.background=t.background.clone()),null!==t.environment&&(this.environment=t.environment.clone()),null!==t.fog&&(this.fog=t.fog.clone()),null!==t.overrideMaterial&&(this.overrideMaterial=t.overrideMaterial.clone()),this.autoUpdate=t.autoUpdate,this.matrixAutoUpdate=t.matrixAutoUpdate,this}toJSON(t){const n=super.toJSON(t);return null!==this.background&&(n.object.background=this.background.toJSON(t)),null!==this.environment&&(n.object.environment=this.environment.toJSON(t)),null!==this.fog&&(n.object.fog=this.fog.toJSON()),n}}function Vot(t,n){this.array=t,this.stride=n,this.count=void 0!==t?t.length/n:0,this.usage=F9,this.updateRange={offset:0,count:-1},this.version=0,this.uuid=U9.generateUUID()}Object.defineProperty(Vot.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(Vot.prototype,{isInterleavedBuffer:!0,onUploadCallback:function(){},setUsage:function(t){return this.usage=t,this},copy:function(t){return this.array=new t.array.constructor(t.array),this.count=t.count,this.stride=t.stride,this.usage=t.usage,this},copyAt:function(t,n,e){t*=this.stride,e*=n.stride;for(let a=0,o=this.stride;a<o;a++)this.array[t+a]=n.array[e+a];return this},set:function(t,n=0){return this.array.set(t,n),this},clone:function(t){void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=U9.generateUUID()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=this.array.slice(0).buffer);const n=new Vot(new this.array.constructor(t.arrayBuffers[this.array.buffer._uuid]),this.stride);return n.setUsage(this.usage),n},onUpload:function(t){return this.onUploadCallback=t,this},toJSON:function(t){return void 0===t.arrayBuffers&&(t.arrayBuffers={}),void 0===this.array.buffer._uuid&&(this.array.buffer._uuid=U9.generateUUID()),void 0===t.arrayBuffers[this.array.buffer._uuid]&&(t.arrayBuffers[this.array.buffer._uuid]=Array.prototype.slice.call(new Uint32Array(this.array.buffer))),{uuid:this.uuid,buffer:this.array.buffer._uuid,type:this.array.constructor.name,stride:this.stride}}});const jot=new ttt;function Uot(t,n,e,a){this.name="",this.data=t,this.itemSize=n,this.offset=e,this.normalized=!0===a}function Wot(t){ynt.call(this),this.type="SpriteMaterial",this.color=new Ont(16777215),this.map=null,this.alphaMap=null,this.rotation=0,this.sizeAttenuation=!0,this.transparent=!0,this.setValues(t)}let Got;Object.defineProperties(Uot.prototype,{count:{get:function(){return this.data.count}},array:{get:function(){return this.data.array}},needsUpdate:{set:function(t){this.data.needsUpdate=t}}}),Object.assign(Uot.prototype,{isInterleavedBufferAttribute:!0,applyMatrix4:function(t){for(let n=0,e=this.data.count;n<e;n++)jot.x=this.getX(n),jot.y=this.getY(n),jot.z=this.getZ(n),jot.applyMatrix4(t),this.setXYZ(n,jot.x,jot.y,jot.z);return this},setX:function(t,n){return this.data.array[t*this.data.stride+this.offset]=n,this},setY:function(t,n){return this.data.array[t*this.data.stride+this.offset+1]=n,this},setZ:function(t,n){return this.data.array[t*this.data.stride+this.offset+2]=n,this},setW:function(t,n){return this.data.array[t*this.data.stride+this.offset+3]=n,this},getX:function(t){return this.data.array[t*this.data.stride+this.offset]},getY:function(t){return this.data.array[t*this.data.stride+this.offset+1]},getZ:function(t){return this.data.array[t*this.data.stride+this.offset+2]},getW:function(t){return this.data.array[t*this.data.stride+this.offset+3]},setXY:function(t,n,e){return this.data.array[(t=t*this.data.stride+this.offset)+0]=n,this.data.array[t+1]=e,this},setXYZ:function(t,n,e,a){return this.data.array[(t=t*this.data.stride+this.offset)+0]=n,this.data.array[t+1]=e,this.data.array[t+2]=a,this},setXYZW:function(t,n,e,a,o){return this.data.array[(t=t*this.data.stride+this.offset)+0]=n,this.data.array[t+1]=e,this.data.array[t+2]=a,this.data.array[t+3]=o,this},clone:function(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.");const t=[];for(let n=0;n<this.count;n++){const e=n*this.data.stride+this.offset;for(let n=0;n<this.itemSize;n++)t.push(this.data.array[e+n])}return new Snt(new this.array.constructor(t),this.itemSize,this.normalized)}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.clone(t)),new Uot(t.interleavedBuffers[this.data.uuid],this.itemSize,this.offset,this.normalized)},toJSON:function(t){if(void 0===t){console.log("THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.");const t=[];for(let n=0;n<this.count;n++){const e=n*this.data.stride+this.offset;for(let n=0;n<this.itemSize;n++)t.push(this.data.array[e+n])}return{itemSize:this.itemSize,type:this.array.constructor.name,array:t,normalized:this.normalized}}return void 0===t.interleavedBuffers&&(t.interleavedBuffers={}),void 0===t.interleavedBuffers[this.data.uuid]&&(t.interleavedBuffers[this.data.uuid]=this.data.toJSON(t)),{isInterleavedBufferAttribute:!0,itemSize:this.itemSize,data:this.data.uuid,offset:this.offset,normalized:this.normalized}}}),(Wot.prototype=Object.create(ynt.prototype)).constructor=Wot,Wot.prototype.isSpriteMaterial=!0,Wot.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.rotation=t.rotation,this.sizeAttenuation=t.sizeAttenuation,this};const Yot=new ttt,qot=new ttt,Zot=new ttt,Xot=new W9,Jot=new W9,Qot=new Stt,Kot=new ttt,$ot=new ttt,trt=new ttt,nrt=new W9,ert=new W9,art=new W9;function ort(t){if($tt.call(this),this.type="Sprite",void 0===Got){Got=new Xnt;const t=new Vot(new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),5);Got.setIndex([0,1,2,0,2,3]),Got.setAttribute("position",new Uot(t,3,0,!1)),Got.setAttribute("uv",new Uot(t,2,3,!1))}this.geometry=Got,this.material=void 0!==t?t:new Wot,this.center=new W9(.5,.5)}function rrt(t,n,e,a,o,r){Xot.subVectors(t,e).addScalar(.5).multiply(a),void 0!==o?(Jot.x=r*Xot.x-o*Xot.y,Jot.y=o*Xot.x+r*Xot.y):Jot.copy(Xot),t.copy(n),t.x+=Jot.x,t.y+=Jot.y,t.applyMatrix4(Qot)}ort.prototype=Object.assign(Object.create($tt.prototype),{constructor:ort,isSprite:!0,raycast:function(t,n){null===t.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.'),qot.setFromMatrixScale(this.matrixWorld),Qot.copy(t.camera.matrixWorld),this.modelViewMatrix.multiplyMatrices(t.camera.matrixWorldInverse,this.matrixWorld),Zot.setFromMatrixPosition(this.modelViewMatrix),t.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&qot.multiplyScalar(-Zot.z);const e=this.material.rotation;let a,o;0!==e&&(o=Math.cos(e),a=Math.sin(e));const r=this.center;rrt(Kot.set(-.5,-.5,0),Zot,r,qot,a,o),rrt($ot.set(.5,-.5,0),Zot,r,qot,a,o),rrt(trt.set(.5,.5,0),Zot,r,qot,a,o),nrt.set(0,0),ert.set(1,0),art.set(1,1);let i=t.ray.intersectTriangle(Kot,$ot,trt,!1,Yot);if(null===i&&(rrt($ot.set(-.5,.5,0),Zot,r,qot,a,o),ert.set(0,1),i=t.ray.intersectTriangle(Kot,trt,$ot,!1,Yot),null===i))return;const c=t.ray.origin.distanceTo(Yot);c<t.near||c>t.far||n.push({distance:c,point:Yot.clone(),uv:bnt.getUV(Yot,Kot,$ot,trt,nrt,ert,art,new W9),face:null,object:this})},copy:function(t){return $tt.prototype.copy.call(this,t),void 0!==t.center&&this.center.copy(t.center),this.material=t.material,this}});const irt=new ttt,crt=new ttt;function srt(){$tt.call(this),this._currentLevel=0,this.type="LOD",Object.defineProperties(this,{levels:{enumerable:!0,value:[]}}),this.autoUpdate=!0}srt.prototype=Object.assign(Object.create($tt.prototype),{constructor:srt,isLOD:!0,copy:function(t){$tt.prototype.copy.call(this,t,!1);const n=t.levels;for(let t=0,e=n.length;t<e;t++){const e=n[t];this.addLevel(e.object.clone(),e.distance)}return this.autoUpdate=t.autoUpdate,this},addLevel:function(t,n=0){n=Math.abs(n);const e=this.levels;let a;for(a=0;a<e.length&&!(n<e[a].distance);a++);return e.splice(a,0,{distance:n,object:t}),this.add(t),this},getCurrentLevel:function(){return this._currentLevel},getObjectForDistance:function(t){const n=this.levels;if(n.length>0){let e,a;for(e=1,a=n.length;e<a&&!(t<n[e].distance);e++);return n[e-1].object}return null},raycast:function(t,n){if(this.levels.length>0){irt.setFromMatrixPosition(this.matrixWorld);const e=t.ray.origin.distanceTo(irt);this.getObjectForDistance(e).raycast(t,n)}},update:function(t){const n=this.levels;if(n.length>1){irt.setFromMatrixPosition(t.matrixWorld),crt.setFromMatrixPosition(this.matrixWorld);const e=irt.distanceTo(crt)/t.zoom;let a,o;for(n[0].object.visible=!0,a=1,o=n.length;a<o&&e>=n[a].distance;a++)n[a-1].object.visible=!1,n[a].object.visible=!0;for(this._currentLevel=a-1;a<o;a++)n[a].object.visible=!1}},toJSON:function(t){const n=$tt.prototype.toJSON.call(this,t);!1===this.autoUpdate&&(n.object.autoUpdate=!1),n.object.levels=[];const e=this.levels;for(let t=0,a=e.length;t<a;t++){const a=e[t];n.object.levels.push({object:a.object.uuid,distance:a.distance})}return n}});const lrt=new ttt,mrt=new Q9,drt=new Q9,grt=new ttt,prt=new Stt;function brt(t,n){t&&t.isGeometry&&console.error("THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead."),bet.call(this,t,n),this.type="SkinnedMesh",this.bindMode="attached",this.bindMatrix=new Stt,this.bindMatrixInverse=new Stt}function urt(){$tt.call(this),this.type="Bone"}brt.prototype=Object.assign(Object.create(bet.prototype),{constructor:brt,isSkinnedMesh:!0,copy:function(t){return bet.prototype.copy.call(this,t),this.bindMode=t.bindMode,this.bindMatrix.copy(t.bindMatrix),this.bindMatrixInverse.copy(t.bindMatrixInverse),this.skeleton=t.skeleton,this},bind:function(t,n){this.skeleton=t,void 0===n&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),n=this.matrixWorld),this.bindMatrix.copy(n),this.bindMatrixInverse.copy(n).invert()},pose:function(){this.skeleton.pose()},normalizeSkinWeights:function(){const t=new Q9,n=this.geometry.attributes.skinWeight;for(let e=0,a=n.count;e<a;e++){t.x=n.getX(e),t.y=n.getY(e),t.z=n.getZ(e),t.w=n.getW(e);const a=1/t.manhattanLength();a!==1/0?t.multiplyScalar(a):t.set(1,0,0,0),n.setXYZW(e,t.x,t.y,t.z,t.w)}},updateMatrixWorld:function(t){bet.prototype.updateMatrixWorld.call(this,t),"attached"===this.bindMode?this.bindMatrixInverse.copy(this.matrixWorld).invert():"detached"===this.bindMode?this.bindMatrixInverse.copy(this.bindMatrix).invert():console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)},boneTransform:function(t,n){const e=this.skeleton,a=this.geometry;mrt.fromBufferAttribute(a.attributes.skinIndex,t),drt.fromBufferAttribute(a.attributes.skinWeight,t),lrt.fromBufferAttribute(a.attributes.position,t).applyMatrix4(this.bindMatrix),n.set(0,0,0);for(let t=0;t<4;t++){const a=drt.getComponent(t);if(0!==a){const o=mrt.getComponent(t);prt.multiplyMatrices(e.bones[o].matrixWorld,e.boneInverses[o]),n.addScaledVector(grt.copy(lrt).applyMatrix4(prt),a)}}return n.applyMatrix4(this.bindMatrixInverse)}}),urt.prototype=Object.assign(Object.create($tt.prototype),{constructor:urt,isBone:!0});const frt=new Stt,hrt=new Stt;function _rt(t=[],n=[]){this.uuid=U9.generateUUID(),this.bones=t.slice(0),this.boneInverses=n,this.boneMatrices=null,this.boneTexture=null,this.boneTextureSize=0,this.frame=-1,this.init()}Object.assign(_rt.prototype,{init:function(){const t=this.bones,n=this.boneInverses;if(this.boneMatrices=new Float32Array(16*t.length),0===n.length)this.calculateInverses();else if(t.length!==n.length){console.warn("THREE.Skeleton: Number of inverse bone matrices does not match amount of bones."),this.boneInverses=[];for(let t=0,n=this.bones.length;t<n;t++)this.boneInverses.push(new Stt)}},calculateInverses:function(){this.boneInverses.length=0;for(let t=0,n=this.bones.length;t<n;t++){const n=new Stt;this.bones[t]&&n.copy(this.bones[t].matrixWorld).invert(),this.boneInverses.push(n)}},pose:function(){for(let t=0,n=this.bones.length;t<n;t++){const n=this.bones[t];n&&n.matrixWorld.copy(this.boneInverses[t]).invert()}for(let t=0,n=this.bones.length;t<n;t++){const n=this.bones[t];n&&(n.parent&&n.parent.isBone?(n.matrix.copy(n.parent.matrixWorld).invert(),n.matrix.multiply(n.matrixWorld)):n.matrix.copy(n.matrixWorld),n.matrix.decompose(n.position,n.quaternion,n.scale))}},update:function(){const t=this.bones,n=this.boneInverses,e=this.boneMatrices,a=this.boneTexture;for(let a=0,o=t.length;a<o;a++)frt.multiplyMatrices(t[a]?t[a].matrixWorld:hrt,n[a]),frt.toArray(e,16*a);null!==a&&(a.needsUpdate=!0)},clone:function(){return new _rt(this.bones,this.boneInverses)},getBoneByName:function(t){for(let n=0,e=this.bones.length;n<e;n++){const e=this.bones[n];if(e.name===t)return e}},dispose:function(){null!==this.boneTexture&&(this.boneTexture.dispose(),this.boneTexture=null)},fromJSON:function(t,n){this.uuid=t.uuid;for(let e=0,a=t.bones.length;e<a;e++){const a=t.bones[e];let o=n[a];void 0===o&&(console.warn("THREE.Skeleton: No bone found with UUID:",a),o=new urt),this.bones.push(o),this.boneInverses.push((new Stt).fromArray(t.boneInverses[e]))}return this.init(),this},toJSON:function(){const t={metadata:{version:4.5,type:"Skeleton",generator:"Skeleton.toJSON"},bones:[],boneInverses:[]};t.uuid=this.uuid;const n=this.bones,e=this.boneInverses;for(let a=0,o=n.length;a<o;a++)t.bones.push(n[a].uuid),t.boneInverses.push(e[a].toArray());return t}});const Crt=new Stt,Mrt=new Stt,Ort=[],Prt=new bet;function xrt(t,n,e){bet.call(this,t,n),this.instanceMatrix=new Snt(new Float32Array(16*e),16),this.instanceColor=null,this.count=e,this.frustumCulled=!1}function yrt(t){ynt.call(this),this.type="LineBasicMaterial",this.color=new Ont(16777215),this.linewidth=1,this.linecap="round",this.linejoin="round",this.morphTargets=!1,this.setValues(t)}xrt.prototype=Object.assign(Object.create(bet.prototype),{constructor:xrt,isInstancedMesh:!0,copy:function(t){return bet.prototype.copy.call(this,t),this.instanceMatrix.copy(t.instanceMatrix),null!==t.instanceColor&&(this.instanceColor=t.instanceColor.clone()),this.count=t.count,this},getColorAt:function(t,n){n.fromArray(this.instanceColor.array,3*t)},getMatrixAt:function(t,n){n.fromArray(this.instanceMatrix.array,16*t)},raycast:function(t,n){const e=this.matrixWorld,a=this.count;if(Prt.geometry=this.geometry,Prt.material=this.material,void 0!==Prt.material)for(let o=0;o<a;o++){this.getMatrixAt(o,Crt),Mrt.multiplyMatrices(e,Crt),Prt.matrixWorld=Mrt,Prt.raycast(t,Ort);for(let t=0,e=Ort.length;t<e;t++){const e=Ort[t];e.instanceId=o,e.object=this,n.push(e)}Ort.length=0}},setColorAt:function(t,n){null===this.instanceColor&&(this.instanceColor=new Snt(new Float32Array(3*this.count),3)),n.toArray(this.instanceColor.array,3*t)},setMatrixAt:function(t,n){n.toArray(this.instanceMatrix.array,16*t)},updateMorphTargets:function(){},dispose:function(){this.dispatchEvent({type:"dispose"})}}),(yrt.prototype=Object.create(ynt.prototype)).constructor=yrt,yrt.prototype.isLineBasicMaterial=!0,yrt.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.linewidth=t.linewidth,this.linecap=t.linecap,this.linejoin=t.linejoin,this.morphTargets=t.morphTargets,this};const krt=new ttt,vrt=new ttt,wrt=new Stt,Srt=new wtt,Ert=new Ctt;function Art(t=new Xnt,n=new yrt){$tt.call(this),this.type="Line",this.geometry=t,this.material=n,this.updateMorphTargets()}Art.prototype=Object.assign(Object.create($tt.prototype),{constructor:Art,isLine:!0,copy:function(t){return $tt.prototype.copy.call(this,t),this.material=t.material,this.geometry=t.geometry,this},computeLineDistances:function(){const t=this.geometry;if(t.isBufferGeometry)if(null===t.index){const n=t.attributes.position,e=[0];for(let t=1,a=n.count;t<a;t++)krt.fromBufferAttribute(n,t-1),vrt.fromBufferAttribute(n,t),e[t]=e[t-1],e[t]+=krt.distanceTo(vrt);t.setAttribute("lineDistance",new Fnt(e,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.Line.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this},raycast:function(t,n){const e=this.geometry,a=this.matrixWorld,o=t.params.Line.threshold;if(null===e.boundingSphere&&e.computeBoundingSphere(),Ert.copy(e.boundingSphere),Ert.applyMatrix4(a),Ert.radius+=o,!1===t.ray.intersectsSphere(Ert))return;wrt.copy(a).invert(),Srt.copy(t.ray).applyMatrix4(wrt);const r=o/((this.scale.x+this.scale.y+this.scale.z)/3),i=r*r,c=new ttt,s=new ttt,l=new ttt,m=new ttt,d=this.isLineSegments?2:1;if(e.isBufferGeometry){const a=e.index,o=e.attributes.position;if(null!==a){const e=a.array;for(let a=0,r=e.length-1;a<r;a+=d){const r=e[a+1];if(c.fromBufferAttribute(o,e[a]),s.fromBufferAttribute(o,r),Srt.distanceSqToSegment(c,s,m,l)>i)continue;m.applyMatrix4(this.matrixWorld);const d=t.ray.origin.distanceTo(m);d<t.near||d>t.far||n.push({distance:d,point:l.clone().applyMatrix4(this.matrixWorld),index:a,face:null,faceIndex:null,object:this})}}else for(let e=0,a=o.count-1;e<a;e+=d){if(c.fromBufferAttribute(o,e),s.fromBufferAttribute(o,e+1),Srt.distanceSqToSegment(c,s,m,l)>i)continue;m.applyMatrix4(this.matrixWorld);const a=t.ray.origin.distanceTo(m);a<t.near||a>t.far||n.push({distance:a,point:l.clone().applyMatrix4(this.matrixWorld),index:e,face:null,faceIndex:null,object:this})}}else e.isGeometry&&console.error("THREE.Line.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const n=t.morphAttributes,e=Object.keys(n);if(e.length>0){const t=n[e[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let n=0,e=t.length;n<e;n++){const e=t[n].name||String(n);this.morphTargetInfluences.push(0),this.morphTargetDictionary[e]=n}}}}else{const n=t.morphTargets;void 0!==n&&n.length>0&&console.error("THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}});const zrt=new ttt,Rrt=new ttt;function Trt(t,n){Art.call(this,t,n),this.type="LineSegments"}function Drt(t,n){Art.call(this,t,n),this.type="LineLoop"}function Irt(t){ynt.call(this),this.type="PointsMaterial",this.color=new Ont(16777215),this.map=null,this.alphaMap=null,this.size=1,this.sizeAttenuation=!0,this.morphTargets=!1,this.setValues(t)}Trt.prototype=Object.assign(Object.create(Art.prototype),{constructor:Trt,isLineSegments:!0,computeLineDistances:function(){const t=this.geometry;if(t.isBufferGeometry)if(null===t.index){const n=t.attributes.position,e=[];for(let t=0,a=n.count;t<a;t+=2)zrt.fromBufferAttribute(n,t),Rrt.fromBufferAttribute(n,t+1),e[t]=0===t?0:e[t-1],e[t+1]=e[t]+zrt.distanceTo(Rrt);t.setAttribute("lineDistance",new Fnt(e,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else t.isGeometry&&console.error("THREE.LineSegments.computeLineDistances() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");return this}}),Drt.prototype=Object.assign(Object.create(Art.prototype),{constructor:Drt,isLineLoop:!0}),(Irt.prototype=Object.create(ynt.prototype)).constructor=Irt,Irt.prototype.isPointsMaterial=!0,Irt.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.alphaMap=t.alphaMap,this.size=t.size,this.sizeAttenuation=t.sizeAttenuation,this.morphTargets=t.morphTargets,this};const Nrt=new Stt,Frt=new wtt,Lrt=new Ctt,Hrt=new ttt;function Brt(t=new Xnt,n=new Irt){$tt.call(this),this.type="Points",this.geometry=t,this.material=n,this.updateMorphTargets()}function Vrt(t,n,e,a,o,r,i){const c=Frt.distanceSqToPoint(t);if(c<e){const e=new ttt;Frt.closestPointToPoint(t,e),e.applyMatrix4(a);const s=o.ray.origin.distanceTo(e);if(s<o.near||s>o.far)return;r.push({distance:s,distanceToRay:Math.sqrt(c),point:e,index:n,face:null,object:i})}}function jrt(t,n,e,a,o,r,i,c,s){X9.call(this,t,n,e,a,o,r,i,c,s),this.format=void 0!==i?i:k9,this.minFilter=void 0!==r?r:_9,this.magFilter=void 0!==o?o:_9,this.generateMipmaps=!1;const l=this;"requestVideoFrameCallback"in t&&t.requestVideoFrameCallback((function n(){l.needsUpdate=!0,t.requestVideoFrameCallback(n)}))}function Urt(t,n,e,a,o,r,i,c,s,l,m,d){X9.call(this,null,r,i,c,s,l,a,o,m,d),this.image={width:n,height:e},this.mipmaps=t,this.flipY=!1,this.generateMipmaps=!1}function Wrt(t,n,e,a,o,r,i,c,s){X9.call(this,t,n,e,a,o,r,i,c,s),this.needsUpdate=!0}function Grt(t,n,e,a,o,r,i,c,s,l){if((l=void 0!==l?l:w9)!==w9&&l!==S9)throw new Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===e&&l===w9&&(e=M9),void 0===e&&l===S9&&(e=y9),X9.call(this,null,a,o,r,i,c,l,e,s),this.image={width:t,height:n},this.magFilter=void 0!==i?i:h9,this.minFilter=void 0!==c?c:h9,this.flipY=!1,this.generateMipmaps=!1}Brt.prototype=Object.assign(Object.create($tt.prototype),{constructor:Brt,isPoints:!0,copy:function(t){return $tt.prototype.copy.call(this,t),this.material=t.material,this.geometry=t.geometry,this},raycast:function(t,n){const e=this.geometry,a=this.matrixWorld,o=t.params.Points.threshold;if(null===e.boundingSphere&&e.computeBoundingSphere(),Lrt.copy(e.boundingSphere),Lrt.applyMatrix4(a),Lrt.radius+=o,!1===t.ray.intersectsSphere(Lrt))return;Nrt.copy(a).invert(),Frt.copy(t.ray).applyMatrix4(Nrt);const r=o/((this.scale.x+this.scale.y+this.scale.z)/3),i=r*r;if(e.isBufferGeometry){const o=e.index,r=e.attributes.position;if(null!==o){const e=o.array;for(let o=0,c=e.length;o<c;o++){const c=e[o];Hrt.fromBufferAttribute(r,c),Vrt(Hrt,c,i,a,t,n,this)}}else for(let e=0,o=r.count;e<o;e++)Hrt.fromBufferAttribute(r,e),Vrt(Hrt,e,i,a,t,n,this)}else console.error("THREE.Points.raycast() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},updateMorphTargets:function(){const t=this.geometry;if(t.isBufferGeometry){const n=t.morphAttributes,e=Object.keys(n);if(e.length>0){const t=n[e[0]];if(void 0!==t){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let n=0,e=t.length;n<e;n++){const e=t[n].name||String(n);this.morphTargetInfluences.push(0),this.morphTargetDictionary[e]=n}}}}else{const n=t.morphTargets;void 0!==n&&n.length>0&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")}}}),jrt.prototype=Object.assign(Object.create(X9.prototype),{constructor:jrt,clone:function(){return new this.constructor(this.image).copy(this)},isVideoTexture:!0,update:function(){const t=this.image;0=="requestVideoFrameCallback"in t&&t.readyState>=t.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}}),(Urt.prototype=Object.create(X9.prototype)).constructor=Urt,Urt.prototype.isCompressedTexture=!0,(Wrt.prototype=Object.create(X9.prototype)).constructor=Wrt,Wrt.prototype.isCanvasTexture=!0,(Grt.prototype=Object.create(X9.prototype)).constructor=Grt,Grt.prototype.isDepthTexture=!0;class Yrt extends Xnt{constructor(t=1,n=8,e=0,a=2*Math.PI){super(),this.type="CircleGeometry",this.parameters={radius:t,segments:n,thetaStart:e,thetaLength:a},n=Math.max(3,n);const o=[],r=[],i=[],c=[],s=new ttt,l=new W9;r.push(0,0,0),i.push(0,0,1),c.push(.5,.5);for(let o=0,m=3;o<=n;o++,m+=3){const d=e+o/n*a;s.x=t*Math.cos(d),s.y=t*Math.sin(d),r.push(s.x,s.y,s.z),i.push(0,0,1),l.x=(r[m]/t+1)/2,l.y=(r[m+1]/t+1)/2,c.push(l.x,l.y)}for(let t=1;t<=n;t++)o.push(t,t+1,0);this.setIndex(o),this.setAttribute("position",new Fnt(r,3)),this.setAttribute("normal",new Fnt(i,3)),this.setAttribute("uv",new Fnt(c,2))}}function qrt(t,n,e,a,o){let r,i;if(o===(function c(t,n,e,a){let o=0;for(let r=n,i=e-a;r<e;r+=a)o+=(t[i]-t[r])*(t[r+1]+t[i+1]),i=r;return o})(t,n,e,a)>0)for(r=n;r<e;r+=a)i=bit(r,t[r],t[r+1],i);else for(r=e-a;r>=n;r-=a)i=bit(r,t[r],t[r+1],i);return i&&sit(i,i.next)&&(uit(i),i=i.next),i}function Zrt(t,n){if(!t)return t;n||(n=t);let e,a=t;do{if(e=!1,a.steiner||!sit(a,a.next)&&0!==cit(a.prev,a,a.next))a=a.next;else{if(uit(a),a=n=a.prev,a===a.next)break;e=!0}}while(e||a!==n);return n}function Xrt(t,n,e,a,o,r,i){if(!t)return;!i&&r&&(function c(t,n,e,a){let o=t;do{null===o.z&&(o.z=ait(o.x,o.y,n,e,a)),o.prevZ=o.prev,o.nextZ=o.next,o=o.next}while(o!==t);o.prevZ.nextZ=null,o.prevZ=null,(function r(t){let n,e,a,o,r,i,c,s,l=1;do{for(e=t,t=null,r=null,i=0;e;){for(i++,a=e,c=0,n=0;n<l&&(c++,a=a.nextZ,a);n++);for(s=l;c>0||s>0&&a;)0!==c&&(0===s||!a||e.z<=a.z)?(o=e,e=e.nextZ,c--):(o=a,a=a.nextZ,s--),r?r.nextZ=o:t=o,o.prevZ=r,r=o;e=a}r.nextZ=null,l*=2}while(i>1)})(o)})(t,a,o,r);let s,l,m=t;for(;t.prev!==t.next;)if(s=t.prev,l=t.next,r?Qrt(t,a,o,r):Jrt(t))n.push(s.i/e),n.push(t.i/e),n.push(l.i/e),uit(t),t=l.next,m=l.next;else if((t=l)===m){i?1===i?Xrt(t=Krt(Zrt(t),n,e),n,e,a,o,r,2):2===i&&$rt(t,n,e,a,o,r):Xrt(Zrt(t),n,e,a,o,r,1);break}}function Jrt(t){const n=t.prev,e=t,a=t.next;if(cit(n,e,a)>=0)return!1;let o=t.next.next;for(;o!==t.prev;){if(rit(n.x,n.y,e.x,e.y,a.x,a.y,o.x,o.y)&&cit(o.prev,o,o.next)>=0)return!1;o=o.next}return!0}function Qrt(t,n,e,a){const o=t.prev,r=t,i=t.next;if(cit(o,r,i)>=0)return!1;const c=o.x>r.x?o.x>i.x?o.x:i.x:r.x>i.x?r.x:i.x,s=o.y>r.y?o.y>i.y?o.y:i.y:r.y>i.y?r.y:i.y,l=ait(o.x<r.x?o.x<i.x?o.x:i.x:r.x<i.x?r.x:i.x,o.y<r.y?o.y<i.y?o.y:i.y:r.y<i.y?r.y:i.y,n,e,a),m=ait(c,s,n,e,a);let d=t.prevZ,g=t.nextZ;for(;d&&d.z>=l&&g&&g.z<=m;){if(d!==t.prev&&d!==t.next&&rit(o.x,o.y,r.x,r.y,i.x,i.y,d.x,d.y)&&cit(d.prev,d,d.next)>=0)return!1;if(d=d.prevZ,g!==t.prev&&g!==t.next&&rit(o.x,o.y,r.x,r.y,i.x,i.y,g.x,g.y)&&cit(g.prev,g,g.next)>=0)return!1;g=g.nextZ}for(;d&&d.z>=l;){if(d!==t.prev&&d!==t.next&&rit(o.x,o.y,r.x,r.y,i.x,i.y,d.x,d.y)&&cit(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;g&&g.z<=m;){if(g!==t.prev&&g!==t.next&&rit(o.x,o.y,r.x,r.y,i.x,i.y,g.x,g.y)&&cit(g.prev,g,g.next)>=0)return!1;g=g.nextZ}return!0}function Krt(t,n,e){let a=t;do{const o=a.prev,r=a.next.next;!sit(o,r)&&lit(o,a,a.next,r)&&git(o,r)&&git(r,o)&&(n.push(o.i/e),n.push(a.i/e),n.push(r.i/e),uit(a),uit(a.next),a=t=r),a=a.next}while(a!==t);return Zrt(a)}function $rt(t,n,e,a,o,r){let i=t;do{let t=i.next.next;for(;t!==i.prev;){if(i.i!==t.i&&iit(i,t)){let c=pit(i,t);return i=Zrt(i,i.next),c=Zrt(c,c.next),Xrt(i,n,e,a,o,r),void Xrt(c,n,e,a,o,r)}t=t.next}i=i.next}while(i!==t)}function tit(t,n){return t.x-n.x}function nit(t,n){if(n=(function e(t,n){let e=n;const a=t.x,o=t.y;let r,i=-1/0;do{if(o<=e.y&&o>=e.next.y&&e.next.y!==e.y){const t=e.x+(o-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(t<=a&&t>i){if(i=t,t===a){if(o===e.y)return e;if(o===e.next.y)return e.next}r=e.x<e.next.x?e:e.next}}e=e.next}while(e!==n);if(!r)return null;if(a===i)return r;const c=r,s=r.x,l=r.y;let m,d=1/0;e=r;do{a>=e.x&&e.x>=s&&a!==e.x&&rit(o<l?a:i,o,s,l,o<l?i:a,o,e.x,e.y)&&(m=Math.abs(o-e.y)/(a-e.x),git(e,t)&&(m<d||m===d&&(e.x>r.x||e.x===r.x&&eit(r,e)))&&(r=e,d=m)),e=e.next}while(e!==c);return r})(t,n)){const e=pit(n,t);Zrt(n,n.next),Zrt(e,e.next)}}function eit(t,n){return cit(t.prev,t,n.prev)<0&&cit(n.next,t,t.next)<0}function ait(t,n,e,a,o){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-e)*o)|t<<8))|t<<4))|t<<2))|t<<1))|(n=1431655765&((n=858993459&((n=252645135&((n=16711935&((n=32767*(n-a)*o)|n<<8))|n<<4))|n<<2))|n<<1))<<1}function oit(t){let n=t,e=t;do{(n.x<e.x||n.x===e.x&&n.y<e.y)&&(e=n),n=n.next}while(n!==t);return e}function rit(t,n,e,a,o,r,i,c){return(o-i)*(n-c)-(t-i)*(r-c)>=0&&(t-i)*(a-c)-(e-i)*(n-c)>=0&&(e-i)*(r-c)-(o-i)*(a-c)>=0}function iit(t,n){return t.next.i!==n.i&&t.prev.i!==n.i&&!(function e(t,n){let e=t;do{if(e.i!==t.i&&e.next.i!==t.i&&e.i!==n.i&&e.next.i!==n.i&&lit(e,e.next,t,n))return!0;e=e.next}while(e!==t);return!1})(t,n)&&(git(t,n)&&git(n,t)&&(function a(t,n){let e=t,a=!1;const o=(t.x+n.x)/2,r=(t.y+n.y)/2;do{e.y>r!=e.next.y>r&&e.next.y!==e.y&&o<(e.next.x-e.x)*(r-e.y)/(e.next.y-e.y)+e.x&&(a=!a),e=e.next}while(e!==t);return a})(t,n)&&(cit(t.prev,t,n.prev)||cit(t,n.prev,n))||sit(t,n)&&cit(t.prev,t,t.next)>0&&cit(n.prev,n,n.next)>0)}function cit(t,n,e){return(n.y-t.y)*(e.x-n.x)-(n.x-t.x)*(e.y-n.y)}function sit(t,n){return t.x===n.x&&t.y===n.y}function lit(t,n,e,a){const o=dit(cit(t,n,e)),r=dit(cit(t,n,a)),i=dit(cit(e,a,t)),c=dit(cit(e,a,n));return o!==r&&i!==c||!(0!==o||!mit(t,e,n))||!(0!==r||!mit(t,a,n))||!(0!==i||!mit(e,t,a))||!(0!==c||!mit(e,n,a))}function mit(t,n,e){return n.x<=Math.max(t.x,e.x)&&n.x>=Math.min(t.x,e.x)&&n.y<=Math.max(t.y,e.y)&&n.y>=Math.min(t.y,e.y)}function dit(t){return t>0?1:t<0?-1:0}function git(t,n){return cit(t.prev,t,t.next)<0?cit(t,n,t.next)>=0&&cit(t,t.prev,n)>=0:cit(t,n,t.prev)<0||cit(t,t.next,n)<0}function pit(t,n){const e=new fit(t.i,t.x,t.y),a=new fit(n.i,n.x,n.y),o=t.next,r=n.prev;return t.next=n,n.prev=t,e.next=o,o.prev=e,a.next=e,e.prev=a,r.next=a,a.prev=r,a}function bit(t,n,e,a){const o=new fit(t,n,e);return a?(o.next=a.next,o.prev=a,a.next.prev=o,a.next=o):(o.prev=o,o.next=o),o}function uit(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function fit(t,n,e){this.i=t,this.x=n,this.y=e,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}new ttt,new ttt,new ttt,new bnt;const hit={area:function(t){const n=t.length;let e=0;for(let a=n-1,o=0;o<n;a=o++)e+=t[a].x*t[o].y-t[o].x*t[a].y;return.5*e},isClockWise:function(t){return hit.area(t)<0},triangulateShape:function(t,n){const e=[],a=[],o=[];_it(t),Cit(e,t);let r=t.length;n.forEach(_it);for(let t=0;t<n.length;t++)a.push(r),r+=n[t].length,Cit(e,n[t]);const i=(function(t,n,e){e=e||2;const a=n&&n.length,o=a?n[0]*e:t.length;let r=qrt(t,0,o,e,!0);const i=[];if(!r||r.next===r.prev)return i;let c,s,l,m,d,g,p;if(a&&(r=(function b(t,n,e,a){const o=[];let r,i,c,s,l;for(r=0,i=n.length;r<i;r++)c=n[r]*a,s=r<i-1?n[r+1]*a:t.length,l=qrt(t,c,s,a,!1),l===l.next&&(l.steiner=!0),o.push(oit(l));for(o.sort(tit),r=0;r<o.length;r++)nit(o[r],e),e=Zrt(e,e.next);return e})(t,n,r,e)),t.length>80*e){c=l=t[0],s=m=t[1];for(let n=e;n<o;n+=e)d=t[n],g=t[n+1],d<c&&(c=d),g<s&&(s=g),d>l&&(l=d),g>m&&(m=g);p=Math.max(l-c,m-s),p=0!==p?1/p:0}return Xrt(r,i,e,c,s,p),i})(e,a);for(let t=0;t<i.length;t+=3)o.push(i.slice(t,t+3));return o}};function _it(t){const n=t.length;n>2&&t[n-1].equals(t[0])&&t.pop()}function Cit(t,n){for(let e=0;e<n.length;e++)t.push(n[e].x),t.push(n[e].y)}class Mit extends Xnt{constructor(t,n){super(),this.type="ExtrudeGeometry",this.parameters={shapes:t,options:n},t=Array.isArray(t)?t:[t];const e=this,a=[],o=[];for(let n=0,e=t.length;n<e;n++)r(t[n]);function r(t){const r=[],i=void 0!==n.curveSegments?n.curveSegments:12,c=void 0!==n.steps?n.steps:1;let s=void 0!==n.depth?n.depth:100,l=void 0===n.bevelEnabled||n.bevelEnabled,m=void 0!==n.bevelThickness?n.bevelThickness:6,d=void 0!==n.bevelSize?n.bevelSize:m-2,g=void 0!==n.bevelOffset?n.bevelOffset:0,p=void 0!==n.bevelSegments?n.bevelSegments:3;const b=n.extrudePath,u=void 0!==n.UVGenerator?n.UVGenerator:Oit;void 0!==n.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),s=n.amount);let f,h,_,C,M,O=!1;b&&(f=b.getSpacedPoints(c),O=!0,l=!1,h=b.computeFrenetFrames(c,!1),_=new ttt,C=new ttt,M=new ttt),l||(p=0,m=0,d=0,g=0);const P=t.extractPoints(i);let x=P.shape;const y=P.holes;if(!hit.isClockWise(x)){x=x.reverse();for(let t=0,n=y.length;t<n;t++){const n=y[t];hit.isClockWise(n)&&(y[t]=n.reverse())}}const k=hit.triangulateShape(x,y),v=x;for(let t=0,n=y.length;t<n;t++)x=x.concat(y[t]);function w(t,n,e){return n||console.error("THREE.ExtrudeGeometry: vec does not exist"),n.clone().multiplyScalar(e).add(t)}const S=x.length,E=k.length;function A(t,n,e){let a,o,r;const i=t.x-n.x,c=t.y-n.y,s=e.x-t.x,l=e.y-t.y,m=i*i+c*c;if(Math.abs(i*l-c*s)>Number.EPSILON){const d=Math.sqrt(m),g=Math.sqrt(s*s+l*l),p=n.x-c/d,b=n.y+i/d,u=((e.x-l/g-p)*l-(e.y+s/g-b)*s)/(i*l-c*s);a=p+i*u-t.x,o=b+c*u-t.y;const f=a*a+o*o;if(f<=2)return new W9(a,o);r=Math.sqrt(f/2)}else{let t=!1;i>Number.EPSILON?s>Number.EPSILON&&(t=!0):i<-Number.EPSILON?s<-Number.EPSILON&&(t=!0):Math.sign(c)===Math.sign(l)&&(t=!0),t?(a=-c,o=i,r=Math.sqrt(m)):(a=i,o=c,r=Math.sqrt(m/2))}return new W9(a/r,o/r)}const z=[];for(let t=0,n=v.length,e=n-1,a=t+1;t<n;t++,e++,a++)e===n&&(e=0),a===n&&(a=0),z[t]=A(v[t],v[e],v[a]);const R=[];let T,D=z.concat();for(let t=0,n=y.length;t<n;t++){const n=y[t];T=[];for(let t=0,e=n.length,a=e-1,o=t+1;t<e;t++,a++,o++)a===e&&(a=0),o===e&&(o=0),T[t]=A(n[t],n[a],n[o]);R.push(T),D=D.concat(T)}for(let t=0;t<p;t++){const n=t/p,e=m*Math.cos(n*Math.PI/2),a=d*Math.sin(n*Math.PI/2)+g;for(let t=0,n=v.length;t<n;t++){const n=w(v[t],z[t],a);F(n.x,n.y,-e)}for(let t=0,n=y.length;t<n;t++){const n=y[t];T=R[t];for(let t=0,o=n.length;t<o;t++){const o=w(n[t],T[t],a);F(o.x,o.y,-e)}}}const I=d+g;for(let t=0;t<S;t++){const n=l?w(x[t],D[t],I):x[t];O?(C.copy(h.normals[0]).multiplyScalar(n.x),_.copy(h.binormals[0]).multiplyScalar(n.y),M.copy(f[0]).add(C).add(_),F(M.x,M.y,M.z)):F(n.x,n.y,0)}for(let t=1;t<=c;t++)for(let n=0;n<S;n++){const e=l?w(x[n],D[n],I):x[n];O?(C.copy(h.normals[t]).multiplyScalar(e.x),_.copy(h.binormals[t]).multiplyScalar(e.y),M.copy(f[t]).add(C).add(_),F(M.x,M.y,M.z)):F(e.x,e.y,s/c*t)}for(let t=p-1;t>=0;t--){const n=t/p,e=m*Math.cos(n*Math.PI/2),a=d*Math.sin(n*Math.PI/2)+g;for(let t=0,n=v.length;t<n;t++){const n=w(v[t],z[t],a);F(n.x,n.y,s+e)}for(let t=0,n=y.length;t<n;t++){const n=y[t];T=R[t];for(let t=0,o=n.length;t<o;t++){const o=w(n[t],T[t],a);O?F(o.x,o.y+f[c-1].y,f[c-1].x+e):F(o.x,o.y,s+e)}}}function N(t,n){let e=t.length;for(;--e>=0;){const a=e;let o=e-1;o<0&&(o=t.length-1);for(let t=0,e=c+2*p;t<e;t++){const e=S*t,r=S*(t+1);H(n+a+e,n+o+e,n+o+r,n+a+r)}}}function F(t,n,e){r.push(t),r.push(n),r.push(e)}function L(t,n,o){B(t),B(n),B(o);const r=a.length/3,i=u.generateTopUV(e,a,r-3,r-2,r-1);V(i[0]),V(i[1]),V(i[2])}function H(t,n,o,r){B(t),B(n),B(r),B(n),B(o),B(r);const i=a.length/3,c=u.generateSideWallUV(e,a,i-6,i-3,i-2,i-1);V(c[0]),V(c[1]),V(c[3]),V(c[1]),V(c[2]),V(c[3])}function B(t){a.push(r[3*t+0]),a.push(r[3*t+1]),a.push(r[3*t+2])}function V(t){o.push(t.x),o.push(t.y)}!(function j(){const t=a.length/3;if(l){let t=0,n=S*t;for(let t=0;t<E;t++){const e=k[t];L(e[2]+n,e[1]+n,e[0]+n)}t=c+2*p,n=S*t;for(let t=0;t<E;t++){const e=k[t];L(e[0]+n,e[1]+n,e[2]+n)}}else{for(let t=0;t<E;t++){const n=k[t];L(n[2],n[1],n[0])}for(let t=0;t<E;t++){const n=k[t];L(n[0]+S*c,n[1]+S*c,n[2]+S*c)}}e.addGroup(t,a.length/3-t,0)})(),(function U(){const t=a.length/3;let n=0;N(v,n),n+=v.length;for(let t=0,e=y.length;t<e;t++){const e=y[t];N(e,n),n+=e.length}e.addGroup(t,a.length/3-t,1)})()}this.setAttribute("position",new Fnt(a,3)),this.setAttribute("uv",new Fnt(o,2)),this.computeVertexNormals()}toJSON(){const t=Xnt.prototype.toJSON.call(this);return(function n(t,e,a){if(a.shapes=[],Array.isArray(t))for(let n=0,e=t.length;n<e;n++)a.shapes.push(t[n].uuid);else a.shapes.push(t.uuid);return void 0!==e.extrudePath&&(a.options.extrudePath=e.extrudePath.toJSON()),a})(this.parameters.shapes,this.parameters.options,t)}}const Oit={generateTopUV:function(t,n,e,a,o){const r=n[3*a],i=n[3*a+1],c=n[3*o],s=n[3*o+1];return[new W9(n[3*e],n[3*e+1]),new W9(r,i),new W9(c,s)]},generateSideWallUV:function(t,n,e,a,o,r){const i=n[3*e],c=n[3*e+1],s=n[3*e+2],l=n[3*a],m=n[3*a+1],d=n[3*a+2],g=n[3*o],p=n[3*o+1],b=n[3*o+2],u=n[3*r],f=n[3*r+1],h=n[3*r+2];return Math.abs(c-m)<.01?[new W9(i,1-s),new W9(l,1-d),new W9(g,1-b),new W9(u,1-h)]:[new W9(c,1-s),new W9(m,1-d),new W9(p,1-b),new W9(f,1-h)]}};function Pit(t,n,e){Xnt.call(this),this.type="ParametricGeometry",this.parameters={func:t,slices:n,stacks:e};const a=[],o=[],r=[],i=[],c=1e-5,s=new ttt,l=new ttt,m=new ttt,d=new ttt,g=new ttt;t.length<3&&console.error("THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.");const p=n+1;for(let a=0;a<=e;a++){const p=a/e;for(let e=0;e<=n;e++){const a=e/n;t(a,p,l),o.push(l.x,l.y,l.z),a-c>=0?(t(a-c,p,m),d.subVectors(l,m)):(t(a+c,p,m),d.subVectors(m,l)),p-c>=0?(t(a,p-c,m),g.subVectors(l,m)):(t(a,p+c,m),g.subVectors(m,l)),s.crossVectors(d,g).normalize(),r.push(s.x,s.y,s.z),i.push(a,p)}}for(let t=0;t<e;t++)for(let e=0;e<n;e++){const n=t*p+e+1,o=(t+1)*p+e+1,r=(t+1)*p+e;a.push(t*p+e,n,r),a.push(n,o,r)}this.setIndex(a),this.setAttribute("position",new Fnt(o,3)),this.setAttribute("normal",new Fnt(r,3)),this.setAttribute("uv",new Fnt(i,2))}(Pit.prototype=Object.create(Xnt.prototype)).constructor=Pit;class xit extends Xnt{constructor(t,n=12){super(),this.type="ShapeGeometry",this.parameters={shapes:t,curveSegments:n};const e=[],a=[],o=[],r=[];let i=0,c=0;if(!1===Array.isArray(t))s(t);else for(let n=0;n<t.length;n++)s(t[n]),this.addGroup(i,c,n),i+=c,c=0;function s(t){const i=a.length/3,s=t.extractPoints(n);let l=s.shape;const m=s.holes;!1===hit.isClockWise(l)&&(l=l.reverse());for(let t=0,n=m.length;t<n;t++){const n=m[t];!0===hit.isClockWise(n)&&(m[t]=n.reverse())}const d=hit.triangulateShape(l,m);for(let t=0,n=m.length;t<n;t++)l=l.concat(m[t]);for(let t=0,n=l.length;t<n;t++){const n=l[t];a.push(n.x,n.y,0),o.push(0,0,1),r.push(n.x,n.y)}for(let t=0,n=d.length;t<n;t++){const n=d[t];e.push(n[0]+i,n[1]+i,n[2]+i),c+=3}}this.setIndex(e),this.setAttribute("position",new Fnt(a,3)),this.setAttribute("normal",new Fnt(o,3)),this.setAttribute("uv",new Fnt(r,2))}toJSON(){const t=Xnt.prototype.toJSON.call(this);return(function n(t,e){if(e.shapes=[],Array.isArray(t))for(let n=0,a=t.length;n<a;n++)e.shapes.push(t[n].uuid);else e.shapes.push(t.uuid);return e})(this.parameters.shapes,t)}}function yit(t){ynt.call(this),this.type="ShadowMaterial",this.color=new Ont(0),this.transparent=!0,this.setValues(t)}function kit(t){Met.call(this,t),this.type="RawShaderMaterial"}function vit(t){ynt.call(this),this.defines={STANDARD:""},this.type="MeshStandardMaterial",this.color=new Ont(16777215),this.roughness=1,this.metalness=0,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Ont(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new W9(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.roughnessMap=null,this.metalnessMap=null,this.alphaMap=null,this.envMap=null,this.envMapIntensity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.vertexTangents=!1,this.setValues(t)}function wit(t){vit.call(this),this.defines={STANDARD:"",PHYSICAL:""},this.type="MeshPhysicalMaterial",this.clearcoat=0,this.clearcoatMap=null,this.clearcoatRoughness=0,this.clearcoatRoughnessMap=null,this.clearcoatNormalScale=new W9(1,1),this.clearcoatNormalMap=null,this.reflectivity=.5,Object.defineProperty(this,"ior",{get:function(){return(1+.4*this.reflectivity)/(1-.4*this.reflectivity)},set:function(t){this.reflectivity=U9.clamp(2.5*(t-1)/(t+1),0,1)}}),this.sheen=null,this.transmission=0,this.transmissionMap=null,this.setValues(t)}function Sit(t){ynt.call(this),this.type="MeshPhongMaterial",this.color=new Ont(16777215),this.specular=new Ont(1118481),this.shininess=30,this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Ont(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new W9(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function Eit(t){ynt.call(this),this.defines={TOON:""},this.type="MeshToonMaterial",this.color=new Ont(16777215),this.map=null,this.gradientMap=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Ont(0),this.emissiveIntensity=1,this.emissiveMap=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new W9(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function Ait(t){ynt.call(this),this.type="MeshNormalMaterial",this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new W9(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.wireframe=!1,this.wireframeLinewidth=1,this.fog=!1,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function zit(t){ynt.call(this),this.type="MeshLambertMaterial",this.color=new Ont(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.emissive=new Ont(0),this.emissiveIntensity=1,this.emissiveMap=null,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.combine=0,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function Rit(t){ynt.call(this),this.defines={MATCAP:""},this.type="MeshMatcapMaterial",this.color=new Ont(16777215),this.matcap=null,this.map=null,this.bumpMap=null,this.bumpScale=1,this.normalMap=null,this.normalMapType=0,this.normalScale=new W9(1,1),this.displacementMap=null,this.displacementScale=1,this.displacementBias=0,this.alphaMap=null,this.skinning=!1,this.morphTargets=!1,this.morphNormals=!1,this.setValues(t)}function Tit(t){yrt.call(this),this.type="LineDashedMaterial",this.scale=1,this.dashSize=3,this.gapSize=1,this.setValues(t)}(yit.prototype=Object.create(ynt.prototype)).constructor=yit,yit.prototype.isShadowMaterial=!0,yit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this},(kit.prototype=Object.create(Met.prototype)).constructor=kit,kit.prototype.isRawShaderMaterial=!0,(vit.prototype=Object.create(ynt.prototype)).constructor=vit,vit.prototype.isMeshStandardMaterial=!0,vit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.defines={STANDARD:""},this.color.copy(t.color),this.roughness=t.roughness,this.metalness=t.metalness,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.roughnessMap=t.roughnessMap,this.metalnessMap=t.metalnessMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.envMapIntensity=t.envMapIntensity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this.vertexTangents=t.vertexTangents,this},(wit.prototype=Object.create(vit.prototype)).constructor=wit,wit.prototype.isMeshPhysicalMaterial=!0,wit.prototype.copy=function(t){return vit.prototype.copy.call(this,t),this.defines={STANDARD:"",PHYSICAL:""},this.clearcoat=t.clearcoat,this.clearcoatMap=t.clearcoatMap,this.clearcoatRoughness=t.clearcoatRoughness,this.clearcoatRoughnessMap=t.clearcoatRoughnessMap,this.clearcoatNormalMap=t.clearcoatNormalMap,this.clearcoatNormalScale.copy(t.clearcoatNormalScale),this.reflectivity=t.reflectivity,this.sheen=t.sheen?(this.sheen||new Ont).copy(t.sheen):null,this.transmission=t.transmission,this.transmissionMap=t.transmissionMap,this},(Sit.prototype=Object.create(ynt.prototype)).constructor=Sit,Sit.prototype.isMeshPhongMaterial=!0,Sit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.specular.copy(t.specular),this.shininess=t.shininess,this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(Eit.prototype=Object.create(ynt.prototype)).constructor=Eit,Eit.prototype.isMeshToonMaterial=!0,Eit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.gradientMap=t.gradientMap,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(Ait.prototype=Object.create(ynt.prototype)).constructor=Ait,Ait.prototype.isMeshNormalMaterial=!0,Ait.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(zit.prototype=Object.create(ynt.prototype)).constructor=zit,zit.prototype.isMeshLambertMaterial=!0,zit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.color.copy(t.color),this.map=t.map,this.lightMap=t.lightMap,this.lightMapIntensity=t.lightMapIntensity,this.aoMap=t.aoMap,this.aoMapIntensity=t.aoMapIntensity,this.emissive.copy(t.emissive),this.emissiveMap=t.emissiveMap,this.emissiveIntensity=t.emissiveIntensity,this.specularMap=t.specularMap,this.alphaMap=t.alphaMap,this.envMap=t.envMap,this.combine=t.combine,this.reflectivity=t.reflectivity,this.refractionRatio=t.refractionRatio,this.wireframe=t.wireframe,this.wireframeLinewidth=t.wireframeLinewidth,this.wireframeLinecap=t.wireframeLinecap,this.wireframeLinejoin=t.wireframeLinejoin,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(Rit.prototype=Object.create(ynt.prototype)).constructor=Rit,Rit.prototype.isMeshMatcapMaterial=!0,Rit.prototype.copy=function(t){return ynt.prototype.copy.call(this,t),this.defines={MATCAP:""},this.color.copy(t.color),this.matcap=t.matcap,this.map=t.map,this.bumpMap=t.bumpMap,this.bumpScale=t.bumpScale,this.normalMap=t.normalMap,this.normalMapType=t.normalMapType,this.normalScale.copy(t.normalScale),this.displacementMap=t.displacementMap,this.displacementScale=t.displacementScale,this.displacementBias=t.displacementBias,this.alphaMap=t.alphaMap,this.skinning=t.skinning,this.morphTargets=t.morphTargets,this.morphNormals=t.morphNormals,this},(Tit.prototype=Object.create(yrt.prototype)).constructor=Tit,Tit.prototype.isLineDashedMaterial=!0,Tit.prototype.copy=function(t){return yrt.prototype.copy.call(this,t),this.scale=t.scale,this.dashSize=t.dashSize,this.gapSize=t.gapSize,this};var Dit=Object.freeze({__proto__:null,ShadowMaterial:yit,SpriteMaterial:Wot,RawShaderMaterial:kit,ShaderMaterial:Met,PointsMaterial:Irt,MeshPhysicalMaterial:wit,MeshStandardMaterial:vit,MeshPhongMaterial:Sit,MeshToonMaterial:Eit,MeshNormalMaterial:Ait,MeshLambertMaterial:zit,MeshDepthMaterial:wot,MeshDistanceMaterial:Sot,MeshBasicMaterial:knt,MeshMatcapMaterial:Rit,LineDashedMaterial:Tit,LineBasicMaterial:yrt,Material:ynt});const Iit={arraySlice:function(t,n,e){return Iit.isTypedArray(t)?new t.constructor(t.subarray(n,void 0!==e?e:t.length)):t.slice(n,e)},convertArray:function(t,n,e){return!t||!e&&t.constructor===n?t:"number"==typeof n.BYTES_PER_ELEMENT?new n(t):Array.prototype.slice.call(t)},isTypedArray:function(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)},getKeyframeOrder:function(t){const n=t.length,e=new Array(n);for(let t=0;t!==n;++t)e[t]=t;return e.sort((function a(n,e){return t[n]-t[e]})),e},sortedArray:function(t,n,e){const a=t.length,o=new t.constructor(a);for(let r=0,i=0;i!==a;++r){const a=e[r]*n;for(let e=0;e!==n;++e)o[i++]=t[a+e]}return o},flattenJSON:function(t,n,e,a){let o=1,r=t[0];for(;void 0!==r&&void 0===r[a];)r=t[o++];if(void 0===r)return;let i=r[a];if(void 0!==i)if(Array.isArray(i))do{i=r[a],void 0!==i&&(n.push(r.time),e.push.apply(e,i)),r=t[o++]}while(void 0!==r);else if(void 0!==i.toArray)do{i=r[a],void 0!==i&&(n.push(r.time),i.toArray(e,e.length)),r=t[o++]}while(void 0!==r);else do{i=r[a],void 0!==i&&(n.push(r.time),e.push(i)),r=t[o++]}while(void 0!==r)},subclip:function(t,n,e,a,o=30){const r=t.clone();r.name=n;const i=[];for(let t=0;t<r.tracks.length;++t){const n=r.tracks[t],c=n.getValueSize(),s=[],l=[];for(let t=0;t<n.times.length;++t){const r=n.times[t]*o;if(!(r<e||r>=a)){s.push(n.times[t]);for(let e=0;e<c;++e)l.push(n.values[t*c+e])}}0!==s.length&&(n.times=Iit.convertArray(s,n.times.constructor),n.values=Iit.convertArray(l,n.values.constructor),i.push(n))}r.tracks=i;let c=1/0;for(let t=0;t<r.tracks.length;++t)c>r.tracks[t].times[0]&&(c=r.tracks[t].times[0]);for(let t=0;t<r.tracks.length;++t)r.tracks[t].shift(-1*c);return r.resetDuration(),r},makeClipAdditive:function(t,n=0,e=t,a=30){a<=0&&(a=30);const o=e.tracks.length,r=n/a;for(let n=0;n<o;++n){const a=e.tracks[n],o=a.ValueTypeName;if("bool"===o||"string"===o)continue;const i=t.tracks.find((function(t){return t.name===a.name&&t.ValueTypeName===o}));if(void 0===i)continue;let c=0;const s=a.getValueSize();a.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(c=s/3);let l=0;const m=i.getValueSize();i.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline&&(l=m/3);const d=a.times.length-1;let g;if(r<=a.times[0])g=Iit.arraySlice(a.values,c,s-c);else if(r>=a.times[d]){const t=d*s+c;g=Iit.arraySlice(a.values,t,t+s-c)}else{const t=a.createInterpolant(),n=c,e=s-c;t.evaluate(r),g=Iit.arraySlice(t.resultBuffer,n,e)}"quaternion"===o&&(new $9).fromArray(g).normalize().conjugate().toArray(g);const p=i.times.length;for(let t=0;t<p;++t){const n=t*m+l;if("quaternion"===o)$9.multiplyQuaternionsFlat(i.values,n,g,0,i.values,n);else{const t=m-2*l;for(let e=0;e<t;++e)i.values[n+e]-=g[e]}}}return t.blendMode=2501,t}};function Nit(t,n,e,a){this.parameterPositions=t,this._cachedIndex=0,this.resultBuffer=void 0!==a?a:new n.constructor(e),this.sampleValues=n,this.valueSize=e}function Fit(t,n,e,a){Nit.call(this,t,n,e,a),this._weightPrev=-0,this._offsetPrev=-0,this._weightNext=-0,this._offsetNext=-0}function Lit(t,n,e,a){Nit.call(this,t,n,e,a)}function Hit(t,n,e,a){Nit.call(this,t,n,e,a)}function Bit(t,n,e,a){if(void 0===t)throw new Error("THREE.KeyframeTrack: track name is undefined");if(void 0===n||0===n.length)throw new Error("THREE.KeyframeTrack: no keyframes in track named "+t);this.name=t,this.times=Iit.convertArray(n,this.TimeBufferType),this.values=Iit.convertArray(e,this.ValueBufferType),this.setInterpolation(a||this.DefaultInterpolation)}function Vit(t,n,e){Bit.call(this,t,n,e)}function jit(t,n,e,a){Bit.call(this,t,n,e,a)}function Uit(t,n,e,a){Bit.call(this,t,n,e,a)}function Wit(t,n,e,a){Nit.call(this,t,n,e,a)}function Git(t,n,e,a){Bit.call(this,t,n,e,a)}function Yit(t,n,e,a){Bit.call(this,t,n,e,a)}function qit(t,n,e,a){Bit.call(this,t,n,e,a)}function Zit(t,n=-1,e,a=2500){this.name=t,this.tracks=e,this.duration=n,this.blendMode=a,this.uuid=U9.generateUUID(),this.duration<0&&this.resetDuration()}function Xit(t){if(void 0===t.type)throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");const n=(function e(t){switch(t.toLowerCase()){case"scalar":case"double":case"float":case"number":case"integer":return Uit;case"vector":case"vector2":case"vector3":case"vector4":return qit;case"color":return jit;case"quaternion":return Git;case"bool":case"boolean":return Vit;case"string":return Yit}throw new Error("THREE.KeyframeTrack: Unsupported typeName: "+t)})(t.type);if(void 0===t.times){const n=[],e=[];Iit.flattenJSON(t.keys,n,e,"value"),t.times=n,t.values=e}return void 0!==n.parse?n.parse(t):new n(t.name,t.times,t.values,t.interpolation)}Object.assign(Nit.prototype,{evaluate:function(t){const n=this.parameterPositions;let e=this._cachedIndex,a=n[e],o=n[e-1];t:{n:{let r;e:{a:if(!(t<a)){for(let r=e+2;;){if(void 0===a){if(t<o)break a;return e=n.length,this._cachedIndex=e,this.afterEnd_(e-1,t,o)}if(e===r)break;if(o=a,a=n[++e],t<a)break n}r=n.length;break e}if(t>=o)break t;{const i=n[1];t<i&&(e=2,o=i);for(let r=e-2;;){if(void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,a);if(e===r)break;if(a=o,o=n[--e-1],t>=o)break n}r=e,e=0}}for(;e<r;){const a=e+r>>>1;t<n[a]?r=a:e=a+1}if(a=n[e],o=n[e-1],void 0===o)return this._cachedIndex=0,this.beforeStart_(0,t,a);if(void 0===a)return e=n.length,this._cachedIndex=e,this.afterEnd_(e-1,o,t)}this._cachedIndex=e,this.intervalChanged_(e,o,a)}return this.interpolate_(e,o,t,a)},settings:null,DefaultSettings_:{},getSettings_:function(){return this.settings||this.DefaultSettings_},copySampleValue_:function(t){const n=this.resultBuffer,e=this.sampleValues,a=this.valueSize,o=t*a;for(let t=0;t!==a;++t)n[t]=e[o+t];return n},interpolate_:function(){throw new Error("call to abstract method")},intervalChanged_:function(){}}),Object.assign(Nit.prototype,{beforeStart_:Nit.prototype.copySampleValue_,afterEnd_:Nit.prototype.copySampleValue_}),Fit.prototype=Object.assign(Object.create(Nit.prototype),{constructor:Fit,DefaultSettings_:{endingStart:R9,endingEnd:R9},intervalChanged_:function(t,n,e){const a=this.parameterPositions;let o=t-2,r=t+1,i=a[o],c=a[r];if(void 0===i)switch(this.getSettings_().endingStart){case T9:o=t,i=2*n-e;break;case D9:o=a.length-2,i=n+a[o]-a[o+1];break;default:o=t,i=e}if(void 0===c)switch(this.getSettings_().endingEnd){case T9:r=t,c=2*e-n;break;case D9:r=1,c=e+a[1]-a[0];break;default:r=t-1,c=n}const s=.5*(e-n),l=this.valueSize;this._weightPrev=s/(n-i),this._weightNext=s/(c-e),this._offsetPrev=o*l,this._offsetNext=r*l},interpolate_:function(t,n,e,a){const o=this.resultBuffer,r=this.sampleValues,i=this.valueSize,c=t*i,s=c-i,l=this._offsetPrev,m=this._offsetNext,d=this._weightPrev,g=this._weightNext,p=(e-n)/(a-n),b=p*p,u=b*p,f=-d*u+2*d*b-d*p,h=(1+d)*u+(-1.5-2*d)*b+(-.5+d)*p+1,_=(-1-g)*u+(1.5+g)*b+.5*p,C=g*u-g*b;for(let t=0;t!==i;++t)o[t]=f*r[l+t]+h*r[s+t]+_*r[c+t]+C*r[m+t];return o}}),Lit.prototype=Object.assign(Object.create(Nit.prototype),{constructor:Lit,interpolate_:function(t,n,e,a){const o=this.resultBuffer,r=this.sampleValues,i=this.valueSize,c=t*i,s=c-i,l=(e-n)/(a-n),m=1-l;for(let t=0;t!==i;++t)o[t]=r[s+t]*m+r[c+t]*l;return o}}),Hit.prototype=Object.assign(Object.create(Nit.prototype),{constructor:Hit,interpolate_:function(t){return this.copySampleValue_(t-1)}}),Object.assign(Bit,{toJSON:function(t){const n=t.constructor;let e;if(void 0!==n.toJSON)e=n.toJSON(t);else{e={name:t.name,times:Iit.convertArray(t.times,Array),values:Iit.convertArray(t.values,Array)};const n=t.getInterpolation();n!==t.DefaultInterpolation&&(e.interpolation=n)}return e.type=t.ValueTypeName,e}}),Object.assign(Bit.prototype,{constructor:Bit,TimeBufferType:Float32Array,ValueBufferType:Float32Array,DefaultInterpolation:A9,InterpolantFactoryMethodDiscrete:function(t){return new Hit(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodLinear:function(t){return new Lit(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodSmooth:function(t){return new Fit(this.times,this.values,this.getValueSize(),t)},setInterpolation:function(t){let n;switch(t){case E9:n=this.InterpolantFactoryMethodDiscrete;break;case A9:n=this.InterpolantFactoryMethodLinear;break;case z9:n=this.InterpolantFactoryMethodSmooth}if(void 0===n){const n="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant){if(t===this.DefaultInterpolation)throw new Error(n);this.setInterpolation(this.DefaultInterpolation)}return console.warn("THREE.KeyframeTrack:",n),this}return this.createInterpolant=n,this},getInterpolation:function(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return E9;case this.InterpolantFactoryMethodLinear:return A9;case this.InterpolantFactoryMethodSmooth:return z9}},getValueSize:function(){return this.values.length/this.times.length},shift:function(t){if(0!==t){const n=this.times;for(let e=0,a=n.length;e!==a;++e)n[e]+=t}return this},scale:function(t){if(1!==t){const n=this.times;for(let e=0,a=n.length;e!==a;++e)n[e]*=t}return this},trim:function(t,n){const e=this.times,a=e.length;let o=0,r=a-1;for(;o!==a&&e[o]<t;)++o;for(;-1!==r&&e[r]>n;)--r;if(++r,0!==o||r!==a){o>=r&&(r=Math.max(r,1),o=r-1);const t=this.getValueSize();this.times=Iit.arraySlice(e,o,r),this.values=Iit.arraySlice(this.values,o*t,r*t)}return this},validate:function(){let t=!0;const n=this.getValueSize();n-Math.floor(n)!=0&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),t=!1);const e=this.times,a=this.values,o=e.length;0===o&&(console.error("THREE.KeyframeTrack: Track is empty.",this),t=!1);let r=null;for(let n=0;n!==o;n++){const a=e[n];if("number"==typeof a&&isNaN(a)){console.error("THREE.KeyframeTrack: Time is not a valid number.",this,n,a),t=!1;break}if(null!==r&&r>a){console.error("THREE.KeyframeTrack: Out of order keys.",this,n,a,r),t=!1;break}r=a}if(void 0!==a&&Iit.isTypedArray(a))for(let n=0,e=a.length;n!==e;++n){const e=a[n];if(isNaN(e)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,n,e),t=!1;break}}return t},optimize:function(){const t=Iit.arraySlice(this.times),n=Iit.arraySlice(this.values),e=this.getValueSize(),a=this.getInterpolation()===z9,o=t.length-1;let r=1;for(let i=1;i<o;++i){let o=!1;const c=t[i];if(c!==t[i+1]&&(1!==i||c!==t[0]))if(a)o=!0;else{const t=i*e,a=t-e,r=t+e;for(let i=0;i!==e;++i){const e=n[t+i];if(e!==n[a+i]||e!==n[r+i]){o=!0;break}}}if(o){if(i!==r){t[r]=t[i];const a=i*e,o=r*e;for(let t=0;t!==e;++t)n[o+t]=n[a+t]}++r}}if(o>0){t[r]=t[o];for(let t=o*e,a=r*e,i=0;i!==e;++i)n[a+i]=n[t+i];++r}return r!==t.length?(this.times=Iit.arraySlice(t,0,r),this.values=Iit.arraySlice(n,0,r*e)):(this.times=t,this.values=n),this},clone:function(){const t=Iit.arraySlice(this.times,0),n=Iit.arraySlice(this.values,0),e=new(0,this.constructor)(this.name,t,n);return e.createInterpolant=this.createInterpolant,e}}),Vit.prototype=Object.assign(Object.create(Bit.prototype),{constructor:Vit,ValueTypeName:"bool",ValueBufferType:Array,DefaultInterpolation:E9,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0}),jit.prototype=Object.assign(Object.create(Bit.prototype),{constructor:jit,ValueTypeName:"color"}),Uit.prototype=Object.assign(Object.create(Bit.prototype),{constructor:Uit,ValueTypeName:"number"}),Wit.prototype=Object.assign(Object.create(Nit.prototype),{constructor:Wit,interpolate_:function(t,n,e,a){const o=this.resultBuffer,r=this.sampleValues,i=this.valueSize,c=(e-n)/(a-n);let s=t*i;for(let t=s+i;s!==t;s+=4)$9.slerpFlat(o,0,r,s-i,r,s,c);return o}}),Git.prototype=Object.assign(Object.create(Bit.prototype),{constructor:Git,ValueTypeName:"quaternion",DefaultInterpolation:A9,InterpolantFactoryMethodLinear:function(t){return new Wit(this.times,this.values,this.getValueSize(),t)},InterpolantFactoryMethodSmooth:void 0}),Yit.prototype=Object.assign(Object.create(Bit.prototype),{constructor:Yit,ValueTypeName:"string",ValueBufferType:Array,DefaultInterpolation:E9,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0}),qit.prototype=Object.assign(Object.create(Bit.prototype),{constructor:qit,ValueTypeName:"vector"}),Object.assign(Zit,{parse:function(t){const n=[],e=t.tracks,a=1/(t.fps||1);for(let t=0,o=e.length;t!==o;++t)n.push(Xit(e[t]).scale(a));const o=new Zit(t.name,t.duration,n,t.blendMode);return o.uuid=t.uuid,o},toJSON:function(t){const n=[],e=t.tracks,a={name:t.name,duration:t.duration,tracks:n,uuid:t.uuid,blendMode:t.blendMode};for(let t=0,a=e.length;t!==a;++t)n.push(Bit.toJSON(e[t]));return a},CreateFromMorphTargetSequence:function(t,n,e,a){const o=n.length,r=[];for(let t=0;t<o;t++){let i=[],c=[];i.push((t+o-1)%o,t,(t+1)%o),c.push(0,1,0);const s=Iit.getKeyframeOrder(i);i=Iit.sortedArray(i,1,s),c=Iit.sortedArray(c,1,s),a||0!==i[0]||(i.push(o),c.push(c[0])),r.push(new Uit(".morphTargetInfluences["+n[t].name+"]",i,c).scale(1/e))}return new Zit(t,-1,r)},findByName:function(t,n){let e=t;if(!Array.isArray(t)){const n=t;e=n.geometry&&n.geometry.animations||n.animations}for(let t=0;t<e.length;t++)if(e[t].name===n)return e[t];return null},CreateClipsFromMorphTargetSequences:function(t,n,e){const a={},o=/^([\w-]*?)([\d]+)$/;for(let n=0,e=t.length;n<e;n++){const e=t[n],r=e.name.match(o);if(r&&r.length>1){const t=r[1];let n=a[t];n||(a[t]=n=[]),n.push(e)}}const r=[];for(const t in a)r.push(Zit.CreateFromMorphTargetSequence(t,a[t],n,e));return r},parseAnimation:function(t,n){if(!t)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;const e=function(t,n,e,a,o){if(0!==e.length){const r=[],i=[];Iit.flattenJSON(e,r,i,a),0!==r.length&&o.push(new t(n,r,i))}},a=[],o=t.name||"default",r=t.fps||30,i=t.blendMode;let c=t.length||-1;const s=t.hierarchy||[];for(let t=0;t<s.length;t++){const o=s[t].keys;if(o&&0!==o.length)if(o[0].morphTargets){const t={};let n;for(n=0;n<o.length;n++)if(o[n].morphTargets)for(let e=0;e<o[n].morphTargets.length;e++)t[o[n].morphTargets[e]]=-1;for(const e in t){const t=[],r=[];for(let a=0;a!==o[n].morphTargets.length;++a){const a=o[n];t.push(a.time),r.push(a.morphTarget===e?1:0)}a.push(new Uit(".morphTargetInfluence["+e+"]",t,r))}c=t.length*(r||1)}else{const r=".bones["+n[t].name+"]";e(qit,r+".position",o,"pos",a),e(Git,r+".quaternion",o,"rot",a),e(qit,r+".scale",o,"scl",a)}}return 0===a.length?null:new Zit(o,c,a,i)}}),Object.assign(Zit.prototype,{resetDuration:function(){let t=0;for(let n=0,e=this.tracks.length;n!==e;++n){const e=this.tracks[n];t=Math.max(t,e.times[e.times.length-1])}return this.duration=t,this},trim:function(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].trim(0,this.duration);return this},validate:function(){let t=!0;for(let n=0;n<this.tracks.length;n++)t=t&&this.tracks[n].validate();return t},optimize:function(){for(let t=0;t<this.tracks.length;t++)this.tracks[t].optimize();return this},clone:function(){const t=[];for(let n=0;n<this.tracks.length;n++)t.push(this.tracks[n].clone());return new Zit(this.name,this.duration,t,this.blendMode)},toJSON:function(){return Zit.toJSON(this)}});const Jit={enabled:!1,files:{},add:function(t,n){!1!==this.enabled&&(this.files[t]=n)},get:function(t){if(!1!==this.enabled)return this.files[t]},remove:function(t){delete this.files[t]},clear:function(){this.files={}}},Qit=new(function Kit(t,n,e){const a=this;let o,r=!1,i=0,c=0;const s=[];this.onStart=void 0,this.onLoad=t,this.onProgress=n,this.onError=e,this.itemStart=function(t){c++,!1===r&&void 0!==a.onStart&&a.onStart(t,i,c),r=!0},this.itemEnd=function(t){i++,void 0!==a.onProgress&&a.onProgress(t,i,c),i===c&&(r=!1,void 0!==a.onLoad&&a.onLoad())},this.itemError=function(t){void 0!==a.onError&&a.onError(t)},this.resolveURL=function(t){return o?o(t):t},this.setURLModifier=function(t){return o=t,this},this.addHandler=function(t,n){return s.push(t,n),this},this.removeHandler=function(t){const n=s.indexOf(t);return-1!==n&&s.splice(n,2),this},this.getHandler=function(t){for(let n=0,e=s.length;n<e;n+=2){const e=s[n],a=s[n+1];if(e.global&&(e.lastIndex=0),e.test(t))return a}return null}});function $it(t){this.manager=void 0!==t?t:Qit,this.crossOrigin="anonymous",this.withCredentials=!1,this.path="",this.resourcePath="",this.requestHeader={}}Object.assign($it.prototype,{load:function(){},loadAsync:function(t,n){const e=this;return new Promise((function(a,o){e.load(t,a,n,o)}))},parse:function(){},setCrossOrigin:function(t){return this.crossOrigin=t,this},setWithCredentials:function(t){return this.withCredentials=t,this},setPath:function(t){return this.path=t,this},setResourcePath:function(t){return this.resourcePath=t,this},setRequestHeader:function(t){return this.requestHeader=t,this}});const tct={};function nct(t){$it.call(this,t)}function ect(t){$it.call(this,t)}function act(t){$it.call(this,t)}function oct(t){$it.call(this,t)}function rct(t){$it.call(this,t)}function ict(t){$it.call(this,t)}function cct(t){$it.call(this,t)}function sct(){this.type="Curve",this.arcLengthDivisions=200}function lct(t,n,e,a,o,r,i,c){sct.call(this),this.type="EllipseCurve",this.aX=t||0,this.aY=n||0,this.xRadius=e||1,this.yRadius=a||1,this.aStartAngle=o||0,this.aEndAngle=r||2*Math.PI,this.aClockwise=i||!1,this.aRotation=c||0}function mct(t,n,e,a,o,r){lct.call(this,t,n,e,e,a,o,r),this.type="ArcCurve"}function dct(){let t=0,n=0,e=0,a=0;function o(o,r,i,c){t=o,n=i,e=-3*o+3*r-2*i-c,a=2*o-2*r+i+c}return{initCatmullRom:function(t,n,e,a,r){o(n,e,r*(e-t),r*(a-n))},initNonuniformCatmullRom:function(t,n,e,a,r,i,c){let s=(n-t)/r-(e-t)/(r+i)+(e-n)/i,l=(e-n)/i-(a-n)/(i+c)+(a-e)/c;s*=i,l*=i,o(n,e,s,l)},calc:function(o){const r=o*o;return t+n*o+e*r+a*(r*o)}}}nct.prototype=Object.assign(Object.create($it.prototype),{constructor:nct,load:function(t,n,e,a){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const o=this,r=Jit.get(t);if(void 0!==r)return o.manager.itemStart(t),setTimeout((function(){n&&n(r),o.manager.itemEnd(t)}),0),r;if(void 0!==tct[t])return void tct[t].push({onLoad:n,onProgress:e,onError:a});const i=t.match(/^data:(.*?)(;base64)?,(.*)$/);let c;if(i){const e=i[1],r=!!i[2];let c=i[3];c=decodeURIComponent(c),r&&(c=atob(c));try{let a;const r=(this.responseType||"").toLowerCase();switch(r){case"arraybuffer":case"blob":const t=new Uint8Array(c.length);for(let n=0;n<c.length;n++)t[n]=c.charCodeAt(n);a="blob"===r?new Blob([t.buffer],{type:e}):t.buffer;break;case"document":const n=new DOMParser;a=n.parseFromString(c,e);break;case"json":a=JSON.parse(c);break;default:a=c}setTimeout((function(){n&&n(a),o.manager.itemEnd(t)}),0)}catch(n){setTimeout((function(){a&&a(n),o.manager.itemError(t),o.manager.itemEnd(t)}),0)}}else{tct[t]=[],tct[t].push({onLoad:n,onProgress:e,onError:a}),c=new XMLHttpRequest,c.open("GET",t,!0),c.addEventListener("load",(function(n){const e=this.response,a=tct[t];if(delete tct[t],200===this.status||0===this.status){0===this.status&&console.warn("THREE.FileLoader: HTTP Status 0 received."),Jit.add(t,e);for(let t=0,n=a.length;t<n;t++){const n=a[t];n.onLoad&&n.onLoad(e)}o.manager.itemEnd(t)}else{for(let t=0,e=a.length;t<e;t++){const e=a[t];e.onError&&e.onError(n)}o.manager.itemError(t),o.manager.itemEnd(t)}}),!1),c.addEventListener("progress",(function(n){const e=tct[t];for(let t=0,a=e.length;t<a;t++){const a=e[t];a.onProgress&&a.onProgress(n)}}),!1),c.addEventListener("error",(function(n){const e=tct[t];delete tct[t];for(let t=0,a=e.length;t<a;t++){const a=e[t];a.onError&&a.onError(n)}o.manager.itemError(t),o.manager.itemEnd(t)}),!1),c.addEventListener("abort",(function(n){const e=tct[t];delete tct[t];for(let t=0,a=e.length;t<a;t++){const a=e[t];a.onError&&a.onError(n)}o.manager.itemError(t),o.manager.itemEnd(t)}),!1),void 0!==this.responseType&&(c.responseType=this.responseType),void 0!==this.withCredentials&&(c.withCredentials=this.withCredentials),c.overrideMimeType&&c.overrideMimeType(void 0!==this.mimeType?this.mimeType:"text/plain");for(const t in this.requestHeader)c.setRequestHeader(t,this.requestHeader[t]);c.send(null)}return o.manager.itemStart(t),c},setResponseType:function(t){return this.responseType=t,this},setMimeType:function(t){return this.mimeType=t,this}}),ect.prototype=Object.assign(Object.create($it.prototype),{constructor:ect,load:function(t,n,e,a){const o=this,r=new nct(o.manager);r.setPath(o.path),r.setRequestHeader(o.requestHeader),r.setWithCredentials(o.withCredentials),r.load(t,(function(e){try{n(o.parse(JSON.parse(e)))}catch(n){a?a(n):console.error(n),o.manager.itemError(t)}}),e,a)},parse:function(t){const n=[];for(let e=0;e<t.length;e++){const a=Zit.parse(t[e]);n.push(a)}return n}}),act.prototype=Object.assign(Object.create($it.prototype),{constructor:act,load:function(t,n,e,a){const o=this,r=[],i=new Urt,c=new nct(this.manager);c.setPath(this.path),c.setResponseType("arraybuffer"),c.setRequestHeader(this.requestHeader),c.setWithCredentials(o.withCredentials);let s=0;function l(l){c.load(t[l],(function(t){const e=o.parse(t,!0);r[l]={width:e.width,height:e.height,format:e.format,mipmaps:e.mipmaps},s+=1,6===s&&(1===e.mipmapCount&&(i.minFilter=_9),i.image=r,i.format=e.format,i.needsUpdate=!0,n&&n(i))}),e,a)}if(Array.isArray(t))for(let n=0,e=t.length;n<e;++n)l(n);else c.load(t,(function(t){const e=o.parse(t,!0);if(e.isCubemap){const t=e.mipmaps.length/e.mipmapCount;for(let n=0;n<t;n++){r[n]={mipmaps:[]};for(let t=0;t<e.mipmapCount;t++)r[n].mipmaps.push(e.mipmaps[n*e.mipmapCount+t]),r[n].format=e.format,r[n].width=e.width,r[n].height=e.height}i.image=r}else i.image.width=e.width,i.image.height=e.height,i.mipmaps=e.mipmaps;1===e.mipmapCount&&(i.minFilter=_9),i.format=e.format,i.needsUpdate=!0,n&&n(i)}),e,a);return i}}),oct.prototype=Object.assign(Object.create($it.prototype),{constructor:oct,load:function(t,n,e,a){void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const o=this,r=Jit.get(t);if(void 0!==r)return o.manager.itemStart(t),setTimeout((function(){n&&n(r),o.manager.itemEnd(t)}),0),r;const i=document.createElementNS("http://www.w3.org/1999/xhtml","img");function c(){i.removeEventListener("load",c,!1),i.removeEventListener("error",s,!1),Jit.add(t,this),n&&n(this),o.manager.itemEnd(t)}function s(n){i.removeEventListener("load",c,!1),i.removeEventListener("error",s,!1),a&&a(n),o.manager.itemError(t),o.manager.itemEnd(t)}return i.addEventListener("load",c,!1),i.addEventListener("error",s,!1),"data:"!==t.substr(0,5)&&void 0!==this.crossOrigin&&(i.crossOrigin=this.crossOrigin),o.manager.itemStart(t),i.src=t,i}}),rct.prototype=Object.assign(Object.create($it.prototype),{constructor:rct,load:function(t,n,e,a){const o=new ket,r=new oct(this.manager);r.setCrossOrigin(this.crossOrigin),r.setPath(this.path);let i=0;function c(e){r.load(t[e],(function(t){o.images[e]=t,i++,6===i&&(o.needsUpdate=!0,n&&n(o))}),void 0,a)}for(let n=0;n<t.length;++n)c(n);return o}}),ict.prototype=Object.assign(Object.create($it.prototype),{constructor:ict,load:function(t,n,e,a){const o=this,r=new wet,i=new nct(this.manager);return i.setResponseType("arraybuffer"),i.setRequestHeader(this.requestHeader),i.setPath(this.path),i.setWithCredentials(o.withCredentials),i.load(t,(function(t){const e=o.parse(t);e&&(void 0!==e.image?r.image=e.image:void 0!==e.data&&(r.image.width=e.width,r.image.height=e.height,r.image.data=e.data),r.wrapS=void 0!==e.wrapS?e.wrapS:u9,r.wrapT=void 0!==e.wrapT?e.wrapT:u9,r.magFilter=void 0!==e.magFilter?e.magFilter:_9,r.minFilter=void 0!==e.minFilter?e.minFilter:_9,r.anisotropy=void 0!==e.anisotropy?e.anisotropy:1,void 0!==e.encoding&&(r.encoding=e.encoding),void 0!==e.flipY&&(r.flipY=e.flipY),void 0!==e.format&&(r.format=e.format),void 0!==e.type&&(r.type=e.type),void 0!==e.mipmaps&&(r.mipmaps=e.mipmaps,r.minFilter=C9),1===e.mipmapCount&&(r.minFilter=_9),r.needsUpdate=!0,n&&n(r,e))}),e,a),r}}),cct.prototype=Object.assign(Object.create($it.prototype),{constructor:cct,load:function(t,n,e,a){const o=new X9,r=new oct(this.manager);return r.setCrossOrigin(this.crossOrigin),r.setPath(this.path),r.load(t,(function(e){o.image=e;const a=t.search(/\.jpe?g($|\?)/i)>0||0===t.search(/^data\:image\/jpeg/);o.format=a?k9:v9,o.needsUpdate=!0,void 0!==n&&n(o)}),e,a),o}}),Object.assign(sct.prototype,{getPoint:function(){return console.warn("THREE.Curve: .getPoint() not implemented."),null},getPointAt:function(t,n){const e=this.getUtoTmapping(t);return this.getPoint(e,n)},getPoints:function(t=5){const n=[];for(let e=0;e<=t;e++)n.push(this.getPoint(e/t));return n},getSpacedPoints:function(t=5){const n=[];for(let e=0;e<=t;e++)n.push(this.getPointAt(e/t));return n},getLength:function(){const t=this.getLengths();return t[t.length-1]},getLengths:function(t){if(void 0===t&&(t=this.arcLengthDivisions),this.cacheArcLengths&&this.cacheArcLengths.length===t+1&&!this.needsUpdate)return this.cacheArcLengths;this.needsUpdate=!1;const n=[];let e,a=this.getPoint(0),o=0;n.push(0);for(let r=1;r<=t;r++)e=this.getPoint(r/t),o+=e.distanceTo(a),n.push(o),a=e;return this.cacheArcLengths=n,n},updateArcLengths:function(){this.needsUpdate=!0,this.getLengths()},getUtoTmapping:function(t,n){const e=this.getLengths();let a=0;const o=e.length;let r;r=n||t*e[o-1];let i,c=0,s=o-1;for(;c<=s;)if(a=Math.floor(c+(s-c)/2),i=e[a]-r,i<0)c=a+1;else{if(!(i>0)){s=a;break}s=a-1}if(a=s,e[a]===r)return a/(o-1);const l=e[a];return(a+(r-l)/(e[a+1]-l))/(o-1)},getTangent:function(t,n){const e=1e-4;let a=t-e,o=t+e;a<0&&(a=0),o>1&&(o=1);const r=this.getPoint(a),i=this.getPoint(o),c=n||(r.isVector2?new W9:new ttt);return c.copy(i).sub(r).normalize(),c},getTangentAt:function(t,n){const e=this.getUtoTmapping(t);return this.getTangent(e,n)},computeFrenetFrames:function(t,n){const e=new ttt,a=[],o=[],r=[],i=new ttt,c=new Stt;for(let n=0;n<=t;n++)a[n]=this.getTangentAt(n/t,new ttt),a[n].normalize();o[0]=new ttt,r[0]=new ttt;let s=Number.MAX_VALUE;const l=Math.abs(a[0].x),m=Math.abs(a[0].y),d=Math.abs(a[0].z);l<=s&&(s=l,e.set(1,0,0)),m<=s&&(s=m,e.set(0,1,0)),d<=s&&e.set(0,0,1),i.crossVectors(a[0],e).normalize(),o[0].crossVectors(a[0],i),r[0].crossVectors(a[0],o[0]);for(let n=1;n<=t;n++){if(o[n]=o[n-1].clone(),r[n]=r[n-1].clone(),i.crossVectors(a[n-1],a[n]),i.length()>Number.EPSILON){i.normalize();const t=Math.acos(U9.clamp(a[n-1].dot(a[n]),-1,1));o[n].applyMatrix4(c.makeRotationAxis(i,t))}r[n].crossVectors(a[n],o[n])}if(!0===n){let n=Math.acos(U9.clamp(o[0].dot(o[t]),-1,1));n/=t,a[0].dot(i.crossVectors(o[0],o[t]))>0&&(n=-n);for(let e=1;e<=t;e++)o[e].applyMatrix4(c.makeRotationAxis(a[e],n*e)),r[e].crossVectors(a[e],o[e])}return{tangents:a,normals:o,binormals:r}},clone:function(){return(new this.constructor).copy(this)},copy:function(t){return this.arcLengthDivisions=t.arcLengthDivisions,this},toJSON:function(){const t={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};return t.arcLengthDivisions=this.arcLengthDivisions,t.type=this.type,t},fromJSON:function(t){return this.arcLengthDivisions=t.arcLengthDivisions,this}}),(lct.prototype=Object.create(sct.prototype)).constructor=lct,lct.prototype.isEllipseCurve=!0,lct.prototype.getPoint=function(t,n){const e=n||new W9,a=2*Math.PI;let o=this.aEndAngle-this.aStartAngle;const r=Math.abs(o)<Number.EPSILON;for(;o<0;)o+=a;for(;o>a;)o-=a;o<Number.EPSILON&&(o=r?0:a),!0!==this.aClockwise||r||(o===a?o=-a:o-=a);const i=this.aStartAngle+t*o;let c=this.aX+this.xRadius*Math.cos(i),s=this.aY+this.yRadius*Math.sin(i);if(0!==this.aRotation){const t=Math.cos(this.aRotation),n=Math.sin(this.aRotation),e=c-this.aX,a=s-this.aY;c=e*t-a*n+this.aX,s=e*n+a*t+this.aY}return e.set(c,s)},lct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this},lct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.aX=this.aX,t.aY=this.aY,t.xRadius=this.xRadius,t.yRadius=this.yRadius,t.aStartAngle=this.aStartAngle,t.aEndAngle=this.aEndAngle,t.aClockwise=this.aClockwise,t.aRotation=this.aRotation,t},lct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.aX=t.aX,this.aY=t.aY,this.xRadius=t.xRadius,this.yRadius=t.yRadius,this.aStartAngle=t.aStartAngle,this.aEndAngle=t.aEndAngle,this.aClockwise=t.aClockwise,this.aRotation=t.aRotation,this},(mct.prototype=Object.create(lct.prototype)).constructor=mct,mct.prototype.isArcCurve=!0;const gct=new ttt,pct=new dct,bct=new dct,uct=new dct;function fct(t=[],n=!1,e="centripetal",a=.5){sct.call(this),this.type="CatmullRomCurve3",this.points=t,this.closed=n,this.curveType=e,this.tension=a}function hct(t,n,e,a,o){const r=.5*(a-n),i=.5*(o-e),c=t*t;return(2*e-2*a+r+i)*(t*c)+(-3*e+3*a-2*r-i)*c+r*t+e}function _ct(t,n,e,a){return(function o(t,n){const e=1-t;return e*e*n})(t,n)+(function r(t,n){return 2*(1-t)*t*n})(t,e)+(function i(t,n){return t*t*n})(t,a)}function Cct(t,n,e,a,o){return(function r(t,n){const e=1-t;return e*e*e*n})(t,n)+(function i(t,n){const e=1-t;return 3*e*e*t*n})(t,e)+(function c(t,n){return 3*(1-t)*t*t*n})(t,a)+(function s(t,n){return t*t*t*n})(t,o)}function Mct(t=new W9,n=new W9,e=new W9,a=new W9){sct.call(this),this.type="CubicBezierCurve",this.v0=t,this.v1=n,this.v2=e,this.v3=a}function Oct(t=new ttt,n=new ttt,e=new ttt,a=new ttt){sct.call(this),this.type="CubicBezierCurve3",this.v0=t,this.v1=n,this.v2=e,this.v3=a}function Pct(t=new W9,n=new W9){sct.call(this),this.type="LineCurve",this.v1=t,this.v2=n}function xct(t=new ttt,n=new ttt){sct.call(this),this.type="LineCurve3",this.v1=t,this.v2=n}function yct(t=new W9,n=new W9,e=new W9){sct.call(this),this.type="QuadraticBezierCurve",this.v0=t,this.v1=n,this.v2=e}function kct(t=new ttt,n=new ttt,e=new ttt){sct.call(this),this.type="QuadraticBezierCurve3",this.v0=t,this.v1=n,this.v2=e}function vct(t=[]){sct.call(this),this.type="SplineCurve",this.points=t}(fct.prototype=Object.create(sct.prototype)).constructor=fct,fct.prototype.isCatmullRomCurve3=!0,fct.prototype.getPoint=function(t,n=new ttt){const e=n,a=this.points,o=a.length,r=(o-(this.closed?0:1))*t;let i,c,s=Math.floor(r),l=r-s;this.closed?s+=s>0?0:(Math.floor(Math.abs(s)/o)+1)*o:0===l&&s===o-1&&(s=o-2,l=1),this.closed||s>0?i=a[(s-1)%o]:(gct.subVectors(a[0],a[1]).add(a[0]),i=gct);const m=a[s%o],d=a[(s+1)%o];if(this.closed||s+2<o?c=a[(s+2)%o]:(gct.subVectors(a[o-1],a[o-2]).add(a[o-1]),c=gct),"centripetal"===this.curveType||"chordal"===this.curveType){const t="chordal"===this.curveType?.5:.25;let n=Math.pow(i.distanceToSquared(m),t),e=Math.pow(m.distanceToSquared(d),t),a=Math.pow(d.distanceToSquared(c),t);e<1e-4&&(e=1),n<1e-4&&(n=e),a<1e-4&&(a=e),pct.initNonuniformCatmullRom(i.x,m.x,d.x,c.x,n,e,a),bct.initNonuniformCatmullRom(i.y,m.y,d.y,c.y,n,e,a),uct.initNonuniformCatmullRom(i.z,m.z,d.z,c.z,n,e,a)}else"catmullrom"===this.curveType&&(pct.initCatmullRom(i.x,m.x,d.x,c.x,this.tension),bct.initCatmullRom(i.y,m.y,d.y,c.y,this.tension),uct.initCatmullRom(i.z,m.z,d.z,c.z,this.tension));return e.set(pct.calc(l),bct.calc(l),uct.calc(l)),e},fct.prototype.copy=function(t){sct.prototype.copy.call(this,t),this.points=[];for(let n=0,e=t.points.length;n<e;n++)this.points.push(t.points[n].clone());return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this},fct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);t.points=[];for(let n=0,e=this.points.length;n<e;n++)t.points.push(this.points[n].toArray());return t.closed=this.closed,t.curveType=this.curveType,t.tension=this.tension,t},fct.prototype.fromJSON=function(t){sct.prototype.fromJSON.call(this,t),this.points=[];for(let n=0,e=t.points.length;n<e;n++){const e=t.points[n];this.points.push((new ttt).fromArray(e))}return this.closed=t.closed,this.curveType=t.curveType,this.tension=t.tension,this},(Mct.prototype=Object.create(sct.prototype)).constructor=Mct,Mct.prototype.isCubicBezierCurve=!0,Mct.prototype.getPoint=function(t,n=new W9){const e=n,a=this.v0,o=this.v1,r=this.v2,i=this.v3;return e.set(Cct(t,a.x,o.x,r.x,i.x),Cct(t,a.y,o.y,r.y,i.y)),e},Mct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this},Mct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t},Mct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this},(Oct.prototype=Object.create(sct.prototype)).constructor=Oct,Oct.prototype.isCubicBezierCurve3=!0,Oct.prototype.getPoint=function(t,n=new ttt){const e=n,a=this.v0,o=this.v1,r=this.v2,i=this.v3;return e.set(Cct(t,a.x,o.x,r.x,i.x),Cct(t,a.y,o.y,r.y,i.y),Cct(t,a.z,o.z,r.z,i.z)),e},Oct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this.v3.copy(t.v3),this},Oct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t.v3=this.v3.toArray(),t},Oct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this.v3.fromArray(t.v3),this},(Pct.prototype=Object.create(sct.prototype)).constructor=Pct,Pct.prototype.isLineCurve=!0,Pct.prototype.getPoint=function(t,n=new W9){const e=n;return 1===t?e.copy(this.v2):(e.copy(this.v2).sub(this.v1),e.multiplyScalar(t).add(this.v1)),e},Pct.prototype.getPointAt=function(t,n){return this.getPoint(t,n)},Pct.prototype.getTangent=function(t,n){const e=n||new W9;return e.copy(this.v2).sub(this.v1).normalize(),e},Pct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v1.copy(t.v1),this.v2.copy(t.v2),this},Pct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},Pct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(xct.prototype=Object.create(sct.prototype)).constructor=xct,xct.prototype.isLineCurve3=!0,xct.prototype.getPoint=function(t,n=new ttt){const e=n;return 1===t?e.copy(this.v2):(e.copy(this.v2).sub(this.v1),e.multiplyScalar(t).add(this.v1)),e},xct.prototype.getPointAt=function(t,n){return this.getPoint(t,n)},xct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v1.copy(t.v1),this.v2.copy(t.v2),this},xct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},xct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(yct.prototype=Object.create(sct.prototype)).constructor=yct,yct.prototype.isQuadraticBezierCurve=!0,yct.prototype.getPoint=function(t,n=new W9){const e=n,a=this.v0,o=this.v1,r=this.v2;return e.set(_ct(t,a.x,o.x,r.x),_ct(t,a.y,o.y,r.y)),e},yct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this},yct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},yct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(kct.prototype=Object.create(sct.prototype)).constructor=kct,kct.prototype.isQuadraticBezierCurve3=!0,kct.prototype.getPoint=function(t,n=new ttt){const e=n,a=this.v0,o=this.v1,r=this.v2;return e.set(_ct(t,a.x,o.x,r.x),_ct(t,a.y,o.y,r.y),_ct(t,a.z,o.z,r.z)),e},kct.prototype.copy=function(t){return sct.prototype.copy.call(this,t),this.v0.copy(t.v0),this.v1.copy(t.v1),this.v2.copy(t.v2),this},kct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);return t.v0=this.v0.toArray(),t.v1=this.v1.toArray(),t.v2=this.v2.toArray(),t},kct.prototype.fromJSON=function(t){return sct.prototype.fromJSON.call(this,t),this.v0.fromArray(t.v0),this.v1.fromArray(t.v1),this.v2.fromArray(t.v2),this},(vct.prototype=Object.create(sct.prototype)).constructor=vct,vct.prototype.isSplineCurve=!0,vct.prototype.getPoint=function(t,n=new W9){const e=n,a=this.points,o=(a.length-1)*t,r=Math.floor(o),i=o-r,c=a[0===r?r:r-1],s=a[r],l=a[r>a.length-2?a.length-1:r+1],m=a[r>a.length-3?a.length-1:r+2];return e.set(hct(i,c.x,s.x,l.x,m.x),hct(i,c.y,s.y,l.y,m.y)),e},vct.prototype.copy=function(t){sct.prototype.copy.call(this,t),this.points=[];for(let n=0,e=t.points.length;n<e;n++)this.points.push(t.points[n].clone());return this},vct.prototype.toJSON=function(){const t=sct.prototype.toJSON.call(this);t.points=[];for(let n=0,e=this.points.length;n<e;n++)t.points.push(this.points[n].toArray());return t},vct.prototype.fromJSON=function(t){sct.prototype.fromJSON.call(this,t),this.points=[];for(let n=0,e=t.points.length;n<e;n++){const e=t.points[n];this.points.push((new W9).fromArray(e))}return this};var wct=Object.freeze({__proto__:null,ArcCurve:mct,CatmullRomCurve3:fct,CubicBezierCurve:Mct,CubicBezierCurve3:Oct,EllipseCurve:lct,LineCurve:Pct,LineCurve3:xct,QuadraticBezierCurve:yct,QuadraticBezierCurve3:kct,SplineCurve:vct});function Sct(){sct.call(this),this.type="CurvePath",this.curves=[],this.autoClose=!1}function Ect(t){Sct.call(this),this.type="Path",this.currentPoint=new W9,t&&this.setFromPoints(t)}function Act(t){Ect.call(this,t),this.uuid=U9.generateUUID(),this.type="Shape",this.holes=[]}function zct(t,n=1){$tt.call(this),this.type="Light",this.color=new Ont(t),this.intensity=n}function Rct(t,n,e){zct.call(this,t,e),this.type="HemisphereLight",this.position.copy($tt.DefaultUp),this.updateMatrix(),this.groundColor=new Ont(n)}function Tct(t){this.camera=t,this.bias=0,this.normalBias=0,this.radius=1,this.mapSize=new W9(512,512),this.map=null,this.mapPass=null,this.matrix=new Stt,this.autoUpdate=!0,this.needsUpdate=!1,this._frustum=new zet,this._frameExtents=new W9(1,1),this._viewportCount=1,this._viewports=[new Q9(0,0,1,1)]}function Dct(){Tct.call(this,new Pet(50,1,.5,500)),this.focus=1}function Ict(t,n,e,a,o,r){zct.call(this,t,n),this.type="SpotLight",this.position.copy($tt.DefaultUp),this.updateMatrix(),this.target=new $tt,Object.defineProperty(this,"power",{get:function(){return this.intensity*Math.PI},set:function(t){this.intensity=t/Math.PI}}),this.distance=void 0!==e?e:0,this.angle=void 0!==a?a:Math.PI/3,this.penumbra=void 0!==o?o:0,this.decay=void 0!==r?r:1,this.shadow=new Dct}function Nct(){Tct.call(this,new Pet(90,1,.5,500)),this._frameExtents=new W9(4,2),this._viewportCount=6,this._viewports=[new Q9(2,1,1,1),new Q9(0,1,1,1),new Q9(3,1,1,1),new Q9(1,1,1,1),new Q9(3,0,1,1),new Q9(1,0,1,1)],this._cubeDirections=[new ttt(1,0,0),new ttt(-1,0,0),new ttt(0,0,1),new ttt(0,0,-1),new ttt(0,1,0),new ttt(0,-1,0)],this._cubeUps=[new ttt(0,1,0),new ttt(0,1,0),new ttt(0,1,0),new ttt(0,1,0),new ttt(0,0,1),new ttt(0,0,-1)]}function Fct(t,n,e,a){zct.call(this,t,n),this.type="PointLight",Object.defineProperty(this,"power",{get:function(){return 4*this.intensity*Math.PI},set:function(t){this.intensity=t/(4*Math.PI)}}),this.distance=void 0!==e?e:0,this.decay=void 0!==a?a:1,this.shadow=new Nct}function Lct(t=-1,n=1,e=1,a=-1,o=.1,r=2e3){Oet.call(this),this.type="OrthographicCamera",this.zoom=1,this.view=null,this.left=t,this.right=n,this.top=e,this.bottom=a,this.near=o,this.far=r,this.updateProjectionMatrix()}function Hct(){Tct.call(this,new Lct(-5,5,5,-5,.5,500))}function Bct(t,n){zct.call(this,t,n),this.type="DirectionalLight",this.position.copy($tt.DefaultUp),this.updateMatrix(),this.target=new $tt,this.shadow=new Hct}function Vct(t,n){zct.call(this,t,n),this.type="AmbientLight"}function jct(t,n,e,a){zct.call(this,t,n),this.type="RectAreaLight",this.width=void 0!==e?e:10,this.height=void 0!==a?a:10}Sct.prototype=Object.assign(Object.create(sct.prototype),{constructor:Sct,add:function(t){this.curves.push(t)},closePath:function(){const t=this.curves[0].getPoint(0),n=this.curves[this.curves.length-1].getPoint(1);t.equals(n)||this.curves.push(new Pct(n,t))},getPoint:function(t){const n=t*this.getLength(),e=this.getCurveLengths();let a=0;for(;a<e.length;){if(e[a]>=n){const t=e[a]-n,o=this.curves[a],r=o.getLength();return o.getPointAt(0===r?0:1-t/r)}a++}return null},getLength:function(){const t=this.getCurveLengths();return t[t.length-1]},updateArcLengths:function(){this.needsUpdate=!0,this.cacheLengths=null,this.getCurveLengths()},getCurveLengths:function(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;const t=[];let n=0;for(let e=0,a=this.curves.length;e<a;e++)n+=this.curves[e].getLength(),t.push(n);return this.cacheLengths=t,t},getSpacedPoints:function(t=40){const n=[];for(let e=0;e<=t;e++)n.push(this.getPoint(e/t));return this.autoClose&&n.push(n[0]),n},getPoints:function(t=12){const n=[];let e;for(let a=0,o=this.curves;a<o.length;a++){const r=o[a],i=r.getPoints(r&&r.isEllipseCurve?2*t:r&&(r.isLineCurve||r.isLineCurve3)?1:r&&r.isSplineCurve?t*r.points.length:t);for(let t=0;t<i.length;t++){const a=i[t];e&&e.equals(a)||(n.push(a),e=a)}}return this.autoClose&&n.length>1&&!n[n.length-1].equals(n[0])&&n.push(n[0]),n},copy:function(t){sct.prototype.copy.call(this,t),this.curves=[];for(let n=0,e=t.curves.length;n<e;n++)this.curves.push(t.curves[n].clone());return this.autoClose=t.autoClose,this},toJSON:function(){const t=sct.prototype.toJSON.call(this);t.autoClose=this.autoClose,t.curves=[];for(let n=0,e=this.curves.length;n<e;n++)t.curves.push(this.curves[n].toJSON());return t},fromJSON:function(t){sct.prototype.fromJSON.call(this,t),this.autoClose=t.autoClose,this.curves=[];for(let n=0,e=t.curves.length;n<e;n++){const e=t.curves[n];this.curves.push((new wct[e.type]).fromJSON(e))}return this}}),Ect.prototype=Object.assign(Object.create(Sct.prototype),{constructor:Ect,setFromPoints:function(t){this.moveTo(t[0].x,t[0].y);for(let n=1,e=t.length;n<e;n++)this.lineTo(t[n].x,t[n].y);return this},moveTo:function(t,n){return this.currentPoint.set(t,n),this},lineTo:function(t,n){const e=new Pct(this.currentPoint.clone(),new W9(t,n));return this.curves.push(e),this.currentPoint.set(t,n),this},quadraticCurveTo:function(t,n,e,a){const o=new yct(this.currentPoint.clone(),new W9(t,n),new W9(e,a));return this.curves.push(o),this.currentPoint.set(e,a),this},bezierCurveTo:function(t,n,e,a,o,r){const i=new Mct(this.currentPoint.clone(),new W9(t,n),new W9(e,a),new W9(o,r));return this.curves.push(i),this.currentPoint.set(o,r),this},splineThru:function(t){const n=new vct([this.currentPoint.clone()].concat(t));return this.curves.push(n),this.currentPoint.copy(t[t.length-1]),this},arc:function(t,n,e,a,o,r){return this.absarc(t+this.currentPoint.x,n+this.currentPoint.y,e,a,o,r),this},absarc:function(t,n,e,a,o,r){return this.absellipse(t,n,e,e,a,o,r),this},ellipse:function(t,n,e,a,o,r,i,c){return this.absellipse(t+this.currentPoint.x,n+this.currentPoint.y,e,a,o,r,i,c),this},absellipse:function(t,n,e,a,o,r,i,c){const s=new lct(t,n,e,a,o,r,i,c);if(this.curves.length>0){const t=s.getPoint(0);t.equals(this.currentPoint)||this.lineTo(t.x,t.y)}this.curves.push(s);const l=s.getPoint(1);return this.currentPoint.copy(l),this},copy:function(t){return Sct.prototype.copy.call(this,t),this.currentPoint.copy(t.currentPoint),this},toJSON:function(){const t=Sct.prototype.toJSON.call(this);return t.currentPoint=this.currentPoint.toArray(),t},fromJSON:function(t){return Sct.prototype.fromJSON.call(this,t),this.currentPoint.fromArray(t.currentPoint),this}}),Act.prototype=Object.assign(Object.create(Ect.prototype),{constructor:Act,getPointsHoles:function(t){const n=[];for(let e=0,a=this.holes.length;e<a;e++)n[e]=this.holes[e].getPoints(t);return n},extractPoints:function(t){return{shape:this.getPoints(t),holes:this.getPointsHoles(t)}},copy:function(t){Ect.prototype.copy.call(this,t),this.holes=[];for(let n=0,e=t.holes.length;n<e;n++)this.holes.push(t.holes[n].clone());return this},toJSON:function(){const t=Ect.prototype.toJSON.call(this);t.uuid=this.uuid,t.holes=[];for(let n=0,e=this.holes.length;n<e;n++)t.holes.push(this.holes[n].toJSON());return t},fromJSON:function(t){Ect.prototype.fromJSON.call(this,t),this.uuid=t.uuid,this.holes=[];for(let n=0,e=t.holes.length;n<e;n++){const e=t.holes[n];this.holes.push((new Ect).fromJSON(e))}return this}}),zct.prototype=Object.assign(Object.create($tt.prototype),{constructor:zct,isLight:!0,copy:function(t){return $tt.prototype.copy.call(this,t),this.color.copy(t.color),this.intensity=t.intensity,this},toJSON:function(t){const n=$tt.prototype.toJSON.call(this,t);return n.object.color=this.color.getHex(),n.object.intensity=this.intensity,void 0!==this.groundColor&&(n.object.groundColor=this.groundColor.getHex()),void 0!==this.distance&&(n.object.distance=this.distance),void 0!==this.angle&&(n.object.angle=this.angle),void 0!==this.decay&&(n.object.decay=this.decay),void 0!==this.penumbra&&(n.object.penumbra=this.penumbra),void 0!==this.shadow&&(n.object.shadow=this.shadow.toJSON()),n}}),Rct.prototype=Object.assign(Object.create(zct.prototype),{constructor:Rct,isHemisphereLight:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.groundColor.copy(t.groundColor),this}}),Object.assign(Tct.prototype,{_projScreenMatrix:new Stt,_lightPositionWorld:new ttt,_lookTarget:new ttt,getViewportCount:function(){return this._viewportCount},getFrustum:function(){return this._frustum},updateMatrices:function(t){const n=this.camera,e=this.matrix,a=this._projScreenMatrix,o=this._lookTarget,r=this._lightPositionWorld;r.setFromMatrixPosition(t.matrixWorld),n.position.copy(r),o.setFromMatrixPosition(t.target.matrixWorld),n.lookAt(o),n.updateMatrixWorld(),a.multiplyMatrices(n.projectionMatrix,n.matrixWorldInverse),this._frustum.setFromProjectionMatrix(a),e.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1),e.multiply(n.projectionMatrix),e.multiply(n.matrixWorldInverse)},getViewport:function(t){return this._viewports[t]},getFrameExtents:function(){return this._frameExtents},copy:function(t){return this.camera=t.camera.clone(),this.bias=t.bias,this.radius=t.radius,this.mapSize.copy(t.mapSize),this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){const t={};return 0!==this.bias&&(t.bias=this.bias),0!==this.normalBias&&(t.normalBias=this.normalBias),1!==this.radius&&(t.radius=this.radius),512===this.mapSize.x&&512===this.mapSize.y||(t.mapSize=this.mapSize.toArray()),t.camera=this.camera.toJSON(!1).object,delete t.camera.matrix,t}}),Dct.prototype=Object.assign(Object.create(Tct.prototype),{constructor:Dct,isSpotLightShadow:!0,updateMatrices:function(t){const n=this.camera,e=2*U9.RAD2DEG*t.angle*this.focus,a=this.mapSize.width/this.mapSize.height,o=t.distance||n.far;e===n.fov&&a===n.aspect&&o===n.far||(n.fov=e,n.aspect=a,n.far=o,n.updateProjectionMatrix()),Tct.prototype.updateMatrices.call(this,t)}}),Ict.prototype=Object.assign(Object.create(zct.prototype),{constructor:Ict,isSpotLight:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.distance=t.distance,this.angle=t.angle,this.penumbra=t.penumbra,this.decay=t.decay,this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}),Nct.prototype=Object.assign(Object.create(Tct.prototype),{constructor:Nct,isPointLightShadow:!0,updateMatrices:function(t,n=0){const e=this.camera,a=this.matrix,o=this._lightPositionWorld,r=this._lookTarget,i=this._projScreenMatrix;o.setFromMatrixPosition(t.matrixWorld),e.position.copy(o),r.copy(e.position),r.add(this._cubeDirections[n]),e.up.copy(this._cubeUps[n]),e.lookAt(r),e.updateMatrixWorld(),a.makeTranslation(-o.x,-o.y,-o.z),i.multiplyMatrices(e.projectionMatrix,e.matrixWorldInverse),this._frustum.setFromProjectionMatrix(i)}}),Fct.prototype=Object.assign(Object.create(zct.prototype),{constructor:Fct,isPointLight:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.distance=t.distance,this.decay=t.decay,this.shadow=t.shadow.clone(),this}}),Lct.prototype=Object.assign(Object.create(Oet.prototype),{constructor:Lct,isOrthographicCamera:!0,copy:function(t,n){return Oet.prototype.copy.call(this,t,n),this.left=t.left,this.right=t.right,this.top=t.top,this.bottom=t.bottom,this.near=t.near,this.far=t.far,this.zoom=t.zoom,this.view=null===t.view?null:Object.assign({},t.view),this},setViewOffset:function(t,n,e,a,o,r){null===this.view&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=t,this.view.fullHeight=n,this.view.offsetX=e,this.view.offsetY=a,this.view.width=o,this.view.height=r,this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1),this.updateProjectionMatrix()},updateProjectionMatrix:function(){const t=(this.right-this.left)/(2*this.zoom),n=(this.top-this.bottom)/(2*this.zoom),e=(this.right+this.left)/2,a=(this.top+this.bottom)/2;let o=e-t,r=e+t,i=a+n,c=a-n;if(null!==this.view&&this.view.enabled){const t=(this.right-this.left)/this.view.fullWidth/this.zoom,n=(this.top-this.bottom)/this.view.fullHeight/this.zoom;o+=t*this.view.offsetX,r=o+t*this.view.width,i-=n*this.view.offsetY,c=i-n*this.view.height}this.projectionMatrix.makeOrthographic(o,r,i,c,this.near,this.far),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()},toJSON:function(t){const n=$tt.prototype.toJSON.call(this,t);return n.object.zoom=this.zoom,n.object.left=this.left,n.object.right=this.right,n.object.top=this.top,n.object.bottom=this.bottom,n.object.near=this.near,n.object.far=this.far,null!==this.view&&(n.object.view=Object.assign({},this.view)),n}}),Hct.prototype=Object.assign(Object.create(Tct.prototype),{constructor:Hct,isDirectionalLightShadow:!0,updateMatrices:function(t){Tct.prototype.updateMatrices.call(this,t)}}),Bct.prototype=Object.assign(Object.create(zct.prototype),{constructor:Bct,isDirectionalLight:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.target=t.target.clone(),this.shadow=t.shadow.clone(),this}}),Vct.prototype=Object.assign(Object.create(zct.prototype),{constructor:Vct,isAmbientLight:!0}),jct.prototype=Object.assign(Object.create(zct.prototype),{constructor:jct,isRectAreaLight:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.width=t.width,this.height=t.height,this},toJSON:function(t){const n=zct.prototype.toJSON.call(this,t);return n.object.width=this.width,n.object.height=this.height,n}});class Uct{constructor(){Object.defineProperty(this,"isSphericalHarmonics3",{value:!0}),this.coefficients=[];for(let t=0;t<9;t++)this.coefficients.push(new ttt)}set(t){for(let n=0;n<9;n++)this.coefficients[n].copy(t[n]);return this}zero(){for(let t=0;t<9;t++)this.coefficients[t].set(0,0,0);return this}getAt(t,n){const e=t.x,a=t.y,o=t.z,r=this.coefficients;return n.copy(r[0]).multiplyScalar(.282095),n.addScaledVector(r[1],.488603*a),n.addScaledVector(r[2],.488603*o),n.addScaledVector(r[3],.488603*e),n.addScaledVector(r[4],e*a*1.092548),n.addScaledVector(r[5],a*o*1.092548),n.addScaledVector(r[6],.315392*(3*o*o-1)),n.addScaledVector(r[7],e*o*1.092548),n.addScaledVector(r[8],.546274*(e*e-a*a)),n}getIrradianceAt(t,n){const e=t.x,a=t.y,o=t.z,r=this.coefficients;return n.copy(r[0]).multiplyScalar(.886227),n.addScaledVector(r[1],1.023328*a),n.addScaledVector(r[2],1.023328*o),n.addScaledVector(r[3],1.023328*e),n.addScaledVector(r[4],.858086*e*a),n.addScaledVector(r[5],.858086*a*o),n.addScaledVector(r[6],.743125*o*o-.247708),n.addScaledVector(r[7],.858086*e*o),n.addScaledVector(r[8],.429043*(e*e-a*a)),n}add(t){for(let n=0;n<9;n++)this.coefficients[n].add(t.coefficients[n]);return this}addScaledSH(t,n){for(let e=0;e<9;e++)this.coefficients[e].addScaledVector(t.coefficients[e],n);return this}scale(t){for(let n=0;n<9;n++)this.coefficients[n].multiplyScalar(t);return this}lerp(t,n){for(let e=0;e<9;e++)this.coefficients[e].lerp(t.coefficients[e],n);return this}equals(t){for(let n=0;n<9;n++)if(!this.coefficients[n].equals(t.coefficients[n]))return!1;return!0}copy(t){return this.set(t.coefficients)}clone(){return(new this.constructor).copy(this)}fromArray(t,n=0){const e=this.coefficients;for(let a=0;a<9;a++)e[a].fromArray(t,n+3*a);return this}toArray(t=[],n=0){const e=this.coefficients;for(let a=0;a<9;a++)e[a].toArray(t,n+3*a);return t}static getBasisAt(t,n){const e=t.x,a=t.y,o=t.z;n[0]=.282095,n[1]=.488603*a,n[2]=.488603*o,n[3]=.488603*e,n[4]=1.092548*e*a,n[5]=1.092548*a*o,n[6]=.315392*(3*o*o-1),n[7]=1.092548*e*o,n[8]=.546274*(e*e-a*a)}}function Wct(t,n){zct.call(this,void 0,n),this.type="LightProbe",this.sh=void 0!==t?t:new Uct}function Gct(t){$it.call(this,t),this.textures={}}function Yct(){Xnt.call(this),this.type="InstancedBufferGeometry",this.instanceCount=1/0}function qct(t,n,e,a){"number"==typeof e&&(a=e,e=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.")),Snt.call(this,t,n,e),this.meshPerAttribute=a||1}function Zct(t){$it.call(this,t)}function Xct(t){"undefined"==typeof createImageBitmap&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported."),"undefined"==typeof fetch&&console.warn("THREE.ImageBitmapLoader: fetch() not supported."),$it.call(this,t),this.options={premultiplyAlpha:"none"}}function Jct(){this.type="ShapePath",this.color=new Ont,this.subPaths=[],this.currentPath=null}Wct.prototype=Object.assign(Object.create(zct.prototype),{constructor:Wct,isLightProbe:!0,copy:function(t){return zct.prototype.copy.call(this,t),this.sh.copy(t.sh),this},fromJSON:function(t){return this.intensity=t.intensity,this.sh.fromArray(t.sh),this},toJSON:function(t){const n=zct.prototype.toJSON.call(this,t);return n.object.sh=this.sh.toArray(),n}}),Gct.prototype=Object.assign(Object.create($it.prototype),{constructor:Gct,load:function(t,n,e,a){const o=this,r=new nct(o.manager);r.setPath(o.path),r.setRequestHeader(o.requestHeader),r.setWithCredentials(o.withCredentials),r.load(t,(function(e){try{n(o.parse(JSON.parse(e)))}catch(n){a?a(n):console.error(n),o.manager.itemError(t)}}),e,a)},parse:function(t){const n=this.textures;function e(t){return void 0===n[t]&&console.warn("THREE.MaterialLoader: Undefined texture",t),n[t]}const a=new Dit[t.type];if(void 0!==t.uuid&&(a.uuid=t.uuid),void 0!==t.name&&(a.name=t.name),void 0!==t.color&&void 0!==a.color&&a.color.setHex(t.color),void 0!==t.roughness&&(a.roughness=t.roughness),void 0!==t.metalness&&(a.metalness=t.metalness),void 0!==t.sheen&&(a.sheen=(new Ont).setHex(t.sheen)),void 0!==t.emissive&&void 0!==a.emissive&&a.emissive.setHex(t.emissive),void 0!==t.specular&&void 0!==a.specular&&a.specular.setHex(t.specular),void 0!==t.shininess&&(a.shininess=t.shininess),void 0!==t.clearcoat&&(a.clearcoat=t.clearcoat),void 0!==t.clearcoatRoughness&&(a.clearcoatRoughness=t.clearcoatRoughness),void 0!==t.fog&&(a.fog=t.fog),void 0!==t.flatShading&&(a.flatShading=t.flatShading),void 0!==t.blending&&(a.blending=t.blending),void 0!==t.combine&&(a.combine=t.combine),void 0!==t.side&&(a.side=t.side),void 0!==t.opacity&&(a.opacity=t.opacity),void 0!==t.transparent&&(a.transparent=t.transparent),void 0!==t.alphaTest&&(a.alphaTest=t.alphaTest),void 0!==t.depthTest&&(a.depthTest=t.depthTest),void 0!==t.depthWrite&&(a.depthWrite=t.depthWrite),void 0!==t.colorWrite&&(a.colorWrite=t.colorWrite),void 0!==t.stencilWrite&&(a.stencilWrite=t.stencilWrite),void 0!==t.stencilWriteMask&&(a.stencilWriteMask=t.stencilWriteMask),void 0!==t.stencilFunc&&(a.stencilFunc=t.stencilFunc),void 0!==t.stencilRef&&(a.stencilRef=t.stencilRef),void 0!==t.stencilFuncMask&&(a.stencilFuncMask=t.stencilFuncMask),void 0!==t.stencilFail&&(a.stencilFail=t.stencilFail),void 0!==t.stencilZFail&&(a.stencilZFail=t.stencilZFail),void 0!==t.stencilZPass&&(a.stencilZPass=t.stencilZPass),void 0!==t.wireframe&&(a.wireframe=t.wireframe),void 0!==t.wireframeLinewidth&&(a.wireframeLinewidth=t.wireframeLinewidth),void 0!==t.wireframeLinecap&&(a.wireframeLinecap=t.wireframeLinecap),void 0!==t.wireframeLinejoin&&(a.wireframeLinejoin=t.wireframeLinejoin),void 0!==t.rotation&&(a.rotation=t.rotation),1!==t.linewidth&&(a.linewidth=t.linewidth),void 0!==t.dashSize&&(a.dashSize=t.dashSize),void 0!==t.gapSize&&(a.gapSize=t.gapSize),void 0!==t.scale&&(a.scale=t.scale),void 0!==t.polygonOffset&&(a.polygonOffset=t.polygonOffset),void 0!==t.polygonOffsetFactor&&(a.polygonOffsetFactor=t.polygonOffsetFactor),void 0!==t.polygonOffsetUnits&&(a.polygonOffsetUnits=t.polygonOffsetUnits),void 0!==t.skinning&&(a.skinning=t.skinning),void 0!==t.morphTargets&&(a.morphTargets=t.morphTargets),void 0!==t.morphNormals&&(a.morphNormals=t.morphNormals),void 0!==t.dithering&&(a.dithering=t.dithering),void 0!==t.vertexTangents&&(a.vertexTangents=t.vertexTangents),void 0!==t.visible&&(a.visible=t.visible),void 0!==t.toneMapped&&(a.toneMapped=t.toneMapped),void 0!==t.userData&&(a.userData=t.userData),void 0!==t.vertexColors&&(a.vertexColors="number"==typeof t.vertexColors?t.vertexColors>0:t.vertexColors),void 0!==t.uniforms)for(const n in t.uniforms){const o=t.uniforms[n];switch(a.uniforms[n]={},o.type){case"t":a.uniforms[n].value=e(o.value);break;case"c":a.uniforms[n].value=(new Ont).setHex(o.value);break;case"v2":a.uniforms[n].value=(new W9).fromArray(o.value);break;case"v3":a.uniforms[n].value=(new ttt).fromArray(o.value);break;case"v4":a.uniforms[n].value=(new Q9).fromArray(o.value);break;case"m3":a.uniforms[n].value=(new G9).fromArray(o.value);break;case"m4":a.uniforms[n].value=(new Stt).fromArray(o.value);break;default:a.uniforms[n].value=o.value}}if(void 0!==t.defines&&(a.defines=t.defines),void 0!==t.vertexShader&&(a.vertexShader=t.vertexShader),void 0!==t.fragmentShader&&(a.fragmentShader=t.fragmentShader),void 0!==t.extensions)for(const n in t.extensions)a.extensions[n]=t.extensions[n];if(void 0!==t.shading&&(a.flatShading=1===t.shading),void 0!==t.size&&(a.size=t.size),void 0!==t.sizeAttenuation&&(a.sizeAttenuation=t.sizeAttenuation),void 0!==t.map&&(a.map=e(t.map)),void 0!==t.matcap&&(a.matcap=e(t.matcap)),void 0!==t.alphaMap&&(a.alphaMap=e(t.alphaMap)),void 0!==t.bumpMap&&(a.bumpMap=e(t.bumpMap)),void 0!==t.bumpScale&&(a.bumpScale=t.bumpScale),void 0!==t.normalMap&&(a.normalMap=e(t.normalMap)),void 0!==t.normalMapType&&(a.normalMapType=t.normalMapType),void 0!==t.normalScale){let n=t.normalScale;!1===Array.isArray(n)&&(n=[n,n]),a.normalScale=(new W9).fromArray(n)}return void 0!==t.displacementMap&&(a.displacementMap=e(t.displacementMap)),void 0!==t.displacementScale&&(a.displacementScale=t.displacementScale),void 0!==t.displacementBias&&(a.displacementBias=t.displacementBias),void 0!==t.roughnessMap&&(a.roughnessMap=e(t.roughnessMap)),void 0!==t.metalnessMap&&(a.metalnessMap=e(t.metalnessMap)),void 0!==t.emissiveMap&&(a.emissiveMap=e(t.emissiveMap)),void 0!==t.emissiveIntensity&&(a.emissiveIntensity=t.emissiveIntensity),void 0!==t.specularMap&&(a.specularMap=e(t.specularMap)),void 0!==t.envMap&&(a.envMap=e(t.envMap)),void 0!==t.envMapIntensity&&(a.envMapIntensity=t.envMapIntensity),void 0!==t.reflectivity&&(a.reflectivity=t.reflectivity),void 0!==t.refractionRatio&&(a.refractionRatio=t.refractionRatio),void 0!==t.lightMap&&(a.lightMap=e(t.lightMap)),void 0!==t.lightMapIntensity&&(a.lightMapIntensity=t.lightMapIntensity),void 0!==t.aoMap&&(a.aoMap=e(t.aoMap)),void 0!==t.aoMapIntensity&&(a.aoMapIntensity=t.aoMapIntensity),void 0!==t.gradientMap&&(a.gradientMap=e(t.gradientMap)),void 0!==t.clearcoatMap&&(a.clearcoatMap=e(t.clearcoatMap)),void 0!==t.clearcoatRoughnessMap&&(a.clearcoatRoughnessMap=e(t.clearcoatRoughnessMap)),void 0!==t.clearcoatNormalMap&&(a.clearcoatNormalMap=e(t.clearcoatNormalMap)),void 0!==t.clearcoatNormalScale&&(a.clearcoatNormalScale=(new W9).fromArray(t.clearcoatNormalScale)),void 0!==t.transmission&&(a.transmission=t.transmission),void 0!==t.transmissionMap&&(a.transmissionMap=e(t.transmissionMap)),a},setTextures:function(t){return this.textures=t,this}}),Yct.prototype=Object.assign(Object.create(Xnt.prototype),{constructor:Yct,isInstancedBufferGeometry:!0,copy:function(t){return Xnt.prototype.copy.call(this,t),this.instanceCount=t.instanceCount,this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){const t=Xnt.prototype.toJSON.call(this);return t.instanceCount=this.instanceCount,t.isInstancedBufferGeometry=!0,t}}),qct.prototype=Object.assign(Object.create(Snt.prototype),{constructor:qct,isInstancedBufferAttribute:!0,copy:function(t){return Snt.prototype.copy.call(this,t),this.meshPerAttribute=t.meshPerAttribute,this},toJSON:function(){const t=Snt.prototype.toJSON.call(this);return t.meshPerAttribute=this.meshPerAttribute,t.isInstancedBufferAttribute=!0,t}}),Zct.prototype=Object.assign(Object.create($it.prototype),{constructor:Zct,load:function(t,n,e,a){const o=this,r=new nct(o.manager);r.setPath(o.path),r.setRequestHeader(o.requestHeader),r.setWithCredentials(o.withCredentials),r.load(t,(function(e){try{n(o.parse(JSON.parse(e)))}catch(n){a?a(n):console.error(n),o.manager.itemError(t)}}),e,a)},parse:function(t){const n={},e={};function a(t,a){if(void 0!==n[a])return n[a];const o=t.interleavedBuffers[a],r=(function i(t,n){if(void 0!==e[n])return e[n];const a=new Uint32Array(t.arrayBuffers[n]).buffer;return e[n]=a,a})(t,o.buffer),c=new Vot(Vnt(o.type,r),o.stride);return c.uuid=o.uuid,n[a]=c,c}const o=t.isInstancedBufferGeometry?new Yct:new Xnt,r=t.data.index;if(void 0!==r){const t=Vnt(r.type,r.array);o.setIndex(new Snt(t,1))}const i=t.data.attributes;for(const n in i){const e=i[n];let r;if(e.isInterleavedBufferAttribute)r=new Uot(a(t.data,e.data),e.itemSize,e.offset,e.normalized);else{const t=Vnt(e.type,e.array);r=new(e.isInstancedBufferAttribute?qct:Snt)(t,e.itemSize,e.normalized)}void 0!==e.name&&(r.name=e.name),o.setAttribute(n,r)}const c=t.data.morphAttributes;if(c)for(const n in c){const e=c[n],r=[];for(let n=0,o=e.length;n<o;n++){const o=e[n];let i;i=o.isInterleavedBufferAttribute?new Uot(a(t.data,o.data),o.itemSize,o.offset,o.normalized):new Snt(Vnt(o.type,o.array),o.itemSize,o.normalized),void 0!==o.name&&(i.name=o.name),r.push(i)}o.morphAttributes[n]=r}t.data.morphTargetsRelative&&(o.morphTargetsRelative=!0);const s=t.data.groups||t.data.drawcalls||t.data.offsets;if(void 0!==s)for(let t=0,n=s.length;t!==n;++t){const n=s[t];o.addGroup(n.start,n.count,n.materialIndex)}const l=t.data.boundingSphere;if(void 0!==l){const t=new ttt;void 0!==l.center&&t.fromArray(l.center),o.boundingSphere=new Ctt(t,l.radius)}return t.name&&(o.name=t.name),t.userData&&(o.userData=t.userData),o}}),Xct.prototype=Object.assign(Object.create($it.prototype),{constructor:Xct,isImageBitmapLoader:!0,setOptions:function t(n){return this.options=n,this},load:function(t,n,e,a){void 0===t&&(t=""),void 0!==this.path&&(t=this.path+t),t=this.manager.resolveURL(t);const o=this,r=Jit.get(t);if(void 0!==r)return o.manager.itemStart(t),setTimeout((function(){n&&n(r),o.manager.itemEnd(t)}),0),r;const i={};i.credentials="anonymous"===this.crossOrigin?"same-origin":"include",fetch(t,i).then((function(t){return t.blob()})).then((function(t){return createImageBitmap(t,o.options)})).then((function(e){Jit.add(t,e),n&&n(e),o.manager.itemEnd(t)})).catch((function(n){a&&a(n),o.manager.itemError(t),o.manager.itemEnd(t)})),o.manager.itemStart(t)}}),Object.assign(Jct.prototype,{moveTo:function(t,n){return this.currentPath=new Ect,this.subPaths.push(this.currentPath),this.currentPath.moveTo(t,n),this},lineTo:function(t,n){return this.currentPath.lineTo(t,n),this},quadraticCurveTo:function(t,n,e,a){return this.currentPath.quadraticCurveTo(t,n,e,a),this},bezierCurveTo:function(t,n,e,a,o,r){return this.currentPath.bezierCurveTo(t,n,e,a,o,r),this},splineThru:function(t){return this.currentPath.splineThru(t),this},toShapes:function(t,n){function e(t){const n=[];for(let e=0,a=t.length;e<a;e++){const a=t[e],o=new Act;o.curves=a.curves,n.push(o)}return n}function a(t,n){const e=n.length;let a=!1;for(let o=e-1,r=0;r<e;o=r++){let e=n[o],i=n[r],c=i.x-e.x,s=i.y-e.y;if(Math.abs(s)>Number.EPSILON){if(s<0&&(e=n[r],c=-c,i=n[o],s=-s),t.y<e.y||t.y>i.y)continue;if(t.y===e.y){if(t.x===e.x)return!0}else{const n=s*(t.x-e.x)-c*(t.y-e.y);if(0===n)return!0;if(n<0)continue;a=!a}}else{if(t.y!==e.y)continue;if(i.x<=t.x&&t.x<=e.x||e.x<=t.x&&t.x<=i.x)return!0}}return a}const o=hit.isClockWise,r=this.subPaths;if(0===r.length)return[];if(!0===n)return e(r);let i,c,s;const l=[];if(1===r.length)return c=r[0],s=new Act,s.curves=c.curves,l.push(s),l;let m=!o(r[0].getPoints());m=t?!m:m;const d=[],g=[];let p,b,u=[],f=0;g[f]=void 0,u[f]=[];for(let n=0,e=r.length;n<e;n++)c=r[n],p=c.getPoints(),i=o(p),i=t?!i:i,i?(!m&&g[f]&&f++,g[f]={s:new Act,p:p},g[f].s.curves=c.curves,m&&f++,u[f]=[]):u[f].push({h:c,p:p[0]});if(!g[0])return e(r);if(g.length>1){let t=!1;const n=[];for(let t=0,n=g.length;t<n;t++)d[t]=[];for(let e=0,o=g.length;e<o;e++){const o=u[e];for(let r=0;r<o.length;r++){const i=o[r];let c=!0;for(let o=0;o<g.length;o++)a(i.p,g[o].p)&&(e!==o&&n.push({froms:e,tos:o,hole:r}),c?(c=!1,d[o].push(i)):t=!0);c&&d[e].push(i)}}n.length>0&&(t||(u=d))}for(let t=0,n=g.length;t<n;t++){s=g[t].s,l.push(s),b=u[t];for(let t=0,n=b.length;t<n;t++)s.holes.push(b[t].h)}return l}});class Qct{constructor(t){Object.defineProperty(this,"isFont",{value:!0}),this.type="Font",this.data=t}generateShapes(t,n=100){const e=[],a=(function o(t,n,e){const a=Array.from?Array.from(t):String(t).split(""),o=n/e.resolution,r=(e.boundingBox.yMax-e.boundingBox.yMin+e.underlineThickness)*o,i=[];let c=0,s=0;for(let t=0;t<a.length;t++){const n=a[t];if("\n"===n)c=0,s-=r;else{const t=Kct(n,o,c,s,e);c+=t.offsetX,i.push(t.path)}}return i})(t,n,this.data);for(let t=0,n=a.length;t<n;t++)Array.prototype.push.apply(e,a[t].toShapes());return e}}function Kct(t,n,e,a,o){const r=o.glyphs[t]||o.glyphs["?"];if(!r)return void console.error('THREE.Font: character "'+t+'" does not exists in font family '+o.familyName+".");const i=new Jct;let c,s,l,m,d,g,p,b;if(r.o){const t=r._cachedOutline||(r._cachedOutline=r.o.split(" "));for(let o=0,r=t.length;o<r;)switch(t[o++]){case"m":c=t[o++]*n+e,s=t[o++]*n+a,i.moveTo(c,s);break;case"l":c=t[o++]*n+e,s=t[o++]*n+a,i.lineTo(c,s);break;case"q":l=t[o++]*n+e,m=t[o++]*n+a,d=t[o++]*n+e,g=t[o++]*n+a,i.quadraticCurveTo(d,g,l,m);break;case"b":l=t[o++]*n+e,m=t[o++]*n+a,d=t[o++]*n+e,g=t[o++]*n+a,p=t[o++]*n+e,b=t[o++]*n+a,i.bezierCurveTo(d,g,p,b,l,m)}}return{offsetX:r.ha*n,path:i}}function $ct(t){$it.call(this,t)}let tst;function nst(t){$it.call(this,t)}function est(t,n,e){Wct.call(this,void 0,e);const a=(new Ont).set(t),o=(new Ont).set(n),r=new ttt(a.r,a.g,a.b),i=new ttt(o.r,o.g,o.b),c=Math.sqrt(Math.PI),s=c*Math.sqrt(.75);this.sh.coefficients[0].copy(r).add(i).multiplyScalar(c),this.sh.coefficients[1].copy(r).sub(i).multiplyScalar(s)}function ast(t,n){Wct.call(this,void 0,n);const e=(new Ont).set(t);this.sh.coefficients[0].set(e.r,e.g,e.b).multiplyScalar(2*Math.sqrt(Math.PI))}$ct.prototype=Object.assign(Object.create($it.prototype),{constructor:$ct,load:function(t,n,e,a){const o=this,r=new nct(this.manager);r.setPath(this.path),r.setRequestHeader(this.requestHeader),r.setWithCredentials(o.withCredentials),r.load(t,(function(t){let e;try{e=JSON.parse(t)}catch(n){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),e=JSON.parse(t.substring(65,t.length-2))}const a=o.parse(e);n&&n(a)}),e,a)},parse:function(t){return new Qct(t)}}),nst.prototype=Object.assign(Object.create($it.prototype),{constructor:nst,load:function(t,n,e,a){const o=this,r=new nct(o.manager);r.setResponseType("arraybuffer"),r.setPath(o.path),r.setRequestHeader(o.requestHeader),r.setWithCredentials(o.withCredentials),r.load(t,(function(e){try{const t=e.slice(0);(void 0===tst&&(tst=new(window.AudioContext||window.webkitAudioContext)),tst).decodeAudioData(t,(function(t){n(t)}))}catch(n){a?a(n):console.error(n),o.manager.itemError(t)}}),e,a)}}),est.prototype=Object.assign(Object.create(Wct.prototype),{constructor:est,isHemisphereLightProbe:!0,copy:function(t){return Wct.prototype.copy.call(this,t),this},toJSON:function(t){return Wct.prototype.toJSON.call(this,t)}}),ast.prototype=Object.assign(Object.create(Wct.prototype),{constructor:ast,isAmbientLightProbe:!0,copy:function(t){return Wct.prototype.copy.call(this,t),this},toJSON:function(t){return Wct.prototype.toJSON.call(this,t)}});const ost=new Stt,rst=new Stt;function ist(t,n,e){let a,o,r;switch(this.binding=t,this.valueSize=e,n){case"quaternion":a=this._slerp,o=this._slerpAdditive,r=this._setAdditiveIdentityQuaternion,this.buffer=new Float64Array(6*e),this._workIndex=5;break;case"string":case"bool":a=this._select,o=this._select,r=this._setAdditiveIdentityOther,this.buffer=new Array(5*e);break;default:a=this._lerp,o=this._lerpAdditive,r=this._setAdditiveIdentityNumeric,this.buffer=new Float64Array(5*e)}this._mixBufferRegion=a,this._mixBufferRegionAdditive=o,this._setIdentity=r,this._origIndex=3,this._addIndex=4,this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,this.useCount=0,this.referenceCount=0}Object.assign(function cst(){this.type="StereoCamera",this.aspect=1,this.eyeSep=.064,this.cameraL=new Pet,this.cameraL.layers.enable(1),this.cameraL.matrixAutoUpdate=!1,this.cameraR=new Pet,this.cameraR.layers.enable(2),this.cameraR.matrixAutoUpdate=!1,this._cache={focus:null,fov:null,aspect:null,near:null,far:null,zoom:null,eyeSep:null}}.prototype,{update:function(t){const n=this._cache;if(n.focus!==t.focus||n.fov!==t.fov||n.aspect!==t.aspect*this.aspect||n.near!==t.near||n.far!==t.far||n.zoom!==t.zoom||n.eyeSep!==this.eyeSep){n.focus=t.focus,n.fov=t.fov,n.aspect=t.aspect*this.aspect,n.near=t.near,n.far=t.far,n.zoom=t.zoom,n.eyeSep=this.eyeSep;const e=t.projectionMatrix.clone(),a=n.eyeSep/2,o=a*n.near/n.focus,r=n.near*Math.tan(U9.DEG2RAD*n.fov*.5)/n.zoom;let i,c;rst.elements[12]=-a,ost.elements[12]=a,i=-r*n.aspect+o,c=r*n.aspect+o,e.elements[0]=2*n.near/(c-i),e.elements[8]=(c+i)/(c-i),this.cameraL.projectionMatrix.copy(e),i=-r*n.aspect-o,c=r*n.aspect-o,e.elements[0]=2*n.near/(c-i),e.elements[8]=(c+i)/(c-i),this.cameraR.projectionMatrix.copy(e)}this.cameraL.matrixWorld.copy(t.matrixWorld).multiply(rst),this.cameraR.matrixWorld.copy(t.matrixWorld).multiply(ost)}}),Object.assign(ist.prototype,{accumulate:function(t,n){const e=this.buffer,a=this.valueSize,o=t*a+a;let r=this.cumulativeWeight;if(0===r){for(let t=0;t!==a;++t)e[o+t]=e[t];r=n}else r+=n,this._mixBufferRegion(e,o,0,n/r,a);this.cumulativeWeight=r},accumulateAdditive:function(t){const n=this.buffer,e=this.valueSize,a=e*this._addIndex;0===this.cumulativeWeightAdditive&&this._setIdentity(),this._mixBufferRegionAdditive(n,a,0,t,e),this.cumulativeWeightAdditive+=t},apply:function(t){const n=this.valueSize,e=this.buffer,a=t*n+n,o=this.cumulativeWeight,r=this.cumulativeWeightAdditive,i=this.binding;this.cumulativeWeight=0,this.cumulativeWeightAdditive=0,o<1&&this._mixBufferRegion(e,a,n*this._origIndex,1-o,n),r>0&&this._mixBufferRegionAdditive(e,a,this._addIndex*n,1,n);for(let t=n,o=n+n;t!==o;++t)if(e[t]!==e[t+n]){i.setValue(e,a);break}},saveOriginalState:function(){const t=this.buffer,n=this.valueSize,e=n*this._origIndex;this.binding.getValue(t,e);for(let a=n,o=e;a!==o;++a)t[a]=t[e+a%n];this._setIdentity(),this.cumulativeWeight=0,this.cumulativeWeightAdditive=0},restoreOriginalState:function(){this.binding.setValue(this.buffer,3*this.valueSize)},_setAdditiveIdentityNumeric:function(){const t=this._addIndex*this.valueSize,n=t+this.valueSize;for(let e=t;e<n;e++)this.buffer[e]=0},_setAdditiveIdentityQuaternion:function(){this._setAdditiveIdentityNumeric(),this.buffer[this._addIndex*this.valueSize+3]=1},_setAdditiveIdentityOther:function(){const t=this._origIndex*this.valueSize,n=this._addIndex*this.valueSize;for(let e=0;e<this.valueSize;e++)this.buffer[n+e]=this.buffer[t+e]},_select:function(t,n,e,a,o){if(a>=.5)for(let a=0;a!==o;++a)t[n+a]=t[e+a]},_slerp:function(t,n,e,a){$9.slerpFlat(t,n,t,n,t,e,a)},_slerpAdditive:function(t,n,e,a,o){const r=this._workIndex*o;$9.multiplyQuaternionsFlat(t,r,t,n,t,e),$9.slerpFlat(t,n,t,n,t,r,a)},_lerp:function(t,n,e,a,o){const r=1-a;for(let i=0;i!==o;++i){const o=n+i;t[o]=t[o]*r+t[e+i]*a}},_lerpAdditive:function(t,n,e,a,o){for(let r=0;r!==o;++r){const o=n+r;t[o]=t[o]+t[e+r]*a}}});const sst=new RegExp("[\\[\\]\\.:\\/]","g"),lst="[^\\[\\]\\.:\\/]",mst="[^"+"\\[\\]\\.:\\/".replace("\\.","")+"]",dst=/((?:WC+[\/:])*)/.source.replace("WC",lst),gst=/(WCOD+)?/.source.replace("WCOD",mst),pst=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC",lst),bst=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC",lst),ust=new RegExp("^"+dst+gst+pst+bst+"$"),fst=["material","materials","bones"];function hst(t,n,e){const a=e||_st.parseTrackName(n);this._targetGroup=t,this._bindings=t.subscribe_(n,a)}function _st(t,n,e){this.path=n,this.parsedPath=e||_st.parseTrackName(n),this.node=_st.findNode(t,this.parsedPath.nodeName)||t,this.rootNode=t}Object.assign(hst.prototype,{getValue:function(t,n){this.bind();const e=this._bindings[this._targetGroup.nCachedObjects_];void 0!==e&&e.getValue(t,n)},setValue:function(t,n){const e=this._bindings;for(let a=this._targetGroup.nCachedObjects_,o=e.length;a!==o;++a)e[a].setValue(t,n)},bind:function(){const t=this._bindings;for(let n=this._targetGroup.nCachedObjects_,e=t.length;n!==e;++n)t[n].bind()},unbind:function(){const t=this._bindings;for(let n=this._targetGroup.nCachedObjects_,e=t.length;n!==e;++n)t[n].unbind()}}),Object.assign(_st,{Composite:hst,create:function(t,n,e){return t&&t.isAnimationObjectGroup?new _st.Composite(t,n,e):new _st(t,n,e)},sanitizeNodeName:function(t){return t.replace(/\s/g,"_").replace(sst,"")},parseTrackName:function(t){const n=ust.exec(t);if(!n)throw new Error("PropertyBinding: Cannot parse trackName: "+t);const e={nodeName:n[2],objectName:n[3],objectIndex:n[4],propertyName:n[5],propertyIndex:n[6]},a=e.nodeName&&e.nodeName.lastIndexOf(".");if(void 0!==a&&-1!==a){const t=e.nodeName.substring(a+1);-1!==fst.indexOf(t)&&(e.nodeName=e.nodeName.substring(0,a),e.objectName=t)}if(null===e.propertyName||0===e.propertyName.length)throw new Error("PropertyBinding: can not parse propertyName from trackName: "+t);return e},findNode:function(t,n){if(!n||""===n||"."===n||-1===n||n===t.name||n===t.uuid)return t;if(t.skeleton){const e=t.skeleton.getBoneByName(n);if(void 0!==e)return e}if(t.children){const e=function(t){for(let a=0;a<t.length;a++){const o=t[a];if(o.name===n||o.uuid===n)return o;const r=e(o.children);if(r)return r}return null},a=e(t.children);if(a)return a}return null}}),Object.assign(_st.prototype,{_getValue_unavailable:function(){},_setValue_unavailable:function(){},BindingType:{Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Versioning:{None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},GetterByBindingType:[function t(n,e){n[e]=this.node[this.propertyName]},function t(n,e){const a=this.resolvedProperty;for(let t=0,o=a.length;t!==o;++t)n[e++]=a[t]},function t(n,e){n[e]=this.resolvedProperty[this.propertyIndex]},function t(n,e){this.resolvedProperty.toArray(n,e)}],SetterByBindingTypeAndVersioning:[[function t(n,e){this.targetObject[this.propertyName]=n[e]},function t(n,e){this.targetObject[this.propertyName]=n[e],this.targetObject.needsUpdate=!0},function t(n,e){this.targetObject[this.propertyName]=n[e],this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(n,e){const a=this.resolvedProperty;for(let t=0,o=a.length;t!==o;++t)a[t]=n[e++]},function t(n,e){const a=this.resolvedProperty;for(let t=0,o=a.length;t!==o;++t)a[t]=n[e++];this.targetObject.needsUpdate=!0},function t(n,e){const a=this.resolvedProperty;for(let t=0,o=a.length;t!==o;++t)a[t]=n[e++];this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(n,e){this.resolvedProperty[this.propertyIndex]=n[e]},function t(n,e){this.resolvedProperty[this.propertyIndex]=n[e],this.targetObject.needsUpdate=!0},function t(n,e){this.resolvedProperty[this.propertyIndex]=n[e],this.targetObject.matrixWorldNeedsUpdate=!0}],[function t(n,e){this.resolvedProperty.fromArray(n,e)},function t(n,e){this.resolvedProperty.fromArray(n,e),this.targetObject.needsUpdate=!0},function t(n,e){this.resolvedProperty.fromArray(n,e),this.targetObject.matrixWorldNeedsUpdate=!0}]],getValue:function t(n,e){this.bind(),this.getValue(n,e)},setValue:function t(n,e){this.bind(),this.setValue(n,e)},bind:function(){let t=this.node;const n=this.parsedPath,e=n.objectName,a=n.propertyName;let o=n.propertyIndex;if(t||(t=_st.findNode(this.rootNode,n.nodeName)||this.rootNode,this.node=t),this.getValue=this._getValue_unavailable,this.setValue=this._setValue_unavailable,!t)return void console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.");if(e){let a=n.objectIndex;switch(e){case"materials":if(!t.material)return void console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);if(!t.material.materials)return void console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);t=t.material.materials;break;case"bones":if(!t.skeleton)return void console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",this);t=t.skeleton.bones;for(let n=0;n<t.length;n++)if(t[n].name===a){a=n;break}break;default:if(void 0===t[e])return void console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);t=t[e]}if(void 0!==a){if(void 0===t[a])return void console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,t);t=t[a]}}const r=t[a];if(void 0===r)return void console.error("THREE.PropertyBinding: Trying to update property for track: "+n.nodeName+"."+a+" but it wasn't found.",t);let i=this.Versioning.None;this.targetObject=t,void 0!==t.needsUpdate?i=this.Versioning.NeedsUpdate:void 0!==t.matrixWorldNeedsUpdate&&(i=this.Versioning.MatrixWorldNeedsUpdate);let c=this.BindingType.Direct;if(void 0!==o){if("morphTargetInfluences"===a){if(!t.geometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);if(!t.geometry.isBufferGeometry)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.",this);if(!t.geometry.morphAttributes)return void console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",this);void 0!==t.morphTargetDictionary[o]&&(o=t.morphTargetDictionary[o])}c=this.BindingType.ArrayElement,this.resolvedProperty=r,this.propertyIndex=o}else void 0!==r.fromArray&&void 0!==r.toArray?(c=this.BindingType.HasFromToArray,this.resolvedProperty=r):Array.isArray(r)?(c=this.BindingType.EntireArray,this.resolvedProperty=r):this.propertyName=a;this.getValue=this.GetterByBindingType[c],this.setValue=this.SetterByBindingTypeAndVersioning[c][i]},unbind:function(){this.node=null,this.getValue=this._getValue_unbound,this.setValue=this._setValue_unbound}}),Object.assign(_st.prototype,{_getValue_unbound:_st.prototype.getValue,_setValue_unbound:_st.prototype.setValue}),Object.assign(function Cst(){this.uuid=U9.generateUUID(),this._objects=Array.prototype.slice.call(arguments),this.nCachedObjects_=0;const t={};this._indicesByUUID=t;for(let n=0,e=arguments.length;n!==e;++n)t[arguments[n].uuid]=n;this._paths=[],this._parsedPaths=[],this._bindings=[],this._bindingsIndicesByPath={};const n=this;this.stats={objects:{get total(){return n._objects.length},get inUse(){return this.total-n.nCachedObjects_}},get bindingsPerObject(){return n._bindings.length}}}.prototype,{isAnimationObjectGroup:!0,add:function(){const t=this._objects,n=this._indicesByUUID,e=this._paths,a=this._parsedPaths,o=this._bindings,r=o.length;let i,c=t.length,s=this.nCachedObjects_;for(let l=0,m=arguments.length;l!==m;++l){const m=arguments[l],d=m.uuid;let g=n[d];if(void 0===g){g=c++,n[d]=g,t.push(m);for(let t=0,n=r;t!==n;++t)o[t].push(new _st(m,e[t],a[t]))}else if(g<s){i=t[g];const c=--s,l=t[c];n[l.uuid]=g,t[g]=l,n[d]=c,t[c]=m;for(let t=0,n=r;t!==n;++t){const n=o[t];let r=n[g];n[g]=n[c],void 0===r&&(r=new _st(m,e[t],a[t])),n[c]=r}}else t[g]!==i&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=s},remove:function(){const t=this._objects,n=this._indicesByUUID,e=this._bindings,a=e.length;let o=this.nCachedObjects_;for(let r=0,i=arguments.length;r!==i;++r){const i=arguments[r],c=i.uuid,s=n[c];if(void 0!==s&&s>=o){const r=o++,l=t[r];n[l.uuid]=s,t[s]=l,n[c]=r,t[r]=i;for(let t=0,n=a;t!==n;++t){const n=e[t],a=n[s];n[s]=n[r],n[r]=a}}}this.nCachedObjects_=o},uncache:function(){const t=this._objects,n=this._indicesByUUID,e=this._bindings,a=e.length;let o=this.nCachedObjects_,r=t.length;for(let i=0,c=arguments.length;i!==c;++i){const c=arguments[i].uuid,s=n[c];if(void 0!==s)if(delete n[c],s<o){const i=--o,c=t[i],l=--r,m=t[l];n[c.uuid]=s,t[s]=c,n[m.uuid]=i,t[i]=m,t.pop();for(let t=0,n=a;t!==n;++t){const n=e[t],a=n[l];n[s]=n[i],n[i]=a,n.pop()}}else{const o=--r,i=t[o];o>0&&(n[i.uuid]=s),t[s]=i,t.pop();for(let t=0,n=a;t!==n;++t){const n=e[t];n[s]=n[o],n.pop()}}}this.nCachedObjects_=o},subscribe_:function(t,n){const e=this._bindingsIndicesByPath;let a=e[t];const o=this._bindings;if(void 0!==a)return o[a];const r=this._paths,i=this._parsedPaths,c=this._objects,s=this.nCachedObjects_,l=new Array(c.length);a=o.length,e[t]=a,r.push(t),i.push(n),o.push(l);for(let e=s,a=c.length;e!==a;++e)l[e]=new _st(c[e],t,n);return l},unsubscribe_:function(t){const n=this._bindingsIndicesByPath,e=n[t];if(void 0!==e){const a=this._paths,o=this._parsedPaths,r=this._bindings,i=r.length-1,c=r[i];n[t[i]]=e,r[e]=c,r.pop(),o[e]=o[i],o.pop(),a[e]=a[i],a.pop()}}});class Mst{constructor(t,n,e=null,a=n.blendMode){this._mixer=t,this._clip=n,this._localRoot=e,this.blendMode=a;const o=n.tracks,r=o.length,i=new Array(r),c={endingStart:R9,endingEnd:R9};for(let t=0;t!==r;++t){const n=o[t].createInterpolant(null);i[t]=n,n.settings=c}this._interpolantSettings=c,this._interpolants=i,this._propertyBindings=new Array(r),this._cacheIndex=null,this._byClipCacheIndex=null,this._timeScaleInterpolant=null,this._weightInterpolant=null,this.loop=2201,this._loopCount=-1,this._startTime=null,this.time=0,this.timeScale=1,this._effectiveTimeScale=1,this.weight=1,this._effectiveWeight=1,this.repetitions=1/0,this.paused=!1,this.enabled=!0,this.clampWhenFinished=!1,this.zeroSlopeAtStart=!0,this.zeroSlopeAtEnd=!0}play(){return this._mixer._activateAction(this),this}stop(){return this._mixer._deactivateAction(this),this.reset()}reset(){return this.paused=!1,this.enabled=!0,this.time=0,this._loopCount=-1,this._startTime=null,this.stopFading().stopWarping()}isRunning(){return this.enabled&&!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)}isScheduled(){return this._mixer._isActiveAction(this)}startAt(t){return this._startTime=t,this}setLoop(t,n){return this.loop=t,this.repetitions=n,this}setEffectiveWeight(t){return this.weight=t,this._effectiveWeight=this.enabled?t:0,this.stopFading()}getEffectiveWeight(){return this._effectiveWeight}fadeIn(t){return this._scheduleFading(t,0,1)}fadeOut(t){return this._scheduleFading(t,1,0)}crossFadeFrom(t,n,e){if(t.fadeOut(n),this.fadeIn(n),e){const e=this._clip.duration,a=t._clip.duration,o=e/a;t.warp(1,a/e,n),this.warp(o,1,n)}return this}crossFadeTo(t,n,e){return t.crossFadeFrom(this,n,e)}stopFading(){const t=this._weightInterpolant;return null!==t&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}setEffectiveTimeScale(t){return this.timeScale=t,this._effectiveTimeScale=this.paused?0:t,this.stopWarping()}getEffectiveTimeScale(){return this._effectiveTimeScale}setDuration(t){return this.timeScale=this._clip.duration/t,this.stopWarping()}syncWith(t){return this.time=t.time,this.timeScale=t.timeScale,this.stopWarping()}halt(t){return this.warp(this._effectiveTimeScale,0,t)}warp(t,n,e){const a=this._mixer,o=a.time,r=this.timeScale;let i=this._timeScaleInterpolant;null===i&&(i=a._lendControlInterpolant(),this._timeScaleInterpolant=i);const c=i.parameterPositions,s=i.sampleValues;return c[0]=o,c[1]=o+e,s[0]=t/r,s[1]=n/r,this}stopWarping(){const t=this._timeScaleInterpolant;return null!==t&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(t)),this}getMixer(){return this._mixer}getClip(){return this._clip}getRoot(){return this._localRoot||this._mixer._root}_update(t,n,e,a){if(!this.enabled)return void this._updateWeight(t);const o=this._startTime;if(null!==o){const a=(t-o)*e;if(a<0||0===e)return;this._startTime=null,n=e*a}n*=this._updateTimeScale(t);const r=this._updateTime(n),i=this._updateWeight(t);if(i>0){const t=this._interpolants,n=this._propertyBindings;switch(this.blendMode){case 2501:for(let e=0,a=t.length;e!==a;++e)t[e].evaluate(r),n[e].accumulateAdditive(i);break;case 2500:default:for(let e=0,o=t.length;e!==o;++e)t[e].evaluate(r),n[e].accumulate(a,i)}}}_updateWeight(t){let n=0;if(this.enabled){n=this.weight;const e=this._weightInterpolant;if(null!==e){const a=e.evaluate(t)[0];n*=a,t>e.parameterPositions[1]&&(this.stopFading(),0===a&&(this.enabled=!1))}}return this._effectiveWeight=n,n}_updateTimeScale(t){let n=0;if(!this.paused){n=this.timeScale;const e=this._timeScaleInterpolant;null!==e&&(n*=e.evaluate(t)[0],t>e.parameterPositions[1]&&(this.stopWarping(),0===n?this.paused=!0:this.timeScale=n))}return this._effectiveTimeScale=n,n}_updateTime(t){const n=this._clip.duration,e=this.loop;let a=this.time+t,o=this._loopCount;const r=2202===e;if(0===t)return-1===o?a:r&&1==(1&o)?n-a:a;if(2200===e){-1===o&&(this._loopCount=0,this._setEndings(!0,!0,!1));t:{if(a>=n)a=n;else{if(!(a<0)){this.time=a;break t}a=0}this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=a,this._mixer.dispatchEvent({type:"finished",action:this,direction:t<0?-1:1})}}else{if(-1===o&&(t>=0?(o=0,this._setEndings(!0,0===this.repetitions,r)):this._setEndings(0===this.repetitions,!0,r)),a>=n||a<0){const e=Math.floor(a/n);a-=n*e,o+=Math.abs(e);const i=this.repetitions-o;if(i<=0)this.clampWhenFinished?this.paused=!0:this.enabled=!1,a=t>0?n:0,this.time=a,this._mixer.dispatchEvent({type:"finished",action:this,direction:t>0?1:-1});else{if(1===i){const n=t<0;this._setEndings(n,!n,r)}else this._setEndings(!1,!1,r);this._loopCount=o,this.time=a,this._mixer.dispatchEvent({type:"loop",action:this,loopDelta:e})}}else this.time=a;if(r&&1==(1&o))return n-a}return a}_setEndings(t,n,e){const a=this._interpolantSettings;e?(a.endingStart=T9,a.endingEnd=T9):(a.endingStart=t?this.zeroSlopeAtStart?T9:R9:D9,a.endingEnd=n?this.zeroSlopeAtEnd?T9:R9:D9)}_scheduleFading(t,n,e){const a=this._mixer,o=a.time;let r=this._weightInterpolant;null===r&&(r=a._lendControlInterpolant(),this._weightInterpolant=r);const i=r.parameterPositions,c=r.sampleValues;return i[0]=o,c[0]=n,i[1]=o+t,c[1]=e,this}}function Ost(t){this._root=t,this._initMemoryManager(),this._accuIndex=0,this.time=0,this.timeScale=1}Ost.prototype=Object.assign(Object.create(B9.prototype),{constructor:Ost,_bindAction:function(t,n){const e=t._localRoot||this._root,a=t._clip.tracks,o=a.length,r=t._propertyBindings,i=t._interpolants,c=e.uuid,s=this._bindingsByRootAndName;let l=s[c];void 0===l&&(l={},s[c]=l);for(let t=0;t!==o;++t){const o=a[t],s=o.name;let m=l[s];if(void 0!==m)r[t]=m;else{if(m=r[t],void 0!==m){null===m._cacheIndex&&(++m.referenceCount,this._addInactiveBinding(m,c,s));continue}m=new ist(_st.create(e,s,n&&n._propertyBindings[t].binding.parsedPath),o.ValueTypeName,o.getValueSize()),++m.referenceCount,this._addInactiveBinding(m,c,s),r[t]=m}i[t].resultBuffer=m.buffer}},_activateAction:function(t){if(!this._isActiveAction(t)){if(null===t._cacheIndex){const n=(t._localRoot||this._root).uuid,e=t._clip.uuid,a=this._actionsByClip[e];this._bindAction(t,a&&a.knownActions[0]),this._addInactiveAction(t,e,n)}const n=t._propertyBindings;for(let t=0,e=n.length;t!==e;++t){const e=n[t];0==e.useCount++&&(this._lendBinding(e),e.saveOriginalState())}this._lendAction(t)}},_deactivateAction:function(t){if(this._isActiveAction(t)){const n=t._propertyBindings;for(let t=0,e=n.length;t!==e;++t){const e=n[t];0==--e.useCount&&(e.restoreOriginalState(),this._takeBackBinding(e))}this._takeBackAction(t)}},_initMemoryManager:function(){this._actions=[],this._nActiveActions=0,this._actionsByClip={},this._bindings=[],this._nActiveBindings=0,this._bindingsByRootAndName={},this._controlInterpolants=[],this._nActiveControlInterpolants=0;const t=this;this.stats={actions:{get total(){return t._actions.length},get inUse(){return t._nActiveActions}},bindings:{get total(){return t._bindings.length},get inUse(){return t._nActiveBindings}},controlInterpolants:{get total(){return t._controlInterpolants.length},get inUse(){return t._nActiveControlInterpolants}}}},_isActiveAction:function(t){const n=t._cacheIndex;return null!==n&&n<this._nActiveActions},_addInactiveAction:function(t,n,e){const a=this._actions,o=this._actionsByClip;let r=o[n];if(void 0===r)r={knownActions:[t],actionByRoot:{}},t._byClipCacheIndex=0,o[n]=r;else{const n=r.knownActions;t._byClipCacheIndex=n.length,n.push(t)}t._cacheIndex=a.length,a.push(t),r.actionByRoot[e]=t},_removeInactiveAction:function(t){const n=this._actions,e=n[n.length-1],a=t._cacheIndex;e._cacheIndex=a,n[a]=e,n.pop(),t._cacheIndex=null;const o=t._clip.uuid,r=this._actionsByClip,i=r[o],c=i.knownActions,s=c[c.length-1],l=t._byClipCacheIndex;s._byClipCacheIndex=l,c[l]=s,c.pop(),t._byClipCacheIndex=null,delete i.actionByRoot[(t._localRoot||this._root).uuid],0===c.length&&delete r[o],this._removeInactiveBindingsForAction(t)},_removeInactiveBindingsForAction:function(t){const n=t._propertyBindings;for(let t=0,e=n.length;t!==e;++t){const e=n[t];0==--e.referenceCount&&this._removeInactiveBinding(e)}},_lendAction:function(t){const n=this._actions,e=t._cacheIndex,a=this._nActiveActions++,o=n[a];t._cacheIndex=a,n[a]=t,o._cacheIndex=e,n[e]=o},_takeBackAction:function(t){const n=this._actions,e=t._cacheIndex,a=--this._nActiveActions,o=n[a];t._cacheIndex=a,n[a]=t,o._cacheIndex=e,n[e]=o},_addInactiveBinding:function(t,n,e){const a=this._bindingsByRootAndName,o=this._bindings;let r=a[n];void 0===r&&(r={},a[n]=r),r[e]=t,t._cacheIndex=o.length,o.push(t)},_removeInactiveBinding:function(t){const n=this._bindings,e=t.binding,a=e.rootNode.uuid,o=e.path,r=this._bindingsByRootAndName,i=r[a],c=n[n.length-1],s=t._cacheIndex;c._cacheIndex=s,n[s]=c,n.pop(),delete i[o],0===Object.keys(i).length&&delete r[a]},_lendBinding:function(t){const n=this._bindings,e=t._cacheIndex,a=this._nActiveBindings++,o=n[a];t._cacheIndex=a,n[a]=t,o._cacheIndex=e,n[e]=o},_takeBackBinding:function(t){const n=this._bindings,e=t._cacheIndex,a=--this._nActiveBindings,o=n[a];t._cacheIndex=a,n[a]=t,o._cacheIndex=e,n[e]=o},_lendControlInterpolant:function(){const t=this._controlInterpolants,n=this._nActiveControlInterpolants++;let e=t[n];return void 0===e&&(e=new Lit(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),e.__cacheIndex=n,t[n]=e),e},_takeBackControlInterpolant:function(t){const n=this._controlInterpolants,e=t.__cacheIndex,a=--this._nActiveControlInterpolants,o=n[a];t.__cacheIndex=a,n[a]=t,o.__cacheIndex=e,n[e]=o},_controlInterpolantsResultBuffer:new Float32Array(1),clipAction:function(t,n,e){const a=n||this._root,o=a.uuid;let r="string"==typeof t?Zit.findByName(a,t):t;const i=null!==r?r.uuid:t,c=this._actionsByClip[i];let s=null;if(void 0===e&&(e=null!==r?r.blendMode:2500),void 0!==c){const t=c.actionByRoot[o];if(void 0!==t&&t.blendMode===e)return t;s=c.knownActions[0],null===r&&(r=s._clip)}if(null===r)return null;const l=new Mst(this,r,n,e);return this._bindAction(l,s),this._addInactiveAction(l,i,o),l},existingAction:function(t,n){const e=n||this._root,a=e.uuid,o="string"==typeof t?Zit.findByName(e,t):t,r=this._actionsByClip[o?o.uuid:t];return void 0!==r&&r.actionByRoot[a]||null},stopAllAction:function(){const t=this._actions;for(let n=this._nActiveActions-1;n>=0;--n)t[n].stop();return this},update:function(t){const n=this._actions,e=this._nActiveActions,a=this.time+=t*=this.timeScale,o=Math.sign(t),r=this._accuIndex^=1;for(let i=0;i!==e;++i)n[i]._update(a,t,o,r);const i=this._bindings,c=this._nActiveBindings;for(let t=0;t!==c;++t)i[t].apply(r);return this},setTime:function(t){this.time=0;for(let t=0;t<this._actions.length;t++)this._actions[t].time=0;return this.update(t)},getRoot:function(){return this._root},uncacheClip:function(t){const n=this._actions,e=t.uuid,a=this._actionsByClip,o=a[e];if(void 0!==o){const t=o.knownActions;for(let e=0,a=t.length;e!==a;++e){const a=t[e];this._deactivateAction(a);const o=a._cacheIndex,r=n[n.length-1];a._cacheIndex=null,a._byClipCacheIndex=null,r._cacheIndex=o,n[o]=r,n.pop(),this._removeInactiveBindingsForAction(a)}delete a[e]}},uncacheRoot:function(t){const n=t.uuid,e=this._actionsByClip;for(const t in e){const a=e[t].actionByRoot[n];void 0!==a&&(this._deactivateAction(a),this._removeInactiveAction(a))}const a=this._bindingsByRootAndName[n];if(void 0!==a)for(const t in a){const n=a[t];n.restoreOriginalState(),this._removeInactiveBinding(n)}},uncacheAction:function(t,n){const e=this.existingAction(t,n);null!==e&&(this._deactivateAction(e),this._removeInactiveAction(e))}});class Pst{constructor(t){"string"==typeof t&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),t=arguments[1]),this.value=t}clone(){return new Pst(void 0===this.value.clone?this.value:this.value.clone())}}function xst(t,n,e){Vot.call(this,t,n),this.meshPerAttribute=e||1}function yst(t,n,e,a,o){this.buffer=t,this.type=n,this.itemSize=e,this.elementSize=a,this.count=o,this.version=0}function kst(t,n,e,a){this.ray=new wtt(t,n),this.near=e||0,this.far=a||1/0,this.camera=null,this.layers=new Htt,this.params={Mesh:{},Line:{threshold:1},LOD:{},Points:{threshold:1},Sprite:{}},Object.defineProperties(this.params,{PointCloud:{get:function(){return console.warn("THREE.Raycaster: params.PointCloud has been renamed to params.Points."),this.Points}}})}function vst(t,n){return t.distance-n.distance}function wst(t,n,e,a){if(t.layers.test(n.layers)&&t.raycast(n,e),!0===a){const a=t.children;for(let t=0,o=a.length;t<o;t++)wst(a[t],n,e,!0)}}xst.prototype=Object.assign(Object.create(Vot.prototype),{constructor:xst,isInstancedInterleavedBuffer:!0,copy:function(t){return Vot.prototype.copy.call(this,t),this.meshPerAttribute=t.meshPerAttribute,this},clone:function(t){const n=Vot.prototype.clone.call(this,t);return n.meshPerAttribute=this.meshPerAttribute,n},toJSON:function(t){const n=Vot.prototype.toJSON.call(this,t);return n.isInstancedInterleavedBuffer=!0,n.meshPerAttribute=this.meshPerAttribute,n}}),Object.defineProperty(yst.prototype,"needsUpdate",{set:function(t){!0===t&&this.version++}}),Object.assign(yst.prototype,{isGLBufferAttribute:!0,setBuffer:function(t){return this.buffer=t,this},setType:function(t,n){return this.type=t,this.elementSize=n,this},setItemSize:function(t){return this.itemSize=t,this},setCount:function(t){return this.count=t,this}}),Object.assign(kst.prototype,{set:function(t,n){this.ray.set(t,n)},setFromCamera:function(t,n){n&&n.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(n.matrixWorld),this.ray.direction.set(t.x,t.y,.5).unproject(n).sub(this.ray.origin).normalize(),this.camera=n):n&&n.isOrthographicCamera?(this.ray.origin.set(t.x,t.y,(n.near+n.far)/(n.near-n.far)).unproject(n),this.ray.direction.set(0,0,-1).transformDirection(n.matrixWorld),this.camera=n):console.error("THREE.Raycaster: Unsupported camera type: "+n.type)},intersectObject:function(t,n,e){const a=e||[];return wst(t,this,a,n),a.sort(vst),a},intersectObjects:function(t,n,e){const a=e||[];if(!1===Array.isArray(t))return console.warn("THREE.Raycaster.intersectObjects: objects is not an Array."),a;for(let e=0,o=t.length;e<o;e++)wst(t[e],this,a,n);return a.sort(vst),a}});const Sst=new W9;function Est(t){$tt.call(this),this.material=t,this.render=function(){},this.hasPositions=!1,this.hasNormals=!1,this.hasColors=!1,this.hasUvs=!1,this.positionArray=null,this.normalArray=null,this.colorArray=null,this.uvArray=null,this.count=0}(Est.prototype=Object.create($tt.prototype)).constructor=Est,Est.prototype.isImmediateRenderObject=!0;const Ast=new knt({side:1,depthWrite:!1,depthTest:!1});function zst(t){console.warn("THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead."),fct.call(this,t),this.type="catmullrom"}function Rst(t,n){if(1===n)return new Ont(t);const e=n5(t);if(!e)throw new Error(`d3 failed to recognize the color: ${t}`);return new Ont(N5(e,"#fff")(1-n))}var Tst,Dst,Ist,Nst,Fst;function Lst(t,n){const e=n.length/2;let a=t.attributes.position;a&&a.count===3*e||(a=new Snt(new Float32Array(3*e),3),t.addAttribute("position",a));const o=a.array;for(let t=0;t<e;t++)o[3*t]=n[2*t],o[3*t+1]=n[2*t+1];a.needsUpdate=!0,t.setDrawRange(0,3*e),t.computeBoundingSphere()}function Hst(t,n,e){const a=Math.max(n.length/2-1,0),o=2*a*3,r=3*o;let i=t.attributes.position;i&&i.count===o||(i=new Snt(new Float32Array(r),3),t.addAttribute("position",i));const c=i.array;for(let t=0;t<a;t++){const[a,o,r,i]=[n[2*t],n[2*t+1],n[2*t+2],n[2*t+3]],s=new W9(a,o),l=new W9(r,i),m=new W9(r-a,i-o),d=new W9(-m.y,m.x).setLength(e/2),g=s.clone().add(d),p=s.clone().sub(d),b=l.clone().add(d),u=l.clone().sub(d),f=[g.x,g.y,0,p.x,p.y,0,b.x,b.y,0,b.x,b.y,0,p.x,p.y,0,u.x,u.y,0];c.set(f,t*f.length)}i.needsUpdate=!0,t.setDrawRange(0,r),t.computeBoundingSphere()}function Bst(t,n,e){const{visible:a,color:o,opacity:r}=e;if(Array.isArray(t.material))throw new Error("Invariant error: only expect one material on an object");const i=t.material;if(i.visible!==a&&(i.visible=a,i.needsUpdate=!0),!a)return!1;const c=Rst(o,null!=r?r:1),s=n(t.geometry);return t.geometry!==s&&(t.geometry=s),i.color.equals(c)||(i.color.set(c),i.needsUpdate=!0),!0}new bet(new fet,Ast),sct.create=function(t,n){return console.log("THREE.Curve.create() has been deprecated"),t.prototype=Object.create(sct.prototype),t.prototype.constructor=t,t.prototype.getPoint=n,t},Object.assign(Ect.prototype,{fromPoints:function(t){return console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints()."),this.setFromPoints(t)}}),zst.prototype=Object.create(fct.prototype),Object.assign(zst.prototype,{initFromArray:function(){console.error("THREE.Spline: .initFromArray() has been removed.")},getControlPointsArray:function(){console.error("THREE.Spline: .getControlPointsArray() has been removed.")},reparametrizeByArcLength:function(){console.error("THREE.Spline: .reparametrizeByArcLength() has been removed.")}}),Object.assign($it.prototype,{extractUrlBase:function(t){return console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead."),(function(t){const n=t.lastIndexOf("/");return-1===n?"./":t.substr(0,n+1)})(t)}}),$it.Handlers={add:function(){console.error("THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.")},get:function(){console.error("THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.")}},Object.assign(class{constructor(t,n){Object.defineProperty(this,"isBox2",{value:!0}),this.min=void 0!==t?t:new W9(1/0,1/0),this.max=void 0!==n?n:new W9(-1/0,-1/0)}set(t,n){return this.min.copy(t),this.max.copy(n),this}setFromPoints(t){this.makeEmpty();for(let n=0,e=t.length;n<e;n++)this.expandByPoint(t[n]);return this}setFromCenterAndSize(t,n){const e=Sst.copy(n).multiplyScalar(.5);return this.min.copy(t).sub(e),this.max.copy(t).add(e),this}clone(){return(new this.constructor).copy(this)}copy(t){return this.min.copy(t.min),this.max.copy(t.max),this}makeEmpty(){return this.min.x=this.min.y=1/0,this.max.x=this.max.y=-1/0,this}isEmpty(){return this.max.x<this.min.x||this.max.y<this.min.y}getCenter(t){return void 0===t&&(console.warn("THREE.Box2: .getCenter() target is now required"),t=new W9),this.isEmpty()?t.set(0,0):t.addVectors(this.min,this.max).multiplyScalar(.5)}getSize(t){return void 0===t&&(console.warn("THREE.Box2: .getSize() target is now required"),t=new W9),this.isEmpty()?t.set(0,0):t.subVectors(this.max,this.min)}expandByPoint(t){return this.min.min(t),this.max.max(t),this}expandByVector(t){return this.min.sub(t),this.max.add(t),this}expandByScalar(t){return this.min.addScalar(-t),this.max.addScalar(t),this}containsPoint(t){return!(t.x<this.min.x||t.x>this.max.x||t.y<this.min.y||t.y>this.max.y)}containsBox(t){return this.min.x<=t.min.x&&t.max.x<=this.max.x&&this.min.y<=t.min.y&&t.max.y<=this.max.y}getParameter(t,n){return void 0===n&&(console.warn("THREE.Box2: .getParameter() target is now required"),n=new W9),n.set((t.x-this.min.x)/(this.max.x-this.min.x),(t.y-this.min.y)/(this.max.y-this.min.y))}intersectsBox(t){return!(t.max.x<this.min.x||t.min.x>this.max.x||t.max.y<this.min.y||t.min.y>this.max.y)}clampPoint(t,n){return void 0===n&&(console.warn("THREE.Box2: .clampPoint() target is now required"),n=new W9),n.copy(t).clamp(this.min,this.max)}distanceToPoint(t){return Sst.copy(t).clamp(this.min,this.max).sub(t).length()}intersect(t){return this.min.max(t.min),this.max.min(t.max),this}union(t){return this.min.min(t.min),this.max.max(t.max),this}translate(t){return this.min.add(t),this.max.add(t),this}equals(t){return t.min.equals(this.min)&&t.max.equals(this.max)}}.prototype,{center:function(t){return console.warn("THREE.Box2: .center() has been renamed to .getCenter()."),this.getCenter(t)},empty:function(){return console.warn("THREE.Box2: .empty() has been renamed to .isEmpty()."),this.isEmpty()},isIntersectionBox:function(t){return console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},size:function(t){return console.warn("THREE.Box2: .size() has been renamed to .getSize()."),this.getSize(t)}}),Object.assign(att.prototype,{center:function(t){return console.warn("THREE.Box3: .center() has been renamed to .getCenter()."),this.getCenter(t)},empty:function(){return console.warn("THREE.Box3: .empty() has been renamed to .isEmpty()."),this.isEmpty()},isIntersectionBox:function(t){return console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},isIntersectionSphere:function(t){return console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(t)},size:function(t){return console.warn("THREE.Box3: .size() has been renamed to .getSize()."),this.getSize(t)}}),Object.assign(Ctt.prototype,{empty:function(){return console.warn("THREE.Sphere: .empty() has been renamed to .isEmpty()."),this.isEmpty()}}),zet.prototype.setFromMatrix=function(t){return console.warn("THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix()."),this.setFromProjectionMatrix(t)},Object.assign(U9,{random16:function(){return console.warn("THREE.Math: .random16() has been deprecated. Use Math.random() instead."),Math.random()},nearestPowerOfTwo:function(t){return console.warn("THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo()."),U9.floorPowerOfTwo(t)},nextPowerOfTwo:function(t){return console.warn("THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo()."),U9.ceilPowerOfTwo(t)}}),Object.assign(G9.prototype,{flattenToArrayOffset:function(t,n){return console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(t,n)},multiplyVector3:function(t){return console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead."),t.applyMatrix3(this)},multiplyVector3Array:function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},applyToBufferAttribute:function(t){return console.warn("THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead."),t.applyMatrix3(this)},applyToVector3Array:function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")},getInverse:function(t){return console.warn("THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(t).invert()}}),Object.assign(Stt.prototype,{extractPosition:function(t){return console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition()."),this.copyPosition(t)},flattenToArrayOffset:function(t,n){return console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead."),this.toArray(t,n)},getPosition:function(){return console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead."),(new ttt).setFromMatrixColumn(this,3)},setRotationFromQuaternion:function(t){return console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion()."),this.makeRotationFromQuaternion(t)},multiplyToArray:function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},multiplyVector3:function(t){return console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},multiplyVector4:function(t){return console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},multiplyVector3Array:function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},rotateAxis:function(t){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead."),t.transformDirection(this)},crossVector:function(t){return console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},translate:function(){console.error("THREE.Matrix4: .translate() has been removed.")},rotateX:function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},rotateY:function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},rotateZ:function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},rotateByAxis:function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},applyToBufferAttribute:function(t){return console.warn("THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead."),t.applyMatrix4(this)},applyToVector3Array:function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},makeFrustum:function(t,n,e,a,o,r){return console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead."),this.makePerspective(t,n,a,e,o,r)},getInverse:function(t){return console.warn("THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead."),this.copy(t).invert()}}),ant.prototype.isIntersectionLine=function(t){return console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine()."),this.intersectsLine(t)},Object.assign($9.prototype,{multiplyVector3:function(t){return console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead."),t.applyQuaternion(this)},inverse:function(){return console.warn("THREE.Quaternion: .inverse() has been renamed to invert()."),this.invert()}}),Object.assign(wtt.prototype,{isIntersectionBox:function(t){return console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox()."),this.intersectsBox(t)},isIntersectionPlane:function(t){return console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane()."),this.intersectsPlane(t)},isIntersectionSphere:function(t){return console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere()."),this.intersectsSphere(t)}}),Object.assign(bnt.prototype,{area:function(){return console.warn("THREE.Triangle: .area() has been renamed to .getArea()."),this.getArea()},barycoordFromPoint:function(t,n){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),this.getBarycoord(t,n)},midpoint:function(t){return console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint()."),this.getMidpoint(t)},normal:function(t){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),this.getNormal(t)},plane:function(t){return console.warn("THREE.Triangle: .plane() has been renamed to .getPlane()."),this.getPlane(t)}}),Object.assign(bnt,{barycoordFromPoint:function(t,n,e,a,o){return console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord()."),bnt.getBarycoord(t,n,e,a,o)},normal:function(t,n,e,a){return console.warn("THREE.Triangle: .normal() has been renamed to .getNormal()."),bnt.getNormal(t,n,e,a)}}),Object.assign(Act.prototype,{extractAllPoints:function(t){return console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead."),this.extractPoints(t)},extrude:function(t){return console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead."),new Mit(this,t)},makeGeometry:function(t){return console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead."),new xit(this,t)}}),Object.assign(W9.prototype,{fromAttribute:function(t,n,e){return console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,n,e)},distanceToManhattan:function(t){return console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(t)},lengthManhattan:function(){return console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign(ttt.prototype,{setEulerFromRotationMatrix:function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},setEulerFromQuaternion:function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},getPositionFromMatrix:function(t){return console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition()."),this.setFromMatrixPosition(t)},getScaleFromMatrix:function(t){return console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale()."),this.setFromMatrixScale(t)},getColumnFromMatrix:function(t,n){return console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn()."),this.setFromMatrixColumn(n,t)},applyProjection:function(t){return console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead."),this.applyMatrix4(t)},fromAttribute:function(t,n,e){return console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,n,e)},distanceToManhattan:function(t){return console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo()."),this.manhattanDistanceTo(t)},lengthManhattan:function(){return console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign(Q9.prototype,{fromAttribute:function(t,n,e){return console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute()."),this.fromBufferAttribute(t,n,e)},lengthManhattan:function(){return console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength()."),this.manhattanLength()}}),Object.assign($tt.prototype,{getChildByName:function(t){return console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName()."),this.getObjectByName(t)},renderDepth:function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},translate:function(t,n){return console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead."),this.translateOnAxis(n,t)},getWorldRotation:function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")},applyMatrix:function(t){return console.warn("THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(t)}}),Object.defineProperties($tt.prototype,{eulerOrder:{get:function(){return console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order},set:function(t){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order."),this.rotation.order=t}},useQuaternion:{get:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")},set:function(){console.warn("THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.")}}}),Object.assign(bet.prototype,{setDrawMode:function(){console.error("THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}),Object.defineProperties(bet.prototype,{drawMode:{get:function(){return console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode."),0},set:function(){console.error("THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.")}}}),Object.defineProperties(srt.prototype,{objects:{get:function(){return console.warn("THREE.LOD: .objects has been renamed to .levels."),this.levels}}}),Object.defineProperty(_rt.prototype,"useVertexTexture",{get:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")},set:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")}}),brt.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")},Object.defineProperty(sct.prototype,"__arcLengthDivisions",{get:function(){return console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions."),this.arcLengthDivisions},set:function(t){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions."),this.arcLengthDivisions=t}}),Pet.prototype.setLens=function(t,n){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup."),void 0!==n&&(this.filmGauge=n),this.setFocalLength(t)},Object.defineProperties(zct.prototype,{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(t){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov."),this.shadow.camera.fov=t}},shadowCameraLeft:{set:function(t){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left."),this.shadow.camera.left=t}},shadowCameraRight:{set:function(t){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right."),this.shadow.camera.right=t}},shadowCameraTop:{set:function(t){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top."),this.shadow.camera.top=t}},shadowCameraBottom:{set:function(t){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom."),this.shadow.camera.bottom=t}},shadowCameraNear:{set:function(t){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near."),this.shadow.camera.near=t}},shadowCameraFar:{set:function(t){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far."),this.shadow.camera.far=t}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},shadowBias:{set:function(t){console.warn("THREE.Light: .shadowBias is now .shadow.bias."),this.shadow.bias=t}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(t){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width."),this.shadow.mapSize.width=t}},shadowMapHeight:{set:function(t){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height."),this.shadow.mapSize.height=t}}}),Object.defineProperties(Snt.prototype,{length:{get:function(){return console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead."),this.array.length}},dynamic:{get:function(){return console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.usage===L9},set:function(){console.warn("THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead."),this.setUsage(L9)}}}),Object.assign(Snt.prototype,{setDynamic:function(t){return console.warn("THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===t?L9:F9),this},copyIndicesArray:function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")},setArray:function(){console.error("THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}}),Object.assign(Xnt.prototype,{addIndex:function(t){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex()."),this.setIndex(t)},addAttribute:function(t,n){return console.warn("THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute()."),n&&n.isBufferAttribute||n&&n.isInterleavedBufferAttribute?"index"===t?(console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(n),this):this.setAttribute(t,n):(console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.setAttribute(t,new Snt(arguments[1],arguments[2])))},addDrawCall:function(t,n,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset."),console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup()."),this.addGroup(t,n)},clearDrawCalls:function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups()."),this.clearGroups()},computeOffsets:function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")},removeAttribute:function(t){return console.warn("THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute()."),this.deleteAttribute(t)},applyMatrix:function(t){return console.warn("THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4()."),this.applyMatrix4(t)}}),Object.defineProperties(Xnt.prototype,{drawcalls:{get:function(){return console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups."),this.groups}},offsets:{get:function(){return console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups."),this.groups}}}),Object.defineProperties(Yct.prototype,{maxInstancedCount:{get:function(){return console.warn("THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount."),this.instanceCount},set:function(t){console.warn("THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount."),this.instanceCount=t}}}),Object.defineProperties(kst.prototype,{linePrecision:{get:function(){return console.warn("THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead."),this.params.Line.threshold},set:function(t){console.warn("THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead."),this.params.Line.threshold=t}}}),Object.defineProperties(Vot.prototype,{dynamic:{get:function(){return console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead."),this.usage===L9},set:function(t){console.warn("THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead."),this.setUsage(t)}}}),Object.assign(Vot.prototype,{setDynamic:function(t){return console.warn("THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead."),this.setUsage(!0===t?L9:F9),this},setArray:function(){console.error("THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers")}}),Object.assign(Mit.prototype,{getArrays:function(){console.error("THREE.ExtrudeGeometry: .getArrays() has been removed.")},addShapeList:function(){console.error("THREE.ExtrudeGeometry: .addShapeList() has been removed.")},addShape:function(){console.error("THREE.ExtrudeGeometry: .addShape() has been removed.")}}),Object.assign(Bot.prototype,{dispose:function(){console.error("THREE.Scene: .dispose() has been removed.")}}),Object.defineProperties(Pst.prototype,{dynamic:{set:function(){console.warn("THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.")}},onUpdate:{value:function(){return console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead."),this}}}),Object.defineProperties(ynt.prototype,{wrapAround:{get:function(){console.warn("THREE.Material: .wrapAround has been removed.")},set:function(){console.warn("THREE.Material: .wrapAround has been removed.")}},overdraw:{get:function(){console.warn("THREE.Material: .overdraw has been removed.")},set:function(){console.warn("THREE.Material: .overdraw has been removed.")}},wrapRGB:{get:function(){return console.warn("THREE.Material: .wrapRGB has been removed."),new Ont}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(t){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===t}},stencilMask:{get:function(){return console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask},set:function(t){console.warn("THREE."+this.type+": .stencilMask has been removed. Use .stencilFuncMask instead."),this.stencilFuncMask=t}}}),Object.defineProperties(Sit.prototype,{metal:{get:function(){return console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead."),!1},set:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead")}}}),Object.defineProperties(wit.prototype,{transparency:{get:function(){return console.warn("THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission."),this.transmission},set:function(t){console.warn("THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission."),this.transmission=t}}}),Object.defineProperties(Met.prototype,{derivatives:{get:function(){return console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives},set:function(t){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives."),this.extensions.derivatives=t}}}),Object.assign(Lot.prototype,{clearTarget:function(t,n,e,a){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead."),this.setRenderTarget(t),this.clear(n,e,a)},animate:function(t){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop()."),this.setAnimationLoop(t)},getCurrentRenderTarget:function(){return console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget()."),this.getRenderTarget()},getMaxAnisotropy:function(){return console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy()."),this.capabilities.getMaxAnisotropy()},getPrecision:function(){return console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision."),this.capabilities.precision},resetGLState:function(){return console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset()."),this.state.reset()},supportsFloatTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."),this.extensions.get("OES_texture_float")},supportsHalfFloatTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."),this.extensions.get("OES_texture_half_float")},supportsStandardDerivatives:function(){return console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."),this.extensions.get("OES_standard_derivatives")},supportsCompressedTextureS3TC:function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."),this.extensions.get("WEBGL_compressed_texture_s3tc")},supportsCompressedTexturePVRTC:function(){return console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."),this.extensions.get("WEBGL_compressed_texture_pvrtc")},supportsBlendMinMax:function(){return console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."),this.extensions.get("EXT_blend_minmax")},supportsVertexTextures:function(){return console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures."),this.capabilities.vertexTextures},supportsInstancedArrays:function(){return console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."),this.extensions.get("ANGLE_instanced_arrays")},enableScissorTest:function(t){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest()."),this.setScissorTest(t)},initMaterial:function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},addPrePlugin:function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},addPostPlugin:function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},updateShadowMap:function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},setFaceCulling:function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},allocTextureUnit:function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},setTexture:function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},setTexture2D:function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},setTextureCube:function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},getActiveMipMapLevel:function(){return console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel()."),this.getActiveMipmapLevel()}}),Object.defineProperties(Lot.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(t){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled."),this.shadowMap.enabled=t}},shadowMapType:{get:function(){return this.shadowMap.type},set:function(t){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type."),this.shadowMap.type=t}},shadowMapCullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.")}},context:{get:function(){return console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead."),this.getContext()}},vr:{get:function(){return console.warn("THREE.WebGLRenderer: .vr has been renamed to .xr"),this.xr}},gammaInput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead."),!1},set:function(){console.warn("THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.")}},gammaOutput:{get:function(){return console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),!1},set:function(t){console.warn("THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead."),this.outputEncoding=!0===t?3001:I9}},toneMappingWhitePoint:{get:function(){return console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed."),1},set:function(){console.warn("THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.")}}}),Object.defineProperties(Eot.prototype,{cullFace:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.")}},renderReverseSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.")}},renderSingleSided:{get:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")},set:function(){console.warn("THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.")}}}),Object.defineProperties(K9.prototype,{wrapS:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS},set:function(t){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS."),this.texture.wrapS=t}},wrapT:{get:function(){return console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT},set:function(t){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT."),this.texture.wrapT=t}},magFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter},set:function(t){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter."),this.texture.magFilter=t}},minFilter:{get:function(){return console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter},set:function(t){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter."),this.texture.minFilter=t}},anisotropy:{get:function(){return console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy},set:function(t){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy."),this.texture.anisotropy=t}},offset:{get:function(){return console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset},set:function(t){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset."),this.texture.offset=t}},repeat:{get:function(){return console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat},set:function(t){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat."),this.texture.repeat=t}},format:{get:function(){return console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format},set:function(t){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format."),this.texture.format=t}},type:{get:function(){return console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type},set:function(t){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type."),this.texture.type=t}},generateMipmaps:{get:function(){return console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps},set:function(t){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps."),this.texture.generateMipmaps=t}}}),Object.defineProperties(class extends $tt{constructor(t){super(),this.type="Audio",this.listener=t,this.context=t.context,this.gain=this.context.createGain(),this.gain.connect(t.getInput()),this.autoplay=!1,this.buffer=null,this.detune=0,this.loop=!1,this.loopStart=0,this.loopEnd=0,this.offset=0,this.duration=void 0,this.playbackRate=1,this.isPlaying=!1,this.hasPlaybackControl=!0,this.source=null,this.sourceType="empty",this._startedAt=0,this._progress=0,this._connected=!1,this.filters=[]}getOutput(){return this.gain}setNodeSource(t){return this.hasPlaybackControl=!1,this.sourceType="audioNode",this.source=t,this.connect(),this}setMediaElementSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaNode",this.source=this.context.createMediaElementSource(t),this.connect(),this}setMediaStreamSource(t){return this.hasPlaybackControl=!1,this.sourceType="mediaStreamNode",this.source=this.context.createMediaStreamSource(t),this.connect(),this}setBuffer(t){return this.buffer=t,this.sourceType="buffer",this.autoplay&&this.play(),this}play(t=0){if(!0===this.isPlaying)return void console.warn("THREE.Audio: Audio is already playing.");if(!1===this.hasPlaybackControl)return void console.warn("THREE.Audio: this Audio has no playback control.");this._startedAt=this.context.currentTime+t;const n=this.context.createBufferSource();return n.buffer=this.buffer,n.loop=this.loop,n.loopStart=this.loopStart,n.loopEnd=this.loopEnd,n.onended=this.onEnded.bind(this),n.start(this._startedAt,this._progress+this.offset,this.duration),this.isPlaying=!0,this.source=n,this.setDetune(this.detune),this.setPlaybackRate(this.playbackRate),this.connect()}pause(){if(!1!==this.hasPlaybackControl)return!0===this.isPlaying&&(this._progress+=Math.max(this.context.currentTime-this._startedAt,0)*this.playbackRate,!0===this.loop&&(this._progress=this._progress%(this.duration||this.buffer.duration)),this.source.stop(),this.source.onended=null,this.isPlaying=!1),this;console.warn("THREE.Audio: this Audio has no playback control.")}stop(){if(!1!==this.hasPlaybackControl)return this._progress=0,this.source.stop(),this.source.onended=null,this.isPlaying=!1,this;console.warn("THREE.Audio: this Audio has no playback control.")}connect(){if(this.filters.length>0){this.source.connect(this.filters[0]);for(let t=1,n=this.filters.length;t<n;t++)this.filters[t-1].connect(this.filters[t]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this._connected=!0,this}disconnect(){if(this.filters.length>0){this.source.disconnect(this.filters[0]);for(let t=1,n=this.filters.length;t<n;t++)this.filters[t-1].disconnect(this.filters[t]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this._connected=!1,this}getFilters(){return this.filters}setFilters(t){return t||(t=[]),!0===this._connected?(this.disconnect(),this.filters=t.slice(),this.connect()):this.filters=t.slice(),this}setDetune(t){if(this.detune=t,void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this}getDetune(){return this.detune}getFilter(){return this.getFilters()[0]}setFilter(t){return this.setFilters(t?[t]:[])}setPlaybackRate(t){if(!1!==this.hasPlaybackControl)return this.playbackRate=t,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this;console.warn("THREE.Audio: this Audio has no playback control.")}getPlaybackRate(){return this.playbackRate}onEnded(){this.isPlaying=!1}getLoop(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop}setLoop(t){if(!1!==this.hasPlaybackControl)return this.loop=t,!0===this.isPlaying&&(this.source.loop=this.loop),this;console.warn("THREE.Audio: this Audio has no playback control.")}setLoopStart(t){return this.loopStart=t,this}setLoopEnd(t){return this.loopEnd=t,this}getVolume(){return this.gain.gain.value}setVolume(t){return this.gain.gain.setTargetAtTime(t,this.context.currentTime,.01),this}}.prototype,{load:{value:function(t){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");const n=this;return(new nst).load(t,(function(t){n.setBuffer(t)})),this}},startTime:{set:function(){console.warn("THREE.Audio: .startTime is now .play( delay ).")}}}),yet.prototype.updateCubeMap=function(t,n){return console.warn("THREE.CubeCamera: .updateCubeMap() is now .update()."),this.update(t,n)},yet.prototype.clear=function(t,n,e,a){return console.warn("THREE.CubeCamera: .clear() is now .renderTarget.clear()."),this.renderTarget.clear(t,n,e,a)},q9.crossOrigin=void 0,q9.loadTexture=function(t,n,e,a){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");const o=new cct;o.setCrossOrigin(this.crossOrigin);const r=o.load(t,e,void 0,a);return n&&(r.mapping=n),r},q9.loadTextureCube=function(t,n,e,a){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");const o=new rct;o.setCrossOrigin(this.crossOrigin);const r=o.load(t,e,void 0,a);return n&&(r.mapping=n),r},q9.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")},q9.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")},"undefined"!=typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("register",{detail:{revision:"125"}})),"undefined"!=typeof window&&(window.__THREE__?console.warn("WARNING: Multiple instances of Three.js being imported."):window.__THREE__="125"),(function(t){t[t.CIRCLE=0]="CIRCLE",t[t.LINE=1]="LINE",t[t.TRIANGLE=2]="TRIANGLE",t[t.TRAPEZOID=3]="TRAPEZOID"})(Tst||(Tst={}));class Vst{constructor(t,n,e){this.coordinator=n,this.scene=new Bot,s9()&&t instanceof OffscreenCanvas&&(t.style=t.style||{}),this.renderer=new Lot({canvas:t,context:t.getContext("webgl2",{antialias:!0,precision:"highp",alpha:!0})}),this.renderer.setPixelRatio(e)}onResize(t){this.renderer.setSize(t.width,t.height)}destroyObject(t){const n=t.obj3d;if(this.scene.remove(n),n instanceof bet){n.geometry.dispose();const t=Array.isArray(n.material)?n.material:[n.material];for(const n of t)n.dispose()}}createOrUpdateLineObject(t,n,e){var a;if(!t&&!e.visible)return null;const{visible:o,width:r}=e;if(!t){const t=Rst(e.color,null!==(a=e.opacity)&&void 0!==a?a:1),i=new Xnt,c=new yrt({color:t}),s=new bet(i,c);return c.visible=o,Hst(i,n,r),this.scene.add(s),{type:Tst.LINE,data:n,obj3d:s,width:r}}const{data:i,obj3d:c,width:s}=t;return Bst(c,(t=>(r===s&&i&&l9(i,n)||Hst(t,n,r),t)),e)?{type:Tst.LINE,data:n,obj3d:c,width:r}:t}createMesh(t,n){if(!n.visible)return null;const{visible:e,color:a,opacity:o}=n;return new bet(t,new knt({color:Rst(a,null!=o?o:1),visible:e}))}createOrUpdateTriangleObject(t,n,e){const{size:a}=e,o=a*Math.sqrt(3)/2,r=new Float32Array([n.x-a/2,n.y-o/3,n.x+a/2,n.y-o/3,n.x,n.y+2*o/3]);if(!t){const t=new Xnt;Lst(t,r);const a=this.createMesh(t,e);return null===a?null:(this.scene.add(a),{type:Tst.TRIANGLE,data:n,obj3d:a})}return Bst(t.obj3d,(t=>(Lst(t,r),t)),e)?{type:Tst.TRIANGLE,data:n,obj3d:t.obj3d}:t}createOrUpdateCircleObject(t,n,e){const{radius:a}=e,o=new Yrt(e.radius);if(!t){const t=this.createMesh(o,e);return null===t?null:(t.position.set(n.x,n.y,0),this.scene.add(t),{type:Tst.CIRCLE,data:{loc:n,radius:a},obj3d:t})}return Bst(t.obj3d,(()=>o),e)?(t.obj3d.position.set(n.x,n.y,0),{type:Tst.CIRCLE,data:{loc:n,radius:a},obj3d:t.obj3d}):t}createOrUpdateTrapezoidObject(t,n,e,a){if(n.y!==e.y)throw new RangeError("Input error: start.y != end.y.");const{altitude:o}=a,r=2/Math.sqrt(3)*o,i=new Act([new W9(n.x-r/2,n.y-o/2),new W9(n.x,n.y+o/2),new W9(e.x,e.y+o/2),new W9(e.x+r/2,e.y-o/2)]);i.autoClose=!0;const c=new xit(i);if(!t){const t=this.createMesh(c,a);return null===t?null:(this.scene.add(t),{type:Tst.TRAPEZOID,data:[n,e],obj3d:t})}return Bst(t.obj3d,(()=>c),a)?{type:Tst.TRAPEZOID,data:[n,e],obj3d:t.obj3d}:t}flush(){this.renderer.render(this.scene,this.coordinator.getCamera())}}class jst{constructor(t,n){this.renderCache=t,this.renderer=n}setLine(t,n,e){const a=this.renderer.createOrUpdateLineObject(this.renderCache.getFromPreviousFrame(t),n,e);a&&this.renderCache.setToCurrentFrame(t,a)}setTriangle(t,n,e){const a=this.renderer.createOrUpdateTriangleObject(this.renderCache.getFromPreviousFrame(t),n,e);a&&this.renderCache.setToCurrentFrame(t,a)}setCircle(t,n,e){const a=this.renderer.createOrUpdateCircleObject(this.renderCache.getFromPreviousFrame(t),n,e);a&&this.renderCache.setToCurrentFrame(t,a)}setTrapezoid(t,n,e,a){const o=this.renderer.createOrUpdateTrapezoidObject(this.renderCache.getFromPreviousFrame(t),n,e,a);o&&this.renderCache.setToCurrentFrame(t,o)}}class Ust{constructor(){this.prevFrameCache=new Map,this.currFrameCache=new Map}getFromPreviousFrame(t){const n=this.prevFrameCache.get(t);return null!=n?n:null}setToCurrentFrame(t,n){this.currFrameCache.set(t,n)}finalizeFrameAndGetRemoved(){const t=[];for(const[n,e]of this.prevFrameCache.entries())this.currFrameCache.has(n)||t.push(e);return this.prevFrameCache=this.currFrameCache,this.currFrameCache=new Map,t}}!(function(t){t[t.NUMBER=0]="NUMBER",t[t.NAN=1]="NAN"})(Dst||(Dst={}));class Wst extends class{constructor(t){this.rawSeriesData=[],this.series=[],this.paintDirty=!0,this.renderCache=new Ust,this.coordinateIdentifier=null,this.layout={x:0,width:1,y:0,height:1},this.getMetadataMapImpl=t.getMetadataMap,this.coordinator=t.coordinator,this.renderer=t.renderer,this.paintBrush=new jst(this.renderCache,this.renderer)}setLayoutRect(t){this.layout.x===t.x&&this.layout.width===t.width&&this.layout.y===t.y&&this.layout.height===t.height||(this.paintDirty=!0),this.layout=t}getLayoutRect(){return this.layout}getMetadataMap(){return this.getMetadataMapImpl()}markAsPaintDirty(){this.paintDirty=!0}render(){if(this.transformCoordinatesIfStale(),this.paintDirty){this.redraw();for(const t of this.renderCache.finalizeFrameAndGetRemoved())this.renderer.destroyObject(t);this.paintDirty=!1}}isCoordinateUpdated(){return this.coordinator.getUpdateIdentifier()!==this.coordinateIdentifier}clearCoordinateIdentifier(){this.coordinateIdentifier=null}setData(t){this.clearCoordinateIdentifier(),this.rawSeriesData=t}transformCoordinatesIfStale(){if(!this.isCoordinateUpdated())return;const t=this.getLayoutRect();this.series=new Array(this.rawSeriesData.length);for(let n=0;n<this.rawSeriesData.length;n++){const e=this.rawSeriesData[n];this.series[n]={id:e.id,polyline:new Float32Array(2*e.points.length)};for(let a=0;a<e.points.length;a++){const[o,r]=this.coordinator.transformDataToUiCoord(t,[e.points[a].x,e.points[a].y]);this.series[n].polyline[2*a]=o,this.series[n].polyline[2*a+1]=r}}this.coordinateIdentifier=this.coordinator.getUpdateIdentifier(),this.markAsPaintDirty()}}{recordPartition(t,n,e){return t?{type:Dst.NUMBER,polyline:n}:{type:Dst.NAN,polyline:n.map(((t,n)=>isNaN(t)?n%2==0?e.x:e.y:t))}}partitionPolyline(t){const n=[];let e=0,a=!1;const o=this.coordinator.transformDataToUiCoord(this.getLayoutRect(),[0,0]),r={x:o[0],y:o[1]};let i=null;for(let o=0;o<t.length;o+=2){const r=t[o],c=t[o+1],s=isNaN(r)||isNaN(c);s!==a&&e!==o&&(n.push(this.recordPartition(!a,t.slice(e,o),null===i?{x:r,y:c}:i)),e=o),s||(i={x:r,y:c}),a=s}return e!==t.length-1&&n.push(this.recordPartition(!a,t.slice(e,t.length),null!=i?i:r)),n}redraw(){var t,n,e;for(const a of this.series){const o=this.getMetadataMap()[a.id];if(!o)continue;if(a.polyline.length%2!=0)throw new Error(`Cannot have odd length-ed polyline: ${a.polyline.length}`);const r=this.partitionPolyline(a.polyline);for(const[i,{type:c,polyline:s}]of r.entries())if(c===Dst.NUMBER)2===s.length?this.paintBrush.setCircle(JSON.stringify(["circle",a.id,i]),{x:s[0],y:s[1]},{color:o.color,visible:o.visible,opacity:null!==(t=o.opacity)&&void 0!==t?t:1,radius:4}):this.paintBrush.setLine(JSON.stringify(["line",a.id,i]),s,{color:o.color,visible:o.visible,opacity:null!==(n=o.opacity)&&void 0!==n?n:1,width:2});else if(!o.aux)for(let t=0;t<s.length;t+=2)this.paintBrush.setTriangle(JSON.stringify(["NaN",a.id,s[t],s[t+1]]),{x:s[t],y:s[t+1]},{color:o.color,visible:o.visible,opacity:null!==(e=o.opacity)&&void 0!==e?e:1,size:12})}}}class Gst extends m9{constructor(){super(...arguments),this.camera=new Lct(0,1e3,1e3,0,0,100)}isYAxisPointedDown(){return!1}setDomContainerRect(t){super.setDomContainerRect(t),this.camera.left=t.x,this.camera.right=t.x+t.width,this.camera.top=t.y+t.height,this.camera.bottom=t.y,this.camera.updateProjectionMatrix()}getCamera(){return this.camera}}class Yst{constructor(t){switch(this.metadataMap={},this.shouldRepaint=!1,this.callbacks=t.callbacks,t.type){case V$.SVG:this.coordinator=new m9,this.renderer=new g9(t.container);break;case V$.WEBGL:{const n=new Gst;this.coordinator=n,this.renderer=new Vst(t.container,n,t.devicePixelRatio);break}}this.seriesLineView=new Wst({renderer:this.renderer,coordinator:this.coordinator,getMetadataMap:()=>this.metadataMap}),this.resize(t.domDimension)}dispose(){}setXScaleType(t){this.coordinator.setXScale(a9(t)),this.scheduleRepaint()}setYScaleType(t){this.coordinator.setYScale(a9(t)),this.scheduleRepaint()}resize(t){this.coordinator.setDomContainerRect(Object.assign({x:0,y:0},t)),this.renderer.onResize(Object.assign({x:0,y:0},t)),this.seriesLineView.setLayoutRect(Object.assign(Object.assign({},t),{x:0,y:0})),this.scheduleRepaint()}setMetadata(t){let n=!1;Object.entries(t).forEach((([t,e])=>{const a=this.metadataMap[t];a&&e.color===a.color&&e.visible===a.visible&&e.opacity===a.opacity||(n=!0),this.metadataMap[t]=e})),n&&this.seriesLineView.markAsPaintDirty(),this.scheduleRepaint()}setViewBox(t){this.coordinator.setViewBoxRect({x:t.x[0],width:t.x[1]-t.x[0],y:t.y[0],height:t.y[1]-t.y[0]}),this.scheduleRepaint()}setData(t){this.seriesLineView.setData(t),this.scheduleRepaint()}scheduleRepaint(){this.shouldRepaint||(this.shouldRepaint=!0,self.requestAnimationFrame((()=>{this.repaint(),this.shouldRepaint=!1})))}repaint(){this.seriesLineView.render(),this.renderer.flush(),this.callbacks.onDrawEnd()}}function qst(t){if(t.includes("/"))throw new RangeError("Worker factory only allows file name and no resource path.");return new Worker(t)}!(function(t){t[t.SERIES_DATA_UPDATED=0]="SERIES_DATA_UPDATED",t[t.SERIES_METADATA_CHANGED=1]="SERIES_METADATA_CHANGED",t[t.SCALE_UPDATED=2]="SCALE_UPDATED",t[t.VIEW_BOX_UPDATED=3]="VIEW_BOX_UPDATED",t[t.INIT=4]="INIT",t[t.DOM_RESIZED=5]="DOM_RESIZED"})(Ist||(Ist={})),(function(t){t[t.ON_REDRAW_END=0]="ON_REDRAW_END"})(Nst||(Nst={}));class Zst{constructor(t){if(this.callbacks=t.callbacks,t.type!==V$.WEBGL)throw new RangeError(`Cannot use non WEBGL renderer for the offscreen line chart. Received ${V$[t.type]} `);const n=new MessageChannel;n.port1.onmessage=t=>{this.onMessageFromWorker(t.data)},this.txMessagePort=n.port1;const e=t.container.transferControlToOffscreen();this.workerInstance=Zst.workerPool.getNext();const a={type:Ist.INIT,canvas:e,devicePixelRatio:window.devicePixelRatio,dim:t.domDimension,rendererType:t.type};this.workerInstance.postMessage(a,[e,n.port2])}dispose(){this.workerInstance.free(),this.txMessagePort.close()}setXScaleType(t){this.sendMessage({type:Ist.SCALE_UPDATED,axis:"x",scaleType:t})}setYScaleType(t){this.sendMessage({type:Ist.SCALE_UPDATED,axis:"y",scaleType:t})}resize(t){this.sendMessage({type:Ist.DOM_RESIZED,dim:t})}setMetadata(t){this.sendMessage({type:Ist.SERIES_METADATA_CHANGED,metadata:t})}setViewBox(t){this.sendMessage({type:Ist.VIEW_BOX_UPDATED,extent:t})}setData(t){const n=(function e(t){const n=t.reduce(((t,n)=>t+n.points.length),0);let e=0;const a=new Float64Array(2*n),o=[];for(const n of t){o.push({id:n.id,length:n.points.length});for(let t=0;t<n.points.length;t++)a[e++]=n.points[t].x,a[e++]=n.points[t].y}return{idsAndLengths:o,flattenedSeries:a.buffer}})(t);this.sendMessage({type:Ist.SERIES_DATA_UPDATED,compactDataSeries:n},[n.flattenedSeries])}sendMessage(t,n){n?this.txMessagePort.postMessage(t,n):this.txMessagePort.postMessage(t)}onMessageFromWorker(t){switch(t.type){case Nst.ON_REDRAW_END:this.callbacks.onDrawEnd()}}}function Xst(t,n){return"x"===n?[0,t.width]:[t.height,0]}function Jst(t,n){const e=Math.floor(t/50);return Math.min(e,n)}function Qst(t,n){if(1&t&&(ui(),tp(0,"line",2)),2&t){const t=n.$implicit,e=gp();Dp("zero",0===t),Ng("x1",e.getDomX(t))("x2",e.getDomX(t))("y2",e.domDim.height)}}function Kst(t,n){if(1&t&&(ui(),tp(0,"line",3)),2&t){const t=n.$implicit,e=gp();Dp("zero",0===t),Ng("y1",e.getDomY(t))("x2",e.domDim.width)("y2",e.getDomY(t))}}Zst.workerPool=new class{constructor(t,n=10,e=qst){this.workerResourcePath=t,this.maxPoolSize=n,this.workerFactory=e,this.workers=[]}getNext(){let t;if(this.workers.every((({activeCount:t})=>t>0))&&this.workers.length<this.maxPoolSize){const n=this.workerFactory(this.workerResourcePath);t={activeCount:0,postMessage:(t,e)=>{n.postMessage(t,e)},free:()=>{t.activeCount=Math.max(t.activeCount-1,0)}},this.workers.push(t)}else{const n=this.workers.map((({activeCount:t})=>t)),e=n.indexOf(Math.min(...n));t=this.workers[e]}return t.activeCount++,t}}("chart_worker.js?_file_hash=a69548e3");class $st{getDomX(t){return this.xScale.forward(this.viewExtent.x,Xst(this.domDim,"x"),t)}getDomY(t){return this.yScale.forward(this.viewExtent.y,Xst(this.domDim,"y"),t)}getXTicks(){return this.xScale.ticks(this.viewExtent.x,Jst(this.domDim.width,this.xGridCount))}getYTicks(){return this.yScale.ticks(this.viewExtent.y,Jst(this.domDim.height,this.yGridCount))}}function tlt(t,n,e,a,o,r){let i;switch(t.deltaMode){case WheelEvent.DOM_DELTA_PIXEL:i=1;break;case WheelEvent.DOM_DELTA_LINE:i=8;break;case WheelEvent.DOM_DELTA_PAGE:i=20;break;default:i=1,console.warn(`Unknown WheelEvent deltaMode: ${t.deltaMode}.`)}const c=t.deltaY*i,s=c<0?Math.max(c*a,-.95):c*a,{width:l,height:m}=e,d=[o.reverse(n.x,[0,l],-t.offsetX*s),o.reverse(n.x,[0,l],l+(l-t.offsetX)*s)],g=[r.reverse(n.y,[m,0],-t.offsetY*s),r.reverse(n.y,[m,0],m+(m-t.offsetY)*s)];return{x:d[1]<d[0]?[d[1],d[0]]:d,y:g[1]<g[0]?[g[1],g[0]]:g}}$st.ɵfac=function t(n){return new(n||$st)},$st.ɵcmp=_o({type:$st,selectors:[["line-chart-grid-view"]],inputs:{viewExtent:"viewExtent",xScale:"xScale",xGridCount:"xGridCount",yScale:"yScale",yGridCount:"yGridCount",domDim:"domDim"},decls:3,vars:2,consts:[["y1","0",3,"zero",4,"ngFor","ngForOf"],["x1","0",3,"zero",4,"ngFor","ngForOf"],["y1","0"],["x1","0"]],template:function t(n,e){1&n&&(ui(),Kg(0,"svg"),Yg(1,Qst,1,5,"line",0),Yg(2,Kst,1,5,"line",1),$g()),2&n&&(ws(1),Jg("ngForOf",e.getXTicks()),ws(1),Jg("ngForOf",e.getYTicks()))},directives:[jM],styles:["[_nghost-%COMP%] {\n        display: flex;\n        overflow: hidden;\n      }\n\n      svg[_ngcontent-%COMP%] {\n        height: 100%;\n        width: 100%;\n      }\n\n      line[_ngcontent-%COMP%] {\n        stroke: #ccc;\n        stroke-width: 1px;\n      }\n\n      .zero[_ngcontent-%COMP%] {\n        stroke: #aaa;\n        stroke-width: 1.5px;\n      }"],changeDetection:0}),(function(t){t[t.LEFT=1]="LEFT",t[t.RIGHT=2]="RIGHT",t[t.MIDDLE=4]="MIDDLE",t[t.FOURTH=8]="FOURTH",t[t.FIFTH=32]="FIFTH"})(Fst||(Fst={}));const nlt=["dots"];function elt(t,n){if(1&t&&(ui(),tp(0,"circle",12)),2&t){const t=gp().$implicit,n=gp(2);Ng("cx",n.getDomX(t.point.x))("cy",n.getDomY(t.point.y))("fill",t.metadata.color)}}function alt(t,n){if(1&t&&(ui(),np(0),Yg(1,elt,1,3,"circle",11),ep()),2&t){const t=n.$implicit,e=gp(2);ws(1),Jg("ngIf",e.shouldRenderTooltipPoint(t.point))}}function olt(t,n){if(1&t&&(ui(),np(0),Yg(1,alt,2,1,"ng-container",10),ep()),2&t){const t=gp();ws(1),Jg("ngForOf",t.cursoredData)("ngForTrackBy",t.trackBySeriesName)}}function rlt(t,n){if(1&t&&(ui(),tp(0,"rect",13)),2&t){const t=gp();Ng("x",t.zoomBoxInUiCoordinate.x)("width",t.zoomBoxInUiCoordinate.width)("y",t.zoomBoxInUiCoordinate.y)("height",t.zoomBoxInUiCoordinate.height)}}const ilt=function(t,n){return{data:t,cursorLocationInDataCoord:n}};function clt(t,n){if(1&t&&(Kg(0,"div",14),ap(1,15),$g()),2&t){const t=gp(),n=qg(11);ws(1),Jg("ngTemplateOutlet",t.tooltipTemplate?t.tooltipTemplate:n)("ngTemplateOutletContext",ff(2,ilt,t.cursoredData,t.cursorLocationInDataCoord))}}function slt(t,n){if(1&t&&(np(0),Kg(1,"tr",17),Kg(2,"td",18),tp(3,"span"),$g(),Kg(4,"td",19),Jp(5),$g(),Kg(6,"td"),Jp(7),$g(),Kg(8,"td"),Jp(9),$g(),$g(),ep()),2&t){const t=n.$implicit;ws(3),Tp("background-color",t.metadata.color),ws(2),Qp(t.metadata.displayName),ws(2),Qp(t.point.y),ws(2),Qp(t.point.x)}}function llt(t,n){if(1&t&&(Kg(0,"table"),Kg(1,"thead"),Kg(2,"tr"),tp(3,"th",16),Kg(4,"th"),Jp(5,"Name"),$g(),Kg(6,"th"),Jp(7,"Y"),$g(),Kg(8,"th"),Jp(9,"X"),$g(),$g(),$g(),Kg(10,"tbody"),Yg(11,slt,10,5,"ng-container",10),$g(),$g()),2&t){const t=n.data,e=gp();ws(11),Jg("ngForOf",t)("ngForTrackBy",e.trackBySeriesName)}}var mlt;!(function(t){t[t.NONE=0]="NONE",t[t.DRAG_ZOOMING=1]="DRAG_ZOOMING",t[t.SCROLL_ZOOMING=2]="SCROLL_ZOOMING",t[t.PANNING=3]="PANNING"})(mlt||(mlt={}));class dlt{constructor(t,n){this.changeDetector=t,this.scrollStrategy=n,this.onViewExtentChange=new Ef,this.onViewExtentReset=new Ef,this.InteractionState=mlt,this.state=mlt.NONE,this.specialKeyPressed=!1,this.zoomBoxInUiCoordinate={x:0,width:0,height:0,y:0},this.tooltipPositions=[{offsetY:5,originX:"start",overlayX:"start",originY:"bottom",overlayY:"top"},{offsetY:5,originX:"end",overlayX:"end",originY:"bottom",overlayY:"top"},{offsetY:-15,originX:"start",overlayX:"start",originY:"top",overlayY:"bottom"},{offsetY:-15,originX:"end",overlayX:"end",originY:"top",overlayY:"bottom"},{offsetX:5,originX:"end",overlayX:"start",originY:"top",overlayY:"top"},{offsetX:-5,originX:"start",overlayX:"end",originY:"top",overlayY:"top"}],this.cursorLocationInDataCoord=null,this.cursoredData=[],this.tooltipDisplayAttached=!1,this.showZoomInstruction=!1,this.dragStartCoord=null,this.isCursorInside=!1,this.ngUnsubscribe=new x}ngAfterViewInit(){Vt(this.dotsContainer.nativeElement,"dblclick",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((()=>{this.onViewExtentReset.emit(),this.state=mlt.NONE,this.changeDetector.markForCheck()})),Vt(window,"keydown",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{const n=this.shouldPan(t);n!==this.specialKeyPressed&&(this.specialKeyPressed=n,this.changeDetector.markForCheck())})),Vt(window,"keyup",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{const n=this.shouldPan(t);n!==this.specialKeyPressed&&(this.specialKeyPressed=n,this.changeDetector.markForCheck())})),Vt(this.dotsContainer.nativeElement,"mousedown",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{const n=this.state,e=this.shouldPan(t)?mlt.PANNING:mlt.DRAG_ZOOMING;n===mlt.NONE&&e===mlt.DRAG_ZOOMING&&(this.dragStartCoord={x:t.offsetX,y:t.offsetY},this.zoomBoxInUiCoordinate={x:t.offsetX,width:0,y:t.offsetY,height:0}),n!==e&&(this.state=e,this.changeDetector.markForCheck())})),Vt(this.dotsContainer.nativeElement,"mouseup",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{const n=(t.buttons&Fst.LEFT)===Fst.LEFT;this.dragStartCoord=null;const e=this.zoomBoxInUiCoordinate;if(!n&&this.state===mlt.DRAG_ZOOMING&&e.width>0&&e.height>0){const t=this.getDataX(e.x),n=this.getDataX(e.x+e.width),a=this.getDataY(e.y+e.height),o=this.getDataY(e.y);this.onViewExtentChange.emit({dataExtent:{x:[t,n],y:[a,o]}})}this.state!==mlt.NONE&&(this.state=mlt.NONE,this.changeDetector.markForCheck())})),Vt(this.dotsContainer.nativeElement,"mouseenter",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{this.isCursorInside=!0,this.updateTooltip(t),this.changeDetector.markForCheck()})),Vt(this.dotsContainer.nativeElement,"mouseleave",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{this.dragStartCoord=null,this.isCursorInside=!1,this.updateTooltip(t),this.state=mlt.NONE,this.changeDetector.markForCheck()})),Vt(this.dotsContainer.nativeElement,"mousemove",{passive:!0}).pipe(de(this.ngUnsubscribe)).subscribe((t=>{switch(this.state){case mlt.SCROLL_ZOOMING:this.state=mlt.NONE,this.updateTooltip(t),this.changeDetector.markForCheck();break;case mlt.NONE:this.updateTooltip(t),this.changeDetector.markForCheck();break;case mlt.PANNING:{const n=-t.movementX,e=-t.movementY,{width:a,height:o}=this.domDim,r=this.getDataX(n),i=this.getDataX(a+n),c=this.getDataY(o+e),s=this.getDataY(e);this.onViewExtentChange.emit({dataExtent:{x:[r,i],y:[c,s]}});break}case mlt.DRAG_ZOOMING:{if(!this.dragStartCoord)break;const n=[this.dragStartCoord.x,t.offsetX],e=[this.dragStartCoord.y,t.offsetY];this.zoomBoxInUiCoordinate={x:Math.min(...n),width:Math.max(...n)-Math.min(...n),y:Math.min(...e),height:Math.max(...e)-Math.min(...e)}}this.changeDetector.markForCheck()}})),Vt(this.dotsContainer.nativeElement,"wheel",{passive:!1}).pipe(de(this.ngUnsubscribe),se((t=>{const n=!t.ctrlKey&&!t.shiftKey&&t.altKey;return this.showZoomInstruction=!n,this.changeDetector.markForCheck(),n?(t.preventDefault(),Z(t)):Zt(3e3).pipe(he((()=>{this.showZoomInstruction=!1,this.changeDetector.markForCheck()})),ft((()=>null)))})),Gt((t=>Boolean(t)))).subscribe((t=>{this.onViewExtentChange.emit({dataExtent:tlt(t,this.viewExtent,this.domDim,.01,this.xScale,this.yScale)}),this.state!==mlt.SCROLL_ZOOMING&&(this.state=mlt.SCROLL_ZOOMING,this.changeDetector.markForCheck())}))}ngOnChanges(){this.updateCursoredDataAndTooltipVisibility()}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}shouldPan(t){const n=t.shiftKey||t.altKey;if(t instanceof KeyboardEvent)return n;const e=(t.buttons&Fst.LEFT)===Fst.LEFT,a=(t.buttons&Fst.MIDDLE)===Fst.MIDDLE;return!(!e&&!a)&&(a&&!e||n)}trackBySeriesName(t,n){return n.id}getDomX(t){return this.xScale.forward(this.viewExtent.x,Xst(this.domDim,"x"),t)}getDataX(t){return this.xScale.reverse(this.viewExtent.x,Xst(this.domDim,"x"),t)}getDomY(t){return this.yScale.forward(this.viewExtent.y,Xst(this.domDim,"y"),t)}getDataY(t){return this.yScale.reverse(this.viewExtent.y,Xst(this.domDim,"y"),t)}shouldRenderTooltipPoint(t){return null!==t&&!isNaN(t.x)&&!isNaN(t.y)}updateTooltip(t){this.cursorLocationInDataCoord={x:this.getDataX(t.offsetX),y:this.getDataY(t.offsetY)},this.updateCursoredDataAndTooltipVisibility()}onTooltipDisplayDetached(){this.tooltipDisplayAttached=!1}updateCursoredDataAndTooltipVisibility(){const t=this.cursorLocationInDataCoord;if(null===t)return this.cursoredData=[],void(this.tooltipDisplayAttached=!1);this.cursoredData=this.isCursorInside?this.seriesData.map((t=>({seriesDatum:t,metadata:this.seriesMetadataMap[t.id]}))).filter((({metadata:t})=>t&&t.visible&&!Boolean(t.aux))).map((({seriesDatum:n,metadata:e})=>{const a=(function o(t,n){const e=Math.min(o0(t.map((({x:t})=>t)),n),t.length-1),a=Math.max(0,e-1);return Math.abs(t[a].x-n)-Math.abs(t[e].x-n)<=0?a:e})(n.points,t.x);return{id:n.id,closestPointIndex:a,point:n.points[a],metadata:e}})).filter((t=>t)):[],this.tooltipDisplayAttached=Boolean(this.cursoredData.length)}}function glt(t,n,e,a){return{major:[],minor:t.ticks(a,e).map((t=>({value:t,tickFormattedString:n.formatTick(t)})))}}function plt(t,n){if(1&t&&(ui(),Kg(0,"g",17),Kg(1,"text"),Jp(2),$g(),Kg(3,"title"),Jp(4),$g(),$g()),2&t){const t=n.$implicit,e=gp();ws(1),Ng("x",e.textXPosition(t.value))("y",e.textYPosition(t.value)),ws(1),Kp(" ",t.tickFormattedString," "),ws(2),Qp(e.getFormatter().formatReadable(t.value))}}function blt(t,n){if(1&t&&(Kg(0,"span",20),Kg(1,"span"),Jp(2),$g(),$g()),2&t){const t=n.$implicit,e=n.index,a=n.last,o=gp(2);Tp("left",o.getMajorXPosition(t)+"px")("width",o.getMajorWidthString(t,a,o.majorTicks[e+1]))("bottom",o.getMajorYPosition(t)+"px")("height",o.getMajorHeightString(t,a,o.majorTicks[e+1])),Dp("major-label",!0)("last",a),Jg("title",o.getFormatter().formatReadable(t.start)),ws(2),Qp(t.tickFormattedString)}}function ult(t,n){if(1&t&&(Kg(0,"div",18),Yg(1,blt,3,14,"span",19),$g()),2&t){const t=gp();ws(1),Jg("ngForOf",t.majorTicks)("ngForTrackBy",t.trackByMajorTick)}}dlt.ɵfac=function t(n){return new(n||dlt)(Zg(Vm),Zg(qA))},dlt.ɵcmp=_o({type:dlt,selectors:[["line-chart-interactive-view"]],viewQuery:function t(n,e){var a;1&n&&(jf(nlt,!0,xu),Uf(Oz,!0)),2&n&&(Vf(a=Zf())&&(e.dotsContainer=a.first),Vf(a=Zf())&&(e.overlay=a.first))},hostVars:2,hostBindings:function t(n,e){2&n&&Dp("show-zoom-instruction",e.showZoomInstruction)},inputs:{seriesData:"seriesData",seriesMetadataMap:"seriesMetadataMap",viewExtent:"viewExtent",xScale:"xScale",yScale:"yScale",domDim:"domDim",tooltipOriginEl:"tooltipOriginEl",tooltipTemplate:"tooltipTemplate"},outputs:{onViewExtentChange:"onViewExtentChange",onViewExtentReset:"onViewExtentReset"},features:[Mu([{provide:qA,useFactory:function flt(t){return t.scrollStrategies.reposition()},deps:[hz]}]),pr],decls:12,vars:15,consts:[[1,"dots"],["dots",""],[4,"ngIf"],["class","zoom-box",4,"ngIf"],[1,"zoom-instruction"],[1,"instruction-content"],["cdkOverlayOrigin","",1,"tooltip-origin"],["tooltipOrigin","cdkOverlayOrigin"],["cdkConnectedOverlay","",3,"cdkConnectedOverlayOrigin","cdkConnectedOverlayOpen","cdkConnectedOverlayPositions","cdkConnectedOverlayScrollStrategy","cdkConnectedOverlayLockPosition","cdkConnectedOverlayFlexibleDimensions","cdkConnectedOverlayGrowAfterOpen","detach"],["defaultTooltip",""],[4,"ngFor","ngForOf","ngForTrackBy"],["r","4",4,"ngIf"],["r","4"],[1,"zoom-box"],[1,"tooltip-container"],[3,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"circle-header"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]],template:function t(n,e){1&n&&(ui(),Kg(0,"svg",0,1),Yg(2,olt,2,2,"ng-container",2),Yg(3,rlt,1,4,"rect",3),$g(),fi(),Kg(4,"div",4),Kg(5,"span",5),Jp(6,"Alt + Scroll to Zoom"),$g(),$g(),tp(7,"div",6,7),Yg(9,clt,2,5,"ng-template",8),cp("detach",(function t(){return e.onTooltipDisplayDetached()})),Yg(10,llt,12,2,"ng-template",null,9,Kf)),2&n&&(Dp("pannable",e.specialKeyPressed)("draggable",e.state===e.InteractionState.NONE||e.state===e.InteractionState.DRAG_ZOOMING)("panning",e.state===e.InteractionState.PANNING),ws(2),Jg("ngIf",e.state===e.InteractionState.NONE),ws(1),Jg("ngIf",e.state===e.InteractionState.DRAG_ZOOMING),ws(6),Jg("cdkConnectedOverlayOrigin",e.tooltipOriginEl)("cdkConnectedOverlayOpen",e.tooltipDisplayAttached&&e.state===e.InteractionState.NONE)("cdkConnectedOverlayPositions",e.tooltipPositions)("cdkConnectedOverlayScrollStrategy",e.scrollStrategy)("cdkConnectedOverlayLockPosition",!1)("cdkConnectedOverlayFlexibleDimensions",!0)("cdkConnectedOverlayGrowAfterOpen",!0))},directives:[WM,Mz,Oz,jM,tO],styles:["[_nghost-%COMP%]{display:flex;position:relative;user-select:none}.dots[_ngcontent-%COMP%]{height:100%;width:100%}.dots.draggable[_ngcontent-%COMP%]{cursor:crosshair}.dots.pannable[_ngcontent-%COMP%]{cursor:grab}.dots.panning[_ngcontent-%COMP%]{cursor:grabbing}.tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.6);display:inline-block;height:10px;width:10px}.tooltip-origin[_ngcontent-%COMP%]{bottom:0;left:0;position:absolute;right:0}.tooltip-container[_ngcontent-%COMP%]{background:rgba(0,0,0,.85);border-radius:4px;color:#fff;contain:paint style layout;font-size:.9em;overflow:auto;padding:5px;pointer-events:none;width:100%}th[_ngcontent-%COMP%], td[_ngcontent-%COMP%]{padding:2px 5px;text-align:left}th[_ngcontent-%COMP%]{font-weight:500;padding-bottom:5px}.zoom-box[_ngcontent-%COMP%]{fill-opacity:.03;fill:#000;stroke:#ccc}.zoom-instruction[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:center;left:0;opacity:0;pointer-events:none;position:absolute;right:0;top:10px;transition:opacity .5s}.instruction-content[_ngcontent-%COMP%]{background:rgba(0,0,0,.6);border-radius:5px;color:#fff;padding:5px 10px;user-select:none}.show-zoom-instruction[_nghost-%COMP%]   .zoom-instruction[_ngcontent-%COMP%]{opacity:1}"],changeDetection:0});class hlt{constructor(){this.onViewExtentChange=new Ef,this.editMenuOpened=!1,this.majorTicks=[],this.minorTicks=[]}ngOnChanges(){let t=null;const n=Jst("x"===this.axis?this.domDim.width:this.domDim.height,this.gridCount);t=this.scale instanceof o9?(function e(t,n,a,o){const[r,i]=o,c=Math.abs(i-r);if(c>.001)return glt(t,n,a,o);const s=t.ticks([r,i],a),l=(function m(t){const n=t.toExponential().split("e-",2);return 2===n.length?Number(n[1])-1:0})(c),d=t.ticks([r,i],2),g=[],p=new Map;for(const t of d){const[e,a=""]=String(t).split(".",2),o=Number(e+"."+a.slice(0,l));p.set(o,{start:o,tickFormattedString:n.formatShort(o)})}const b=10*Math.pow(10,-l);for(const t of s)for(const n of p.keys()){const e=Math.abs(t-n);if(e>=0&&e<b){const e=String(t).slice(String(n).length);g.push({value:t,tickFormattedString:`…${e||"0"}`});break}}return{major:Array.from(p.values()),minor:g}})(this.scale,this.getFormatter(),n,this.axisExtent):this.scale instanceof i9?(function a(t,n,e,o){const[r,i]=o;let c=t.ticks(o,2);if(i-r>=864e5||c.length>2)return glt(t,n,e,o);const s=t.ticks(o,e);return{major:c.map((t=>({start:t,tickFormattedString:n.formatShort(t)}))),minor:s.map((t=>({value:t,tickFormattedString:n.formatTick(t)})))}})(this.scale,this.getFormatter(),n,this.axisExtent):glt(this.scale,this.getFormatter(),n,this.axisExtent),this.majorTicks=t.major,this.minorTicks=t.minor}getFormatter(){var t;return null!==(t=this.customFormatter)&&void 0!==t?t:this.scale.defaultFormatter}trackByMinorTick(t){return t.value}trackByMajorTick(t){return t.start}getDomPos(t){return this.scale.forward(this.axisExtent,Xst(this.domDim,this.axis),t)}textXPosition(t){return"x"===this.axis?String(this.getDomPos(t)):"100%"}textYPosition(t){return"x"===this.axis?"":String(this.getDomPos(t))}getMajorXPosition(t){return"y"===this.axis?0:Math.min(this.domDim.width,Math.max(0,this.getDomPos(t.start)))}getMajorWidthString(t,n,e){return"y"===this.axis?"":(n||!e?this.domDim.width:this.getMajorXPosition(e))-this.getMajorXPosition(t)+"px"}getMajorYPosition(t){return"x"===this.axis?0:this.domDim.height-Math.min(this.domDim.height,Math.max(0,this.getDomPos(t.start)))}getMajorHeightString(t,n,e){return"x"===this.axis?"":(n||!e?this.domDim.height:this.getMajorYPosition(e))-this.getMajorYPosition(t)+"px"}keydownPreventClose(t){"Escape"!==t.key&&t.stopPropagation()}extentChanged(t,n){let e=Number(t),a=Number(n);if(a<e){const t=e;e=a,a=t}Number.isFinite(e)&&Number.isFinite(a)&&this.onViewExtentChange.emit([e,a])}onAxisUpdateMenuOpen(t,n,e){t.value=String(e[0]),n.value=String(e[1]),t.focus()}setEditMenuOpened(t){this.editMenuOpened=t}}hlt.ɵfac=function t(n){return new(n||hlt)},hlt.ɵcmp=_o({type:hlt,selectors:[["line-chart-axis"]],inputs:{axisExtent:"axisExtent",axis:"axis",scale:"scale",gridCount:"gridCount",domDim:"domDim",customFormatter:"customFormatter"},outputs:{onViewExtentChange:"onViewExtentChange"},features:[pr],decls:26,vars:13,consts:[[1,"line"],[1,"minor"],[1,"ticks"],["class","minor-tick-label",4,"ngFor","ngForOf","ngForTrackBy"],["mat-icon-button","","title","Click to manually set min & max values",3,"matMenuTriggerFor","menuOpened","menuClosed"],["matMenuTrigger","matMenuTrigger"],["svgIcon","edit_24px"],["class","major ticks",4,"ngIf"],["xPosition","before",3,"yPosition"],["manualControl","matMenu"],[1,"extent-edit-input",3,"click","keydown"],["type","number",3,"value"],["minInput",""],["maxInput",""],[1,"extent-edit-control",3,"keydown"],["mat-raised-button","","color","primary",1,"extent-edit-change",3,"click"],["mat-stroked-button","",1,"extent-edit-cancel",3,"click"],[1,"minor-tick-label"],[1,"major","ticks"],[3,"major-label","last","left","width","bottom","height","title",4,"ngFor","ngForOf","ngForTrackBy"],[3,"title"]],template:function t(n,e){if(1&n){const t=op();Kg(0,"div"),tp(1,"div",0),Kg(2,"div",1),ui(),Kg(3,"svg",2),Yg(4,plt,5,4,"g",3),$g(),fi(),Kg(5,"button",4,5),cp("menuOpened",(function n(){jr(t);const a=qg(15),o=qg(20);return e.onAxisUpdateMenuOpen(a,o,e.axisExtent),e.setEditMenuOpened(!0)}))("menuClosed",(function t(){return e.setEditMenuOpened(!1)})),tp(7,"mat-icon",6),$g(),$g(),Yg(8,ult,2,2,"div",7),$g(),Kg(9,"mat-menu",8,9),Kg(11,"div",10),cp("click",(function t(n){return n.stopPropagation()}))("keydown",(function t(n){return e.keydownPreventClose(n)})),Kg(12,"label"),Jp(13,"min"),$g(),tp(14,"input",11,12),$g(),Kg(16,"div",10),cp("click",(function t(n){return n.stopPropagation()}))("keydown",(function t(n){return e.keydownPreventClose(n)})),Kg(17,"label"),Jp(18,"max"),$g(),tp(19,"input",11,13),$g(),Kg(21,"div",14),cp("keydown",(function t(n){return e.keydownPreventClose(n)})),Kg(22,"button",15),cp("click",(function n(){jr(t);const a=qg(15),o=qg(20),r=qg(6);return e.extentChanged(a.value,o.value),r.closeMenu()})),Jp(23," Change "),$g(),Kg(24,"button",16),cp("click",(function n(){return jr(t),qg(6).closeMenu()})),Jp(25," Cancel "),$g(),$g(),$g()}if(2&n){const t=qg(10);Fp(e.axis+"-axis axis"),ws(4),Jg("ngForOf",e.minorTicks)("ngForTrackBy",e.trackByMinorTick),ws(1),Dp("extent-edit-button",!0)("extent-edit-menu-opened",e.editMenuOpened),Jg("matMenuTriggerFor",t),ws(3),Jg("ngIf",e.majorTicks.length),ws(1),Jg("yPosition","y"===e.axis?"above":"below"),ws(5),Jg("value",e.axisExtent[0]),ws(5),Jg("value",e.axisExtent[1])}},directives:[jM,eA,Iq,BB,WM,Aq],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{contain:strict;display:flex;overflow:hidden}.major-label[_ngcontent-%COMP%], text[_ngcontent-%COMP%]{font-size:11px;user-select:none}.axis[_ngcontent-%COMP%]{display:flex;height:100%;width:100%}.major[_ngcontent-%COMP%], .minor[_ngcontent-%COMP%]{flex:1 0;overflow:hidden}.line[_ngcontent-%COMP%]{background-color:#aaa;flex:0 0 1px;justify-content:stretch}.ticks[_ngcontent-%COMP%]{height:100%;position:relative;width:100%}.x-axis[_ngcontent-%COMP%]{flex-direction:column}.x-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-bottom:3px}.x-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:text-before-edge;text-anchor:middle}.x-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to right, #0000 0%, #000 10%, #000 90%, #0000 100%);mask-image:linear-gradient(to right, #0000 0%, #000 10%, #000 90%, #0000 100%)}.y-axis[_ngcontent-%COMP%]{flex-direction:row-reverse}.y-axis[_ngcontent-%COMP%]   .line[_ngcontent-%COMP%]{margin-left:5px}.y-axis[_ngcontent-%COMP%]   text[_ngcontent-%COMP%]{dominant-baseline:central;text-anchor:end}.y-axis[_ngcontent-%COMP%]   .ticks[_ngcontent-%COMP%]{-webkit-mask-image:linear-gradient(to bottom, #0000 0%, #000 10%, #000 90%, #0000 100%);mask-image:linear-gradient(to bottom, #0000 0%, #000 10%, #000 90%, #0000 100%)}.extent-edit-button[_ngcontent-%COMP%]{background-color:#eee;display:none;font-size:0;height:24px;line-height:24px;position:absolute;right:5px;top:5px;width:24px}.extent-edit-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:16px;width:16px;line-height:16px}.extent-edit-input[_ngcontent-%COMP%]{align-items:center;column-gap:5px;display:grid;font-size:12px;grid-template-columns:30px minmax(auto, 100px);height:30px;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]{align-items:center;display:flex;flex-direction:row-reverse;justify-content:flex-end;margin:10px 20px}.extent-edit-control[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]{font-size:12px;height:30px;line-height:1.4;margin-left:5px;padding:0 10px}.axis[_ngcontent-%COMP%]:hover   .extent-edit-button[_ngcontent-%COMP%], .extent-edit-menu-opened[_ngcontent-%COMP%]{display:initial}.major[_ngcontent-%COMP%]{position:relative;overflow:hidden;contain:strict}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;overflow:hidden;position:absolute;white-space:nowrap}.major[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]   span[_ngcontent-%COMP%]{max-width:100%}.x-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-left:1px solid #9e9e9e;padding:0 5px}.x-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-right:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%]{border-bottom:1px solid #9e9e9e;height:100%;padding:5px 0;width:100%}.y-axis[_ngcontent-%COMP%]   .major-label.last[_ngcontent-%COMP%]{border-top:1px solid #9e9e9e}.y-axis[_ngcontent-%COMP%]   .major-label[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{transform:rotate(-90deg);transform-origin:center}'],changeDetection:0});const _lt=["seriesView"],Clt=["xAxis"],Mlt=["yAxis"],Olt=["chartEl"];function Plt(t,n){1&t&&(ui(),tp(0,"svg",null,13))}function xlt(t,n){1&t&&tp(0,"canvas",null,13)}const ylt={x:[0,1],y:[0,1]};class klt{constructor(t){this.changeDetector=t,this.RendererType=V$,this.preferredRendererType=V$.WEBGL,this.xScaleType=j$.LINEAR,this.yScaleType=j$.LINEAR,this.ignoreYOutliers=!1,this.Y_GRID_COUNT=6,this.X_GRID_COUNT=10,this.xScale=a9(this.xScaleType),this.yScale=a9(this.xScaleType),this.viewBox=ylt,this.domDimensions={main:{width:0,height:0},xAxis:{width:0,height:0},yAxis:{width:0,height:0}},this.isDataUpdated=!1,this.isMetadataUpdated=!1,this.isFixedViewBoxUpdated=!1,this.isViewBoxOverridden=!1,this.isViewBoxChanged=!0,this.scaleUpdated=!0}ngOnChanges(t){t.xScaleType&&(this.xScale=a9(this.xScaleType),this.scaleUpdated=!0),t.yScaleType&&(this.yScale=a9(this.yScaleType),this.scaleUpdated=!0),t.seriesData&&(this.isDataUpdated=!0),t.fixedViewBox&&(this.isFixedViewBoxUpdated=!0),t.seriesMetadataMap&&(this.isMetadataUpdated=!0),this.scaleUpdated&&(this.isViewBoxOverridden=!1),this.isViewBoxChanged=this.isViewBoxChanged||this.scaleUpdated||!this.isViewBoxOverridden&&this.shouldUpdateDefaultViewBox(t),this.updateLineChart()}ngAfterViewInit(){this.initializeChart(),this.updateLineChart(),this.changeDetector.detectChanges()}onViewResize(){this.lineChart&&(this.readAndUpdateDomDimensions(),this.lineChart.resize(this.domDimensions.main),this.changeDetector.detectChanges())}shouldUpdateDefaultViewBox(t){if(t.xScaleType||t.yScaleType||t.ignoreYOutliers)return!0;if(t.seriesData)return!0;const n=t.seriesMetadataMap;if(n){const t=n.previousValue;if(Object.keys(this.seriesMetadataMap).length!==Object.keys(null!=t?t:{}).length)return!0;for(const[n,e]of Object.entries(this.seriesMetadataMap)){const a=t&&t[n];if(!a||e.visible!==a.visible)return!0}}return!1}initializeChart(){if(this.lineChart)throw new Error("LineChart should not be initialized multiple times.");const t=this.getRendererType(),n={onDrawEnd:()=>{}};let e=null;switch(this.readAndUpdateDomDimensions(),t){case V$.SVG:e={type:V$.SVG,container:this.chartEl.nativeElement,callbacks:n,domDimension:this.domDimensions.main};break;case V$.WEBGL:e={type:V$.WEBGL,container:this.chartEl.nativeElement,devicePixelRatio:window.devicePixelRatio,callbacks:n,domDimension:this.domDimensions.main};break;default:throw new Error(`<line-chart> does not yet support rendererType: ${t}`)}const a=t!==V$.SVG&&s9();this.lineChart=new(a?Zst:Yst)(e)}ngOnDestroy(){this.lineChart&&this.lineChart.dispose()}getRendererType(){return(function t(n){switch(n){case V$.SVG:return V$.SVG;case V$.WEBGL:return(function e(){return c9})()?V$.WEBGL:V$.SVG;default:throw new Error(`Unknown rendererType: ${n}`)}})(this.preferredRendererType)}readAndUpdateDomDimensions(){this.domDimensions={main:{width:this.seriesView.nativeElement.clientWidth,height:this.seriesView.nativeElement.clientHeight},xAxis:{width:this.xAxis.nativeElement.clientWidth,height:this.xAxis.nativeElement.clientHeight},yAxis:{width:this.yAxis.nativeElement.clientWidth,height:this.yAxis.nativeElement.clientHeight}}}updateLineChart(){var t,n;if(this.lineChart&&!this.disableUpdate){if(this.scaleUpdated&&(this.scaleUpdated=!1,this.lineChart.setXScaleType(this.xScaleType),this.lineChart.setYScaleType(this.yScaleType)),this.isMetadataUpdated&&(this.isMetadataUpdated=!1,this.lineChart.setMetadata(this.seriesMetadataMap)),this.isDataUpdated&&(this.isDataUpdated=!1,this.lineChart.setData(this.seriesData)),this.isFixedViewBoxUpdated&&this.fixedViewBox)this.viewBox=this.fixedViewBox;else if(!this.isViewBoxOverridden&&this.isViewBoxChanged){const e=(function e(t,n,a,o,r){let i=null,c=null,s=[];for(const{id:e,points:a}of t){const t=n[e];if(t&&!t.aux&&t.visible)for(let t=0;t<a.length;t++){const{x:n,y:e}=a[t];o(n)&&(i=null===i||n<i?n:i,c=null===c||n>c?n:c),r(e)&&s.push(e)}}s.sort(e0);let l=s[0],m=s[s.length-1];return a&&s.length>2&&(l=s[Math.ceil(.05*(s.length-1))],m=s[Math.floor(.95*(s.length-1))]),{x:null!==i&&null!==c?[i,c]:void 0,y:void 0!==l&&void 0!==m?[l,m]:void 0}})(this.seriesData,this.seriesMetadataMap,this.ignoreYOutliers,this.xScale.isSafeNumber,this.yScale.isSafeNumber);this.viewBox={x:this.xScale.niceDomain(null!==(t=e.x)&&void 0!==t?t:ylt.x),y:this.yScale.niceDomain(null!==(n=e.y)&&void 0!==n?n:ylt.y)}}(this.isFixedViewBoxUpdated||this.isViewBoxChanged)&&(this.isFixedViewBoxUpdated=!1,this.isViewBoxChanged=!1,this.lineChart.setViewBox(this.viewBox))}}onViewBoxChanged({dataExtent:t}){this.isViewBoxOverridden=!0,this.isViewBoxChanged=!0,this.viewBox=t,this.updateLineChart()}viewBoxReset(){this.isViewBoxOverridden=!1,this.isViewBoxChanged=!0,this.updateLineChart()}getIsViewBoxOverridden(){return this.isViewBoxOverridden}onViewBoxChangedFromAxis(t,n){const e=Object.assign(Object.assign({},this.viewBox),{[n]:t});this.onViewBoxChanged({dataExtent:e})}}function vlt(t,n){1&t&&tp(0,"mat-spinner",24)}function wlt(t,n){if(1&t&&tp(0,"line-chart",27),2&t){const t=gp(2),n=qg(32);Jg("disableUpdate",!t.isCardVisible)("preferredRendererType",t.RendererType.WEBGL)("seriesData",t.dataSeries)("seriesMetadataMap",t.chartMetadataMap)("xScaleType",t.newXScaleType)("yScaleType",t.newYScaleType)("customXFormatter",t.xAxisType===t.XAxisType.RELATIVE?t.relativeXFormatter:void 0)("ignoreYOutliers",t.ignoreOutliers)("tooltipTemplate",n)}}function Slt(t,n){if(1&t){const t=op();Kg(0,"tb-line-chart",28),cp("onResize",(function n(){return jr(t),gp(2).redraw()})),$g()}if(2&t){const t=gp(2);Jg("colorScale",t.runColorScale)("seriesDataList",t.seriesDataList)("tooltipColumns",t.tooltipColumns)("tooltipSortingMethod",t.tooltipSort)("ignoreYOutliers",t.ignoreOutliers)("xAxisType",t.chartXAxisType())("smoothingEnabled",t.scalarSmoothing>0)("smoothingWeight",t.scalarSmoothing)("yAxisType",t.yAxisType)("resizeEventDebouncePeriodInMs",t.RESIZE_REDRAW_DEBOUNCE_TIME_IN_MS)}}function Elt(t,n){if(1&t&&(np(0),Yg(1,wlt,1,9,"line-chart",25),Yg(2,Slt,1,10,"ng-template",null,26,Kf),ep()),2&t){const t=qg(3),n=gp();ws(1),Jg("ngIf",n.gpuLineChartEnabled)("ngIfElse",t)}}function Alt(t,n){1&t&&(Kg(0,"th"),Jp(1,"Smoothed"),$g())}function zlt(t,n){1&t&&(Kg(0,"th"),Jp(1,"Relative"),$g())}function Rlt(t,n){if(1&t&&(Kg(0,"td"),Jp(1),$g()),2&t){const t=gp().$implicit;ws(1),Qp(t.point.y)}}function Tlt(t,n){if(1&t&&(Kg(0,"td"),Jp(1),$g()),2&t){const t=gp().$implicit,n=gp(2);ws(1),Kp(" ",n.relativeXFormatter.formatReadable(t.point.x)," ")}}function Dlt(t,n){if(1&t&&(np(0),Kg(1,"tr",32),Kg(2,"td",33),tp(3,"span"),$g(),Kg(4,"td",34),Jp(5),$g(),Yg(6,Rlt,2,1,"td",22),Kg(7,"td"),Jp(8),$g(),Kg(9,"td"),Jp(10),yf(11,"number"),$g(),Kg(12,"td"),Jp(13),yf(14,"date"),$g(),Yg(15,Tlt,2,1,"td",22),$g(),ep()),2&t){const t=n.$implicit,e=gp(2);ws(1),Dp("closest",t.metadata.closest),ws(2),Tp("background-color",t.metadata.color),ws(2),Qp(t.metadata.displayName),ws(1),Jg("ngIf",e.smoothingEnabled),ws(2),Qp(t.point.value),ws(2),Qp(kf(11,10,t.point.step)),ws(3),Qp(vf(14,12,t.point.wallTime,"short")),ws(2),Jg("ngIf",e.xAxisType===e.XAxisType.RELATIVE)}}function Ilt(t,n){if(1&t&&(Kg(0,"table",29),Kg(1,"thead"),Kg(2,"tr"),tp(3,"th",30),Kg(4,"th"),Jp(5,"Run"),$g(),Yg(6,Alt,2,0,"th",22),Kg(7,"th"),Jp(8,"Value"),$g(),Kg(9,"th"),Jp(10,"Step"),$g(),Kg(11,"th"),Jp(12,"Time"),$g(),Yg(13,zlt,2,0,"th",22),$g(),$g(),Kg(14,"tbody"),Yg(15,Dlt,16,15,"ng-container",31),$g(),$g()),2&t){const t=n.data,e=n.cursorLocationInDataCoord,a=gp();ws(6),Jg("ngIf",a.smoothingEnabled),ws(7),Jg("ngIf",a.xAxisType===a.XAxisType.RELATIVE),ws(2),Jg("ngForOf",a.getCursorAwareTooltipData(t,e))("ngForTrackBy",a.trackByTooltipDatum)}}klt.ɵfac=function t(n){return new(n||klt)(Zg(Vm))},klt.ɵcmp=_o({type:klt,selectors:[["line-chart"]],viewQuery:function t(n,e){var a;1&n&&(jf(_lt,!0,xu),jf(Clt,!0,xu),jf(Mlt,!0,xu),Uf(Olt,!0,xu)),2&n&&(Vf(a=Zf())&&(e.seriesView=a.first),Vf(a=Zf())&&(e.xAxis=a.first),Vf(a=Zf())&&(e.yAxis=a.first),Vf(a=Zf())&&(e.chartEl=a.first))},inputs:{preferredRendererType:"preferredRendererType",seriesData:"seriesData",fixedViewBox:"fixedViewBox",seriesMetadataMap:"seriesMetadataMap",xScaleType:"xScaleType",yScaleType:"yScaleType",customXFormatter:"customXFormatter",customYFormatter:"customYFormatter",tooltipTemplate:"tooltipTemplate",disableUpdate:"disableUpdate",ignoreYOutliers:"ignoreYOutliers"},features:[pr],decls:14,vars:27,consts:[["detectResize","","cdkOverlayOrigin","",1,"container",3,"resizeEventDebouncePeriodInMs","onResize"],["overlayTarget","cdkOverlayOrigin"],[1,"series-view"],["seriesView",""],[3,"viewExtent","xScale","yScale","xGridCount","yGridCount","domDim"],[4,"ngIf"],[3,"seriesData","seriesMetadataMap","viewExtent","xScale","yScale","tooltipOriginEl","domDim","tooltipTemplate","onViewExtentChange","onViewExtentReset"],["axis","y",1,"y-axis",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["yAxis",""],["axis","x",1,"x-axis",3,"axisExtent","customFormatter","domDim","gridCount","scale","onViewExtentChange"],["xAxis",""],[1,"dot"],[1,"rect"],["chartEl",""]],template:function t(n,e){if(1&n&&(Kg(0,"div",0,1),cp("onResize",(function t(){return e.onViewResize()})),Kg(2,"div",2,3),tp(4,"line-chart-grid-view",4),Yg(5,Plt,2,0,"svg",5),Yg(6,xlt,2,0,"canvas",5),Kg(7,"line-chart-interactive-view",6),cp("onViewExtentChange",(function t(n){return e.onViewBoxChanged(n)}))("onViewExtentReset",(function t(){return e.viewBoxReset()})),$g(),$g(),Kg(8,"line-chart-axis",7,8),cp("onViewExtentChange",(function t(n){return e.onViewBoxChangedFromAxis(n,"y")})),$g(),Kg(10,"line-chart-axis",9,10),cp("onViewExtentChange",(function t(n){return e.onViewBoxChangedFromAxis(n,"x")})),$g(),Kg(12,"div",11),tp(13,"span",12),$g(),$g()),2&n){const t=qg(1);Jg("resizeEventDebouncePeriodInMs",0),ws(4),Jg("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("xGridCount",e.X_GRID_COUNT)("yGridCount",e.Y_GRID_COUNT)("domDim",e.domDimensions.main),ws(1),Jg("ngIf",e.getRendererType()===e.RendererType.SVG),ws(1),Jg("ngIf",e.getRendererType()===e.RendererType.WEBGL),ws(1),Jg("seriesData",e.seriesData)("seriesMetadataMap",e.seriesMetadataMap)("viewExtent",e.viewBox)("xScale",e.xScale)("yScale",e.yScale)("tooltipOriginEl",t)("domDim",e.domDimensions.main)("tooltipTemplate",e.tooltipTemplate),ws(1),Jg("axisExtent",e.viewBox.y)("customFormatter",e.customYFormatter)("domDim",e.domDimensions.yAxis)("gridCount",e.Y_GRID_COUNT)("scale",e.yScale),ws(2),Jg("axisExtent",e.viewBox.x)("customFormatter",e.customXFormatter)("domDim",e.domDimensions.xAxis)("gridCount",e.X_GRID_COUNT)("scale",e.xScale)}},directives:[_Y,Mz,$st,WM,dlt,hlt],styles:['[_nghost-%COMP%]{contain:strict;display:inline-block}.container[_ngcontent-%COMP%]{background:#fff;display:grid;height:100%;overflow:hidden;width:100%;grid-template-areas:"yaxis series" "dot xaxis";grid-template-columns:50px 1fr;grid-auto-rows:1fr 30px}.series-view[_ngcontent-%COMP%]{grid-area:series;position:relative;overflow:hidden}.series-view[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   svg[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-grid-view[_ngcontent-%COMP%], .series-view[_ngcontent-%COMP%]   line-chart-interactive-view[_ngcontent-%COMP%]{height:100%;left:0;position:absolute;top:0;width:100%}.x-axis[_ngcontent-%COMP%]{grid-area:xaxis}.y-axis[_ngcontent-%COMP%]{grid-area:yaxis}.dot[_ngcontent-%COMP%]{align-items:flex-start;display:flex;grid-area:dot;justify-content:flex-end}.dot[_ngcontent-%COMP%]   .rect[_ngcontent-%COMP%]{height:1px;width:1px;background-color:#aaa}'],changeDetection:0});const Nlt=[{title:"Name",evaluate:t=>t.dataset.metadata().meta.displayName},{title:"Value",evaluate:t=>(function n(t){return isNaN(t)||!Number.isFinite(t)||Number.isInteger(t)&&Math.abs(t)<t0?t.toString():t.toPrecision(4)})(t.datum.y)},{title:"Step",evaluate:t=>t.datum.step.toString()},{title:"Time",evaluate:t=>new Date(1e3*t.datum.wallTime).toLocaleString()},{title:"Relative",evaluate:t=>{const n=t.dataset.data();return(function e(t){const n=[],e=t/36e5,a=Math.floor(e/24);a&&n.push(a.toString()+"d");const o=e-24*a,r=Math.floor(o);(r||a)&&n.push(r.toString()+"h");const i=60*(o-r),c=Math.floor(i);(c||r||a)&&n.push(c.toString()+"m");const s=Math.floor(60*(i-c));return n.push(s.toString()+"s"),n.join(" ")})(1e3*(t.datum.wallTime-(n.length>0?n[0].wallTime:0)))}}];class Flt{constructor(t,n){this.ref=t,this.dialog=n,this.RESIZE_REDRAW_DEBOUNCE_TIME_IN_MS=50,this.DataLoadState=fR,this.RendererType=V$,this.onFullSizeToggle=new Ef,this.onPinClicked=new Ef,this.yAxisType=UT.LINEAR,this.newYScaleType=j$.LINEAR,this.XAxisType=WT,this.tooltipColumns=Nlt,this.relativeXFormatter=$8}chartXAxisType(){switch(this.xAxisType){case WT.STEP:return jT.STEP;case WT.WALL_TIME:return jT.WALL_TIME;case WT.RELATIVE:return jT.RELATIVE;default:throw new Error("Invalid xAxisType for line chart.")}}toggleYAxisType(){this.yAxisType=this.yAxisType===UT.LINEAR?UT.LOG:UT.LINEAR,this.newYScaleType=this.yAxisType===UT.LINEAR?j$.LINEAR:j$.LOG10}resetDomain(){this.lineChart&&this.lineChart.resetDomain(),this.newLineChart&&this.newLineChart.viewBoxReset()}redraw(){this.lineChart&&this.ref.nativeElement.clientWidth&&this.lineChart.redraw()}trackByTooltipDatum(t,n){return n.id}getCursorAwareTooltipData(t,n){const e=t.map((t=>Object.assign(Object.assign({},t),{metadata:Object.assign(Object.assign({},t.metadata),{closest:!1,distSqToCursor:Math.hypot(t.point.x-n.x,t.point.y-n.y)})})));let a=1/0,o=0;for(let t=0;t<e.length;t++)a>e[t].metadata.distSqToCursor&&(a=e[t].metadata.distSqToCursor,o=t);switch(e.length&&(e[o].metadata.closest=!0),this.tooltipSort){case VT.DEFAULT:return e;case VT.ASCENDING:return e.sort(((t,n)=>t.point.y-n.point.y));case VT.DESCENDING:return e.sort(((t,n)=>n.point.y-t.point.y));case VT.NEAREST:return e.sort(((t,n)=>t.metadata.distSqToCursor-n.metadata.distSqToCursor))}}openDataDownloadDialog(){this.dialog.open(this.DataDownloadComponent,{data:{cardId:this.cardId}})}}Flt.ɵfac=function t(n){return new(n||Flt)(Zg(xu),Zg(bB))},Flt.ɵcmp=_o({type:Flt,selectors:[["scalar-card-component"]],viewQuery:function t(n,e){var a;1&n&&(Uf(n0,!0),Uf(klt,!0)),2&n&&(Vf(a=Zf())&&(e.lineChart=a.first),Vf(a=Zf())&&(e.newLineChart=a.first))},inputs:{cardId:"cardId",loadState:"loadState",title:"title",tag:"tag",tooltipSort:"tooltipSort",xAxisType:"xAxisType",showFullSize:"showFullSize",isPinned:"isPinned",DataDownloadComponent:"DataDownloadComponent",newXScaleType:"newXScaleType",runColorScale:"runColorScale",ignoreOutliers:"ignoreOutliers",scalarSmoothing:"scalarSmoothing",seriesDataList:"seriesDataList",isCardVisible:"isCardVisible",smoothingEnabled:"smoothingEnabled",gpuLineChartEnabled:"gpuLineChartEnabled",dataSeries:"dataSeries",chartMetadataMap:"chartMetadataMap",isEverVisible:"isEverVisible"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked"},decls:33,vars:10,consts:function(){return[[1,"heading"],[1,"tag",3,"title","value"],[1,"controls"],["mat-icon-button","",1,"pin-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Pin card"):$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`],[3,"svgIcon"],["mat-icon-button","","title","Toggle full size mode",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle full size mode"):$localize`:A button on line chart that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`],["mat-icon-button","","title","More line chart options",3,"matMenuTriggerFor",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("More line chart options"):$localize`:An overflow menu button that opens more line chart options␟b260fab946a3077ce20fd28e336979f586720e8d␟878053740210336435:More line chart options`],["svgIcon","more_vert_24px"],["menu","matMenu"],["mat-menu-item","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle Y-axis log scale on line chart"):$localize`:A button that toggles log scale on y-axis on a line chart␟fe91f96ab9b3baca5a48913f2b0fae84483d93e3␟3374645620638883926:Toggle Y-axis log scale on line chart`],["svgIcon","line_weight_24px"],["mat-menu-item","",3,"disabled","title","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Fit line chart domains to data"):$localize`:A button that resets line chart domain to the data␟e68a552941ab427a99e7437e08443f30ac71ccd6␟3830646521058268558:Fit line chart domains to data`],["svgIcon","settings_overscan_24px"],["mat-menu-item","","aria-label","Open dialog to download data",3,"click"],["svgIcon","get_app_24px"],[1,"chart-container"],["diameter","18",4,"ngIf"],[4,"ngIf"],["tooltip",""],["diameter","18"],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate",4,"ngIf","ngIfElse"],["legacyChart",""],[3,"disableUpdate","preferredRendererType","seriesData","seriesMetadataMap","xScaleType","yScaleType","customXFormatter","ignoreYOutliers","tooltipTemplate"],["detectResize","",3,"colorScale","seriesDataList","tooltipColumns","tooltipSortingMethod","ignoreYOutliers","xAxisType","smoothingEnabled","smoothingWeight","yAxisType","resizeEventDebouncePeriodInMs","onResize"],[1,"tooltip"],[1,"circle-header"],[4,"ngFor","ngForOf","ngForTrackBy"],[1,"tooltip-row"],[1,"tooltip-row-circle"],[1,"name"]]},template:function t(n,e){if(1&n&&(Kg(0,"div",0),tp(1,"tb-truncated-path",1),Kg(2,"span",2),Kg(3,"button",3),lu(4,4),cp("click",(function t(){return e.onPinClicked.emit(!e.isPinned)})),tp(5,"mat-icon",5),$g(),Kg(6,"button",6),lu(7,7),cp("click",(function t(){return e.onFullSizeToggle.emit()})),tp(8,"mat-icon",5),$g(),Kg(9,"button",8),lu(10,9),tp(11,"mat-icon",10),$g(),Kg(12,"mat-menu",null,11),Kg(14,"button",12),lu(15,13),cp("click",(function t(){return e.toggleYAxisType()})),tp(16,"mat-icon",14),Kg(17,"span"),Jp(18,"Toggle Y-axis log scale"),$g(),$g(),Kg(19,"button",15),lu(20,16),cp("click",(function t(){return e.resetDomain()})),tp(21,"mat-icon",17),Kg(22,"span"),Jp(23,"Fit domain to data"),$g(),$g(),Kg(24,"button",18),cp("click",(function t(){return e.openDataDownloadDialog()})),tp(25,"mat-icon",19),Kg(26,"span"),Jp(27,"Download data"),$g(),$g(),$g(),$g(),$g(),Kg(28,"div",20),Yg(29,vlt,1,0,"mat-spinner",21),Yg(30,Elt,4,2,"ng-container",22),Yg(31,Ilt,16,4,"ng-template",null,23,Kf),$g()),2&n){const t=qg(13);ws(1),_p("title",e.tag),_p("value",e.title),ws(2),Ng("title",e.isPinned?"Unpin card":"Pin card"),ws(2),Jg("svgIcon",e.isPinned?"keep_24px":"keep_outline_24px"),ws(3),Jg("svgIcon",e.showFullSize?"fullscreen_exit_24px":"fullscreen_24px"),ws(1),Jg("matMenuTriggerFor",t),ws(10),Jg("disabled",!e.seriesDataList||!e.seriesDataList.length||e.newLineChart&&!e.newLineChart.getIsViewBoxOverridden())("title",e.newLineChart&&!e.newLineChart.getIsViewBoxOverridden?"Line chart is already fitted to data. When data updates, the line chart will auto fit to its domain.":""),ws(10),Jg("ngIf",e.loadState===e.DataLoadState.LOADING),ws(1),Jg("ngIf",e.isEverVisible)}},directives:[S$,eA,BB,Iq,Aq,xq,WM,hZ,klt,n0,_Y,jM],pipes:[fO,lO],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:space-between;font-size:14px;margin-bottom:4px;position:relative}.tag[_ngcontent-%COMP%]{overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.controls[_ngcontent-%COMP%]{color:#616161;flex-shrink:0;margin-right:-12px;white-space:nowrap}.chart-container[_ngcontent-%COMP%]{position:relative;flex:1}.chart-container[_ngcontent-%COMP%]   mat-spinner[_ngcontent-%COMP%]{position:absolute;right:11px;top:11px}.chart-container[_ngcontent-%COMP%]   line-chart[_ngcontent-%COMP%], .chart-container[_ngcontent-%COMP%]   tb-line-chart[_ngcontent-%COMP%]{display:block;height:100%}.tooltip[_ngcontent-%COMP%]{border-spacing:4px;font-size:13px}.tooltip[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{text-align:left}.tooltip[_ngcontent-%COMP%]   .tooltip-row[_ngcontent-%COMP%]{white-space:nowrap}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%]{align-items:center;display:inline-flex;height:12px;width:12px}.tooltip[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-radius:50%;border:1px solid rgba(255,255,255,.4);display:inline-block;height:10px;width:10px}.tooltip[_ngcontent-%COMP%]   .closest[_ngcontent-%COMP%]   .tooltip-row-circle[_ngcontent-%COMP%] > span[_ngcontent-%COMP%]{border-color:#fff;box-shadow:inset 0 0 0 1px #fff}'],changeDetection:0});const Llt=function(){return[]},Hlt=function(){return{}};function Blt(t,n){return t.length===n.length&&t.every(((t,e)=>{const a=n[e],o=t.points,r=a.points;return t.seriesId===a.seriesId&&t.metadata.displayName===a.metadata.displayName&&t.visible===a.visible&&o.length===r.length&&o.every(((t,n)=>{const e=r[n];return t.x===e.x&&t.y===e.y}))}))}function Vlt(t,n){return t.length===n.length&&t.every(((t,e)=>{const a=n[e],o=t.points,r=a.points;return t.runId===a.runId&&o.length===r.length&&o.every(((t,n)=>{const e=r[n];return t.x===e.x&&t.y===e.y}))}))}class jlt{constructor(t){this.store=t,this.DataDownloadComponent=$$,this.fullWidthChanged=new Ef,this.fullHeightChanged=new Ef,this.pinStateChanged=new Ef,this.legacySeriesDataList$=Z([]),this.isCardVisible$=this.store.select(nD).pipe(ft((t=>t.has(this.cardId))),vn()),this.isEverVisible$=this.isCardVisible$.pipe(be((t=>!t),!0)),this.tooltipSort$=this.store.select(dD),this.ignoreOutliers$=this.store.select(gD),this.xAxisType$=this.store.select(pD),this.newXScaleType$=this.xAxisType$.pipe(ft((t=>{switch(t){case WT.STEP:case WT.RELATIVE:return j$.LINEAR;case WT.WALL_TIME:return j$.TIME;default:throw new Error(`Invalid xAxisType for line chart. ${t}`)}}))),this.scalarSmoothing$=this.store.select(uD),this.gpuLineChartEnabled$=this.store.select(uR),this.smoothingEnabled$=this.store.select(uD).pipe(ft((t=>t>0))),this.showFullSize=!1}isScalarCardMetadata(t){const{plugin:n}=t;return n===gT.SCALARS}onFullSizeToggle(){this.showFullSize=!this.showFullSize,this.fullWidthChanged.emit(this.showFullSize),this.fullHeightChanged.emit(this.showFullSize)}ngOnInit(){const t=this.store.select($T,this.cardId).pipe(Gt((t=>!!t&&this.isScalarCardMetadata(t))),ft((t=>t))),n=this.store.select(QT,this.cardId).pipe(Gt((t=>Boolean(t))),ft((t=>t)),ae(1)).pipe(sn(this.store.select(pD)),ft((([t,n])=>Object.keys(t).map((e=>({runId:e,points:this.stepSeriesToLineSeries(t[e],n)}))))),vn(Vlt));function e(t){return JSON.stringify(["smoothed",t])}this.legacySeriesDataList$=n.pipe(se((t=>t.length?Et(t.map((t=>this.getRunDisplayName(t.runId).pipe(ft((n=>({seriesId:t.runId,points:t.points,metadata:{displayName:n},visible:!1}))))))):Z([]))),sn(this.store.select(KD)),ln(0),ft((([t,n])=>t.map((t=>Object.assign(Object.assign({},t),{visible:Boolean(n&&n.get(t.seriesId))}))))),ce([]),vn(Blt));const a=n.pipe(sn(this.store.select(pD)),ft((([t,n])=>t.map((t=>{let e=t.points.map((t=>{const e=1e3*t.wallTime,a=n===WT.STEP?t.x:e;return Object.assign(Object.assign({},t),{x:a,wallTime:e})}));if(n===WT.RELATIVE&&e.length){const t=e[0];e=e.map((n=>Object.assign(Object.assign({},n),{x:n.x-t.x})))}return{runId:t.runId,points:e}}))))).pipe(sn(this.store.select(fD)),ft((([t,n])=>n?(function e(t){var n;const e=[];for(const a of t){const t=[];let o=Number.isFinite(null===(n=a.points[0])||void 0===n?void 0:n.x)?a.points[0].x:-1/0,r=[];for(const n of a.points)Number.isFinite(n.x)?(n.x<o&&(t.push({seriesId:JSON.stringify([a.runId,t.length]),runId:a.runId,points:r}),r=[]),r.push(n),o=n.x):r.push(n);t.push({seriesId:JSON.stringify([a.runId,t.length]),runId:a.runId,points:r});for(let n=0;n<t.length;n++)e.push(Object.assign(Object.assign({},t[n]),{partitionIndex:n,partitionSize:t.length}))}return e})(t):t.map((t=>Object.assign(Object.assign({},t),{seriesId:t.runId,partitionIndex:0,partitionSize:1}))))),ae(1));this.dataSeries$=a.pipe(sn(this.store.select(uD)),se((([t,n])=>{const a=t.map((({seriesId:t,points:n})=>({id:t,points:n})));return n<=0?Z(a):Rt((function o(t,n){var e;return CR(this,void 0,void 0,(function*(){Number.isFinite(n)||(n=0),n=Math.max(0,Math.min(n,1));const a=[];for(const o of t){const t=null===(e=o.points[0])||void 0===e?void 0:e.y;if(o.points.every((n=>n.y==t))){a.push(o);continue}let r=o.points.length>0?0:NaN,i=0;const c=o.points.map((t=>{const e=t.y;if(Number.isFinite(e)){r=r*n+(1-n)*e,i++;const a=1===n?1:1-Math.pow(n,i);return{x:t.x,y:r/a}}return{x:t.x,y:e}}));a.push({id:o.id,points:c})}return a}))})(a,n)).pipe(ft((t=>{const n=a.map(((n,a)=>({id:e(n.id),points:t[a].points.map((({y:t},e)=>Object.assign(Object.assign({},n.points[e]),{y:t})))})));return[...a,...n]})))})),ce([])),this.chartMetadataMap$=a.pipe(se((t=>Et(t.map((t=>this.getRunDisplayName(t.runId).pipe(ft((n=>Object.assign(Object.assign({},t),{displayName:n}))))))))),sn(this.store.select(KD),this.store.select(GD),this.store.select(uD)),ln(0),ft((([t,n,a,o])=>{var r;const i={},c=o>0;for(const e of t){const{seriesId:t,runId:o,displayName:c,partitionIndex:s,partitionSize:l}=e;i[t]={type:U$.ORIGINAL,id:t,displayName:l>1?`${c}: ${s}`:c,visible:Boolean(n&&n.get(o)),color:null!==(r=a[o])&&void 0!==r?r:"#fff",aux:!1,opacity:1}}if(!c)return i;for(const[t,n]of Object.entries(i)){const a=e(t);i[a]=Object.assign(Object.assign({},n),{id:a,type:U$.DERIVED,aux:!1,originalSeriesId:t}),n.aux=!0,n.opacity=.25}return i})),ce({})),this.loadState$=this.store.select(JT,this.cardId),this.tag$=t.pipe(ft((t=>t.tag))),this.title$=this.tag$.pipe(ft((t=>QK(t,this.groupName)))),this.isPinned$=this.store.select(cD,this.cardId)}getRunDisplayName(t){return Et([this.store.select(TD,{runId:t}),this.store.select(oR),this.store.select(DD,{runId:t})]).pipe(ft((([n,e,a])=>E$(t,a,n?e[n]:null))))}stepSeriesToLineSeries(t,n){const e=n===WT.STEP;return t.map((t=>Object.assign(Object.assign({},t),{x:e?t.step:t.wallTime,y:t.value})))}}function Ult(t,n,e){const a=[],{left:o,right:r}=n,i=(r-o)/e;let c=0,s=0;for(let n=0;n<e;n++){const r=o+n*i,l=r+i,m=n===e-1;let d=s;for(s=0;c<t.length;){const n=t[c],e=Wlt(n,r,l,!m);if(d+=e.curr,s+=e.next,n.x+n.dx>l)break;c++}a.push({x:r,dx:i,y:d})}return a}function Wlt(t,n,e,a){const o=t.x,r=t.x+t.dx;if(o>e||r<n)return{curr:0,next:0};if(0===t.dx)return a&&r===e?{curr:.5*t.y,next:.5*t.y}:{curr:t.y,next:0};const i=Math.min(r,e)-Math.max(o,n);return{curr:t.y*i/t.dx,next:0}}jlt.ɵfac=function t(n){return new(n||jlt)(Zg(cv))},jlt.ɵcmp=_o({type:jlt,selectors:[["scalar-card"]],inputs:{DataDownloadComponent:"DataDownloadComponent",cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:19,vars:58,consts:[[3,"cardId","DataDownloadComponent","loadState","runColorScale","title","tag","seriesDataList","tooltipSort","ignoreOutliers","xAxisType","newXScaleType","scalarSmoothing","showFullSize","isPinned","dataSeries","chartMetadataMap","gpuLineChartEnabled","smoothingEnabled","isCardVisible","isEverVisible","onFullSizeToggle","onPinClicked"]],template:function t(n,e){1&n&&(Kg(0,"scalar-card-component",0),cp("onFullSizeToggle",(function t(){return e.onFullSizeToggle()}))("onPinClicked",(function t(n){return e.pinStateChanged.emit(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),yf(10,"async"),yf(11,"async"),yf(12,"async"),yf(13,"async"),yf(14,"async"),yf(15,"async"),yf(16,"async"),yf(17,"async"),yf(18,"async"),$g()),2&n&&Jg("cardId",e.cardId)("DataDownloadComponent",e.DataDownloadComponent)("loadState",kf(1,20,e.loadState$))("runColorScale",e.runColorScale)("title",kf(2,22,e.title$))("tag",kf(3,24,e.tag$))("seriesDataList",kf(4,26,e.legacySeriesDataList$))("tooltipSort",kf(5,28,e.tooltipSort$))("ignoreOutliers",kf(6,30,e.ignoreOutliers$))("xAxisType",kf(7,32,e.xAxisType$))("newXScaleType",kf(8,34,e.newXScaleType$))("scalarSmoothing",kf(9,36,e.scalarSmoothing$))("showFullSize",e.showFullSize)("isPinned",kf(10,38,e.isPinned$))("dataSeries",kf(11,40,e.gpuLineChartEnabled$)?kf(12,42,e.dataSeries$):bf(56,Llt))("chartMetadataMap",kf(13,44,e.gpuLineChartEnabled$)?kf(14,46,e.chartMetadataMap$):bf(57,Hlt))("gpuLineChartEnabled",kf(15,48,e.gpuLineChartEnabled$))("smoothingEnabled",kf(16,50,e.smoothingEnabled$))("isCardVisible",kf(17,52,e.isCardVisible$))("isEverVisible",kf(18,54,e.isEverVisible$))},directives:[Flt],pipes:[oO],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0});class Glt{constructor(t){this.host=t,this.mode=HT.OFFSET,this.timeProperty=LT.STEP,this.element=document.createElement("vz-histogram-timeseries"),this.element.mode=this.mode,this.element.timeProperty=this.timeProperty}ngOnInit(){this.host.nativeElement.appendChild(this.element)}ngOnChanges(t){if(t.name||t.data){const t=this.data.map((t=>{const{step:n,bins:e}=t;return{step:n,bins:e,wall_time:t.wallTime}}));this.element.setSeriesData(this.name,t)}t.mode&&(this.element.mode=this.mode),t.timeProperty&&(this.element.timeProperty=this.timeProperty),t.colorScale&&this.colorScale&&(this.element.colorScale=this.colorScale)}redraw(){this.element.redraw()}}function Ylt(t,n){1&t&&(Kg(0,"span",14),tp(1,"mat-spinner",15),$g())}function qlt(t,n){if(1&t){const t=op();Kg(0,"tb-histogram",16),cp("onResize",(function n(){return jr(t),gp().redraw()})),$g()}if(2&t){const t=gp();Jg("name",t.runId)("data",t.data)("mode",t.mode)("timeProperty",t.timeProperty(t.xAxisType))("colorScale",t.runColorScale)("resizeEventDebouncePeriodInMs",t.RESIZE_REDRAW_DEBOUNCE_TIME_IN_MS)}}function Zlt(t,n){1&t&&(Kg(0,"div",18),Jp(1," Data failed to load. "),$g())}function Xlt(t,n){if(1&t&&Yg(0,Zlt,2,0,"div",17),2&t){const t=gp();Jg("ngIf",t.loadState===t.DataLoadState.FAILED)}}Glt.ɵfac=function t(n){return new(n||Glt)(Zg(xu))},Glt.ɵcmp=_o({type:Glt,selectors:[["tb-histogram"]],inputs:{mode:"mode",timeProperty:"timeProperty",colorScale:"colorScale",name:"name",data:"data"},features:[pr],decls:0,vars:0,template:function t(n,e){},styles:["[_nghost-%COMP%] {\n        display: flex;\n      }"]});const Jlt=function(t){return{backgroundColor:t}};class Qlt{constructor(t){this.ref=t,this.RESIZE_REDRAW_DEBOUNCE_TIME_IN_MS=50,this.DataLoadState=fR,this.onFullSizeToggle=new Ef,this.onPinClicked=new Ef}timeProperty(t){switch(t){case WT.STEP:return LT.STEP;case WT.WALL_TIME:return LT.WALL_TIME;case WT.RELATIVE:return LT.RELATIVE;default:throw new Error("Invalid xAxisType for histogram time property.")}}redraw(){this.histogramComponent&&this.ref.nativeElement.clientHeight&&this.histogramComponent.redraw()}}Qlt.ɵfac=function t(n){return new(n||Qlt)(Zg(xu))},Qlt.ɵcmp=_o({type:Qlt,selectors:[["histogram-card-component"]],viewQuery:function t(n,e){var a;1&n&&Uf(Glt,!0),2&n&&Vf(a=Zf())&&(e.histogramComponent=a.first)},inputs:{loadState:"loadState",title:"title",tag:"tag",runId:"runId",data:"data",mode:"mode",xAxisType:"xAxisType",runColorScale:"runColorScale",showFullSize:"showFullSize",isPinned:"isPinned"},outputs:{onFullSizeToggle:"onFullSizeToggle",onPinClicked:"onPinClicked"},decls:16,vars:12,consts:function(){return[[1,"heading"],[1,"tag",3,"title","value"],[1,"run"],[1,"dot",3,"ngStyle"],[1,"run-text",3,"runId"],[1,"controls"],["mat-icon-button","",1,"pin-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Pin card"):$localize`:A button to pin a card.␟e665dc712bd5f18d4dfa3a29e125d565cc51e2f6␟7284606426234375344:Pin card`],[3,"svgIcon"],["mat-icon-button","","title","Toggle full size mode",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle full size mode"):$localize`:A button on a histogram card that toggles full size mode.␟fc8f767d0b9f930187a1bae34477ad28736ece33␟915721563638926597:Toggle full size mode`],["class","spinner",4,"ngIf"],["detectResize","",3,"name","data","mode","timeProperty","colorScale","resizeEventDebouncePeriodInMs","onResize",4,"ngIf","ngIfElse"],["noData",""],[1,"spinner"],["diameter","18"],["detectResize","",3,"name","data","mode","timeProperty","colorScale","resizeEventDebouncePeriodInMs","onResize"],["class","empty-message",4,"ngIf"],[1,"empty-message"]]},template:function t(n,e){if(1&n&&(Kg(0,"div",0),tp(1,"tb-truncated-path",1),Kg(2,"div",2),tp(3,"span",3),tp(4,"card-run-name",4),$g(),Kg(5,"span",5),Kg(6,"button",6),lu(7,7),cp("click",(function t(){return e.onPinClicked.emit(!e.isPinned)})),tp(8,"mat-icon",8),$g(),Kg(9,"button",9),lu(10,10),cp("click",(function t(){return e.onFullSizeToggle.emit()})),tp(11,"mat-icon",8),$g(),$g(),Yg(12,Ylt,2,0,"span",11),$g(),Yg(13,qlt,1,6,"tb-histogram",12),Yg(14,Xlt,1,1,"ng-template",null,13,Kf)),2&n){const t=qg(15);ws(1),_p("title",e.tag),_p("value",e.title),ws(2),Jg("ngStyle",uf(10,Jlt,e.runColorScale(e.runId))),ws(1),Jg("runId",e.runId),ws(2),Ng("title",e.isPinned?"Unpin card":"Pin card"),ws(2),Jg("svgIcon",e.isPinned?"keep_24px":"keep_outline_24px"),ws(3),Jg("svgIcon",e.showFullSize?"fullscreen_exit_24px":"fullscreen_24px"),ws(1),Jg("ngIf",e.loadState===e.DataLoadState.LOADING),ws(1),Jg("ngIf",e.data&&e.data.length)("ngIfElse",t)}},directives:[S$,$M,z$,eA,BB,WM,hZ,Glt,_Y],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;box-sizing:border-box;height:100%;overflow:auto;padding:16px;padding-top:4px}.heading[_ngcontent-%COMP%]{align-items:center;display:grid;grid-template-areas:"tag controls" "run spinner";grid-template-columns:1fr auto;font-size:14px;margin-bottom:4px}.tag[_ngcontent-%COMP%]{grid-area:tag;overflow:hidden}.pin-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{height:18px}.run[_ngcontent-%COMP%]{grid-area:run;display:flex;white-space:nowrap;font-size:13px;color:#616161}.run[_ngcontent-%COMP%]   .dot[_ngcontent-%COMP%]{flex:none;display:inline-block;width:13px;height:13px;border-radius:50%;margin-right:4px}.run[_ngcontent-%COMP%]   .run-text[_ngcontent-%COMP%]{overflow:hidden;text-overflow:ellipsis;max-width:120px}.controls[_ngcontent-%COMP%]{color:#616161;grid-area:controls;justify-self:flex-end;flex-shrink:0;margin-right:-12px;white-space:nowrap}.spinner[_ngcontent-%COMP%]{display:flex;grid-area:spinner;height:100%;justify-content:center;position:relative}mat-spinner[_ngcontent-%COMP%]{top:0;right:0;position:absolute}tb-histogram[_ngcontent-%COMP%]{flex-grow:1;overflow:hidden}.empty-message[_ngcontent-%COMP%]{margin-top:1em;font-size:13px}'],changeDetection:0});class Klt{constructor(t){this.store=t,this.fullWidthChanged=new Ef,this.fullHeightChanged=new Ef,this.pinStateChanged=new Ef,this.mode$=this.store.select(bD),this.xAxisType$=this.store.select(pD),this.showFullSize=!1}isHistogramCardMetadata(t){const{plugin:n}=t;return n===gT.HISTOGRAMS}onFullSizeToggle(){this.showFullSize=!this.showFullSize,this.fullWidthChanged.emit(this.showFullSize),this.fullHeightChanged.emit(this.showFullSize)}ngOnInit(){const t=this.store.select($T,this.cardId).pipe(Gt((t=>!!t&&this.isHistogramCardMetadata(t))),ft((t=>t))),n=Et([t,this.store.select(QT,this.cardId)]);this.data$=n.pipe(ft((([t,n])=>{const e=t.runId;return n&&n.hasOwnProperty(e)?(function a(t,n=30){if(!t.length||n<1)return[];const e=(function a(t){let n=null,e=null;for(const{bins:a}of t){if(!a.length)continue;const t=a[a.length-1],o=a[0].x,r=t.x+t.dx;(null===n||o<n)&&(n=o),(null===e||r>e)&&(e=r)}return null===n||null===e?null:{left:n,right:e}})(t);return e&&e.left===e.right&&(e.right=1.1*e.right+1,e.left=e.left/1.1-1),t.map((t=>({step:t.step,wallTime:t.wallTime,bins:e?Ult(t.bins,e,n):[]})))})(n[e].map((t=>{const{wallTime:n,step:e}=t;return{wallTime:n,step:e,bins:t.bins.map((t=>({x:t.min,dx:t.max-t.min,y:t.count})))}}))):[]}))),this.loadState$=this.store.select(JT,this.cardId),this.tag$=t.pipe(ft((t=>t.tag))),this.title$=this.tag$.pipe(ft((t=>QK(t,this.groupName)))),this.runId$=t.pipe(ft((t=>t.runId))),this.isPinned$=this.store.select(cD,this.cardId)}}function $lt(t,n){if(1&t){const t=op();Kg(0,"image-card",4),cp("fullWidthChanged",(function n(e){return jr(t),gp().onFullWidthChanged(e)}))("pinStateChanged",(function n(){return jr(t),gp().onPinStateChanged()})),$g()}if(2&t){const t=gp();Jg("cardId",t.cardId)("groupName",t.groupName)("runColorScale",t.runColorScale)}}function tmt(t,n){if(1&t){const t=op();Kg(0,"scalar-card",5),cp("fullWidthChanged",(function n(e){return jr(t),gp().onFullWidthChanged(e)}))("fullHeightChanged",(function n(e){return jr(t),gp().onFullHeightChanged(e)}))("pinStateChanged",(function n(){return jr(t),gp().onPinStateChanged()})),$g()}if(2&t){const t=gp();Jg("cardId",t.cardId)("groupName",t.groupName)("runColorScale",t.runColorScale)}}function nmt(t,n){if(1&t){const t=op();Kg(0,"histogram-card",5),cp("fullWidthChanged",(function n(e){return jr(t),gp().onFullWidthChanged(e)}))("fullHeightChanged",(function n(e){return jr(t),gp().onFullHeightChanged(e)}))("pinStateChanged",(function n(){return jr(t),gp().onPinStateChanged()})),$g()}if(2&t){const t=gp();Jg("cardId",t.cardId)("groupName",t.groupName)("runColorScale",t.runColorScale)}}function emt(t,n){if(1&t&&(Kg(0,"div"),Jp(1),$g()),2&t){const t=gp();ws(1),Kp("Placeholder error for: ",t.cardId,"")}}Klt.ɵfac=function t(n){return new(n||Klt)(Zg(cv))},Klt.ɵcmp=_o({type:Klt,selectors:[["histogram-card"]],inputs:{cardId:"cardId",groupName:"groupName",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:9,vars:26,consts:[[3,"loadState","title","tag","runId","data","mode","xAxisType","runColorScale","showFullSize","isPinned","onFullSizeToggle","onPinClicked"]],template:function t(n,e){1&n&&(Kg(0,"histogram-card-component",0),cp("onFullSizeToggle",(function t(){return e.onFullSizeToggle()}))("onPinClicked",(function t(n){return e.pinStateChanged.emit(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),$g()),2&n&&Jg("loadState",kf(1,10,e.loadState$))("title",kf(2,12,e.title$))("tag",kf(3,14,e.tag$))("runId",kf(4,16,e.runId$))("data",kf(5,18,e.data$))("mode",kf(6,20,e.mode$))("xAxisType",kf(7,22,e.xAxisType$))("runColorScale",e.runColorScale)("showFullSize",e.showFullSize)("isPinned",kf(8,24,e.isPinned$))},directives:[Qlt],pipes:[oO],styles:["[_nghost-%COMP%] {\n        display: block;\n        height: 100%;\n      }"],changeDetection:0});class amt{constructor(){this.PluginType=gT,this.fullWidthChanged=new Ef,this.fullHeightChanged=new Ef,this.pinStateChanged=new Ef}onFullWidthChanged(t){this.fullWidthChanged.emit(t)}onFullHeightChanged(t){this.fullHeightChanged.emit(t)}onPinStateChanged(){this.pinStateChanged.emit()}}amt.ɵfac=function t(n){return new(n||amt)},amt.ɵcmp=_o({type:amt,selectors:[["card-view-component"]],inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType",runColorScale:"runColorScale"},outputs:{fullWidthChanged:"fullWidthChanged",fullHeightChanged:"fullHeightChanged",pinStateChanged:"pinStateChanged"},decls:5,vars:4,consts:[[3,"ngSwitch"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged",4,"ngSwitchCase"],[3,"cardId","groupName","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged",4,"ngSwitchCase"],[4,"ngSwitchDefault"],[3,"cardId","groupName","runColorScale","fullWidthChanged","pinStateChanged"],[3,"cardId","groupName","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged"]],template:function t(n,e){1&n&&(np(0,0),Yg(1,$lt,1,3,"image-card",1),Yg(2,tmt,1,3,"scalar-card",2),Yg(3,nmt,1,3,"histogram-card",2),Yg(4,emt,2,1,"div",3),ep()),2&n&&(Jg("ngSwitch",e.pluginType),ws(1),Jg("ngSwitchCase",e.PluginType.IMAGES),ws(1),Jg("ngSwitchCase",e.PluginType.SCALARS),ws(1),Jg("ngSwitchCase",e.PluginType.HISTOGRAMS))},directives:[ZM,XM,JM,B$,jlt,Klt],encapsulation:2,changeDetection:0});class omt{constructor(t){this.store=t,this.showFullWidth=!1,this.showFullHeight=!1,this.runColorScale$=this.store.select(GD).pipe((function n(t,e=mt,a=Me){return n=>n.lift(new Oe(t,e,!!a.leading,!!a.trailing))})(350,void 0,{leading:!0,trailing:!0}),ft((t=>n=>{if(!t.hasOwnProperty(n))throw new Error(`[Color scale] unknown runId: ${n}.`);return t[n]})))}onFullWidthChanged(t){this.showFullWidth=t}onFullHeightChanged(t){this.showFullHeight=t}onPinStateChanged(){this.store.select(cD,this.cardId).pipe(Tn(1),ye(this.store.select(lD))).subscribe((([t,n])=>{this.store.dispatch(SK({cardId:this.cardId,canCreateNewPins:n,wasPinned:t}))}))}}function rmt(t,n){1&t&&ap(0)}function imt(t,n){if(1&t&&tp(0,"card-view",4),2&t){const t=n.$implicit,e=gp();Jg("cardId",t.cardId)("groupName",e.groupName)("pluginType",t.plugin)("cardObserver",e.cardObserver)("cardLazyLoader",t.cardId)}}function cmt(t,n){1&t&&ap(0)}function smt(t,n){if(1&t){const t=op();Kg(0,"button",13),lu(1,14),cp("click",(function n(){jr(t);const e=gp(3);return e.pageIndexChanged.emit(e.pageIndex-1)})),Jp(2," Previous "),$g()}2&t&&Jg("disabled",0===gp(3).pageIndex)}function lmt(t,n){1&t&&tp(0,"mat-icon",19)}function mmt(t,n){1&t&&tp(0,"mat-icon",20)}function dmt(t,n){if(1&t){const t=op();Kg(0,"button",15),lu(1,16),cp("click",(function n(){return jr(t),gp(3).groupExpansionToggled.emit()})),Yg(2,lmt,1,0,"mat-icon",17),Yg(3,mmt,1,0,"ng-template",null,18,Kf),$g()}if(2&t){const t=qg(4),n=gp(3);ws(2),Jg("ngIf",n.isGroupExpanded)("ngIfElse",t)}}function gmt(t,n){if(1&t){const t=op();Kg(0,"span",24),Kg(1,"input",25),cp("input",(function n(e){return jr(t),gp(4).onPaginationInputChange(e)}))("change",(function n(e){return jr(t),gp(4).onPaginationInputChange(e)})),$g(),Jp(2),$g()}if(2&t){const t=gp(4);ws(1),Jg("value",t.pageIndex+1)("max",t.numPages),ws(1),Kp(" of ",t.numPages,"")}}function pmt(t,n){if(1&t){const t=op();Kg(0,"span"),Yg(1,gmt,3,3,"span",21),Kg(2,"button",22),lu(3,23),cp("click",(function n(){jr(t);const e=gp(3);return e.pageIndexChanged.emit(e.pageIndex+1)})),Jp(4," Next "),$g(),$g()}if(2&t){const t=gp(2).isBottomControl,n=gp();ws(1),Jg("ngIf",n.showPaginationInput(t)),ws(1),Jg("disabled",n.pageIndex+1>=n.numPages)}}function bmt(t,n){if(1&t&&(Kg(0,"div",6),Kg(1,"span",7),Yg(2,smt,3,1,"button",8),$g(),Kg(3,"span",9),Yg(4,dmt,5,2,"button",10),$g(),Kg(5,"span",11),Yg(6,pmt,5,2,"span",12),$g(),$g()),2&t){const t=gp().isBottomControl,n=gp();ws(2),Jg("ngIf",n.showPaginationControls),ws(2),Jg("ngIf",n.showExpand(t)),ws(2),Jg("ngIf",n.showPaginationControls)}}function umt(t,n){if(1&t&&Yg(0,bmt,7,3,"div",5),2&t){const t=n.isBottomControl,e=gp();Jg("ngIf",e.showPaginationControls||e.showExpand(t))}}omt.ɵfac=function t(n){return new(n||omt)(Zg(cv))},omt.ɵcmp=_o({type:omt,selectors:[["card-view"]],hostVars:4,hostBindings:function t(n,e){2&n&&Dp("full-width",e.showFullWidth)("full-height",e.showFullHeight)},inputs:{cardId:"cardId",groupName:"groupName",pluginType:"pluginType"},decls:2,vars:6,consts:[[3,"cardId","groupName","pluginType","runColorScale","fullWidthChanged","fullHeightChanged","pinStateChanged"]],template:function t(n,e){1&n&&(Kg(0,"card-view-component",0),cp("fullWidthChanged",(function t(n){return e.onFullWidthChanged(n)}))("fullHeightChanged",(function t(n){return e.onFullHeightChanged(n)}))("pinStateChanged",(function t(){return e.onPinStateChanged()})),yf(1,"async"),$g()),2&n&&Jg("cardId",e.cardId)("groupName",e.groupName)("pluginType",e.pluginType)("runColorScale",kf(1,4,e.runColorScale$))},directives:[amt],pipes:[oO],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{background-color:#fff}'],changeDetection:0});const fmt=function(){return{isBottomControl:!1}},hmt=function(){return{isBottomControl:!0}};class _mt{constructor(){this.PluginType=gT,this.pageIndexChanged=new Ef,this.groupExpansionToggled=new Ef}showExpand(t){return!!t&&this.isGroupExpandable}showPaginationInput(t){return t}trackByCards(t,n){return n.cardId}onPaginationInputChange(t){const n=t.target;if("input"===t.type&&""===n.value)return;const e=Number(n.value)-1,a=Math.min(Math.max(0,e),this.numPages-1);n.value!==String(a+1)&&(n.value=String(a+1)),this.pageIndexChanged.emit(a)}}_mt.ɵfac=function t(n){return new(n||_mt)},_mt.ɵcmp=_o({type:_mt,selectors:[["metrics-card-grid-component"]],inputs:{isGroupExpandable:"isGroupExpandable",isGroupExpanded:"isGroupExpanded",groupName:"groupName",pageIndex:"pageIndex",numPages:"numPages",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver",showPaginationControls:"showPaginationControls"},outputs:{pageIndexChanged:"pageIndexChanged",groupExpansionToggled:"groupExpansionToggled"},decls:6,vars:8,consts:function(){return[[4,"ngTemplateOutlet","ngTemplateOutletContext"],[1,"card-grid"],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader",4,"ngFor","ngForOf","ngForTrackBy"],["groupControls",""],[3,"cardId","groupName","pluginType","cardObserver","cardLazyLoader"],["class","group-controls",4,"ngIf"],[1,"group-controls"],[1,"prev-container"],["class","prev pagination-button","mat-button","",3,"disabled","click",4,"ngIf",6,"aria-label"],[1,"expand-container"],["class","expand-group-button","mat-icon-button","",3,"click",4,"ngIf",6,"aria-label"],[1,"input-and-next-container"],[4,"ngIf"],["mat-button","",1,"prev","pagination-button",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Previous page"):$localize`:A button that sets a group to the previous page.␟575e782fd27f2ee70a034a775efe9ad162472250␟3629960544875360046:Previous page`],["mat-icon-button","",1,"expand-group-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Expand group"):$localize`:A button that allows user to expand a tag group.␟ffaa11471b878a6dffe2e68c6f37064a9e074853␟5386054325274779258:Expand group`],["svgIcon","expand_less_24px",4,"ngIf","ngIfElse"],["expandMore",""],["svgIcon","expand_less_24px"],["svgIcon","expand_more_24px"],["class","pagination-input",4,"ngIf"],["mat-button","",1,"next","pagination-button",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Next page"):$localize`:A button that sets a group to the next page.␟ce3cefb1cd0099aa5003dda16ec9eb21fd8ba789␟3337301694210287595:Next page`],[1,"pagination-input"],["type","number","min","1",3,"value","max","input","change"]]},template:function t(n,e){if(1&n&&(Yg(0,rmt,1,0,"ng-container",0),Kg(1,"div",1),Yg(2,imt,1,5,"card-view",2),$g(),Yg(3,cmt,1,0,"ng-container",0),Yg(4,umt,1,1,"ng-template",null,3,Kf)),2&n){const t=qg(5);Jg("ngTemplateOutlet",t)("ngTemplateOutletContext",bf(6,fmt)),ws(2),Jg("ngForOf",e.cardIdsWithMetadata)("ngForTrackBy",e.trackByCards),ws(1),Jg("ngTemplateOutlet",t)("ngTemplateOutletContext",bf(7,hmt))}},directives:[tO,jM,omt,XK,WM,eA,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.card-grid[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill, minmax(335px, auto));gap:16px;padding:16px}card-view[_ngcontent-%COMP%]{border:1px solid #ddd;border-radius:4px;box-sizing:border-box;contain:strict;height:100%;min-height:320px}card-view.full-width[_ngcontent-%COMP%]{contain:layout paint;grid-column-start:1;grid-column-end:-1}card-view.full-height[_ngcontent-%COMP%]{min-height:480px}.group-controls[_ngcontent-%COMP%]{color:#616161;display:grid;align-items:center;grid-template-columns:1fr 1fr 1fr;gap:16px;padding:0 16px}.group-controls[_ngcontent-%COMP%]:first-of-type{padding-top:16px}.group-controls[_ngcontent-%COMP%]:last-of-type{padding-bottom:16px}.prev-container[_ngcontent-%COMP%]{justify-self:flex-start}.expand-container[_ngcontent-%COMP%]{justify-self:center}.input-and-next-container[_ngcontent-%COMP%]{justify-self:flex-end}.pagination-input[_ngcontent-%COMP%]{margin-right:16px}.expand-group-button[_ngcontent-%COMP%], .pagination-button[_ngcontent-%COMP%]{background-color:#fff;color:#616161}'],changeDetection:0});class Cmt{constructor(t){this.store=t,this.groupName=null,this.groupName$=new F(null),this.pageIndex$=new F(0),this.items$=new F([]),this.numPages$=Et([this.items$,this.store.select(VI)]).pipe(ft((([t,n])=>Math.ceil(t.length/n)))),this.isGroupExpanded$=this.groupName$.pipe(se((t=>null!==t?this.store.select(OD,t):Z(!0)))),this.showPaginationControls$=Et([this.numPages$,this.store.select(VI),this.isGroupExpanded$]).pipe(ft((([t,n,e])=>!(t<=1)&&(n<=3||e)))),this.isGroupExpandable$=Et([this.items$,this.store.select(VI)]).pipe(ft((([t,n])=>!(null===this.groupName||n<=3||t.length<=3)))),this.normalizedPageIndex$=Et([this.pageIndex$,this.numPages$]).pipe(he((([t,n])=>{0!==n&&(t>=n?this.pageIndex$.next(n-1):t<0&&this.pageIndex$.next(0))})),ft((([t,n])=>Math.min(Math.max(t,0),n-1))),ae(1)),this.pagedItems$=Et([this.items$,this.store.select(VI),this.normalizedPageIndex$,this.isGroupExpanded$]).pipe(ft((([t,n,e,a])=>{const o=n*e,r=n*e+Math.min(a?n:3,n);return t.slice(o,r)})))}ngOnChanges(t){t.cardIdsWithMetadata&&this.items$.next(this.cardIdsWithMetadata),t.groupName&&this.groupName$.next(this.groupName)}onPageIndexChanged(t){this.pageIndex$.next(t)}onGroupExpansionToggled(){if(null===this.groupName)throw new RangeError("Invariant error: expansion cannot be toggled when groupName is null");this.store.dispatch(wK({tagGroup:this.groupName}))}}function Mmt(t,n){if(1&t&&(Kg(0,"span",6),Jp(1),$g()),2&t){const t=gp().$implicit;ws(1),Kp("",t.items.length," cards")}}function Omt(t,n){if(1&t&&(Kg(0,"div",1),Kg(1,"div",2),Kg(2,"span"),Kg(3,"span",3),Jp(4),$g(),Yg(5,Mmt,2,1,"span",4),$g(),$g(),tp(6,"metrics-card-grid",5),$g()),2&t){const t=n.$implicit,e=gp();ws(3),_p("title",t.groupName),ws(1),Qp(t.groupName),ws(1),Jg("ngIf",t.items.length>1),ws(1),Jg("cardIdsWithMetadata",t.items)("cardObserver",e.cardObserver)("groupName",t.groupName)}}Cmt.ɵfac=function t(n){return new(n||Cmt)(Zg(cv))},Cmt.ɵcmp=_o({type:Cmt,selectors:[["metrics-card-grid"]],inputs:{groupName:"groupName",cardIdsWithMetadata:"cardIdsWithMetadata",cardObserver:"cardObserver"},features:[pr],decls:7,vars:20,consts:[[3,"isGroupExpandable","isGroupExpanded","groupName","pageIndex","numPages","showPaginationControls","cardIdsWithMetadata","cardObserver","pageIndexChanged","groupExpansionToggled"]],template:function t(n,e){1&n&&(Kg(0,"metrics-card-grid-component",0),cp("pageIndexChanged",(function t(n){return e.onPageIndexChanged(n)}))("groupExpansionToggled",(function t(){return e.onGroupExpansionToggled()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),$g()),2&n&&Jg("isGroupExpandable",kf(1,8,e.isGroupExpandable$))("isGroupExpanded",kf(2,10,e.isGroupExpanded$))("groupName",e.groupName)("pageIndex",kf(3,12,e.normalizedPageIndex$))("numPages",kf(4,14,e.numPages$))("showPaginationControls",kf(5,16,e.showPaginationControls$))("cardIdsWithMetadata",kf(6,18,e.pagedItems$))("cardObserver",e.cardObserver)},directives:[_mt],pipes:[oO],encapsulation:2,changeDetection:0});class Pmt{constructor(){this.PluginType=gT}trackByGroup(t,n){return n.groupName}}Pmt.ɵfac=function t(n){return new(n||Pmt)},Pmt.ɵcmp=_o({type:Pmt,selectors:[["metrics-card-groups-component"]],inputs:{cardGroups:"cardGroups",cardObserver:"cardObserver"},decls:1,vars:2,consts:[["class","card-group",4,"ngFor","ngForOf","ngForTrackBy"],[1,"card-group"],[1,"group-toolbar"],["aria-role","heading","aria-level","3",1,"group-title",3,"title"],["class","group-card-count",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver","groupName"],[1,"group-card-count"]],template:function t(n,e){1&n&&Yg(0,Omt,7,6,"div",0),2&n&&Jg("ngForOf",e.cardGroups)("ngForTrackBy",e.trackByGroup)},directives:[jM,WM,Cmt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.group-toolbar[_ngcontent-%COMP%]{background-color:#fff;height:42px;padding:0 16px;display:flex;align-items:center;border-top:1px solid #ebebeb;border-bottom:1px solid #ebebeb}.card-group[_ngcontent-%COMP%]:first-of-type   .group-toolbar[_ngcontent-%COMP%]{border-top:none}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}'],changeDetection:0});const xmt=pv(eD,KD,((t,n)=>t.filter((t=>!fT(t.plugin)||Boolean(n&&n.get(t.runId))))));class ymt{constructor(t){this.store=t,this.cardGroups$=this.store.select(xmt).pipe(ft((t=>(function n(t){const n=new Map,e=t.slice().sort(((t,n)=>KK(t.tag,n.tag)));for(const t of e){const e=t.tag.split("/",1)[0];n.has(e)||n.set(e,{groupName:e,items:[]}),n.get(e).items.push(t)}return[...n.values()]})(t))))}}function kmt(t,n){if(1&t&&(Kg(0,"span",5),Jp(1),$g()),2&t){const t=gp();ws(1),Kp("",t.cardIdsWithMetadata.length," cards")}}ymt.ɵfac=function t(n){return new(n||ymt)(Zg(cv))},ymt.ɵcmp=_o({type:ymt,selectors:[["metrics-card-groups"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardGroups","cardObserver"]],template:function t(n,e){1&n&&(tp(0,"metrics-card-groups-component",0),yf(1,"async")),2&n&&Jg("cardGroups",kf(1,2,e.cardGroups$))("cardObserver",e.cardObserver)},directives:[Pmt],pipes:[oO],encapsulation:2,changeDetection:0});class vmt{}vmt.ɵfac=function t(n){return new(n||vmt)},vmt.ɵcmp=_o({type:vmt,selectors:[["metrics-filtered-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:6,vars:3,consts:[[1,"group-toolbar"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver"],[1,"group-card-count"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"span",1),Kg(2,"span",2),Jp(3,"Tags matching filter"),$g(),Yg(4,kmt,2,1,"span",3),$g(),$g(),tp(5,"metrics-card-grid",4)),2&n&&(ws(4),Jg("ngIf",e.cardIdsWithMetadata.length>1),ws(1),Jg("cardIdsWithMetadata",e.cardIdsWithMetadata)("cardObserver",e.cardObserver))},directives:[WM,Cmt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.group-toolbar[_ngcontent-%COMP%]{background-color:#fff;height:42px;padding:0 16px;display:flex;align-items:center;border-bottom:1px solid #ebebeb}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}'],changeDetection:0});const wmt=pv(eD,KD,((t,n)=>t.filter((t=>!fT(t.plugin)||Boolean(n&&n.get(t.runId))))));class Smt{constructor(t){this.store=t,this.cardIdsWithMetadata$=this.store.select(wmt).pipe(se((t=>Et([Z(t),this.store.select(MD)]))),ft((([t,n])=>{try{return{cardList:t,regex:new RegExp(n)}}catch(n){return{cardList:t,regex:null}}})),Gt((({regex:t})=>null!==t)),ft((({cardList:t,regex:n})=>t.filter((({tag:t})=>n.test(t))))),ft((t=>t.sort(((t,n)=>KK(t.tag,n.tag))))),vn(((t,n)=>t.length===n.length&&t.every(((t,e)=>t.cardId===n[e].cardId)))),ce([]))}}function Emt(t,n){if(1&t&&(Kg(0,"span",7),Jp(1),$g()),2&t){const t=gp();ws(1),Kp("",t.cardIdsWithMetadata.length," cards")}}function Amt(t,n){if(1&t&&tp(0,"metrics-card-grid",8),2&t){const t=gp();Jg("cardIdsWithMetadata",t.cardIdsWithMetadata)("cardObserver",t.cardObserver)}}function zmt(t,n){1&t&&(Kg(0,"div",9),Jp(1,"Pin cards for a quick view and comparison"),$g())}Smt.ɵfac=function t(n){return new(n||Smt)(Zg(cv))},Smt.ɵcmp=_o({type:Smt,selectors:[["metrics-filtered-view"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardIdsWithMetadata","cardObserver"]],template:function t(n,e){1&n&&(tp(0,"metrics-filtered-view-component",0),yf(1,"async")),2&n&&Jg("cardIdsWithMetadata",kf(1,2,e.cardIdsWithMetadata$))("cardObserver",e.cardObserver)},directives:[vmt],pipes:[oO],encapsulation:2,changeDetection:0});class Rmt{}Rmt.ɵfac=function t(n){return new(n||Rmt)},Rmt.ɵcmp=_o({type:Rmt,selectors:[["metrics-pinned-view-component"]],inputs:{cardObserver:"cardObserver",cardIdsWithMetadata:"cardIdsWithMetadata"},decls:9,vars:3,consts:[[1,"group-toolbar"],["svgIcon","keep_24px"],[1,"group-text"],["aria-role","heading","aria-level","3",1,"group-title"],["class","group-card-count",4,"ngIf"],[3,"cardIdsWithMetadata","cardObserver",4,"ngIf","ngIfElse"],["emptyPinnedView",""],[1,"group-card-count"],[3,"cardIdsWithMetadata","cardObserver"],[1,"empty-message"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),tp(1,"mat-icon",1),Kg(2,"span",2),Kg(3,"span",3),Jp(4,"Pinned"),$g(),Yg(5,Emt,2,1,"span",4),$g(),$g(),Yg(6,Amt,1,2,"metrics-card-grid",5),Yg(7,zmt,2,0,"ng-template",null,6,Kf)),2&n){const t=qg(8);ws(5),Jg("ngIf",e.cardIdsWithMetadata.length>1),ws(1),Jg("ngIf",e.cardIdsWithMetadata.length)("ngIfElse",t)}},directives:[BB,WM,Cmt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.group-toolbar[_ngcontent-%COMP%]{background-color:#fff;height:42px;padding:0 16px;display:flex;align-items:center;border-bottom:1px solid #ebebeb}mat-icon[_ngcontent-%COMP%]{color:#616161;flex:none;margin-right:5px}.group-text[_ngcontent-%COMP%]{display:flex;align-items:baseline}.group-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.group-card-count[_ngcontent-%COMP%]{font-size:12px;font-weight:400;color:#616161;margin-left:6px}.empty-message[_ngcontent-%COMP%]{color:#616161;text-align:center;padding:16px;font-size:13px;font-style:italic}'],changeDetection:0});class Tmt{constructor(t){this.store=t,this.cardIdsWithMetadata$=this.store.select(iD).pipe(ce([]))}}function Dmt(t,n){if(1&t&&(Kg(0,"mat-option",2),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t.value)("disabled",t.disabled),ws(1),Kp(" ",t.displayText," ")}}Tmt.ɵfac=function t(n){return new(n||Tmt)(Zg(cv))},Tmt.ɵcmp=_o({type:Tmt,selectors:[["metrics-pinned-view"]],inputs:{cardObserver:"cardObserver"},decls:2,vars:4,consts:[[3,"cardIdsWithMetadata","cardObserver"]],template:function t(n,e){1&n&&(tp(0,"metrics-pinned-view-component",0),yf(1,"async")),2&n&&Jg("cardIdsWithMetadata",kf(1,2,e.cardIdsWithMetadata$))("cardObserver",e.cardObserver)},directives:[Rmt],pipes:[oO],encapsulation:2,changeDetection:0});class Imt{constructor(){this.value="",this.options=[],this.selectionChange=new Ef}}Imt.ɵfac=function t(n){return new(n||Imt)},Imt.ɵcmp=_o({type:Imt,selectors:[["tb-dropdown"]],inputs:{value:"value",options:"options"},outputs:{selectionChange:"selectionChange"},decls:2,vars:2,consts:[[3,"value","selectionChange"],[3,"value","disabled",4,"ngFor","ngForOf"],[3,"value","disabled"]],template:function t(n,e){1&n&&(Kg(0,"mat-select",0),cp("selectionChange",(function t(n){return e.selectionChange.emit(n.value)})),Yg(1,Dmt,2,3,"mat-option",1),$g()),2&n&&(Jg("value",e.value),ws(1),Jg("ngForOf",e.options))},directives:[jH,jM,YE],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}mat-select[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:3px;box-sizing:border-box;padding:6px}mat-select[_ngcontent-%COMP%]:focus{outline-color:-webkit-focus-ring-color;outline-style:auto}']});class Nmt{constructor(t){this.locale=t,this.TooltipSortDropdownOptions=[{value:VT.DEFAULT,displayText:"Default"},{value:VT.ASCENDING,displayText:"Ascending"},{value:VT.DESCENDING,displayText:"Descending"},{value:VT.NEAREST,displayText:"Nearest"}],this.tooltipSortChanged=new Ef,this.ignoreOutliersChanged=new Ef,this.XAxisTypeDropdownOptions=[{value:WT.STEP,displayText:"Step"},{value:WT.RELATIVE,displayText:"Relative"},{value:WT.WALL_TIME,displayText:"Wall"}],this.xAxisTypeChanged=new Ef,this.HistogramModeDropdownOptions=[{value:HT.OFFSET,displayText:"Offset"},{value:HT.OVERLAY,displayText:"Overlay"}],this.histogramModeChanged=new Ef,this.MAX_SMOOTHING_VALUE=.999,this.MAX_SMOOTHING_SLIDER_VALUE=.99,this.scalarSmoothingControlChanged$=new Ef,this.scalarSmoothingChanged=this.scalarSmoothingControlChanged$.pipe(an(250)),this.scalarPartitionXToggled=new Ef,this.imageBrightnessSliderChanged$=new Ef,this.imageBrightnessInMilliChanged=this.imageBrightnessSliderChanged$.pipe(an(250)),this.imageBrightnessReset=new Ef,this.imageContrastSliderChanged$=new Ef,this.imageContrastInMilliChanged=this.imageContrastSliderChanged$.pipe(an(250)),this.imageContrastReset=new Ef,this.imageShowActualSizeChanged=new Ef}onScalarSmoothingInput(t){const n=t.target;if(!n.value)return;const e=Math.min(Math.max(0,parseFloat(n.value)),.999);e!==parseFloat(n.value)&&(n.value=String(e)),this.scalarSmoothingControlChanged$.emit(e)}formatMilliToZeroth(t){return RM(t/1e3,this.locale||"en-US","1.0-2")}}Nmt.ɵfac=function t(n){return new(n||Nmt)(Zg(N_))},Nmt.ɵcmp=_o({type:Nmt,selectors:[["metrics-dashboard-settings-component"]],inputs:{tooltipSort:"tooltipSort",ignoreOutliers:"ignoreOutliers",xAxisType:"xAxisType",histogramMode:"histogramMode",scalarSmoothing:"scalarSmoothing",scalarPartitionX:"scalarPartitionX",imageBrightnessInMilli:"imageBrightnessInMilli",imageContrastInMilli:"imageContrastInMilli",imageShowActualSize:"imageShowActualSize"},outputs:{tooltipSortChanged:"tooltipSortChanged",ignoreOutliersChanged:"ignoreOutliersChanged",xAxisTypeChanged:"xAxisTypeChanged",histogramModeChanged:"histogramModeChanged",scalarSmoothingChanged:"scalarSmoothingChanged",scalarPartitionXToggled:"scalarPartitionXToggled",imageBrightnessInMilliChanged:"imageBrightnessInMilliChanged",imageBrightnessReset:"imageBrightnessReset",imageContrastInMilliChanged:"imageContrastInMilliChanged",imageContrastReset:"imageContrastReset",imageShowActualSizeChanged:"imageShowActualSizeChanged"},decls:56,vars:28,consts:function(){return[[1,"general"],[1,"section-title"],[1,"control-row","x-axis-type"],["id","x-axis-type-label",1,"control-name"],[3,"value","options","selectionChange"],[1,"scalars"],[1,"control-row","scalars-smoothing"],["id","scalars-smoothing-label",1,"control-name"],[1,"slider-row"],["aria-labelledby","scalars-smoothing-label","color","primary",3,"max","min","step","value","thumbLabel","input"],["aria-labelledby","scalars-smoothing-label","type","number","min","0","step","0.001",1,"slider-input",3,"max","value","input"],[1,"control-row","tooltip-sort"],[1,"control-name"],[1,"control-row","scalars-ignore-outliers"],[3,"checked","change"],[1,"control-row","scalars-partition-x"],["svgIcon","help_outline_24px","title","Non-monotonic steps can occur when reusing a logdir with multiple summary writers and overlapping steps. Line charts, without this option enabled, can appear zig zagged. This is common when restarting from a checkpoint.\n\nWhen enabled, a non-monotonic time series composed of N monotonic pieces will be shown as N monotonic lines.",1,"info"],[1,"Histograms"],[1,"control-row","histogram-mode"],[1,"image"],[1,"control-row","image-brightness"],["id","image-brightness-label",1,"control-name"],["aria-labelledby","image-brightness-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","title","Reset brightness",1,"reset-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Reset brightness"):$localize`:A button to reset the image brightness setting␟c482b3a47ea0975fa8be01afb3fbec9b76628bd7␟1189161857240378395:Reset brightness`],["svgIcon","settings_backup_restore_24px"],[1,"control-row","image-contrast"],["id","image-constrast-label",1,"control-name"],["aria-labelledby","image-constrast-label","color","primary",3,"max","min","step","value","thumbLabel","displayWith","input"],["mat-icon-button","","title","Reset contrast",1,"reset-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Reset contrast"):$localize`:A button to reset the image contrast setting␟ed712a8b927041be15252b29eb521ebb1374bad8␟5370703342923611955:Reset contrast`],[1,"control-row","image-show-actual-size"]]},template:function t(n,e){1&n&&(Kg(0,"section",0),Kg(1,"h3",1),Jp(2,"General"),$g(),Kg(3,"div",2),Kg(4,"div",3),Jp(5,"Horizontal Axis"),$g(),Kg(6,"tb-dropdown",4),cp("selectionChange",(function t(n){return e.xAxisTypeChanged.emit(n)})),$g(),$g(),$g(),Kg(7,"section",5),Kg(8,"h3",1),Jp(9,"Scalars"),$g(),Kg(10,"div",6),Kg(11,"div",7),Jp(12,"Smoothing"),$g(),Kg(13,"div",8),Kg(14,"mat-slider",9),cp("input",(function t(n){return e.scalarSmoothingControlChanged$.emit(n.value)})),$g(),Kg(15,"input",10),cp("input",(function t(n){return e.onScalarSmoothingInput(n)})),$g(),$g(),$g(),Kg(16,"div",11),Kg(17,"div",12),Jp(18,"Tooltip sorting method"),$g(),Kg(19,"tb-dropdown",4),cp("selectionChange",(function t(n){return e.tooltipSortChanged.emit(n)})),$g(),$g(),Kg(20,"div",13),Kg(21,"mat-checkbox",14),cp("change",(function t(n){return e.ignoreOutliersChanged.emit(n.checked)})),Jp(22,"Ignore outliers in chart scaling"),$g(),$g(),Kg(23,"div",15),Kg(24,"mat-checkbox",14),cp("change",(function t(){return e.scalarPartitionXToggled.emit()})),Jp(25,"Partition non-monotonic X axis"),$g(),tp(26,"mat-icon",16),$g(),$g(),Kg(27,"section",17),Kg(28,"h3",1),Jp(29,"Histograms"),$g(),Kg(30,"div",18),Kg(31,"div",12),Jp(32,"Mode"),$g(),Kg(33,"tb-dropdown",4),cp("selectionChange",(function t(n){return e.histogramModeChanged.emit(n)})),$g(),$g(),$g(),Kg(34,"section",19),Kg(35,"h3",1),Jp(36,"Images"),$g(),Kg(37,"div",20),Kg(38,"div",21),Jp(39,"Brightness"),$g(),Kg(40,"div",8),Kg(41,"mat-slider",22),cp("input",(function t(n){return e.imageBrightnessSliderChanged$.emit(n.value)})),$g(),Kg(42,"button",23),lu(43,24),cp("click",(function t(){return e.imageBrightnessReset.emit()})),tp(44,"mat-icon",25),$g(),$g(),$g(),Kg(45,"div",26),Kg(46,"div",27),Jp(47,"Contrast"),$g(),Kg(48,"div",8),Kg(49,"mat-slider",28),cp("input",(function t(n){return e.imageContrastSliderChanged$.emit(n.value)})),$g(),Kg(50,"button",29),lu(51,30),cp("click",(function t(){return e.imageContrastReset.emit()})),tp(52,"mat-icon",25),$g(),$g(),$g(),Kg(53,"div",31),Kg(54,"mat-checkbox",14),cp("change",(function t(n){return e.imageShowActualSizeChanged.emit(n.checked)})),Jp(55,"Show actual image size"),$g(),$g(),$g()),2&n&&(ws(6),Jg("value",e.xAxisType)("options",e.XAxisTypeDropdownOptions),ws(8),Jg("max",e.MAX_SMOOTHING_SLIDER_VALUE)("min",0)("step",.01)("value",e.scalarSmoothing)("thumbLabel",!0),ws(1),Jg("max",e.MAX_SMOOTHING_VALUE)("value",e.scalarSmoothing),ws(4),Jg("value",e.tooltipSort)("options",e.TooltipSortDropdownOptions),ws(2),Jg("checked",e.ignoreOutliers),ws(3),Jg("checked",e.scalarPartitionX),ws(9),Jg("value",e.histogramMode)("options",e.HistogramModeDropdownOptions),ws(8),Jg("max",2e3)("min",0)("step",10)("value",e.imageBrightnessInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),ws(8),Jg("max",5e3)("min",0)("step",10)("value",e.imageContrastInMilli)("thumbLabel",!0)("displayWith",e.formatMilliToZeroth),ws(5),Jg("checked",e.imageShowActualSize))},directives:[Imt,XW,rV,BB,eA],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{color:#616161;font-size:12px}section[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb;padding:16px}.section-title[_ngcontent-%COMP%]{color:#212121;text-transform:uppercase;font-weight:500;font-size:13px;line-height:normal;margin:0 0 12px 0}section[_ngcontent-%COMP%]   .control-row[_ngcontent-%COMP%]:not(:last-child){margin-bottom:12px}.control-name[_ngcontent-%COMP%]{margin-bottom:8px}.slider-row[_ngcontent-%COMP%]{display:flex;align-items:center;height:28px}.slider-row[_ngcontent-%COMP%]   .reset-button[_ngcontent-%COMP%]{margin-left:6px}.slider-row[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{border:1px solid #8e98a3;border-radius:2px;box-sizing:border-box;height:100%;margin-left:12px;padding:0 4px}.scalars-smoothing[_ngcontent-%COMP%]   .slider-input[_ngcontent-%COMP%]{flex:none;width:5em}.scalars-partition-x[_ngcontent-%COMP%]{align-items:center;display:flex}.scalars-partition-x[_ngcontent-%COMP%]   .info[_ngcontent-%COMP%]{height:15px;margin-left:5px;width:15px}mat-slider[_ngcontent-%COMP%]{flex:1;margin-left:-8px;margin-right:-8px}tb-dropdown[_ngcontent-%COMP%]{display:block}'],changeDetection:0});class Fmt{constructor(t){this.store=t,this.tooltipSort$=this.store.select(dD),this.ignoreOutliers$=this.store.select(gD),this.xAxisType$=this.store.select(pD),this.histogramMode$=this.store.select(bD),this.scalarSmoothing$=this.store.select(uD),this.scalarPartitionX$=this.store.select(fD),this.imageBrightnessInMilli$=this.store.select(hD),this.imageContrastInMilli$=this.store.select(_D),this.imageShowActualSize$=this.store.select(CD)}onTooltipSortChanged(t){this.store.dispatch(mK({sort:t}))}onIgnoreOutliersChanged(){this.store.dispatch(dK())}onXAxisTypeChanged(t){this.store.dispatch(gK({xAxisType:t}))}onHistogramModeChanged(t){this.store.dispatch(MK({histogramMode:t}))}onScalarSmoothingChanged(t){this.store.dispatch(pK({smoothing:t}))}onScalarPartitionXToggled(){this.store.dispatch(bK())}onImageBrightnessInMilliChanged(t){this.store.dispatch(uK({brightnessInMilli:t}))}onImageBrightnessReset(){this.store.dispatch(hK())}onImageContrastReset(){this.store.dispatch(_K())}onImageContrastInMilliChanged(t){this.store.dispatch(fK({contrastInMilli:t}))}onImageShowActualSizeChanged(){this.store.dispatch(CK())}}Fmt.ɵfac=function t(n){return new(n||Fmt)(Zg(cv))},Fmt.ɵcmp=_o({type:Fmt,selectors:[["metrics-dashboard-settings"]],decls:10,vars:27,consts:[[3,"tooltipSort","ignoreOutliers","xAxisType","histogramMode","scalarSmoothing","scalarPartitionX","imageBrightnessInMilli","imageContrastInMilli","imageShowActualSize","tooltipSortChanged","ignoreOutliersChanged","xAxisTypeChanged","histogramModeChanged","scalarSmoothingChanged","scalarPartitionXToggled","imageBrightnessInMilliChanged","imageBrightnessReset","imageContrastInMilliChanged","imageContrastReset","imageShowActualSizeChanged"]],template:function t(n,e){1&n&&(Kg(0,"metrics-dashboard-settings-component",0),cp("tooltipSortChanged",(function t(n){return e.onTooltipSortChanged(n)}))("ignoreOutliersChanged",(function t(){return e.onIgnoreOutliersChanged()}))("xAxisTypeChanged",(function t(n){return e.onXAxisTypeChanged(n)}))("histogramModeChanged",(function t(n){return e.onHistogramModeChanged(n)}))("scalarSmoothingChanged",(function t(n){return e.onScalarSmoothingChanged(n)}))("scalarPartitionXToggled",(function t(){return e.onScalarPartitionXToggled()}))("imageBrightnessInMilliChanged",(function t(n){return e.onImageBrightnessInMilliChanged(n)}))("imageBrightnessReset",(function t(){return e.onImageBrightnessReset()}))("imageContrastInMilliChanged",(function t(n){return e.onImageContrastInMilliChanged(n)}))("imageContrastReset",(function t(){return e.onImageContrastReset()}))("imageShowActualSizeChanged",(function t(){return e.onImageShowActualSizeChanged()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),$g()),2&n&&Jg("tooltipSort",kf(1,9,e.tooltipSort$))("ignoreOutliers",kf(2,11,e.ignoreOutliers$))("xAxisType",kf(3,13,e.xAxisType$))("histogramMode",kf(4,15,e.histogramMode$))("scalarSmoothing",kf(5,17,e.scalarSmoothing$))("scalarPartitionX",kf(6,19,e.scalarPartitionX$))("imageBrightnessInMilli",kf(7,21,e.imageBrightnessInMilli$))("imageContrastInMilli",kf(8,23,e.imageContrastInMilli$))("imageShowActualSize",kf(9,25,e.imageShowActualSize$))},directives:[Nmt],pipes:[oO],encapsulation:2,changeDetection:0});class Lmt{}function Hmt(t,n){1&t&&tp(0,"metrics-filtered-view",8),2&t&&Jg("cardObserver",gp().cardObserver)}function Bmt(t,n){1&t&&tp(0,"metrics-pinned-view",8),2&t&&Jg("cardObserver",gp().cardObserver)}function Vmt(t,n){if(1&t){const t=op();Kg(0,"div",10),Kg(1,"div",11),Kg(2,"h2",12),Jp(3,"Settings"),$g(),Kg(4,"button",13),lu(5,14),cp("click",(function n(){return jr(t),gp().onCloseSidepaneButtonClicked.emit()})),tp(6,"mat-icon",15),$g(),$g(),tp(7,"metrics-dashboard-right-pane"),$g()}}Lmt.ɵfac=function t(n){return new(n||Lmt)},Lmt.ɵcmp=_o({type:Lmt,selectors:[["metrics-dashboard-right-pane"]],decls:1,vars:0,template:function t(n,e){1&n&&tp(0,"metrics-dashboard-settings")},directives:[Fmt],encapsulation:2,changeDetection:0});const jmt=function(t){return{checked:t,"settings-button":!0}};class Umt{constructor(t){this.host=t,this.onSettingsButtonClicked=new Ef,this.onCloseSidepaneButtonClicked=new Ef,this.cardObserver=new ZK(this.host.nativeElement,"600px 0px 600px 0px")}}Umt.ɵfac=function t(n){return new(n||Umt)(Zg(xu))},Umt.ɵcmp=_o({type:Umt,selectors:[["metrics-main-view-component"]],inputs:{showFilteredView:"showFilteredView",isSidepaneOpen:"isSidepaneOpen"},outputs:{onSettingsButtonClicked:"onSettingsButtonClicked",onCloseSidepaneButtonClicked:"onCloseSidepaneButtonClicked"},decls:13,vars:10,consts:function(){return[[1,"toolbar"],[1,"right-items"],["mat-stroked-button","",3,"ngClass","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle settings side pane"):$localize`:Label on a toolbar button to toggle the settings side pane.␟d3516db6bbe6860a55beab66e4969dac625b8d72␟7659285445580838925:Toggle settings side pane`],["svgIcon","settings_24px"],[1,"split-content"],["cdkScrollable","",1,"main"],[3,"cardObserver",4,"ngIf"],[3,"cardObserver"],["class","sidebar",4,"ngIf"],[1,"sidebar"],[1,"header"],[1,"title"],["mat-icon-button","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Close side pane"):$localize`:Label on a button to close the settings side pane.␟04521dc0b6a65cf5c382944c9a8b4b844a3e9598␟8156766997747165871:Close side pane`],["svgIcon","close_24px"]]},template:function t(n,e){1&n&&(Kg(0,"div",0),tp(1,"metrics-tag-filter"),Kg(2,"div",1),Kg(3,"button",2),lu(4,3),cp("click",(function t(){return e.onSettingsButtonClicked.emit()})),tp(5,"mat-icon",4),Jp(6," Settings "),$g(),$g(),$g(),Kg(7,"div",5),Kg(8,"div",6),Yg(9,Hmt,1,1,"metrics-filtered-view",7),Yg(10,Bmt,1,1,"metrics-pinned-view",7),tp(11,"metrics-card-groups",8),$g(),Yg(12,Vmt,8,0,"div",9),$g()),2&n&&(ws(3),Jg("ngClass",uf(8,jmt,e.isSidepaneOpen)),Ng("aria-pressed",e.isSidepaneOpen),ws(6),Jg("ngIf",e.showFilteredView),ws(1),Jg("ngIf",!e.showFilteredView),ws(1),Tp("display",e.showFilteredView?"none":""),Jg("cardObserver",e.cardObserver),ws(1),Jg("ngIf",e.isSidepaneOpen))},directives:[v$,eA,HM,BB,CA,WM,ymt,Smt,Tmt,Lmt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.toolbar[_ngcontent-%COMP%]{flex:none;display:flex;align-items:center;justify-content:space-between;height:48px;padding:0 16px;background-color:#fff;border-bottom:1px solid #ebebeb}.toolbar[_ngcontent-%COMP%]   metrics-tag-filter[_ngcontent-%COMP%]{flex:1 1 100px}.toolbar[_ngcontent-%COMP%]   .right-items[_ngcontent-%COMP%]{border-left:1px solid #ebebeb;margin-left:16px;padding-left:16px}.split-content[_ngcontent-%COMP%]{display:flex;overflow-y:auto;flex:1}.main[_ngcontent-%COMP%], .sidebar[_ngcontent-%COMP%]{overflow-x:hidden;overflow-y:auto;will-change:transform;contain:strict}.main[_ngcontent-%COMP%]{background-color:#f5f6f7;flex:1 1;display:flex;flex-direction:column}.main[_ngcontent-%COMP%]   metrics-filtered-view[_ngcontent-%COMP%], .main[_ngcontent-%COMP%]   metrics-pinned-view[_ngcontent-%COMP%]{border-bottom:1px solid #ebebeb}.sidebar[_ngcontent-%COMP%]{flex:0 0 250px;background-color:#fff;border-left:1px solid #ebebeb}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{display:flex;align-items:center;justify-content:space-between;height:42px;padding:0 16px;border-bottom:1px solid #ebebeb}.sidebar[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]   .title[_ngcontent-%COMP%]{font-size:18px;font-weight:400;line-height:normal;margin:0}.settings-button[_ngcontent-%COMP%]{color:#616161;display:inline-flex}.settings-button.checked[_ngcontent-%COMP%]{background-color:#e0e0e0;border-color:#e0e0e0}.settings-button[_ngcontent-%COMP%]     .mat-button-wrapper{display:inline-flex;align-items:center}.settings-button[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin-right:4px}'],changeDetection:0});class Wmt{constructor(t){this.store=t,this.isSidepaneOpen=!0,this.showFilteredView$=this.store.select(MD).pipe(ft((t=>t.length>0)))}onSettingsButtonClicked(){this.isSidepaneOpen=!this.isSidepaneOpen}onCloseSidepaneButtonClicked(){this.isSidepaneOpen=!1}}Wmt.ɵfac=function t(n){return new(n||Wmt)(Zg(cv))},Wmt.ɵcmp=_o({type:Wmt,selectors:[["metrics-main-view"]],decls:2,vars:4,consts:[[3,"showFilteredView","isSidepaneOpen","onSettingsButtonClicked","onCloseSidepaneButtonClicked"]],template:function t(n,e){1&n&&(Kg(0,"metrics-main-view-component",0),cp("onSettingsButtonClicked",(function t(){return e.onSettingsButtonClicked()}))("onCloseSidepaneButtonClicked",(function t(){return e.onCloseSidepaneButtonClicked()})),yf(1,"async"),$g()),2&n&&Jg("showFilteredView",kf(1,2,e.showFilteredView$))("isSidepaneOpen",e.isSidepaneOpen)},directives:[Umt],pipes:[oO],encapsulation:2,changeDetection:0});class Gmt{}Gmt.ɵfac=function t(n){return new(n||Gmt)},Gmt.ɵcmp=_o({type:Gmt,selectors:[["metrics-dashboard"]],decls:3,vars:0,template:function t(n,e){1&n&&(Kg(0,"nav"),tp(1,"runs-selector"),$g(),tp(2,"metrics-main-view"))},directives:[rK,Wmt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;height:100%}nav[_ngcontent-%COMP%]{border-right:1px solid #ebebeb;flex:none;width:340px}metrics-main-view[_ngcontent-%COMP%]{flex:1 1}'],changeDetection:0});class Ymt{}Ymt.ɵmod=xo({type:Ymt}),Ymt.ɵinj=Ge({factory:function t(n){return new(n||Ymt)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Ymt,{declarations:[Glt],exports:[Glt]});class qmt{}qmt.ɵmod=xo({type:qmt}),qmt.ɵinj=Ge({factory:function t(n){return new(n||qmt)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(qmt,{declarations:[S$],imports:[PO],exports:[S$]});class Zmt{}Zmt.ɵmod=xo({type:Zmt}),Zmt.ɵinj=Ge({factory:function t(n){return new(n||Zmt)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Zmt,{declarations:[z$,A$],imports:[PO],exports:[z$]});class Xmt{}Xmt.ɵmod=xo({type:Xmt}),Xmt.ɵinj=Ge({factory:function t(n){return new(n||Xmt)},imports:[[PO,Ymt,oA,VB,_Z,nq,Zmt,qmt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Xmt,{declarations:[Klt,Qlt],imports:[PO,Ymt,oA,VB,_Z,nq,Zmt,qmt],exports:[Klt]});class Jmt{}Jmt.ɵmod=xo({type:Jmt}),Jmt.ɵinj=Ge({factory:function t(n){return new(n||Jmt)},imports:[[PO,oA,VB,_Z,KW,Zmt,qmt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Jmt,{declarations:[B$,H$],imports:[PO,oA,VB,_Z,KW,Zmt,qmt],exports:[B$]});class Qmt{}Qmt.ɵmod=xo({type:Qmt}),Qmt.ɵinj=Ge({factory:function t(n){return new(n||Qmt)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Qmt,{declarations:[n0],exports:[n0]});class Kmt{}Kmt.ɵmod=xo({type:Kmt}),Kmt.ɵinj=Ge({factory:function t(n){return new(n||Kmt)},imports:[[PO,yz,oA,VB,xV,Fq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Kmt,{declarations:[hlt,dlt,$st],imports:[PO,yz,oA,VB,xV,Fq],exports:[hlt,dlt,$st]});class $mt{}$mt.ɵmod=xo({type:$mt}),$mt.ɵinj=Ge({factory:function t(n){return new(n||$mt)},imports:[[PO,yz,Kmt,nq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo($mt,{declarations:[klt],imports:[PO,yz,Kmt,nq],exports:[klt]});class tdt{}tdt.ɵmod=xo({type:tdt}),tdt.ɵinj=Ge({factory:function t(n){return new(n||tdt)},imports:[[PO,OH,oA,OB,xV,UH,ET]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(tdt,{declarations:[$$,K$],imports:[PO,OH,oA,OB,xV,UH,ET],exports:[$$]});class ndt{}ndt.ɵmod=xo({type:ndt}),ndt.ɵinj=Ge({factory:function t(n){return new(n||ndt)},imports:[[PO,tdt,Qmt,$mt,oA,VB,Fq,_Z,nq,qmt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(ndt,{declarations:[jlt,Flt],imports:[PO,tdt,Qmt,$mt,oA,VB,Fq,_Z,nq,qmt],exports:[jlt]});class edt{}edt.ɵmod=xo({type:edt}),edt.ɵinj=Ge({factory:function t(n){return new(n||edt)},imports:[[PO,Jmt,ndt,Xmt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(edt,{declarations:[XK,amt,omt],imports:[PO,Jmt,ndt,Xmt],exports:[XK,omt]});const adt=["button"],odt=new Fa("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS"),rdt=new Fa("MatButtonToggleGroup"),idt={provide:MF,useExisting:aa((()=>ldt)),multi:!0};let cdt=0;class sdt{constructor(t,n){this.source=t,this.value=n}}class ldt{constructor(t,n){this._changeDetector=t,this._vertical=!1,this._multiple=!1,this._disabled=!1,this._controlValueAccessorChangeFn=()=>{},this._onTouched=()=>{},this._name="mat-button-toggle-group-"+cdt++,this.valueChange=new Ef,this.change=new Ef,this.appearance=n&&n.appearance?n.appearance:"standard"}get name(){return this._name}set name(t){this._name=t,this._buttonToggles&&this._buttonToggles.forEach((t=>{t.name=this._name,t._markForCheck()}))}get vertical(){return this._vertical}set vertical(t){this._vertical=Gw(t)}get value(){const t=this._selectionModel?this._selectionModel.selected:[];return this.multiple?t.map((t=>t.value)):t[0]?t[0].value:void 0}set value(t){this._setSelectionByValue(t),this.valueChange.emit(this.value)}get selected(){const t=this._selectionModel?this._selectionModel.selected:[];return this.multiple?t:t[0]||null}get multiple(){return this._multiple}set multiple(t){this._multiple=Gw(t)}get disabled(){return this._disabled}set disabled(t){this._disabled=Gw(t),this._buttonToggles&&this._buttonToggles.forEach((t=>t._markForCheck()))}ngOnInit(){this._selectionModel=new mA(this.multiple,void 0,!1)}ngAfterContentInit(){this._selectionModel.select(...this._buttonToggles.filter((t=>t.checked)))}writeValue(t){this.value=t,this._changeDetector.markForCheck()}registerOnChange(t){this._controlValueAccessorChangeFn=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this.disabled=t}_emitChangeEvent(){const t=this.selected,n=Array.isArray(t)?t[t.length-1]:t,e=new sdt(n,this.value);this._controlValueAccessorChangeFn(e.value),this.change.emit(e)}_syncButtonToggle(t,n,e=!1,a=!1){this.multiple||!this.selected||t.checked||(this.selected.checked=!1),this._selectionModel?n?this._selectionModel.select(t):this._selectionModel.deselect(t):a=!0,a?Promise.resolve().then((()=>this._updateModelValue(e))):this._updateModelValue(e)}_isSelected(t){return this._selectionModel&&this._selectionModel.isSelected(t)}_isPrechecked(t){return void 0!==this._rawValue&&(this.multiple&&Array.isArray(this._rawValue)?this._rawValue.some((n=>null!=t.value&&n===t.value)):t.value===this._rawValue)}_setSelectionByValue(t){if(this._rawValue=t,this._buttonToggles)if(this.multiple&&t){if(!Array.isArray(t)&&("undefined"==typeof ngDevMode||ngDevMode))throw Error("Value must be an array in multiple-selection mode.");this._clearSelection(),t.forEach((t=>this._selectValue(t)))}else this._clearSelection(),this._selectValue(t)}_clearSelection(){this._selectionModel.clear(),this._buttonToggles.forEach((t=>t.checked=!1))}_selectValue(t){const n=this._buttonToggles.find((n=>null!=n.value&&n.value===t));n&&(n.checked=!0,this._selectionModel.select(n))}_updateModelValue(t){t&&this._emitChangeEvent(),this.valueChange.emit(this.value)}}ldt.ɵfac=function t(n){return new(n||ldt)(Zg(Vm),Zg(odt,8))},ldt.ɵdir=vo({type:ldt,selectors:[["mat-button-toggle-group"]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,ddt,!0),2&n&&Vf(o=Zf())&&(e._buttonToggles=o)},hostAttrs:["role","group",1,"mat-button-toggle-group"],hostVars:5,hostBindings:function t(n,e){2&n&&(Ng("aria-disabled",e.disabled),Dp("mat-button-toggle-vertical",e.vertical)("mat-button-toggle-group-appearance-standard","standard"===e.appearance))},inputs:{appearance:"appearance",name:"name",vertical:"vertical",value:"value",multiple:"multiple",disabled:"disabled"},outputs:{valueChange:"valueChange",change:"change"},exportAs:["matButtonToggleGroup"],features:[Mu([idt,{provide:rdt,useExisting:ldt}])]}),ldt.ctorParameters=()=>[{type:Vm},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[odt]}]}],ldt.propDecorators={_buttonToggles:[{type:qd,args:[aa((()=>ddt)),{descendants:!0}]}],appearance:[{type:f_}],name:[{type:f_}],vertical:[{type:f_}],value:[{type:f_}],valueChange:[{type:h_}],multiple:[{type:f_}],disabled:[{type:f_}],change:[{type:h_}]};const mdt=aE(class{});class ddt extends mdt{constructor(t,n,e,a,o,r){super(),this._changeDetectorRef=n,this._elementRef=e,this._focusMonitor=a,this._isSingleSelector=!1,this._checked=!1,this.ariaLabelledby=null,this._disabled=!1,this.change=new Ef;const i=Number(o);this.tabIndex=i||0===i?i:null,this.buttonToggleGroup=t,this.appearance=r&&r.appearance?r.appearance:"standard"}get buttonId(){return`${this.id}-button`}get appearance(){return this.buttonToggleGroup?this.buttonToggleGroup.appearance:this._appearance}set appearance(t){this._appearance=t}get checked(){return this.buttonToggleGroup?this.buttonToggleGroup._isSelected(this):this._checked}set checked(t){const n=Gw(t);n!==this._checked&&(this._checked=n,this.buttonToggleGroup&&this.buttonToggleGroup._syncButtonToggle(this,this._checked),this._changeDetectorRef.markForCheck())}get disabled(){return this._disabled||this.buttonToggleGroup&&this.buttonToggleGroup.disabled}set disabled(t){this._disabled=Gw(t)}ngOnInit(){const t=this.buttonToggleGroup;this._isSingleSelector=t&&!t.multiple,this.id=this.id||"mat-button-toggle-"+cdt++,this._isSingleSelector&&(this.name=t.name),t&&(t._isPrechecked(this)?this.checked=!0:t._isSelected(this)!==this._checked&&t._syncButtonToggle(this,this._checked))}ngAfterViewInit(){this._focusMonitor.monitor(this._elementRef,!0)}ngOnDestroy(){const t=this.buttonToggleGroup;this._focusMonitor.stopMonitoring(this._elementRef),t&&t._isSelected(this)&&t._syncButtonToggle(this,!1,!1,!0)}focus(t){this._buttonElement.nativeElement.focus(t)}_onButtonClick(){const t=!!this._isSingleSelector||!this._checked;t!==this._checked&&(this._checked=t,this.buttonToggleGroup&&(this.buttonToggleGroup._syncButtonToggle(this,this._checked,!0),this.buttonToggleGroup._onTouched())),this.change.emit(new sdt(this,this.value))}_markForCheck(){this._changeDetectorRef.markForCheck()}}ddt.ɵfac=function t(n){return new(n||ddt)(Zg(rdt,8),Zg(Vm),Zg(xu),Zg(TS),Xg("tabindex"),Zg(odt,8))},ddt.ɵcmp=_o({type:ddt,selectors:[["mat-button-toggle"]],viewQuery:function t(n,e){var a;1&n&&Uf(adt,!0),2&n&&Vf(a=Zf())&&(e._buttonElement=a.first)},hostAttrs:[1,"mat-button-toggle"],hostVars:11,hostBindings:function t(n,e){1&n&&cp("focus",(function t(){return e.focus()})),2&n&&(Ng("tabindex",-1)("id",e.id)("name",null),Dp("mat-button-toggle-standalone",!e.buttonToggleGroup)("mat-button-toggle-checked",e.checked)("mat-button-toggle-disabled",e.disabled)("mat-button-toggle-appearance-standard","standard"===e.appearance))},inputs:{disableRipple:"disableRipple",ariaLabelledby:["aria-labelledby","ariaLabelledby"],tabIndex:"tabIndex",appearance:"appearance",checked:"checked",disabled:"disabled",id:"id",name:"name",ariaLabel:["aria-label","ariaLabel"],value:"value"},outputs:{change:"change"},exportAs:["matButtonToggle"],features:[hg],ngContentSelectors:["*"],decls:6,vars:9,consts:[["type","button",1,"mat-button-toggle-button","mat-focus-indicator",3,"id","disabled","click"],["button",""],[1,"mat-button-toggle-label-content"],[1,"mat-button-toggle-focus-overlay"],["matRipple","",1,"mat-button-toggle-ripple",3,"matRippleTrigger","matRippleDisabled"]],template:function t(n,e){if(1&n&&(bp(),Kg(0,"button",0,1),cp("click",(function t(){return e._onButtonClick()})),Kg(2,"span",2),hp(3),$g(),$g(),tp(4,"span",3),tp(5,"span",4)),2&n){const t=qg(1);Jg("id",e.buttonId)("disabled",e.disabled||null),Ng("tabindex",e.disabled?-1:e.tabIndex)("aria-pressed",e.checked)("name",e.name||null)("aria-label",e.ariaLabel)("aria-labelledby",e.ariaLabelledby),ws(5),Jg("matRippleTrigger",t)("matRippleDisabled",e.disableRipple||e.disabled)}},directives:[zE],styles:[".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:transparent}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.cdk-high-contrast-active .mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:.5}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}.cdk-high-contrast-active .mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.5}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{border-radius:inherit;pointer-events:none;opacity:0;top:0;left:0;right:0;bottom:0;position:absolute}.mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}\n"],encapsulation:2,changeDetection:0}),ddt.ctorParameters=()=>[{type:ldt,decorators:[{type:Ne},{type:Ie,args:[rdt]}]},{type:Vm},{type:xu},{type:TS},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[odt]}]}],ddt.propDecorators={ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}],_buttonElement:[{type:Xd,args:["button"]}],id:[{type:f_}],name:[{type:f_}],value:[{type:f_}],tabIndex:[{type:f_}],appearance:[{type:f_}],checked:[{type:f_}],disabled:[{type:f_}],change:[{type:h_}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class gdt{}gdt.ɵmod=xo({type:gdt}),gdt.ɵinj=Ge({factory:function t(n){return new(n||gdt)},imports:[[tE,RE],tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(gdt,{declarations:function(){return[ldt,ddt]},imports:function(){return[tE,RE]},exports:function(){return[tE,ldt,ddt]}});class pdt{}pdt.ɵmod=xo({type:pdt}),pdt.ɵinj=Ge({factory:function t(n){return new(n||pdt)},imports:[[PO,UH]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(pdt,{declarations:[Imt],imports:[PO,UH],exports:[Imt]});class bdt{}bdt.ɵmod=xo({type:bdt}),bdt.ɵinj=Ge({factory:function t(n){return new(n||bdt)},imports:[[PO,pdt,oA,gdt,mV,VB,UH,KW]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(bdt,{declarations:[Lmt,Nmt,Fmt],imports:[PO,pdt,oA,gdt,mV,VB,UH,KW],exports:[Lmt]});class udt{}udt.ɵmod=xo({type:udt}),udt.ɵinj=Ge({factory:function t(n){return new(n||udt)},imports:[[edt,PO,P$,oA,VB,xV,bdt,vA]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(udt,{declarations:[_mt,Cmt,Pmt,ymt,vmt,Smt,Umt,Wmt,k$,v$,Rmt,Tmt],imports:[edt,PO,P$,oA,VB,xV,bdt,vA],exports:[Wmt]});class fdt{}fdt.ɵmod=xo({type:fdt}),fdt.ɵinj=Ge({factory:function t(n){return new(n||fdt)},imports:[[PO,bdt,iK,udt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(fdt,{declarations:[Gmt],imports:[PO,bdt,iK,udt],exports:[Gmt]});class hdt{}hdt.ɵmod=xo({type:hdt}),hdt.ɵinj=Ge({factory:function t(n){return new(n||hdt)},providers:[{provide:GK,useFactory:function _dt(t){return t?{initialState:Object.assign(Object.assign({},LK),{settings:t})}:{initialState:LK}},deps:[YK]},{provide:YK,useValue:YT}],imports:[[PO,iK,gq.forPlugin(dT,Gmt),ET,fdt,Iv.forFeature(GT,(function Cdt(t,n){return zK(HK,FK)(t,n)}),GK),fw.forFeature([WK]),Mw.registerAlertActions((function Mdt(){return[{actionCreator:SK,alertFromAction:t=>{const{wasPinned:n,canCreateNewPins:e}=t;return n||e?null:{localizedMessage:"Max pin limit exceeded. Remove existing pins before adding more. See https://github.com/tensorflow/tensorboard/issues/4242"}}}]}))]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(hdt,{imports:[PO,iK,gq,ET,fdt,Dv,uw,Mw]});const Odt="npmi";var Pdt,xdt,ydt,kdt;!(function(t){t[t.AND=0]="AND"})(Pdt||(Pdt={})),(function(t){t[t.METRIC=0]="METRIC",t[t.OPERATOR=1]="OPERATOR"})(xdt||(xdt={})),(function(t){t[t.DEFAULT=0]="DEFAULT",t[t.EMBEDDINGS=1]="EMBEDDINGS"})(ydt||(ydt={})),(function(t){t[t.DESCENDING=0]="DESCENDING",t[t.ASCENDNG=1]="ASCENDNG",t[t.SIMILAR=2]="SIMILAR",t[t.DISSIMILAR=3]="DISSIMILAR"})(kdt||(kdt={}));class vdt{}vdt.ɵfac=function t(n){return new(n||vdt)},vdt.ɵcmp=_o({type:vdt,selectors:[["npmi-inactive-view"]],decls:6,vars:0,consts:[[1,"container"],[1,"title"]],template:function t(n,e){1&n&&(Kg(0,"div"),Kg(1,"div",0),Kg(2,"div",1),Jp(3,"nPMI is inactive because no data is available."),$g(),Kg(4,"div"),Jp(5," To use the nPMI, calculate nPMI values, and log them using the summary writer. "),$g(),$g(),$g())},styles:[".container[_ngcontent-%COMP%] {\n  height: 100%;\n  font-family: Roboto;\n  font-size: 15px;\n  padding: 50px;\n}\n\n.title[_ngcontent-%COMP%] {\n  font-size: 135%;\n  font-weight: bold;\n  margin-bottom: 25px;\n}"]});const wdt=uv(Odt),Sdt=pv(wdt,(t=>t.pluginDataLoaded.state)),Edt=pv(wdt,(t=>t.annotationData)),Adt=pv(wdt,(t=>t.runToMetrics)),zdt=pv(wdt,(t=>t.embeddingDataSet)),Rdt=pv(wdt,(t=>t.selectedAnnotations)),Tdt=pv(wdt,(t=>t.flaggedAnnotations)),Ddt=pv(wdt,(t=>t.hiddenAnnotations)),Idt=pv(wdt,(t=>t.annotationsRegex)),Ndt=pv(wdt,(t=>t.metricsRegex)),Fdt=pv(wdt,(t=>t.metricArithmetic)),Ldt=pv(wdt,(t=>t.metricFilters)),Hdt=pv(wdt,(t=>t.sort)),Bdt=pv(wdt,(t=>t.pcExpanded)),Vdt=pv(wdt,(t=>t.annotationsExpanded)),jdt=pv(wdt,(t=>t.sidebarExpanded)),Udt=pv(wdt,(t=>t.showCounts)),Wdt=pv(wdt,(t=>t.showHiddenAnnotations)),Gdt=pv(wdt,(t=>t.viewActive)),Ydt=pv(wdt,(t=>t.sidebarWidth)),qdt=pv(wdt,(t=>t.embeddingsMetric)),Zdt=pv(wdt,(t=>t.embeddingsSidebarWidth)),Xdt=pv(wdt,(t=>t.embeddingsSidebarExpanded)),Jdt=Ok("[NPMI] nPMI Loaded"),Qdt=Ok("[NPMI] nPMI Plugin Data Requested"),Kdt=Ok("[NPMI] nPMI Plugin Data Loaded",{_as:"props",_p:void 0}),$dt=Ok("[NPMI] nPMI Plugin Data Request Failed"),tgt=Ok("[NPMI] Adding/Removing Annotations to/from Selected",{_as:"props",_p:void 0}),ngt=Ok("[NPMI] Annotations Set",{_as:"props",_p:void 0}),egt=Ok("[NPMI] Clearing the Annotation Selection"),agt=Ok("[NPMI] Adding/Removing Annotations to/from Flagged",{_as:"props",_p:void 0}),ogt=Ok("[NPMI] Adding/Removing Annotations to/from Hidden",{_as:"props",_p:void 0}),rgt=Ok("[NPMI] Annotations Regex Changed",{_as:"props",_p:void 0}),igt=Ok("[NPMI] Metrics Regex Changed",{_as:"props",_p:void 0}),cgt=Ok("[NPMI] Metric Filter Added",{_as:"props",_p:void 0}),sgt=Ok("[NPMI] Metric Filter Removed",{_as:"props",_p:void 0}),lgt=Ok("[NPMI] Metric Filter Changed",{_as:"props",_p:void 0}),mgt=Ok("[NPMI] Annotation Sort Changed",{_as:"props",_p:void 0}),dgt=Ok("[NPMI] Similarity Sort Changed",{_as:"props",_p:void 0}),ggt=Ok("[NPMI] Toggle PC Expanded"),pgt=Ok("[NPMI] Toggle Annotations Expanded"),bgt=Ok("[NPMI] Toggle Sidebar Expanded"),ugt=Ok("[NPMI] Show Counts Toggled"),fgt=Ok("[NPMI] Show Hidden Annotations Toggled"),hgt=Ok("[NPMI] Embeddings View Toggled",{_as:"props",_p:void 0}),_gt=Ok("[NPMI] Sidebar Width Changed",{_as:"props",_p:void 0}),Cgt=Ok("[NPMI] Embeddings Sidebar Width Changed",{_as:"props",_p:void 0}),Mgt=Ok("[NPMI] Toggle Embeddings Sidebar Expanded"),Ogt=Ok("[NPMI] Change Embedding DataSet",{_as:"props",_p:void 0});function Pgt(t){return t.startsWith("count@")}function xgt(t){return t.startsWith("nPMI@")||t.startsWith("nPMI_diff@")}function ygt(t){return t.startsWith("nPMI@")}function kgt(t){return t.split("@",2)[1]}const vgt=Uv({pluginDataLoaded:{state:fR.NOT_LOADED,lastLoadedTimeInMs:null},annotationData:{},runToMetrics:{},selectedAnnotations:[],flaggedAnnotations:[],hiddenAnnotations:[],annotationsRegex:"",metricsRegex:"",metricArithmetic:[],metricFilters:{},sort:{metric:"",order:kdt.DESCENDING},pcExpanded:!0,annotationsExpanded:!0,sidebarExpanded:!0,showCounts:!0,showHiddenAnnotations:!1,sidebarWidth:300,viewActive:ydt.DEFAULT,embeddingsMetric:"",embeddingsSidebarWidth:500,embeddingsSidebarExpanded:!0},jv(Qdt,(t=>Object.assign(Object.assign({},t),{pluginDataLoaded:Object.assign(Object.assign({},t.pluginDataLoaded),{state:fR.LOADING})}))),jv($dt,(t=>Object.assign(Object.assign({},t),{pluginDataLoaded:Object.assign(Object.assign({},t.pluginDataLoaded),{state:fR.FAILED})}))),jv(Kdt,((t,{annotationData:n,metrics:e,embeddingDataSet:a})=>{const o={};for(const t in e){o[t]=[];for(const n of e[t])xgt(n)&&o[t].push(n)}return Object.assign(Object.assign({},t),{runToMetrics:o,annotationData:n,embeddingDataSet:a,pluginDataLoaded:{state:fR.LOADED,lastLoadedTimeInMs:Date.now()}})})),jv(tgt,((t,{annotations:n})=>{const e=new Set([...t.selectedAnnotations,...n]);if(e.size===t.selectedAnnotations.length)for(const t of n)e.delete(t);return Object.assign(Object.assign({},t),{selectedAnnotations:[...e]})})),jv(ngt,((t,{annotations:n})=>Object.assign(Object.assign({},t),{selectedAnnotations:n}))),jv(egt,(t=>Object.assign(Object.assign({},t),{selectedAnnotations:[]}))),jv(agt,((t,{annotations:n})=>{const e=new Set([...t.flaggedAnnotations,...n]);if(e.size===t.flaggedAnnotations.length)for(const t of n)e.delete(t);return Object.assign(Object.assign({},t),{flaggedAnnotations:[...e],selectedAnnotations:[]})})),jv(ogt,((t,{annotations:n})=>{const e=new Set([...t.hiddenAnnotations,...n]);if(e.size===t.hiddenAnnotations.length)for(const t of n)e.delete(t);return Object.assign(Object.assign({},t),{hiddenAnnotations:[...e],selectedAnnotations:[]})})),jv(rgt,((t,{regex:n})=>Object.assign(Object.assign({},t),{annotationsRegex:n}))),jv(igt,((t,{regex:n})=>Object.assign(Object.assign({},t),{metricsRegex:n}))),jv(cgt,((t,{metric:n})=>{if(t.metricFilters[n])return t;const e=[];return 0!==t.metricArithmetic.length&&e.push({kind:xdt.OPERATOR,operator:Pdt.AND}),e.push({kind:xdt.METRIC,metric:n}),Object.assign(Object.assign({},t),{metricArithmetic:[...t.metricArithmetic,...e],metricFilters:Object.assign(Object.assign({},t.metricFilters),{[n]:{max:1,min:-1,includeNaN:!1}}),sort:{metric:n,order:kdt.DESCENDING}})})),jv(sgt,((t,{metric:n})=>{if(!t.metricFilters[n])return t;let e=0,a=0,o=2;const r=_R(t.metricFilters,["symbol"==typeof n?n:n+""]);for(const a in t.metricArithmetic){const o=t.metricArithmetic[a];o.kind===xdt.METRIC&&o.metric===n&&(e=parseInt(a))}return 0!==e&&(a=e-1,o=e+1),Object.assign(Object.assign({},t),{metricArithmetic:[...t.metricArithmetic.slice(0,a),...t.metricArithmetic.slice(o)],metricFilters:r})})),jv(lgt,((t,{metric:n,max:e,min:a,includeNaN:o})=>t.metricFilters[n]?Object.assign(Object.assign({},t),{metricFilters:Object.assign(Object.assign({},t.metricFilters),{[n]:{max:e,min:a,includeNaN:o}})}):t)),jv(mgt,((t,{metric:n})=>{const e={metric:n,order:kdt.DESCENDING};return t.sort.metric===n&&t.sort.order===kdt.DESCENDING&&(e.order=kdt.ASCENDNG),Object.assign(Object.assign({},t),{sort:e})})),jv(dgt,((t,{annotation:n})=>{const e={metric:n,order:kdt.SIMILAR};return t.sort.metric===n&&t.sort.order===kdt.SIMILAR&&(e.order=kdt.DISSIMILAR),Object.assign(Object.assign({},t),{sort:e})})),jv(ggt,(t=>Object.assign(Object.assign({},t),{pcExpanded:!t.pcExpanded}))),jv(pgt,(t=>Object.assign(Object.assign({},t),{annotationsExpanded:!t.annotationsExpanded}))),jv(bgt,(t=>Object.assign(Object.assign({},t),{sidebarExpanded:!t.sidebarExpanded}))),jv(ugt,(t=>Object.assign(Object.assign({},t),{showCounts:!t.showCounts}))),jv(fgt,(t=>Object.assign(Object.assign({},t),{showHiddenAnnotations:!t.showHiddenAnnotations}))),jv(hgt,((t,{metric:n})=>{let e=ydt.EMBEDDINGS,a=n;return n===t.embeddingsMetric&&(e=ydt.DEFAULT,a=""),Object.assign(Object.assign({},t),{viewActive:e,embeddingsMetric:a})})),jv(_gt,((t,{sidebarWidth:n})=>Object.assign(Object.assign({},t),{sidebarWidth:n}))),jv(Cgt,((t,{sidebarWidth:n})=>Object.assign(Object.assign({},t),{embeddingsSidebarWidth:n}))),jv(Mgt,(t=>Object.assign(Object.assign({},t),{embeddingsSidebarExpanded:!t.embeddingsSidebarExpanded}))),jv(Ogt,((t,{dataSet:n})=>Object.assign(Object.assign({},t),{embeddingDataSet:n}))));function wgt(t,n){1&t&&tp(0,"mat-icon",7)}function Sgt(t,n){if(1&t&&(Kg(0,"mat-option",8),Jp(1),$g()),2&t){const t=n.$implicit;Jg("value",t),ws(1),Qp(t)}}class Egt{constructor(){this.onRegexFilterValueChange=new Ef,this.onAddFilter=new Ef}onOptionSelected(t,n){this.onAddFilter.emit(t.option.value),n.value=""}}Egt.ɵfac=function t(n){return new(n||Egt)},Egt.ɵcmp=_o({type:Egt,selectors:[["metric-search-component"]],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("valid",e.isRegexFilterValid)},inputs:{completions:"completions",regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange",onAddFilter:"onAddFilter"},decls:7,vars:4,consts:[["svgIcon","search_24px"],["matInput","","autocomplete","off","placeholder","Add Metric Filter",3,"value","matAutocomplete","input"],["matInput",""],["svgIcon","error_24px","class","error-icon","matTooltip","Invalid regex filter. The result may be stale.",4,"ngIf"],["autoActiveFirstOption","",3,"optionSelected"],["filterMatches","matAutocomplete"],[3,"value",4,"ngFor","ngForOf"],["svgIcon","error_24px","matTooltip","Invalid regex filter. The result may be stale.",1,"error-icon"],[3,"value"]],template:function t(n,e){if(1&n){const t=op();tp(0,"mat-icon",0),Kg(1,"input",1,2),cp("input",(function t(n){return e.onRegexFilterValueChange.emit(n.target.value)})),$g(),Yg(3,wgt,1,0,"mat-icon",3),Kg(4,"mat-autocomplete",4,5),cp("optionSelected",(function n(a){jr(t);const o=qg(2);return e.onOptionSelected(a,o)})),Yg(6,Sgt,2,2,"mat-option",6),$g()}if(2&n){const t=qg(5);ws(1),Jg("value",e.regexFilterValue)("matAutocomplete",t),ws(2),Jg("ngIf",!e.isRegexFilterValid),ws(3),Jg("ngForOf",e.completions)}},directives:[BB,PV,M$,WM,m$,jM,YE],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}mat-icon[_ngcontent-%COMP%]{flex:none;margin-right:5px}[_nghost-%COMP%]{display:flex;padding:0 10px;position:relative;font-size:.9em}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   input[_ngcontent-%COMP%]{caret-color:currentColor}'],changeDetection:0});class Agt{constructor(t){this.store=t,this.metricsRegex$=this.store.select(Ndt),this.activeRuns$=this.store.pipe(lv(KD)).pipe(ft((t=>t?Array.from(t.entries()).filter((t=>t[1])).map((t=>t[0])):[]))),this.metricsForActiveRuns$=Et(this.activeRuns$,this.store.select(Adt)).pipe(ft((([t,n])=>{const e=new Set;for(const a of t)if(n[a])for(const t of n[a])e.add(t);return[...e]}))),this.isMetricsFilterValid$=this.metricsRegex$.pipe(ft((t=>{try{return Boolean(new RegExp(t))}catch(t){return!1}}))),this.metricFilterKeys$=this.store.pipe(lv(Ldt)).pipe(ft((t=>Object.keys(t)))),this.completions$=Et(this.metricsForActiveRuns$,this.metricsRegex$,this.metricFilterKeys$).pipe(ft((([t,n,e])=>{const a=t.filter((t=>!e.includes(t)));try{const t=new RegExp(n,"i");return a.filter((n=>t.test(n))).sort()}catch(t){return[]}})))}onFilterChange(t){this.store.dispatch(igt({regex:t}))}onAddFilter(t){this.store.dispatch(cgt({metric:t})),this.store.dispatch(igt({regex:""}))}}function zgt(t,n,e){const a=[[n,...e]];if(!e.length||!t.length)return"data:text/csv;charset=utf-8,"+a.map((t=>t.join(","))).join("\n");const o=e.map((t=>kgt(t)));for(const[e,r]of t){const t=r.filter((t=>t.run===n));if(t.length){const n=[e];for(const e of o){const a=t.find((t=>t.metric===e));n.push(void 0===a?"null":`${a.nPMIValue}`)}a.push(n)}}return"data:text/csv;charset=utf-8,"+a.map((t=>t.join(","))).join("\n")}Agt.ɵfac=function t(n){return new(n||Agt)(Zg(cv))},Agt.ɵcmp=_o({type:Agt,selectors:[["npmi-metric-search"]],decls:4,vars:9,consts:[[3,"regexFilterValue","completions","isRegexFilterValid","onRegexFilterValueChange","onAddFilter"]],template:function t(n,e){1&n&&(Kg(0,"metric-search-component",0),cp("onRegexFilterValueChange",(function t(n){return e.onFilterChange(n)}))("onAddFilter",(function t(n){return e.onAddFilter(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("regexFilterValue",kf(1,3,e.metricsRegex$))("completions",kf(2,5,e.completions$))("isRegexFilterValid",kf(3,7,e.isMetricsFilterValid$))},directives:[Egt],pipes:[oO],encapsulation:2,changeDetection:0});const Rgt=function(t){return{"active-button":t}};class Tgt{downloadResults(){for(const t of this.runs){const n=zgt(this.flaggedData,t,this.metrics),e=document.createElement("a");e.setAttribute("href",n),e.setAttribute("download",`report_${t}.csv`),e.click()}}}Tgt.ɵfac=function t(n){return new(n||Tgt)},Tgt.ɵcmp=_o({type:Tgt,selectors:[["results-download-component"]],inputs:{numFlaggedAnnotations:"numFlaggedAnnotations",runs:"runs",flaggedData:"flaggedData",metrics:"metrics"},decls:4,vars:5,consts:[["mat-stroked-button","","title","Export CSV reports of all flagged annotations. Will generate one CSV per active run.",3,"disabled","ngClass","click"],[1,"button-contents"],["svgIcon","get_app_24px"]],template:function t(n,e){1&n&&(Kg(0,"button",0),cp("click",(function t(){return e.downloadResults()})),Kg(1,"span",1),tp(2,"mat-icon",2),Jp(3),$g(),$g()),2&n&&(Jg("disabled",0===e.numFlaggedAnnotations)("ngClass",uf(3,Rgt,e.numFlaggedAnnotations>0)),ws(3),Kp(" Flagged Rows (",e.numFlaggedAnnotations,") "))},directives:[eA,HM,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.active-button[_ngcontent-%COMP%]{background-color:#ff9800;border:1px solid #ebebeb;color:#fff}.button-contents[_ngcontent-%COMP%]{align-items:center;display:flex;text-transform:uppercase}mat-icon[_ngcontent-%COMP%]{margin-right:6px}'],changeDetection:0});class Dgt{constructor(t){this.store=t,this.flaggedAnnotations$=this.store.select(Tdt),this.numFlaggedAnnotations$=this.flaggedAnnotations$.pipe(ft((t=>t.length))),this.activeRuns$=this.store.select(KD).pipe(ft((t=>t?Array.from(t.entries()).filter((t=>t[1])).map((t=>t[0])):[]))),this.flaggedData$=Et([this.store.select(Edt),this.flaggedAnnotations$]).pipe(ft((([t,n])=>{const e=new Set(n);return Object.entries(t).filter((t=>e.has(t[0])))}))),this.metrics$=Et([this.store.select(Adt),this.activeRuns$,this.store.select(Ldt)]).pipe(ft((([t,n,e])=>{let a=Object.keys(e);for(const e of n)t[e]&&(a=a.concat(t[e].filter((t=>ygt(t)))));return a=[...new Set(a)],a})))}}Dgt.ɵfac=function t(n){return new(n||Dgt)(Zg(cv))},Dgt.ɵcmp=_o({type:Dgt,selectors:[["npmi-results-download"]],decls:5,vars:12,consts:[[3,"numFlaggedAnnotations","runs","flaggedData","metrics"]],template:function t(n,e){1&n&&(tp(0,"results-download-component",0),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async")),2&n&&Jg("numFlaggedAnnotations",kf(1,4,e.numFlaggedAnnotations$))("runs",kf(2,6,e.activeRuns$))("flaggedData",kf(3,8,e.flaggedData$))("metrics",kf(4,10,e.metrics$))},directives:[Tgt],pipes:[oO],encapsulation:2,changeDetection:0});const Igt=new Fa("MatChipRemove"),Ngt=new Fa("MatChipAvatar"),Fgt=new Fa("MatChipTrailingIcon"),Lgt=oE(eE(aE(class{constructor(t){this._elementRef=t}}),"primary"),-1);class Hgt{}Hgt.ɵfac=function t(n){return new(n||Hgt)},Hgt.ɵdir=vo({type:Hgt,selectors:[["mat-chip-avatar"],["","matChipAvatar",""]],hostAttrs:[1,"mat-chip-avatar"],features:[Mu([{provide:Ngt,useExisting:Hgt}])]});class Bgt{}Bgt.ɵfac=function t(n){return new(n||Bgt)},Bgt.ɵdir=vo({type:Bgt,selectors:[["mat-chip-trailing-icon"],["","matChipTrailingIcon",""]],hostAttrs:[1,"mat-chip-trailing-icon"],features:[Mu([{provide:Fgt,useExisting:Bgt}])]});class Vgt extends Lgt{constructor(t,n,e,a,o,r,i,c){super(t),this._elementRef=t,this._ngZone=n,this._changeDetectorRef=r,this._hasFocus=!1,this.chipListSelectable=!0,this._chipListMultiple=!1,this._chipListDisabled=!1,this._selected=!1,this._selectable=!0,this._disabled=!1,this._removable=!0,this._onFocus=new x,this._onBlur=new x,this.selectionChange=new Ef,this.destroyed=new Ef,this.removed=new Ef,this._addHostClassName(),this._chipRippleTarget=(c||document).createElement("div"),this._chipRippleTarget.classList.add("mat-chip-ripple"),this._elementRef.nativeElement.appendChild(this._chipRippleTarget),this._chipRipple=new EE(this,n,this._chipRippleTarget,e),this._chipRipple.setupTriggerEvents(t),this.rippleConfig=a||{},this._animationsDisabled="NoopAnimations"===o,this.tabIndex=null!=i&&parseInt(i)||-1}get rippleDisabled(){return this.disabled||this.disableRipple||!!this.rippleConfig.disabled}get selected(){return this._selected}set selected(t){const n=Gw(t);n!==this._selected&&(this._selected=n,this._dispatchSelectionChange())}get value(){return void 0!==this._value?this._value:this._elementRef.nativeElement.textContent}set value(t){this._value=t}get selectable(){return this._selectable&&this.chipListSelectable}set selectable(t){this._selectable=Gw(t)}get disabled(){return this._chipListDisabled||this._disabled}set disabled(t){this._disabled=Gw(t)}get removable(){return this._removable}set removable(t){this._removable=Gw(t)}get ariaSelected(){return this.selectable&&(this._chipListMultiple||this.selected)?this.selected.toString():null}_addHostClassName(){const t="mat-basic-chip",n=this._elementRef.nativeElement;n.hasAttribute(t)||n.tagName.toLowerCase()===t?n.classList.add(t):n.classList.add("mat-standard-chip")}ngOnDestroy(){this.destroyed.emit({chip:this}),this._chipRipple._removeTriggerEvents()}select(){this._selected||(this._selected=!0,this._dispatchSelectionChange(),this._markForCheck())}deselect(){this._selected&&(this._selected=!1,this._dispatchSelectionChange(),this._markForCheck())}selectViaInteraction(){this._selected||(this._selected=!0,this._dispatchSelectionChange(!0),this._markForCheck())}toggleSelected(t=!1){return this._selected=!this.selected,this._dispatchSelectionChange(t),this._markForCheck(),this.selected}focus(){this._hasFocus||(this._elementRef.nativeElement.focus(),this._onFocus.next({chip:this})),this._hasFocus=!0}remove(){this.removable&&this.removed.emit({chip:this})}_handleClick(t){this.disabled?t.preventDefault():t.stopPropagation()}_handleKeydown(t){if(!this.disabled)switch(t.keyCode){case 46:case 8:this.remove(),t.preventDefault();break;case Vw:this.selectable&&this.toggleSelected(!0),t.preventDefault()}}_blur(){this._ngZone.onStable.pipe(Tn(1)).subscribe((()=>{this._ngZone.run((()=>{this._hasFocus=!1,this._onBlur.next({chip:this})}))}))}_dispatchSelectionChange(t=!1){this.selectionChange.emit({source:this,isUserInput:t,selected:this._selected})}_markForCheck(){this._changeDetectorRef&&this._changeDetectorRef.markForCheck()}}Vgt.ɵfac=function t(n){return new(n||Vgt)(Zg(xu),Zg(J_),Zg(Sw),Zg(AE,8),Zg(dk,8),Zg(Vm),Xg("tabindex"),Zg(zC,8))},Vgt.ɵdir=vo({type:Vgt,selectors:[["mat-basic-chip"],["","mat-basic-chip",""],["mat-chip"],["","mat-chip",""]],contentQueries:function t(n,e,a){var o;1&n&&(Gf(a,Ngt,!0),Gf(a,Fgt,!0),Gf(a,Igt,!0)),2&n&&(Vf(o=Zf())&&(e.avatar=o.first),Vf(o=Zf())&&(e.trailingIcon=o.first),Vf(o=Zf())&&(e.removeIcon=o.first))},hostAttrs:["role","option",1,"mat-chip","mat-focus-indicator"],hostVars:14,hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e._handleClick(n)}))("keydown",(function t(n){return e._handleKeydown(n)}))("focus",(function t(){return e.focus()}))("blur",(function t(){return e._blur()})),2&n&&(Ng("tabindex",e.disabled?null:e.tabIndex)("disabled",e.disabled||null)("aria-disabled",e.disabled.toString())("aria-selected",e.ariaSelected),Dp("mat-chip-selected",e.selected)("mat-chip-with-avatar",e.avatar)("mat-chip-with-trailing-icon",e.trailingIcon||e.removeIcon)("mat-chip-disabled",e.disabled)("_mat-animation-noopable",e._animationsDisabled))},inputs:{color:"color",disableRipple:"disableRipple",tabIndex:"tabIndex",selected:"selected",value:"value",selectable:"selectable",disabled:"disabled",removable:"removable"},outputs:{selectionChange:"selectionChange",destroyed:"destroyed",removed:"removed"},exportAs:["matChip"],features:[hg]}),Vgt.ctorParameters=()=>[{type:xu},{type:J_},{type:Sw},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[AE]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]},{type:Vm},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:void 0,decorators:[{type:Ne},{type:Ie,args:[zC]}]}],Vgt.propDecorators={avatar:[{type:Zd,args:[Ngt]}],trailingIcon:[{type:Zd,args:[Fgt]}],removeIcon:[{type:Zd,args:[Igt]}],selected:[{type:f_}],value:[{type:f_}],selectable:[{type:f_}],disabled:[{type:f_}],removable:[{type:f_}],selectionChange:[{type:h_}],destroyed:[{type:h_}],removed:[{type:h_}]};class jgt{constructor(t,n){this._parentChip=t,n&&"BUTTON"===n.nativeElement.nodeName&&n.nativeElement.setAttribute("type","button")}_handleClick(t){const n=this._parentChip;n.removable&&!n.disabled&&n.remove(),t.stopPropagation()}}jgt.ɵfac=function t(n){return new(n||jgt)(Zg(Vgt),Zg(xu))},jgt.ɵdir=vo({type:jgt,selectors:[["","matChipRemove",""]],hostAttrs:[1,"mat-chip-remove","mat-chip-trailing-icon"],hostBindings:function t(n,e){1&n&&cp("click",(function t(n){return e._handleClick(n)}))},features:[Mu([{provide:Igt,useExisting:jgt}])]}),jgt.ctorParameters=()=>[{type:Vgt},{type:xu}]
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */;const Ugt=new Fa("mat-chips-default-options"),Wgt=rE(
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
class{constructor(t,n,e,a){this._defaultErrorStateMatcher=t,this._parentForm=n,this._parentFormGroup=e,this.ngControl=a}});let Ggt=0;class Ygt{constructor(t,n){this.source=t,this.value=n}}class qgt extends Wgt{constructor(t,n,e,a,o,r,i){super(r,a,o,i),this._elementRef=t,this._changeDetectorRef=n,this._dir=e,this.ngControl=i,this.controlType="mat-chip-list",this._lastDestroyedChipIndex=null,this._destroyed=new x,this._uid="mat-chip-list-"+Ggt++,this._tabIndex=0,this._userTabIndex=null,this._onTouched=()=>{},this._onChange=()=>{},this._multiple=!1,this._compareWith=(t,n)=>t===n,this._required=!1,this._disabled=!1,this.ariaOrientation="horizontal",this._selectable=!0,this.change=new Ef,this.valueChange=new Ef,this.ngControl&&(this.ngControl.valueAccessor=this)}get selected(){return this.multiple?this._selectionModel.selected:this._selectionModel.selected[0]}get role(){return this.empty?null:"listbox"}get multiple(){return this._multiple}set multiple(t){this._multiple=Gw(t),this._syncChipsState()}get compareWith(){return this._compareWith}set compareWith(t){this._compareWith=t,this._selectionModel&&this._initializeSelection()}get value(){return this._value}set value(t){this.writeValue(t),this._value=t}get id(){return this._chipInput?this._chipInput.id:this._uid}get required(){return this._required}set required(t){this._required=Gw(t),this.stateChanges.next()}get placeholder(){return this._chipInput?this._chipInput.placeholder:this._placeholder}set placeholder(t){this._placeholder=t,this.stateChanges.next()}get focused(){return this._chipInput&&this._chipInput.focused||this._hasFocusedChip()}get empty(){return(!this._chipInput||this._chipInput.empty)&&(!this.chips||0===this.chips.length)}get shouldLabelFloat(){return!this.empty||this.focused}get disabled(){return this.ngControl?!!this.ngControl.disabled:this._disabled}set disabled(t){this._disabled=Gw(t),this._syncChipsState()}get selectable(){return this._selectable}set selectable(t){this._selectable=Gw(t),this.chips&&this.chips.forEach((t=>t.chipListSelectable=this._selectable))}set tabIndex(t){this._userTabIndex=t,this._tabIndex=t}get chipSelectionChanges(){return Wt(...this.chips.map((t=>t.selectionChange)))}get chipFocusChanges(){return Wt(...this.chips.map((t=>t._onFocus)))}get chipBlurChanges(){return Wt(...this.chips.map((t=>t._onBlur)))}get chipRemoveChanges(){return Wt(...this.chips.map((t=>t.destroyed)))}ngAfterContentInit(){this._keyManager=new mS(this.chips).withWrap().withVerticalOrientation().withHomeAndEnd().withHorizontalOrientation(this._dir?this._dir.value:"ltr"),this._dir&&this._dir.change.pipe(de(this._destroyed)).subscribe((t=>this._keyManager.withHorizontalOrientation(t))),this._keyManager.tabOut.pipe(de(this._destroyed)).subscribe((()=>{this._allowFocusEscape()})),this.chips.changes.pipe(ce(null),de(this._destroyed)).subscribe((()=>{this.disabled&&Promise.resolve().then((()=>{this._syncChipsState()})),this._resetChips(),this._initializeSelection(),this._updateTabIndex(),this._updateFocusForDestroyedChips(),this.stateChanges.next()}))}ngOnInit(){this._selectionModel=new mA(this.multiple,void 0,!1),this.stateChanges.next()}ngDoCheck(){this.ngControl&&(this.updateErrorState(),this.ngControl.disabled!==this._disabled&&(this.disabled=!!this.ngControl.disabled))}ngOnDestroy(){this._destroyed.next(),this._destroyed.complete(),this.stateChanges.complete(),this._dropSubscriptions()}registerInput(t){this._chipInput=t,this._elementRef.nativeElement.setAttribute("data-mat-chip-input",t.id)}setDescribedByIds(t){this._ariaDescribedby=t.join(" ")}writeValue(t){this.chips&&this._setSelectionByValue(t,!1)}registerOnChange(t){this._onChange=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this.disabled=t,this.stateChanges.next()}onContainerClick(t){this._originatesFromChip(t)||this.focus()}focus(t){this.disabled||this._chipInput&&this._chipInput.focused||(this.chips.length>0?(this._keyManager.setFirstItemActive(),this.stateChanges.next()):(this._focusInput(t),this.stateChanges.next()))}_focusInput(t){this._chipInput&&this._chipInput.focus(t)}_keydown(t){const n=t.target;8===t.keyCode&&this._isInputEmpty(n)?(this._keyManager.setLastItemActive(),t.preventDefault()):n&&n.classList.contains("mat-chip")&&(this._keyManager.onKeydown(t),this.stateChanges.next())}_updateTabIndex(){this._tabIndex=this._userTabIndex||(0===this.chips.length?-1:0)}_updateFocusForDestroyedChips(){if(null!=this._lastDestroyedChipIndex)if(this.chips.length){const t=Math.min(this._lastDestroyedChipIndex,this.chips.length-1);this._keyManager.setActiveItem(t)}else this.focus();this._lastDestroyedChipIndex=null}_isValidIndex(t){return t>=0&&t<this.chips.length}_isInputEmpty(t){return!(!t||"input"!==t.nodeName.toLowerCase()||t.value)}_setSelectionByValue(t,n=!0){if(this._clearSelection(),this.chips.forEach((t=>t.deselect())),Array.isArray(t))t.forEach((t=>this._selectValue(t,n))),this._sortValues();else{const e=this._selectValue(t,n);e&&n&&this._keyManager.setActiveItem(e)}}_selectValue(t,n=!0){const e=this.chips.find((n=>null!=n.value&&this._compareWith(n.value,t)));return e&&(n?e.selectViaInteraction():e.select(),this._selectionModel.select(e)),e}_initializeSelection(){Promise.resolve().then((()=>{(this.ngControl||this._value)&&(this._setSelectionByValue(this.ngControl?this.ngControl.value:this._value,!1),this.stateChanges.next())}))}_clearSelection(t){this._selectionModel.clear(),this.chips.forEach((n=>{n!==t&&n.deselect()})),this.stateChanges.next()}_sortValues(){this._multiple&&(this._selectionModel.clear(),this.chips.forEach((t=>{t.selected&&this._selectionModel.select(t)})),this.stateChanges.next())}_propagateChanges(t){let n=null;n=Array.isArray(this.selected)?this.selected.map((t=>t.value)):this.selected?this.selected.value:t,this._value=n,this.change.emit(new Ygt(this,n)),this.valueChange.emit(n),this._onChange(n),this._changeDetectorRef.markForCheck()}_blur(){this._hasFocusedChip()||this._keyManager.setActiveItem(-1),this.disabled||(this._chipInput?setTimeout((()=>{this.focused||this._markAsTouched()})):this._markAsTouched())}_markAsTouched(){this._onTouched(),this._changeDetectorRef.markForCheck(),this.stateChanges.next()}_allowFocusEscape(){-1!==this._tabIndex&&(this._tabIndex=-1,setTimeout((()=>{this._tabIndex=this._userTabIndex||0,this._changeDetectorRef.markForCheck()})))}_resetChips(){this._dropSubscriptions(),this._listenToChipsFocus(),this._listenToChipsSelection(),this._listenToChipsRemoved()}_dropSubscriptions(){this._chipFocusSubscription&&(this._chipFocusSubscription.unsubscribe(),this._chipFocusSubscription=null),this._chipBlurSubscription&&(this._chipBlurSubscription.unsubscribe(),this._chipBlurSubscription=null),this._chipSelectionSubscription&&(this._chipSelectionSubscription.unsubscribe(),this._chipSelectionSubscription=null),this._chipRemoveSubscription&&(this._chipRemoveSubscription.unsubscribe(),this._chipRemoveSubscription=null)}_listenToChipsSelection(){this._chipSelectionSubscription=this.chipSelectionChanges.subscribe((t=>{t.source.selected?this._selectionModel.select(t.source):this._selectionModel.deselect(t.source),this.multiple||this.chips.forEach((t=>{!this._selectionModel.isSelected(t)&&t.selected&&t.deselect()})),t.isUserInput&&this._propagateChanges()}))}_listenToChipsFocus(){this._chipFocusSubscription=this.chipFocusChanges.subscribe((t=>{let n=this.chips.toArray().indexOf(t.chip);this._isValidIndex(n)&&this._keyManager.updateActiveItem(n),this.stateChanges.next()})),this._chipBlurSubscription=this.chipBlurChanges.subscribe((()=>{this._blur(),this.stateChanges.next()}))}_listenToChipsRemoved(){this._chipRemoveSubscription=this.chipRemoveChanges.subscribe((t=>{const n=t.chip,e=this.chips.toArray().indexOf(t.chip);this._isValidIndex(e)&&n._hasFocus&&(this._lastDestroyedChipIndex=e)}))}_originatesFromChip(t){let n=t.target;for(;n&&n!==this._elementRef.nativeElement;){if(n.classList.contains("mat-chip"))return!0;n=n.parentElement}return!1}_hasFocusedChip(){return this.chips&&this.chips.some((t=>t._hasFocus))}_syncChipsState(){this.chips&&this.chips.forEach((t=>{t._chipListDisabled=this._disabled,t._chipListMultiple=this.multiple}))}}qgt.ɵfac=function t(n){return new(n||qgt)(Zg(xu),Zg(Vm),Zg(US,8),Zg(LL,8),Zg(KL,8),Zg(OE),Zg(AF,10))},qgt.ɵcmp=_o({type:qgt,selectors:[["mat-chip-list"]],contentQueries:function t(n,e,a){var o;1&n&&Gf(a,Vgt,!0),2&n&&Vf(o=Zf())&&(e.chips=o)},hostAttrs:[1,"mat-chip-list"],hostVars:15,hostBindings:function t(n,e){1&n&&cp("focus",(function t(){return e.focus()}))("blur",(function t(){return e._blur()}))("keydown",(function t(n){return e._keydown(n)})),2&n&&(eb("id",e._uid),Ng("tabindex",e.disabled?null:e._tabIndex)("aria-describedby",e._ariaDescribedby||null)("aria-required",e.role?e.required:null)("aria-disabled",e.disabled.toString())("aria-invalid",e.errorState)("aria-multiselectable",e.multiple)("role",e.role)("aria-orientation",e.ariaOrientation),Dp("mat-chip-list-disabled",e.disabled)("mat-chip-list-invalid",e.errorState)("mat-chip-list-required",e.required))},inputs:{ariaOrientation:["aria-orientation","ariaOrientation"],multiple:"multiple",compareWith:"compareWith",value:"value",required:"required",placeholder:"placeholder",disabled:"disabled",selectable:"selectable",tabIndex:"tabIndex",errorStateMatcher:"errorStateMatcher"},outputs:{change:"change",valueChange:"valueChange"},exportAs:["matChipList"],features:[Mu([{provide:aF,useExisting:qgt}]),hg],ngContentSelectors:["*"],decls:2,vars:0,consts:[[1,"mat-chip-list-wrapper"]],template:function t(n,e){1&n&&(bp(),Kg(0,"div",0),hp(1),$g())},styles:['.mat-chip{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:transparent;transform:translateZ(0);border:none;-webkit-appearance:none;-moz-appearance:none}.mat-standard-chip{transition:box-shadow 280ms cubic-bezier(0.4, 0, 0.2, 1);display:inline-flex;padding:7px 12px;border-radius:16px;align-items:center;cursor:default;min-height:32px;height:1px}._mat-animation-noopable.mat-standard-chip{transition:none;animation:none}.mat-standard-chip .mat-chip-remove.mat-icon{width:18px;height:18px}.mat-standard-chip::after{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;opacity:0;content:"";pointer-events:none;transition:opacity 200ms cubic-bezier(0.35, 0, 0.25, 1)}.mat-standard-chip:hover::after{opacity:.12}.mat-standard-chip:focus{outline:none}.mat-standard-chip:focus::after{opacity:.16}.cdk-high-contrast-active .mat-standard-chip{outline:solid 1px}.cdk-high-contrast-active .mat-standard-chip:focus{outline:dotted 2px}.mat-standard-chip.mat-chip-disabled::after{opacity:0}.mat-standard-chip.mat-chip-disabled .mat-chip-remove,.mat-standard-chip.mat-chip-disabled .mat-chip-trailing-icon{cursor:default}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar,.mat-standard-chip.mat-chip-with-avatar{padding-top:0;padding-bottom:0}.mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-right:8px;padding-left:0}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon.mat-chip-with-avatar{padding-left:8px;padding-right:0}.mat-standard-chip.mat-chip-with-trailing-icon{padding-top:7px;padding-bottom:7px;padding-right:8px;padding-left:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-trailing-icon{padding-left:8px;padding-right:12px}.mat-standard-chip.mat-chip-with-avatar{padding-left:0;padding-right:12px}[dir=rtl] .mat-standard-chip.mat-chip-with-avatar{padding-right:0;padding-left:12px}.mat-standard-chip .mat-chip-avatar{width:24px;height:24px;margin-right:8px;margin-left:4px}[dir=rtl] .mat-standard-chip .mat-chip-avatar{margin-left:8px;margin-right:4px}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{width:18px;height:18px;cursor:pointer}.mat-standard-chip .mat-chip-remove,.mat-standard-chip .mat-chip-trailing-icon{margin-left:8px;margin-right:0}[dir=rtl] .mat-standard-chip .mat-chip-remove,[dir=rtl] .mat-standard-chip .mat-chip-trailing-icon{margin-right:8px;margin-left:0}.mat-chip-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none;border-radius:inherit;overflow:hidden}.mat-chip-list-wrapper{display:flex;flex-direction:row;flex-wrap:wrap;align-items:center;margin:-4px}.mat-chip-list-wrapper input.mat-input-element,.mat-chip-list-wrapper .mat-standard-chip{margin:4px}.mat-chip-list-stacked .mat-chip-list-wrapper{flex-direction:column;align-items:flex-start}.mat-chip-list-stacked .mat-chip-list-wrapper .mat-standard-chip{width:100%}.mat-chip-avatar{border-radius:50%;justify-content:center;align-items:center;display:flex;overflow:hidden;object-fit:cover}input.mat-chip-input{width:150px;margin:4px;flex:1 0 150px}\n'],encapsulation:2,changeDetection:0}),qgt.ctorParameters=()=>[{type:xu},{type:Vm},{type:US,decorators:[{type:Ne}]},{type:LL,decorators:[{type:Ne}]},{type:KL,decorators:[{type:Ne}]},{type:OE},{type:AF,decorators:[{type:Ne},{type:Fe}]}],qgt.propDecorators={errorStateMatcher:[{type:f_}],multiple:[{type:f_}],compareWith:[{type:f_}],value:[{type:f_}],required:[{type:f_}],placeholder:[{type:f_}],disabled:[{type:f_}],ariaOrientation:[{type:f_,args:["aria-orientation"]}],selectable:[{type:f_}],tabIndex:[{type:f_}],change:[{type:h_}],valueChange:[{type:h_}],chips:[{type:qd,args:[Vgt,{descendants:!0}]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let Zgt=0;class Xgt{constructor(t,n){this._elementRef=t,this._defaultOptions=n,this.focused=!1,this._addOnBlur=!1,this.separatorKeyCodes=this._defaultOptions.separatorKeyCodes,this.chipEnd=new Ef,this.placeholder="",this.id="mat-chip-list-input-"+Zgt++,this._disabled=!1,this._inputElement=this._elementRef.nativeElement}set chipList(t){t&&(this._chipList=t,this._chipList.registerInput(this))}get addOnBlur(){return this._addOnBlur}set addOnBlur(t){this._addOnBlur=Gw(t)}get disabled(){return this._disabled||this._chipList&&this._chipList.disabled}set disabled(t){this._disabled=Gw(t)}get empty(){return!this._inputElement.value}ngOnChanges(){this._chipList.stateChanges.next()}_keydown(t){t&&9===t.keyCode&&!Ww(t,"shiftKey")&&this._chipList._allowFocusEscape(),this._emitChipEnd(t)}_blur(){this.addOnBlur&&this._emitChipEnd(),this.focused=!1,this._chipList.focused||this._chipList._blur(),this._chipList.stateChanges.next()}_focus(){this.focused=!0,this._chipList.stateChanges.next()}_emitChipEnd(t){!this._inputElement.value&&t&&this._chipList._keydown(t),t&&!this._isSeparatorKey(t)||(this.chipEnd.emit({input:this._inputElement,value:this._inputElement.value}),t&&t.preventDefault())}_onInput(){this._chipList.stateChanges.next()}focus(t){this._inputElement.focus(t)}_isSeparatorKey(t){return!Ww(t)&&new Set(this.separatorKeyCodes).has(t.keyCode)}}Xgt.ɵfac=function t(n){return new(n||Xgt)(Zg(xu),Zg(Ugt))},Xgt.ɵdir=vo({type:Xgt,selectors:[["input","matChipInputFor",""]],hostAttrs:[1,"mat-chip-input","mat-input-element"],hostVars:5,hostBindings:function t(n,e){1&n&&cp("keydown",(function t(n){return e._keydown(n)}))("blur",(function t(){return e._blur()}))("focus",(function t(){return e._focus()}))("input",(function t(){return e._onInput()})),2&n&&(eb("id",e.id),Ng("disabled",e.disabled||null)("placeholder",e.placeholder||null)("aria-invalid",e._chipList&&e._chipList.ngControl?e._chipList.ngControl.invalid:null)("aria-required",e._chipList&&e._chipList.required||null))},inputs:{separatorKeyCodes:["matChipInputSeparatorKeyCodes","separatorKeyCodes"],placeholder:"placeholder",id:"id",chipList:["matChipInputFor","chipList"],addOnBlur:["matChipInputAddOnBlur","addOnBlur"],disabled:"disabled"},outputs:{chipEnd:"matChipInputTokenEnd"},exportAs:["matChipInput","matChipInputFor"],features:[pr]}),Xgt.ctorParameters=()=>[{type:xu},{type:void 0,decorators:[{type:Ie,args:[Ugt]}]}],Xgt.propDecorators={chipList:[{type:f_,args:["matChipInputFor"]}],addOnBlur:[{type:f_,args:["matChipInputAddOnBlur"]}],separatorKeyCodes:[{type:f_,args:["matChipInputSeparatorKeyCodes"]}],chipEnd:[{type:h_,args:["matChipInputTokenEnd"]}],placeholder:[{type:f_}],id:[{type:f_}],disabled:[{type:f_}]};const Jgt={separatorKeyCodes:[Hw]};class Qgt{}Qgt.ɵmod=xo({type:Qgt}),Qgt.ɵinj=Ge({factory:function t(n){return new(n||Qgt)},providers:[OE,{provide:Ugt,useValue:Jgt}]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Qgt,{declarations:[qgt,Vgt,Xgt,jgt,Hgt,Bgt],exports:[qgt,Vgt,Xgt,jgt,Hgt,Bgt]});const Kgt=function(t,n){return{"embedding-selected":t,"embedding-unselected":n}};function $gt(t,n){if(1&t){const t=op();Kg(0,"mat-icon",5),cp("click",(function n(){jr(t);const e=gp();return e.onSelect.emit(e.metric)})),$g()}if(2&t){const t=gp();Jg("ngClass",ff(1,Kgt,t.embeddingsMetric===t.metric,t.embeddingsMetric!==t.metric))}}const tpt=function(t){return{width:t}},npt=function(t){return{"value-invalid":t}};class ept{constructor(){this.onRemove=new Ef,this.onSelect=new Ef,this.onFilterChange=new Ef,this.focusMin=!1,this.focusMax=!1,this.ngUnsubscribe=new x}ngOnInit(){this.minFormControl=new TL(this.filterValues.min,[HF.required,HF.min(-1),HF.max(1),this.minValueValidator.bind(this)]),this.maxFormControl=new TL(this.filterValues.max,[HF.required,HF.min(-1),HF.max(1),this.maxValueValidator.bind(this)]),this.minFormControl.valueChanges.pipe(de(this.ngUnsubscribe)).subscribe((()=>{this.minFormControl.valid&&this.maxFormControl.valid&&this.onFilterChange.emit({min:parseFloat(this.minFormControl.value),max:parseFloat(this.maxFormControl.value)})})),this.maxFormControl.valueChanges.pipe(de(this.ngUnsubscribe)).subscribe((()=>{this.minFormControl.valid&&this.maxFormControl.valid&&this.onFilterChange.emit({min:parseFloat(this.minFormControl.value),max:parseFloat(this.maxFormControl.value)})}))}ngOnChanges(t){this.minFormControl&&this.maxFormControl&&(this.minFormControl.setValue(this.filterValues.min,{emitEvent:!1}),this.maxFormControl.setValue(this.filterValues.max,{emitEvent:!1}))}ngOnDestroy(){this.ngUnsubscribe.next(),this.ngUnsubscribe.complete()}minValueValidator(t){return this.maxFormControl&&"NaN"!==t.value?isNaN(parseFloat(t.value))?{value:"the string you entered is neither NaN nor a number"}:parseFloat(t.value)>parseFloat(this.maxFormControl.value)?{value:"the number you entered is larger than the max value"}:null:null}maxValueValidator(t){return this.minFormControl?"NaN"===this.minFormControl.value&&"NaN"===t.value?null:isNaN(parseFloat(t.value))?{value:"the string you entered is neither NaN nor a number"}:t.value<this.minFormControl.value?{value:"the number you entered is smaller than the min value"}:null:null}getErrorDescription(t){if(t){const n=Object.keys(t)[0];return"required"===n?"you did not enter anything":"min"===n?"the number must be at least -1.0":"max"===n?"the number is bigger than 1.0":t[n]}return""}}ept.ɵfac=function t(n){return new(n||ept)},ept.ɵcmp=_o({type:ept,selectors:[["metric-arithmetic-element-component"]],inputs:{metric:"metric",filterValues:"filterValues",hasEmbeddingsData:"hasEmbeddingsData",embeddingsMetric:"embeddingsMetric"},outputs:{onRemove:"onRemove",onSelect:"onSelect",onFilterChange:"onFilterChange"},features:[pr],decls:10,vars:22,consts:[[1,"filter-chip",3,"removed"],["class","embeddings-button","svgIcon","group_work_24px",3,"ngClass","click",4,"ngIf"],[1,"metric-arithmetic-element-range",3,"keydown"],["matInput","",1,"input-field",3,"value","matTooltip","matTooltipDisabled","ngStyle","ngClass","formControl","focus","focusout"],["matChipRemove","","svgIcon","cancel_24px"],["svgIcon","group_work_24px",1,"embeddings-button",3,"ngClass","click"]],template:function t(n,e){1&n&&(Kg(0,"mat-chip",0),cp("removed",(function t(){return e.onRemove.emit(e.metric)})),Yg(1,$gt,1,4,"mat-icon",1),Jp(2),Kg(3,"div",2),cp("keydown",(function t(n){return n.stopPropagation()})),Jp(4," [ "),Kg(5,"input",3),cp("focus",(function t(){return e.focusMin=!0}))("focusout",(function t(){return e.focusMin=!1})),$g(),Jp(6," ; "),Kg(7,"input",3),cp("focus",(function t(){return e.focusMax=!0}))("focusout",(function t(){return e.focusMax=!1})),$g(),Jp(8," ] "),$g(),tp(9,"mat-icon",4),$g()),2&n&&(ws(1),Jg("ngIf",e.hasEmbeddingsData),ws(1),Kp(" ",e.metric," "),ws(3),Jg("value",e.filterValues.min)("matTooltip",e.getErrorDescription(e.minFormControl.errors))("matTooltipDisabled",!e.minFormControl.invalid)("ngStyle",uf(14,tpt,e.focusMin?"100px":e.minFormControl.value.toString().length+"ch"))("ngClass",uf(16,npt,!e.minFormControl.valid))("formControl",e.minFormControl),ws(2),Jg("value",e.filterValues.max)("matTooltip",e.getErrorDescription(e.maxFormControl.errors))("matTooltipDisabled",!e.maxFormControl.invalid)("ngStyle",uf(18,tpt,e.focusMax?"100px":e.maxFormControl.value.toString().length+"ch"))("ngClass",uf(20,npt,!e.maxFormControl.valid))("formControl",e.maxFormControl))},directives:[Vgt,WM,kF,Yq,$M,HM,RF,JL,BB,jgt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.filter-chip[_ngcontent-%COMP%]{align-items:center;display:flex;margin-left:5px}.metric-arithmetic-element-range[_ngcontent-%COMP%]{align-items:center;background-color:#fff;font-size:.8em;height:30px;justify-content:center;line-height:30px;padding:0 5px;margin-left:5px}.input-field[_ngcontent-%COMP%]{background-color:transparent;border:none;font-family:monospace;font-size:1.1em;transition:width 1s}.input-field[_ngcontent-%COMP%]:focus{background-color:rgba(0,0,0,.12);border:none;outline:none}.value-invalid[_ngcontent-%COMP%]{color:#f44336}.embedding-selected[_ngcontent-%COMP%]{color:#f57c00;opacity:1}.embedding-unselected[_ngcontent-%COMP%]{opacity:.4}.embeddings-button[_ngcontent-%COMP%]{width:18px;height:18px;margin-right:8px;cursor:pointer}'],changeDetection:0});class apt{constructor(t){this.store=t,this.filterValues$=this.store.pipe(lv(Ldt)).pipe(ft((t=>{const n=t[this.metric];return n?{min:n.includeNaN?"NaN":this.roundToThreeDecimalPoints(n.min),max:n.max<n.min?"NaN":this.roundToThreeDecimalPoints(n.max)}:{min:-1,max:1}}))),this.hasEmbeddingsData$=this.store.pipe(lv(zdt)).pipe(ft((t=>void 0!==t))),this.embeddingsMetric$=this.store.pipe(lv(qdt))}remove(t){this.store.dispatch(sgt({metric:t}))}select(t){this.store.dispatch(hgt({metric:t}))}filterChange(t){const n=isNaN(t.min)?-1:t.min,e=isNaN(t.max)?-2:t.max,a=isNaN(t.min);this.store.dispatch(lgt({metric:this.metric,max:e,min:n,includeNaN:a}))}roundToThreeDecimalPoints(t){return Math.round(1e3*(t+Number.EPSILON))/1e3}}apt.ɵfac=function t(n){return new(n||apt)(Zg(cv))},apt.ɵcmp=_o({type:apt,selectors:[["npmi-metric-arithmetic-element"]],inputs:{metric:"metric"},decls:4,vars:10,consts:[[3,"metric","filterValues","hasEmbeddingsData","embeddingsMetric","onRemove","onSelect","onFilterChange"]],template:function t(n,e){1&n&&(Kg(0,"metric-arithmetic-element-component",0),cp("onRemove",(function t(n){return e.remove(n)}))("onSelect",(function t(n){return e.select(n)}))("onFilterChange",(function t(n){return e.filterChange(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("metric",e.metric)("filterValues",kf(1,4,e.filterValues$))("hasEmbeddingsData",kf(2,6,e.hasEmbeddingsData$))("embeddingsMetric",kf(3,8,e.embeddingsMetric$))},directives:[ept],pipes:[oO],encapsulation:2,changeDetection:0});class opt{constructor(){this.Operator=Pdt}}function rpt(t,n){1&t&&tp(0,"npmi-metric-arithmetic-element",4),2&t&&Jg("metric",gp().$implicit.metric)}function ipt(t,n){1&t&&tp(0,"npmi-metric-arithmetic-operator",5),2&t&&Jg("operator",gp().$implicit.operator)}function cpt(t,n){if(1&t&&(Kg(0,"div"),Yg(1,rpt,1,1,"npmi-metric-arithmetic-element",2),Yg(2,ipt,1,1,"npmi-metric-arithmetic-operator",3),$g()),2&t){const t=n.$implicit,e=gp();ws(1),Jg("ngIf",t.kind===e.ArithmeticKind.METRIC),ws(1),Jg("ngIf",t.kind===e.ArithmeticKind.OPERATOR)}}opt.ɵfac=function t(n){return new(n||opt)},opt.ɵcmp=_o({type:opt,selectors:[["npmi-metric-arithmetic-operator"]],inputs:{operator:"operator"},decls:2,vars:1,template:function t(n,e){1&n&&(Kg(0,"mat-chip"),Jp(1),$g()),2&n&&(ws(1),Kp(" ",e.operator===e.Operator.AND?"&":""," "))},directives:[Vgt],encapsulation:2,changeDetection:0});class spt{constructor(){this.ArithmeticKind=xdt}}spt.ɵfac=function t(n){return new(n||spt)},spt.ɵcmp=_o({type:spt,selectors:[["metric-arithmetic-component"]],inputs:{metricArithmetic:"metricArithmetic"},decls:2,vars:2,consts:[[3,"selectable"],[4,"ngFor","ngForOf"],[3,"metric",4,"ngIf"],[3,"operator",4,"ngIf"],[3,"metric"],[3,"operator"]],template:function t(n,e){1&n&&(Kg(0,"mat-chip-list",0),Yg(1,cpt,3,2,"div",1),$g()),2&n&&(Jg("selectable",!1),ws(1),Jg("ngForOf",e.metricArithmetic))},directives:[qgt,jM,WM,apt,opt],styles:["[_nghost-%COMP%]{align-items:center;display:flex;flex-direction:row;flex-wrap:wrap}"],changeDetection:0});class lpt{constructor(t){this.store=t,this.metricArithmetic$=this.store.pipe(lv(Fdt))}}lpt.ɵfac=function t(n){return new(n||lpt)(Zg(cv))},lpt.ɵcmp=_o({type:lpt,selectors:[["npmi-metric-arithmetic"]],decls:2,vars:3,consts:[[3,"metricArithmetic"]],template:function t(n,e){1&n&&(tp(0,"metric-arithmetic-component",0),yf(1,"async")),2&n&&Jg("metricArithmetic",kf(1,1,e.metricArithmetic$))},directives:[spt],pipes:[oO],encapsulation:2,changeDetection:0});class mpt{}function dpt(t,n,e){if(e)return t;const a=Object.assign({},t);return n.forEach((t=>delete a[t])),a}mpt.ɵfac=function t(n){return new(n||mpt)},mpt.ɵcmp=_o({type:mpt,selectors:[["npmi-data-selection"]],decls:4,vars:0,consts:[[1,"data-selection"],[1,"metrics-selector"]],template:function t(n,e){1&n&&(Kg(0,"div",0),tp(1,"npmi-metric-search",1),tp(2,"npmi-results-download"),$g(),tp(3,"npmi-metric-arithmetic"))},directives:[Agt,Dgt,lpt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;background-color:#fff;border:1px solid #ebebeb;padding:10px 20px}.data-selection[_ngcontent-%COMP%]{display:flex;align-items:center}.metrics-selector[_ngcontent-%COMP%]{flex:1 1}'],changeDetection:0});const gpt=["chart"];class ppt{constructor(){this.onRemove=new Ef,this.onUpdateFilter=new Ef,this.height=300,this.chartWidth=0,this.chartHeight=0,this.drawHeight=0,this.drawWidth=0,this.margin={top:20,right:10,bottom:20,left:10},this.drawMargin={top:0,right:0,bottom:20,left:20},this.brush=(function t(){return(function t(n){var e,a=S3,o=w3,r=E3,i=!0,c=S0("start","brush","end"),s=6;function l(t){var e=t.property("__brush",f).selectAll(".overlay").data([v3("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",O3.overlay).merge(e).each((function(){var t=A3(this).extent;j1(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),t.selectAll(".selection").data([v3("selection")]).enter().append("rect").attr("class","selection").attr("cursor",O3.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var a=t.selectAll(".handle").data(n.handles,(function(t){return t.type}));a.exit().remove(),a.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return O3[t.type]})),t.each(m).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",p).filter(r).on("touchstart.brush",p).on("touchmove.brush",b).on("touchend.brush touchcancel.brush",u).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function m(){var t=j1(this),n=A3(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?n[1][0]-s/2:n[0][0]-s/2})).attr("y",(function(t){return"s"===t.type[0]?n[1][1]-s/2:n[0][1]-s/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+s:s})).attr("height",(function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+s:s}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function d(t,n,e){return!e&&t.__brush.emitter||new g(t,n)}function g(t,n){this.that=t,this.args=n,this.state=t.__brush,this.active=0}function p(){if((!e||A1.touches)&&o.apply(this,arguments)){var t,a,r,c,s,l,g,p,b,u,f,h=this,_=A1.target.__data__.type,C="selection"===(i&&A1.metaKey?_="overlay":_)?g3:i&&A1.altKey?u3:b3,M=n===M3?null:y3[_],O=n===C3?null:k3[_],P=A3(h),x=P.extent,y=P.selection,k=x[0][0],v=x[0][1],w=x[1][0],S=x[1][1],E=0,A=0,z=M&&O&&i&&A1.shiftKey,R=A1.touches?_3(A1.changedTouches[0].identifier):G1,T=R(h),D=T,I=d(h,arguments,!0).beforestart();"overlay"===_?(y&&(b=!0),P.selection=y=[[t=n===M3?k:T[0],r=n===C3?v:T[1]],[s=n===M3?w:t,g=n===C3?S:r]]):(t=y[0][0],r=y[0][1],s=y[1][0],g=y[1][1]),a=t,c=r,l=s,p=g;var N=j1(h).attr("pointer-events","none"),F=N.selectAll(".overlay").attr("cursor",O3[_]);if(A1.touches)I.moved=H,I.ended=V;else{var L=j1(A1.view).on("mousemove.brush",H,!0).on("mouseup.brush",V,!0);i&&L.on("keydown.brush",j,!0).on("keyup.brush",U,!0),q1(A1.view)}s3(),c4(h),m.call(h),I.start()}function H(){var t=R(h);!z||u||f||(Math.abs(t[0]-D[0])>Math.abs(t[1]-D[1])?f=!0:u=!0),D=t,b=!0,l3(),B()}function B(){var n;switch(E=D[0]-T[0],A=D[1]-T[1],C){case p3:case g3:M&&(E=Math.max(k-t,Math.min(w-s,E)),a=t+E,l=s+E),O&&(A=Math.max(v-r,Math.min(S-g,A)),c=r+A,p=g+A);break;case b3:M<0?(E=Math.max(k-t,Math.min(w-t,E)),a=t+E,l=s):M>0&&(E=Math.max(k-s,Math.min(w-s,E)),a=t,l=s+E),O<0?(A=Math.max(v-r,Math.min(S-r,A)),c=r+A,p=g):O>0&&(A=Math.max(v-g,Math.min(S-g,A)),c=r,p=g+A);break;case u3:M&&(a=Math.max(k,Math.min(w,t-E*M)),l=Math.max(k,Math.min(w,s+E*M))),O&&(c=Math.max(v,Math.min(S,r-A*O)),p=Math.max(v,Math.min(S,g+A*O)))}l<a&&(M*=-1,n=t,t=s,s=n,n=a,a=l,l=n,_ in P3&&F.attr("cursor",O3[_=P3[_]])),p<c&&(O*=-1,n=r,r=g,g=n,n=c,c=p,p=n,_ in x3&&F.attr("cursor",O3[_=x3[_]])),P.selection&&(y=P.selection),u&&(a=y[0][0],l=y[1][0]),f&&(c=y[0][1],p=y[1][1]),y[0][0]===a&&y[0][1]===c&&y[1][0]===l&&y[1][1]===p||(P.selection=[[a,c],[l,p]],m.call(h),I.brush())}function V(){if(s3(),A1.touches){if(A1.touches.length)return;e&&clearTimeout(e),e=setTimeout((function(){e=null}),500)}else Z1(A1.view,b),L.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);N.attr("pointer-events","all"),F.attr("cursor",O3.overlay),P.selection&&(y=P.selection),z3(y)&&(P.selection=null,m.call(h)),I.end()}function j(){switch(A1.keyCode){case 16:z=M&&O;break;case 18:C===b3&&(M&&(s=l-E*M,t=a+E*M),O&&(g=p-A*O,r=c+A*O),C=u3,B());break;case 32:C!==b3&&C!==u3||(M<0?s=l-E:M>0&&(t=a-E),O<0?g=p-A:O>0&&(r=c-A),C=p3,F.attr("cursor",O3.selection),B());break;default:return}l3()}function U(){switch(A1.keyCode){case 16:z&&(u=f=z=!1,B());break;case 18:C===u3&&(M<0?s=l:M>0&&(t=a),O<0?g=p:O>0&&(r=c),C=b3,B());break;case 32:C===p3&&(A1.altKey?(M&&(s=l-E*M,t=a+E*M),O&&(g=p-A*O,r=c+A*O),C=u3):(M<0?s=l:M>0&&(t=a),O<0?g=p:O>0&&(r=c),C=b3),F.attr("cursor",O3[_]),B());break;default:return}l3()}}function b(){d(this,arguments).moved()}function u(){d(this,arguments).ended()}function f(){var t=this.__brush||{selection:null};return t.extent=h3(a.apply(this,arguments)),t.dim=n,t}return l.move=function(t,e){t.selection?t.on("start.brush",(function(){d(this,arguments).beforestart().start()})).on("interrupt.brush end.brush",(function(){d(this,arguments).end()})).tween("brush",(function(){var t=this,a=t.__brush,o=d(t,arguments),r=a.selection,i=n.input("function"==typeof e?e.apply(this,arguments):e,a.extent),c=M5(r,i);function s(n){a.selection=1===n&&null===i?null:c(n),m.call(t),o.brush()}return null!==r&&null!==i?s:s(1)})):t.each((function(){var t=this,a=arguments,o=t.__brush,r=n.input("function"==typeof e?e.apply(t,a):e,o.extent),i=d(t,a).beforestart();c4(t),o.selection=null===r?null:r,m.call(t),i.start().brush().end()}))},l.clear=function(t){l.move(t,null)},g.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(){return this.starting?(this.starting=!1,this.emit("start")):this.emit("brush"),this},brush:function(){return this.emit("brush"),this},end:function(){return 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(t){!(function e(t,n,a,o){var r=A1;t.sourceEvent=A1,A1=t;try{n.apply(a,o)}finally{A1=r}})(new c3(l,t,n.output(this.state.selection)),c.apply,c,[t,this.that,this.args])}},l.extent=function(t){return arguments.length?(a="function"==typeof t?t:i3(h3(t)),l):a},l.filter=function(t){return arguments.length?(o="function"==typeof t?t:i3(!!t),l):o},l.touchable=function(t){return arguments.length?(r="function"==typeof t?t:i3(!!t),l):r},l.handleSize=function(t){return arguments.length?(s=+t,l):s},l.keyModifiers=function(t){return arguments.length?(i=!!t,l):i},l.on=function(){var t=c.on.apply(c,arguments);return t===c?l:t},l})(M3)})(),this.maxBinSize=0,this.area=(function n(){var t=N8,n=null,e=T8(0),a=F8,o=T8(!0),r=null,i=I8,c=null;function s(s){var l,m,d,g,p,b=s.length,u=!1,f=new Array(b),h=new Array(b);for(null==r&&(c=i(p=F3())),l=0;l<=b;++l){if(!(l<b&&o(g=s[l],l,s))===u)if(u=!u)m=l,c.areaStart(),c.lineStart();else{for(c.lineEnd(),c.lineStart(),d=l-1;d>=m;--d)c.point(f[d],h[d]);c.lineEnd(),c.areaEnd()}u&&(f[l]=+t(g,l,s),h[l]=+e(g,l,s),c.point(n?+n(g,l,s):f[l],a?+a(g,l,s):h[l]))}if(p)return c=null,p+""||null}function l(){return L8().defined(o).curve(i).context(r)}return s.x=function(e){return arguments.length?(t="function"==typeof e?e:T8(+e),n=null,s):t},s.x0=function(n){return arguments.length?(t="function"==typeof n?n:T8(+n),s):t},s.x1=function(t){return arguments.length?(n=null==t?null:"function"==typeof t?t:T8(+t),s):n},s.y=function(t){return arguments.length?(e="function"==typeof t?t:T8(+t),a=null,s):e},s.y0=function(t){return arguments.length?(e="function"==typeof t?t:T8(+t),s):e},s.y1=function(t){return arguments.length?(a=null==t?null:"function"==typeof t?t:T8(+t),s):a},s.lineX0=s.lineY0=function(){return l().x(t).y(e)},s.lineY1=function(){return l().x(t).y(a)},s.lineX1=function(){return l().x(n).y(e)},s.defined=function(t){return arguments.length?(o="function"==typeof t?t:T8(!!t),s):o},s.curve=function(t){return arguments.length?(i=t,null!=r&&(c=i(r)),s):i},s.context=function(t){return arguments.length?(null==t?r=c=null:c=i(r=t),s):r},s})().x0(function(t){return this.xScaleNum(-t.length)}.bind(this)).x1(function(t){return this.xScaleNum(t.length)}.bind(this)).y(function(t){return t.x0===-1/0?this.chartHeight-this.drawMargin.top:this.yScale((t.x1+t.x0)/2)}.bind(this)).curve(j8)}ngAfterViewInit(){this.updateDimensions(),this.svg=j1(this.chartContainer.nativeElement).select("svg"),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.drawContainer=this.mainContainer.append("g").attr("transform",`translate(${this.drawMargin.left}, ${this.drawMargin.top})`),this.dotsGroup=this.drawContainer.append("g").attr("class","dotsGroup"),this.yAxisGroup=this.mainContainer.append("g").attr("class","axis axis--y"),this.xAxisGroup=this.mainContainer.append("g").attr("class","axis axis--x"),this.miscGroup=this.drawContainer.append("g"),this.xScale=d6().padding(.05),this.xAxis=(function t(n){return v0(3,n)})(this.xScale),this.yScale=k6().range([this.drawHeight,0]),this.yAxis=(function n(t){return v0(4,t)})(this.yScale),this.xScaleNum=k6(),this.initializeBrush(),this.drawMisc(),this.redraw()}ngOnChanges(t){this.svg&&this.redraw()}redraw(){this.updateDimensions(),this.setMaxBinSize(),this.updateAxes(),this.draw()}updateDimensions(){this.chartWidth=this.width-this.margin.left-this.margin.right,this.drawWidth=this.chartWidth-this.drawMargin.left-this.drawMargin.right,this.chartHeight=this.height-this.margin.top-this.margin.bottom,this.drawHeight=this.chartHeight-this.drawMargin.top-this.drawMargin.bottom}setMaxBinSize(){Object.values(this.chartData.violinData).forEach((t=>{const n=t.map((t=>t.length)),e=Math.max(...n);this.maxBinSize=Math.max(e,this.maxBinSize)}))}updateAxes(){this.xScale.range([0,this.drawWidth]).domain(Object.keys(this.chartData.violinData)),this.yScale.domain([this.chartData.extremes.min,this.chartData.extremes.max]),this.xScaleNum.range([0,this.xScale.bandwidth()]).domain([-this.maxBinSize,this.maxBinSize])}initializeBrush(){this.brush.on("end",this.brushMoved.bind(this))}draw(){this.drawAxes(),this.drawPlot(),this.refreshMisc(),this.refreshBrush()}drawAxes(){this.yAxisGroup.attr("transform",`translate(${this.drawMargin.left},\n      ${this.drawMargin.top})`).call(this.yAxis),this.xAxisGroup.attr("transform",`translate(${this.drawMargin.left},\n      ${this.drawMargin.top+this.chartHeight})`).call(this.xAxis)}drawPlot(){const t=this.dotsGroup.selectAll(".violin-plot").data(Object.entries(this.chartData.violinData));t.enter().append("path").attr("class","violin-plot").style("stroke",function(t){return this.colorScale(t[0])}.bind(this)).style("fill",function(t){return`${this.colorScale(t[0])}33`}.bind(this)).attr("transform",function(t){return`translate(${this.xScale(t[0])}, 0)`}.bind(this)).datum((function(t){return t[1]})).attr("d",this.area),t.attr("transform",function(t){return`translate(${this.xScale(t[0])}, 0)`}.bind(this)).datum((function(t){return t[1]})).attr("d",this.area),t.exit().remove()}drawMisc(){this.zeroLine=this.miscGroup.append("line").style("stroke","black").attr("x1",0).attr("y1",this.yScale(0)).attr("x2",this.drawWidth).attr("y2",this.yScale(0)),this.nanText=this.miscGroup.append("text").style("fill","black").text("NaN").attr("font-size","10px").attr("text-anchor","end").attr("alignment-baseline","middle").attr("x",-5).attr("y",this.chartHeight-this.drawMargin.top),this.nanLine=this.miscGroup.append("line").style("stroke","grey").style("stroke-dasharray","3, 3").attr("x1",0).attr("y1",this.chartHeight-this.drawMargin.top).attr("x2",this.drawWidth).attr("y2",this.chartHeight-this.drawMargin.top)}refreshMisc(){this.zeroLine.attr("y1",this.yScale(0)).attr("x2",this.drawWidth).attr("y2",this.yScale(0)),this.nanText.attr("y",this.chartHeight-this.drawMargin.top),this.nanLine.attr("y1",this.drawHeight+this.drawMargin.top).attr("x2",this.drawWidth).attr("y2",this.drawHeight+this.drawMargin.top)}refreshBrush(){this.brush.extent([[0,0],[this.drawWidth,this.drawHeight+this.margin.top]]);const t=[0,this.drawHeight+this.margin.top];if(this.filter.max<this.filter.min)t[0]=this.filter.includeNaN?this.yScale(this.chartData.extremes.min):t[1];else{if(!this.filter.includeNaN){const n=Math.max(this.chartData.extremes.min,this.filter.min);t[1]=this.yScale(n)}const n=Math.min(this.chartData.extremes.max,this.filter.max);t[0]=this.yScale(n)}this.drawContainer.call(this.brush).call(this.brush.move,t)}brushMoved(){if(!A1)return;if(!A1.sourceEvent)return;const t=A1.selection;if(t){let n=!1,e=-2,a=this.chartData.extremes.min;t[0]<=this.drawHeight+this.margin.top&&t[1]>=this.drawHeight&&(n=!0),t[0]<this.drawHeight&&(e=this.yScale.invert(t[0])),t[1]<this.drawHeight&&(a=this.yScale.invert(t[1])),this.onUpdateFilter.emit({max:e,min:a,includeNaN:n})}else this.onUpdateFilter.emit({max:1,min:-1,includeNaN:!0})}}ppt.ɵfac=function t(n){return new(n||ppt)},ppt.ɵcmp=_o({type:ppt,selectors:[["violin-filter-component"]],viewQuery:function t(n,e){var a;1&n&&jf(gpt,!0,xu),2&n&&Vf(a=Zf())&&(e.chartContainer=a.first)},inputs:{metricName:"metricName",filter:"filter",chartData:"chartData",width:"width",colorScale:"colorScale"},outputs:{onRemove:"onRemove",onUpdateFilter:"onUpdateFilter"},features:[pr],decls:10,vars:1,consts:function(){return[[1,"chart-container"],["title","Shows the nPMI value distribution per run. Ranges of selected values can be manipulated by modifying the grey box.",1,"chart-head"],[1,"chart-heading"],["mat-icon-button","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Remove Filter"):$localize`:Label for a button that removes a metric filter.␟a6bfad58bb363d5c891d0a5474b1d77ef90a34da␟8454961797762907624:Remove Filter`],["svgIcon","clear_24px"],[1,"chart"],["chart",""],[1,"draw-area"]]},template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"div",1),Kg(2,"div",2),Jp(3),$g(),Kg(4,"button",3),lu(5,4),cp("click",(function t(){return e.onRemove.emit()})),tp(6,"mat-icon",5),$g(),$g(),Kg(7,"div",6,7),ui(),tp(9,"svg",8),$g(),$g()),2&n&&(ws(3),Qp(e.metricName))},directives:[eA,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.chart-container[_ngcontent-%COMP%]{background-color:#fff;border-bottom:1px solid #ebebeb;display:flex;flex-direction:column;overflow:hidden}.chart[_ngcontent-%COMP%]{height:300px;width:100%}.chart-head[_ngcontent-%COMP%]{align-items:center;display:flex;justify-content:space-between}.chart-heading[_ngcontent-%COMP%]{font-size:13px;padding-left:10px;padding-top:10px}.draw-area[_ngcontent-%COMP%]{height:100%;width:100%}.stroked-line[_ngcontent-%COMP%]{stroke:rgba(0,0,0,.12);stroke-dasharray:3 3}'],changeDetection:0});class bpt{constructor(t){this.store=t,this.activeRuns$=this.store.pipe(lv(KD)).pipe(ft((t=>t?Array.from(t.entries()).filter((t=>t[1])).map((t=>t[0])):[]))),this.visibleAnnotations$=Et([this.store.select(Edt),this.store.select(Ddt),this.store.select(Wdt)]).pipe(ft((([t,n,e])=>dpt(t,n,e)))),this.chartWidth$=this.store.pipe(lv(Ydt)).pipe(ft((t=>Math.max(150,t)))),this.runColorScale$=this.store.select(GD).pipe(ft((t=>n=>{if(!t.hasOwnProperty(n))throw new Error(`[Color scale] unknown runId: ${n}.`);return t[n]})))}ngOnInit(){this.chartData$=Et([this.visibleAnnotations$,this.activeRuns$]).pipe(ft((([t,n])=>(function e(t,n,a){const o={},r={},i=new Set(n),c=kgt(a),s={max:-1,min:1};Object.values(t).forEach((t=>{t.forEach((t=>{const n=t.run;if(i.has(n)&&t.metric===c)if(null===t.nPMIValue)r[n]?r[n].push(null):r[n]=[null];else{const e=t.nPMIValue;s.max=s.max<e?e:s.max,s.min=s.min>e?e:s.min,o[t.run]?o[n].push(e):o[n]=[e]}}))}));const l={},m=h0().domain([s.min,s.max]).value((t=>t)),d=h0().domain([-1/0,1/0]).thresholds(0).value((t=>t));for(const t of i)if(l[t]=m(o[t]),r[t]){const n=d(r[t]);l[t].unshift(n[0])}return{violinData:l,extremes:s}})(t,n,this.metricName))))}removeMetric(){this.store.dispatch(sgt({metric:this.metricName}))}updateFilter(t){this.store.dispatch(lgt(Object.assign({metric:this.metricName},t)))}}function upt(t,n){if(1&t&&tp(0,"npmi-violin-filter",9),2&t){const t=n.$implicit;Jg("metricName",t[0])("filter",t[1])}}function fpt(t,n){1&t&&(Kg(0,"div",10),Kg(1,"span",11),Jp(2," You can add more filters at the top. "),$g(),$g())}bpt.ɵfac=function t(n){return new(n||bpt)(Zg(cv))},bpt.ɵcmp=_o({type:bpt,selectors:[["npmi-violin-filter"]],inputs:{metricName:"metricName",filter:"filter"},decls:4,vars:11,consts:[[3,"metricName","filter","chartData","width","colorScale","onRemove","onUpdateFilter"]],template:function t(n,e){1&n&&(Kg(0,"violin-filter-component",0),cp("onRemove",(function t(){return e.removeMetric()}))("onUpdateFilter",(function t(n){return e.updateFilter(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("metricName",e.metricName)("filter",e.filter)("chartData",kf(1,5,e.chartData$))("width",kf(2,7,e.chartWidth$))("colorScale",kf(3,9,e.runColorScale$))},directives:[ppt],pipes:[oO],encapsulation:2,changeDetection:0});class hpt{constructor(){this.toggleSidebarExpanded=new Ef}}hpt.ɵfac=function t(n){return new(n||hpt)},hpt.ɵcmp=_o({type:hpt,selectors:[["violin-filters-component"]],inputs:{sidebarExpanded:"sidebarExpanded",metricFilters:"metricFilters"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded"},decls:10,vars:2,consts:function(){return[[1,"filters-toolbar"],[1,"filters-title"],[1,"side-toggle"],["mat-icon-button","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Expand/Hide Sidebar"):$localize`:Label for a button that expands/hides the sidebar.␟48c29903ce881ab61088f8d49d827203716aaed4␟4658602991970260215:Expand/Hide Sidebar`],["svgIcon","chevron_left_24px"],[1,"filters"],[3,"metricName","filter",4,"ngFor","ngForOf"],["class","filters-hint",4,"ngIf"],[3,"metricName","filter"],[1,"filters-hint"],[1,"filters-hint-text"]]},template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"h3",1),Jp(2,"Active Filters"),$g(),Kg(3,"div",2),Kg(4,"button",3),lu(5,4),cp("click",(function t(){return e.toggleSidebarExpanded.emit()})),tp(6,"mat-icon",5),$g(),$g(),$g(),Kg(7,"div",6),Yg(8,upt,1,2,"npmi-violin-filter",7),$g(),Yg(9,fpt,3,0,"div",8)),2&n&&(ws(8),Jg("ngForOf",e.metricFilters),ws(1),Jg("ngIf",0===e.metricFilters.length))},directives:[eA,BB,jM,WM,bpt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.filters-toolbar[_ngcontent-%COMP%]{align-items:center;border-bottom:1px solid #ebebeb;display:flex;height:42px;justify-content:space-between;padding:0 10px}.filters-title[_ngcontent-%COMP%]{display:inline;font-size:14px;font-weight:500}.side-toggle[_ngcontent-%COMP%]{align-items:center;background-color:#fff;border-radius:3px;border:1px solid #ebebeb;display:flex;height:30px;justify-content:center;width:30px}.filters[_ngcontent-%COMP%]{overflow-y:auto}.filters-hint[_ngcontent-%COMP%]{align-items:center;display:flex;height:42px;padding:0 16px}.filters-hint-text[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}'],changeDetection:0});class _pt{constructor(t){this.store=t,this.sidebarExpanded$=this.store.select(jdt),this.metricFilters$=this.store.select(Ldt).pipe(ft((t=>Object.entries(t))))}onToggleSidebarExpanded(){this.store.dispatch(bgt())}}function Cpt(t,n,e){return t.length!=n.length?e:n.map(((n,e)=>n-t[e])).map((t=>Math.pow(t,2))).reduce(((t,n)=>t+n),0)}_pt.ɵfac=function t(n){return new(n||_pt)(Zg(cv))},_pt.ɵcmp=_o({type:_pt,selectors:[["npmi-violin-filters"]],decls:3,vars:6,consts:[[3,"sidebarExpanded","metricFilters","toggleSidebarExpanded"]],template:function t(n,e){1&n&&(Kg(0,"violin-filters-component",0),cp("toggleSidebarExpanded",(function t(){return e.onToggleSidebarExpanded()})),yf(1,"async"),yf(2,"async"),$g()),2&n&&Jg("sidebarExpanded",kf(1,2,e.sidebarExpanded$))("metricFilters",kf(2,4,e.metricFilters$))},directives:[hpt],pipes:[oO],encapsulation:2,changeDetection:0});const Mpt=["thumbContainer"],Opt=["toggleBar"],Ppt=["input"],xpt=function(){return{enterDuration:150}},ypt=new Fa("mat-slide-toggle-default-options",{providedIn:"root",factory:()=>({disableToggleValue:!1})});
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
let kpt=0;const vpt={provide:MF,useExisting:aa((()=>Ept)),multi:!0};class wpt{constructor(t,n){this.source=t,this.checked=n}}const Spt=oE(eE(aE(nE(class{constructor(t){this._elementRef=t}})),"accent"));class Ept extends Spt{constructor(t,n,e,a,o,r){super(t),this._focusMonitor=n,this._changeDetectorRef=e,this.defaults=o,this._animationMode=r,this._onChange=t=>{},this._onTouched=()=>{},this._uniqueId="mat-slide-toggle-"+ ++kpt,this._required=!1,this._checked=!1,this.name=null,this.id=this._uniqueId,this.labelPosition="after",this.ariaLabel=null,this.ariaLabelledby=null,this.change=new Ef,this.toggleChange=new Ef,this.tabIndex=parseInt(a)||0}get required(){return this._required}set required(t){this._required=Gw(t)}get checked(){return this._checked}set checked(t){this._checked=Gw(t),this._changeDetectorRef.markForCheck()}get inputId(){return`${this.id||this._uniqueId}-input`}ngAfterContentInit(){this._focusMonitor.monitor(this._elementRef,!0).subscribe((t=>{"keyboard"===t||"program"===t?this._inputElement.nativeElement.focus():t||Promise.resolve().then((()=>this._onTouched()))}))}ngOnDestroy(){this._focusMonitor.stopMonitoring(this._elementRef)}_onChangeEvent(t){t.stopPropagation(),this.toggleChange.emit(),this.defaults.disableToggleValue?this._inputElement.nativeElement.checked=this.checked:(this.checked=this._inputElement.nativeElement.checked,this._emitChangeEvent())}_onInputClick(t){t.stopPropagation()}writeValue(t){this.checked=!!t}registerOnChange(t){this._onChange=t}registerOnTouched(t){this._onTouched=t}setDisabledState(t){this.disabled=t,this._changeDetectorRef.markForCheck()}focus(t){this._focusMonitor.focusVia(this._inputElement,"keyboard",t)}toggle(){this.checked=!this.checked,this._onChange(this.checked)}_emitChangeEvent(){this._onChange(this.checked),this.change.emit(new wpt(this,this.checked))}_onLabelTextChange(){this._changeDetectorRef.detectChanges()}}Ept.ɵfac=function t(n){return new(n||Ept)(Zg(xu),Zg(TS),Zg(Vm),Xg("tabindex"),Zg(ypt),Zg(dk,8))},Ept.ɵcmp=_o({type:Ept,selectors:[["mat-slide-toggle"]],viewQuery:function t(n,e){var a;1&n&&(Uf(Mpt,!0),Uf(Opt,!0),Uf(Ppt,!0)),2&n&&(Vf(a=Zf())&&(e._thumbEl=a.first),Vf(a=Zf())&&(e._thumbBarEl=a.first),Vf(a=Zf())&&(e._inputElement=a.first))},hostAttrs:[1,"mat-slide-toggle"],hostVars:12,hostBindings:function t(n,e){2&n&&(eb("id",e.id),Ng("tabindex",e.disabled?null:-1)("aria-label",null)("aria-labelledby",null),Dp("mat-checked",e.checked)("mat-disabled",e.disabled)("mat-slide-toggle-label-before","before"==e.labelPosition)("_mat-animation-noopable","NoopAnimations"===e._animationMode))},inputs:{disabled:"disabled",disableRipple:"disableRipple",color:"color",tabIndex:"tabIndex",name:"name",id:"id",labelPosition:"labelPosition",ariaLabel:["aria-label","ariaLabel"],ariaLabelledby:["aria-labelledby","ariaLabelledby"],required:"required",checked:"checked"},outputs:{change:"change",toggleChange:"toggleChange"},exportAs:["matSlideToggle"],features:[Mu([vpt]),hg],ngContentSelectors:["*"],decls:16,vars:18,consts:[[1,"mat-slide-toggle-label"],["label",""],[1,"mat-slide-toggle-bar"],["toggleBar",""],["type","checkbox","role","switch",1,"mat-slide-toggle-input","cdk-visually-hidden",3,"id","required","tabIndex","checked","disabled","change","click"],["input",""],[1,"mat-slide-toggle-thumb-container"],["thumbContainer",""],[1,"mat-slide-toggle-thumb"],["mat-ripple","",1,"mat-slide-toggle-ripple","mat-focus-indicator",3,"matRippleTrigger","matRippleDisabled","matRippleCentered","matRippleRadius","matRippleAnimation"],[1,"mat-ripple-element","mat-slide-toggle-persistent-ripple"],[1,"mat-slide-toggle-content",3,"cdkObserveContent"],["labelContent",""],[2,"display","none"]],template:function t(n,e){if(1&n&&(bp(),Kg(0,"label",0,1),Kg(2,"div",2,3),Kg(4,"input",4,5),cp("change",(function t(n){return e._onChangeEvent(n)}))("click",(function t(n){return e._onInputClick(n)})),$g(),Kg(6,"div",6,7),tp(8,"div",8),Kg(9,"div",9),tp(10,"div",10),$g(),$g(),$g(),Kg(11,"span",11,12),cp("cdkObserveContent",(function t(){return e._onLabelTextChange()})),Kg(13,"span",13),Jp(14," "),$g(),hp(15),$g(),$g()),2&n){const t=qg(1),n=qg(12);Ng("for",e.inputId),ws(2),Dp("mat-slide-toggle-bar-no-side-margin",!n.textContent||!n.textContent.trim()),ws(2),Jg("id",e.inputId)("required",e.required)("tabIndex",e.tabIndex)("checked",e.checked)("disabled",e.disabled),Ng("name",e.name)("aria-checked",e.checked.toString())("aria-label",e.ariaLabel)("aria-labelledby",e.ariaLabelledby),ws(5),Jg("matRippleTrigger",t)("matRippleDisabled",e.disableRipple||e.disabled)("matRippleCentered",!0)("matRippleRadius",20)("matRippleAnimation",bf(17,xpt))}},directives:[zE,$w],styles:[".mat-slide-toggle{display:inline-block;height:24px;max-width:100%;line-height:24px;white-space:nowrap;outline:none;-webkit-tap-highlight-color:transparent}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb-container{transform:translate3d(16px, 0, 0)}[dir=rtl] .mat-slide-toggle.mat-checked .mat-slide-toggle-thumb-container{transform:translate3d(-16px, 0, 0)}.mat-slide-toggle.mat-disabled{opacity:.38}.mat-slide-toggle.mat-disabled .mat-slide-toggle-label,.mat-slide-toggle.mat-disabled .mat-slide-toggle-thumb-container{cursor:default}.mat-slide-toggle-label{display:flex;flex:1;flex-direction:row;align-items:center;height:inherit;cursor:pointer}.mat-slide-toggle-content{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.mat-slide-toggle-label-before .mat-slide-toggle-label{order:1}.mat-slide-toggle-label-before .mat-slide-toggle-bar{order:2}[dir=rtl] .mat-slide-toggle-label-before .mat-slide-toggle-bar,.mat-slide-toggle-bar{margin-right:8px;margin-left:0}[dir=rtl] .mat-slide-toggle-bar,.mat-slide-toggle-label-before .mat-slide-toggle-bar{margin-left:8px;margin-right:0}.mat-slide-toggle-bar-no-side-margin{margin-left:0;margin-right:0}.mat-slide-toggle-thumb-container{position:absolute;z-index:1;width:20px;height:20px;top:-3px;left:0;transform:translate3d(0, 0, 0);transition:all 80ms linear;transition-property:transform}._mat-animation-noopable .mat-slide-toggle-thumb-container{transition:none}[dir=rtl] .mat-slide-toggle-thumb-container{left:auto;right:0}.mat-slide-toggle-thumb{height:20px;width:20px;border-radius:50%}.mat-slide-toggle-bar{position:relative;width:36px;height:14px;flex-shrink:0;border-radius:8px}.mat-slide-toggle-input{bottom:0;left:10px}[dir=rtl] .mat-slide-toggle-input{left:auto;right:10px}.mat-slide-toggle-bar,.mat-slide-toggle-thumb{transition:all 80ms linear;transition-property:background-color;transition-delay:50ms}._mat-animation-noopable .mat-slide-toggle-bar,._mat-animation-noopable .mat-slide-toggle-thumb{transition:none}.mat-slide-toggle .mat-slide-toggle-ripple{position:absolute;top:calc(50% - 20px);left:calc(50% - 20px);height:40px;width:40px;z-index:1;pointer-events:none}.mat-slide-toggle .mat-slide-toggle-ripple .mat-ripple-element:not(.mat-slide-toggle-persistent-ripple){opacity:.12}.mat-slide-toggle-persistent-ripple{width:100%;height:100%;transform:none}.mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{opacity:.04}.mat-slide-toggle:not(.mat-disabled).cdk-keyboard-focused .mat-slide-toggle-persistent-ripple{opacity:.12}.mat-slide-toggle-persistent-ripple,.mat-slide-toggle.mat-disabled .mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{opacity:0}@media(hover: none){.mat-slide-toggle-bar:hover .mat-slide-toggle-persistent-ripple{display:none}}.cdk-high-contrast-active .mat-slide-toggle-thumb,.cdk-high-contrast-active .mat-slide-toggle-bar{border:1px solid}.cdk-high-contrast-active .mat-slide-toggle.cdk-keyboard-focused .mat-slide-toggle-bar{outline:2px dotted;outline-offset:5px}\n"],encapsulation:2,changeDetection:0}),Ept.ctorParameters=()=>[{type:xu},{type:TS},{type:Vm},{type:String,decorators:[{type:Be,args:["tabindex"]}]},{type:void 0,decorators:[{type:Ie,args:[ypt]}]},{type:String,decorators:[{type:Ne},{type:Ie,args:[dk]}]}],Ept.propDecorators={_thumbEl:[{type:Xd,args:["thumbContainer"]}],_thumbBarEl:[{type:Xd,args:["toggleBar"]}],name:[{type:f_}],id:[{type:f_}],labelPosition:[{type:f_}],ariaLabel:[{type:f_,args:["aria-label"]}],ariaLabelledby:[{type:f_,args:["aria-labelledby"]}],required:[{type:f_}],checked:[{type:f_}],change:[{type:h_}],toggleChange:[{type:h_}],_inputElement:[{type:Xd,args:["input"]}]};
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */
const Apt={provide:NF,useExisting:aa((()=>zpt)),multi:!0};class zpt extends lH{}zpt.ɵfac=function t(n){return Rpt(n||zpt)},zpt.ɵdir=vo({type:zpt,selectors:[["mat-slide-toggle","required","","formControlName",""],["mat-slide-toggle","required","","formControl",""],["mat-slide-toggle","required","","ngModel",""]],features:[Mu([Apt]),hg]});const Rpt=tc(zpt);
/**
     * @license
     * Copyright Google LLC All Rights Reserved.
     *
     * Use of this source code is governed by an MIT-style license that can be
     * found in the LICENSE file at https://angular.io/license
     */class Tpt{}Tpt.ɵmod=xo({type:Tpt}),Tpt.ɵinj=Ge({factory:function t(n){return new(n||Tpt)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Tpt,{declarations:[zpt],exports:[zpt]});class Dpt{}function Ipt(t,n){1&t&&tp(0,"mat-icon",3)}Dpt.ɵmod=xo({type:Dpt}),Dpt.ɵinj=Ge({factory:function t(n){return new(n||Dpt)},imports:[[Tpt,RE,tE,tS],Tpt,tE]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Dpt,{declarations:function(){return[Ept]},imports:function(){return[Tpt,RE,tE,tS]},exports:function(){return[Tpt,Ept,tE]}});class Npt{constructor(){this.onRegexFilterValueChange=new Ef}}Npt.ɵfac=function t(n){return new(n||Npt)},Npt.ɵcmp=_o({type:Npt,selectors:[["npmi-annotations-search-component"]],hostVars:2,hostBindings:function t(n,e){2&n&&Dp("valid",e.isRegexFilterValid)},inputs:{regexFilterValue:"regexFilterValue",isRegexFilterValid:"isRegexFilterValid"},outputs:{onRegexFilterValueChange:"onRegexFilterValueChange"},decls:3,vars:2,consts:[["svgIcon","search_24px"],["autocomplete","off","placeholder","Filter Annotations",3,"value","input"],["svgIcon","error_24px","class","error-icon","matTooltip","Invalid regex filter. The result may be stale.",4,"ngIf"],["svgIcon","error_24px","matTooltip","Invalid regex filter. The result may be stale.",1,"error-icon"]],template:function t(n,e){1&n&&(tp(0,"mat-icon",0),Kg(1,"input",1),cp("input",(function t(n){return e.onRegexFilterValueChange.emit(n.target.value)})),$g(),Yg(2,Ipt,1,0,"mat-icon",2)),2&n&&(ws(1),Jg("value",e.regexFilterValue),ws(1),Jg("ngIf",!e.isRegexFilterValid))},directives:[BB,WM],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;position:relative}[_nghost-%COMP%]:not(.valid){color:#c62828}[_nghost-%COMP%]:not(.valid)   input[_ngcontent-%COMP%]{caret-color:currentColor}[_nghost-%COMP%]:not(.valid)   .error-icon[_ngcontent-%COMP%]{color:#c62828;position:absolute;right:0}'],changeDetection:0});class Fpt{constructor(t){this.store=t,this.annotationsFilter$=this.store.select(Idt),this.isAnnotationsFilterValid$=this.annotationsFilter$.pipe(ft((t=>{try{return new RegExp(t),!0}catch(t){return!1}})))}filterChange(t){this.store.dispatch(rgt({regex:t}))}}function Lpt(t,n){if(1&t){const t=op();np(0),Kg(1,"button",6),lu(2,7),cp("click",(function n(){jr(t);const e=gp();return e.onFlagAnnotations.emit(e.selectedAnnotations)})),tp(3,"mat-icon",8),$g(),Kg(4,"button",9),lu(5,10),cp("click",(function n(){jr(t);const e=gp();return e.onHideAnnotations.emit(e.selectedAnnotations)})),tp(6,"mat-icon",11),$g(),ep()}if(2&t){const t=gp();ws(1),Jg("disabled",0===t.selectedAnnotations.length),ws(3),Jg("disabled",0===t.selectedAnnotations.length)}}function Hpt(t,n){if(1&t){const t=op();np(0),Kg(1,"mat-slide-toggle",12),cp("change",(function n(){return jr(t),gp().onToggleShowCounts.emit()})),Jp(2," Sample Count "),$g(),Kg(3,"mat-slide-toggle",13),cp("change",(function n(){return jr(t),gp().onToggleShowHidden.emit()})),Jp(4," Show Hidden "),$g(),tp(5,"npmi-annotations-search"),ep()}if(2&t){const t=gp();ws(1),Jg("checked",t.showCounts),ws(2),Jg("checked",t.showHidden)}}Fpt.ɵfac=function t(n){return new(n||Fpt)(Zg(cv))},Fpt.ɵcmp=_o({type:Fpt,selectors:[["npmi-annotations-search"]],decls:3,vars:6,consts:[[3,"regexFilterValue","isRegexFilterValid","onRegexFilterValueChange"]],template:function t(n,e){1&n&&(Kg(0,"npmi-annotations-search-component",0),cp("onRegexFilterValueChange",(function t(n){return e.filterChange(n)})),yf(1,"async"),yf(2,"async"),$g()),2&n&&Jg("regexFilterValue",kf(1,2,e.annotationsFilter$))("isRegexFilterValid",kf(2,4,e.isAnnotationsFilterValid$))},directives:[Npt],pipes:[oO],encapsulation:2,changeDetection:0});class Bpt{constructor(){this.onFlagAnnotations=new Ef,this.onHideAnnotations=new Ef,this.onToggleExpanded=new Ef,this.onToggleShowCounts=new Ef,this.onToggleShowHidden=new Ef}}Bpt.ɵfac=function t(n){return new(n||Bpt)},Bpt.ɵcmp=_o({type:Bpt,selectors:[["npmi-annotations-list-toolbar-component"]],inputs:{numAnnotations:"numAnnotations",expanded:"expanded",selectedAnnotations:"selectedAnnotations",annotationsExpanded:"annotationsExpanded",showCounts:"showCounts",showHidden:"showHidden"},outputs:{onFlagAnnotations:"onFlagAnnotations",onHideAnnotations:"onHideAnnotations",onToggleExpanded:"onToggleExpanded",onToggleShowCounts:"onToggleShowCounts",onToggleShowHidden:"onToggleShowHidden"},decls:8,vars:4,consts:function(){return[[1,"annotations-title-container"],[1,"annotations-title"],[4,"ngIf"],["mat-icon-button","",1,"expand-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Hides/Shows the Annotations List"):$localize`:Label for a button that hides/shows the annotations list.␟b3603ba33e5308dd8c5e805e508b2f7233df89d4␟7336374413056342492:Hides/Shows the Annotations List`],[3,"svgIcon"],["mat-icon-button","","title","Flagging annotations adds them to your investigation results, which can later be exported.",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Flag Selected Annotations"):$localize`:Label for a button that flags selected annotations.␟5692ad8831038a90c5863a1e9adf9748cac3cad8␟2244099891313336595:Flag Selected Annotations`],["svgIcon","flag_24px"],["mat-icon-button","","title","Removing non-critical annotations unclutters the view. Removed annotations are removed from all visualizations.",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Hide Selected Annotations"):$localize`:Label for a button that hides selected annotations.␟0342cdb3358fa8e3fa27220a8258a7287430b70f␟5462832391092087485:Hide Selected Annotations`],["svgIcon","visibility_off_24px"],["title","Hides and shows the sample count where applicable (how many samples belong to a category).",1,"show-toggle",3,"checked","change"],["title","Hides and shows hidden annotations in all visualizations.",1,"show-toggle",3,"checked","change"]]},template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"h3",1),Jp(2),$g(),Yg(3,Lpt,7,2,"ng-container",2),$g(),Yg(4,Hpt,6,2,"ng-container",2),Kg(5,"button",3),lu(6,4),cp("click",(function t(){return e.onToggleExpanded.emit()})),tp(7,"mat-icon",5),$g()),2&n&&(ws(2),Kp("Annotations (",e.numAnnotations,")"),ws(1),Jg("ngIf",e.expanded),ws(1),Jg("ngIf",e.expanded),ws(3),Jg("svgIcon",e.expanded?"expand_less_24px":"expand_more_24px"))},directives:[WM,eA,BB,Ept,Fpt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{align-items:center;box-sizing:border-box;display:flex;flex-direction:row;padding:0 16px;width:100%}.annotations-title[_ngcontent-%COMP%]{display:inline;font-size:.9em;font-weight:500;padding-right:10px}.annotations-title-container[_ngcontent-%COMP%]{align-items:center;display:flex;flex-wrap:nowrap;flex:1 1;height:42px}.show-toggle[_ngcontent-%COMP%]{font-size:.9em;margin-right:.8em}'],changeDetection:0});class Vpt{constructor(t){this.store=t,this.selectedAnnotations$=this.store.select(Rdt),this.annotationsExpanded$=this.store.select(Vdt),this.showCounts$=this.store.select(Udt),this.showHidden$=this.store.select(Wdt),this.annotationsFilter$=this.store.select(Idt),this.isAnnotationsFilterValid$=this.annotationsFilter$.pipe(ft((t=>{try{return Boolean(new RegExp(t))}catch(t){return!1}})))}filterChange(t){this.store.dispatch(rgt({regex:t}))}flagAnnotations(t){this.store.dispatch(agt({annotations:t}))}hideAnnotations(t){this.store.dispatch(ogt({annotations:t}))}toggleExpanded(){this.store.dispatch(pgt())}toggleShowCounts(){this.store.dispatch(ugt())}toggleShowHidden(){this.store.dispatch(fgt())}}Vpt.ɵfac=function t(n){return new(n||Vpt)(Zg(cv))},Vpt.ɵcmp=_o({type:Vpt,selectors:[["npmi-annotations-list-toolbar"]],inputs:{numAnnotations:"numAnnotations",expanded:"expanded"},decls:5,vars:14,consts:[[3,"numAnnotations","expanded","selectedAnnotations","annotationsExpanded","showCounts","showHidden","onFlagAnnotations","onHideAnnotations","onToggleExpanded","onToggleShowCounts","onToggleShowHidden"]],template:function t(n,e){1&n&&(Kg(0,"npmi-annotations-list-toolbar-component",0),cp("onFlagAnnotations",(function t(n){return e.flagAnnotations(n)}))("onHideAnnotations",(function t(n){return e.hideAnnotations(n)}))("onToggleExpanded",(function t(){return e.toggleExpanded()}))("onToggleShowCounts",(function t(){return e.toggleShowCounts()}))("onToggleShowHidden",(function t(){return e.toggleShowHidden()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),$g()),2&n&&Jg("numAnnotations",e.numAnnotations)("expanded",e.expanded)("selectedAnnotations",kf(1,6,e.selectedAnnotations$))("annotationsExpanded",kf(2,8,e.annotationsExpanded$))("showCounts",kf(3,10,e.showCounts$))("showHidden",kf(4,12,e.showHidden$))},directives:[Bpt],pipes:[oO],encapsulation:2,changeDetection:0});const jpt=["glyph"];class Upt{ngAfterViewInit(){this.svg=j1(this.glyphSVG.nativeElement),this.mainContainer=this.svg.append("g"),this.draw()}draw(){"circle"==this.shape?this.mainContainer.append("circle").attr("fill",this.color).attr("stroke","black").attr("cx",5).attr("cy",5).attr("r",5):"bar"==this.shape?this.mainContainer.append("rect").attr("fill",this.color).attr("x",0).attr("y",0).attr("width",10).attr("height",10):"runIndicator"==this.shape&&this.mainContainer.append("g").append("path").attr("fill",this.color).attr("stroke","black").attr("d","M 2 0 L 10 0 L 7 5 L 10 10 L 2 10 Z")}}Upt.ɵfac=function t(n){return new(n||Upt)},Upt.ɵcmp=_o({type:Upt,selectors:[["npmi-legend-element"]],viewQuery:function t(n,e){var a;1&n&&jf(jpt,!0,xu),2&n&&Vf(a=Zf())&&(e.glyphSVG=a.first)},inputs:{text:"text",color:"color",shape:"shape"},decls:4,vars:1,consts:[[1,"glyph"],["glyph",""],[1,"legend-element-title"]],template:function t(n,e){1&n&&(ui(),tp(0,"svg",0,1),fi(),Kg(2,"div",2),Jp(3),$g()),2&n&&(ws(3),Qp(e.text))},styles:["[_nghost-%COMP%]{align-items:center;display:flex;padding-right:10px}.legend-element-title[_ngcontent-%COMP%]{font-size:.8em;padding-left:5px}.glyph[_ngcontent-%COMP%]{width:10px;height:10px}"],changeDetection:0});class Wpt{}function Gpt(t,n){if(1&t&&tp(0,"mat-icon",8),2&t){const t=gp(2);Jg("svgIcon",t.sort.order===t.SortOrder.DESCENDING?"arrow_downward_24px":"arrow_upward_24px")("ngClass",t.sort.order===t.SortOrder.DESCENDING?"down-icon":"up-icon")}}function Ypt(t,n){if(1&t){const t=op();Kg(0,"div",4),Kg(1,"div",5),Kg(2,"div",6),cp("click",(function e(){jr(t);const a=n.$implicit;return gp().onChangeSort.emit(a)})),Jp(3),Yg(4,Gpt,1,2,"mat-icon",7),$g(),$g(),$g()}if(2&t){const t=n.$implicit,e=gp();ws(3),Kp(" ",e.stripMetric(t)," "),ws(1),Jg("ngIf",t===e.sort.metric)}}Wpt.ɵfac=function t(n){return new(n||Wpt)},Wpt.ɵcmp=_o({type:Wpt,selectors:[["npmi-annotations-list-legend"]],decls:4,vars:0,consts:[["text","run indicator","color","rgb(0,0,0)","shape","runIndicator"],["text","positive correlation","color","rgb(109, 174, 213)","shape","bar"],["text","negative correlation","color","rgb(249, 105, 76)","shape","bar"],["text","sample count","color","rgb(151, 151, 151)","shape","circle"]],template:function t(n,e){1&n&&(tp(0,"npmi-legend-element",0),tp(1,"npmi-legend-element",1),tp(2,"npmi-legend-element",2),tp(3,"npmi-legend-element",3))},directives:[Upt],styles:["[_nghost-%COMP%]{display:flex;padding:0 16px}"]});class qpt{constructor(){this.onChangeSort=new Ef,this.onAllAnnotationsToggled=new Ef,this.SortOrder=kdt}stripMetric(t){return kgt(t)}}qpt.ɵfac=function t(n){return new(n||qpt)},qpt.ɵcmp=_o({type:qpt,selectors:[["npmi-annotations-list-header-component"]],inputs:{numAnnotations:"numAnnotations",selectedAnnotations:"selectedAnnotations",activeMetrics:"activeMetrics",sort:"sort"},outputs:{onChangeSort:"onChangeSort",onAllAnnotationsToggled:"onAllAnnotationsToggled"},decls:4,vars:2,consts:[[1,"toggle-all-container"],[3,"checked","change"],[1,"annotations-header-containers"],["class","header-column",4,"ngFor","ngForOf"],[1,"header-column"],[1,"header-container"],["tabindex","0","role","button","title","Change the sort by clicking any of the metrics.",1,"header-clickable",3,"click"],["class","sort-icon",3,"svgIcon","ngClass",4,"ngIf"],[1,"sort-icon",3,"svgIcon","ngClass"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"mat-checkbox",1),cp("change",(function t(n){return e.onAllAnnotationsToggled.emit(n.checked)})),$g(),$g(),Kg(2,"div",2),Yg(3,Ypt,5,2,"div",3),$g()),2&n&&(ws(1),Jg("checked",e.selectedAnnotations.length===e.numAnnotations),ws(2),Jg("ngForOf",e.activeMetrics))},directives:[rV,jM,WM,BB,HM],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{border-bottom:2px solid #ebebeb;display:flex;height:28px;align-items:flex-end;margin-top:8px}.annotations-header-containers[_ngcontent-%COMP%]{display:flex;font-size:.9em;font-weight:500;flex-grow:1}.header-column[_ngcontent-%COMP%]{flex:1 1}.header-container[_ngcontent-%COMP%]{display:inline-block}.header-clickable[_ngcontent-%COMP%]{cursor:pointer;display:flex;outline:none}.toggle-all-container[_ngcontent-%COMP%]{margin-left:10px;width:90px}.sort-icon[_ngcontent-%COMP%]{height:16px}'],changeDetection:0});class Zpt{constructor(t){this.store=t,this.selectedAnnotations$=this.store.select(Rdt),this.annotationSort$=this.store.select(Hdt)}changeSort(t){this.store.dispatch(mgt({metric:t}))}allAnnotationsToggled(t){this.store.dispatch(ngt(t?{annotations:Object.keys(this.annotations)}:{annotations:[]}))}}Zpt.ɵfac=function t(n){return new(n||Zpt)(Zg(cv))},Zpt.ɵcmp=_o({type:Zpt,selectors:[["npmi-annotations-list-header"]],inputs:{numAnnotations:"numAnnotations",annotations:"annotations",activeMetrics:"activeMetrics"},decls:3,vars:8,consts:[[3,"numAnnotations","selectedAnnotations","sort","activeMetrics","onChangeSort","onAllAnnotationsToggled"]],template:function t(n,e){1&n&&(Kg(0,"npmi-annotations-list-header-component",0),cp("onChangeSort",(function t(n){return e.changeSort(n)}))("onAllAnnotationsToggled",(function t(n){return e.allAnnotationsToggled(n)})),yf(1,"async"),yf(2,"async"),$g()),2&n&&Jg("numAnnotations",e.numAnnotations)("selectedAnnotations",kf(1,4,e.selectedAnnotations$))("sort",kf(2,6,e.annotationSort$))("activeMetrics",e.activeMetrics)},directives:[qpt],pipes:[oO],encapsulation:2,changeDetection:0});const Xpt=["chart"],Jpt=["hintClip"];function Qpt(t,n){1&t&&tp(0,"mat-icon",12)}function Kpt(t,n){1&t&&tp(0,"mat-icon",13)}function $pt(t,n){if(1&t&&tp(0,"mat-icon",14),2&t){const t=gp();Jg("svgIcon",t.sort.order===t.SortOrder.SIMILAR?"arrow_downward_24px":"arrow_upward_24px")("ngClass",t.sort.order===t.SortOrder.SIMILAR?"down-icon":"up-icon")}}class tbt{constructor(){this.selected=!1,this.onShowSimilarAnnotations=new Ef,this.SortOrder=kdt,this.width=10,this.chartWidth=10,this.chartHeight=10,this.maxDotRadius=10,this.countDotOffset=70,this.countTextPadding=2,this.margin={top:0,right:0,bottom:0,left:100},this.strokeColor="#fff",this.textClass="default-text",this.runs=[]}onResize(t){this.redraw()}ngAfterViewInit(){this.svg=j1(this.annotationContainer.nativeElement).select("svg"),this.xScale=p6().padding(0),this.yScale=p6().padding(0),this.sizeScale=k6().domain([0,1]),this.countSizeScale=k6().range([2,this.maxDotRadius]),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.barsGroup=this.mainContainer.append("g"),this.countDotsGroup=this.mainContainer.append("g"),this.textsGroup=this.mainContainer.append("g"),this.countTextsGroup=this.mainContainer.append("g"),this.runHintGroup=this.svg.append("g"),this.redraw()}ngOnChanges(t){this.svg&&this.redraw()}redraw(){this.selected=this.selectedAnnotations.includes(this.annotation),this.updateDimensions(),this.setTextClass(),this.updateAxes(),this.draw()}updateDimensions(){const t=new Set;this.data.forEach((n=>{t.add(n.run)})),this.runs=[...t],this.svg.style("height",this.numActiveRuns*this.runHeight+"px"),this.chartHeight=this.runs.length*this.runHeight-this.margin.top-this.margin.bottom,this.width=this.annotationContainer.nativeElement.clientWidth||10,this.chartWidth=this.width-this.margin.left-this.margin.right}setTextClass(){this.textClass="default-text",this.flaggedAnnotations.includes(this.annotation)?this.textClass="flag-text":this.hiddenAnnotations.includes(this.annotation)&&(this.textClass="hidden-text")}updateAxes(){this.xScale.rangeRound([0,this.chartWidth-this.chartWidth/this.activeMetrics.length]).domain(this.activeMetrics.map((t=>kgt(t)))),this.yScale.rangeRound([0,this.chartHeight-this.runHeight]).domain(this.runs),this.sizeScale.range([0,this.chartWidth/this.activeMetrics.length]),this.countSizeScale.domain([0,this.maxCount])}draw(){this.drawRunIndicators(),this.drawRunHintTexts(),this.drawBars(),this.drawTexts(),this.showCounts?(this.drawCountDots(),this.drawCountTexts()):(this.countDotsGroup.selectAll(".count-dot").remove(),this.countTextsGroup.selectAll(".count-background-text").remove(),this.countTextsGroup.selectAll(".count-text").remove())}drawRunIndicators(){j1(this.clipPathElement.nativeElement).select("rect").attr("width",this.margin.left-30).attr("height",this.chartHeight);const t=this.runHintGroup.selectAll(".hint").data(this.runs),n=t.enter().append("g").attr("class","hint");n.append("path").attr("d","M 0 0 L 15 0 L 10 10 L 15 20 L 0 20 Z"),n.merge(t).attr("transform",function(t){return`translate(10, ${this.yScale(t)+5})`}.bind(this)).attr("fill",function(t){return this.colorScale(t)}.bind(this)),t.exit().remove()}drawRunHintTexts(){const t=this.runHintGroup.selectAll(".hint-text").data(this.runs);t.enter().append("text").attr("x",25).attr("font-size","10px").attr("alignment-baseline","middle").attr("clip-path","url(#hint-clip)").merge(t).attr("y",function(t){return this.yScale(t)+15}.bind(this)).attr("class",`hint-text ${this.textClass}`).text((t=>{var n;return(null===(n=this.runIdToRuns.get(t))||void 0===n?void 0:n.name)||""})),t.exit().remove()}drawBars(){const t=this.barsGroup.selectAll(".bar").data(this.data);t.enter().append("rect").attr("class","bar").attr("height",20).merge(t).attr("fill",(t=>null===t.nPMIValue?"":t.nPMIValue>=0?A8(t.nPMIValue):R8(-1*t.nPMIValue))).attr("x",function(t){return this.xScale(t.metric)}.bind(this)).attr("y",function(t){return this.yScale(t.run)+5}.bind(this)).attr("width",function(t){return null===t.nPMIValue?0:this.sizeScale(Math.abs(t.nPMIValue))}.bind(this)),t.exit().remove()}drawCountDots(){const t=this.countDotsGroup.selectAll(".count-dot").data(this.data);t.enter().append("circle").attr("class","count-dot").attr("stroke","black").merge(t).attr("fill",function(t){return null===t.countValue?"":z8(t.countValue/this.maxCount)}.bind(this)).attr("cx",function(t){return this.xScale(t.metric)+this.countDotOffset}.bind(this)).attr("cy",function(t){return this.yScale(t.run)+this.runHeight/2}.bind(this)).attr("r",function(t){return null===t.countValue?0:this.countSizeScale(t.countValue)}.bind(this)),t.exit().remove()}drawTexts(){const t=this.textsGroup.selectAll(".npmi-background-text").data(this.data);t.enter().append("text").attr("class","npmi-background-text").attr("stroke-width",3).attr("stroke-linejoin","round").attr("stroke",this.strokeColor).attr("font-size","13px").attr("alignment-baseline","middle").merge(t).attr("x",function(t){return this.xScale(t.metric)+5}.bind(this)).attr("y",function(t){return this.yScale(t.run)+this.runHeight/2}.bind(this)).text((t=>null===t.nPMIValue?"null":Math.round(1e3*(t.nPMIValue+Number.EPSILON))/1e3)),t.exit().remove();const n=this.textsGroup.selectAll(".npmi-text").data(this.data);n.enter().append("text").attr("class","npmi-text").attr("font-size","13px").attr("alignment-baseline","middle").merge(n).attr("x",function(t){return this.xScale(t.metric)+5}.bind(this)).attr("y",function(t){return this.yScale(t.run)+this.runHeight/2}.bind(this)).text((t=>null===t.nPMIValue?"null":Math.round(1e3*(t.nPMIValue+Number.EPSILON))/1e3)),n.exit().remove()}drawCountTexts(){const t=this.countTextsGroup.selectAll(".count-background-text").data(this.data);t.enter().append("text").attr("class","count-background-text").attr("stroke-width",3).attr("stroke-linejoin","round").attr("stroke",this.strokeColor).attr("font-size","10px").attr("alignment-baseline","middle").merge(t).attr("x",function(t){return this.xScale(t.metric)+this.countDotOffset+this.countTextPadding+this.maxDotRadius}.bind(this)).attr("y",function(t){return this.yScale(t.run)+this.runHeight/2}.bind(this)).text((t=>null===t.countValue?"":Intl.NumberFormat().format(t.countValue))),t.exit().remove();const n=this.countTextsGroup.selectAll(".count-text").data(this.data);n.enter().append("text").attr("class","count-text").attr("font-size","10px").attr("alignment-baseline","middle").merge(n).attr("x",function(t){return this.xScale(t.metric)+this.countDotOffset+this.countTextPadding+this.maxDotRadius}.bind(this)).attr("y",function(t){return this.yScale(t.run)+this.runHeight/2}.bind(this)).text((t=>null===t.countValue?"":Intl.NumberFormat().format(t.countValue))),n.exit().remove()}similaritySort(t){this.hasEmbedding&&(t.stopPropagation(),this.onShowSimilarAnnotations.emit())}}tbt.ɵfac=function t(n){return new(n||tbt)},tbt.ɵcmp=_o({type:tbt,selectors:[["annotation-component"]],viewQuery:function t(n,e){var a;1&n&&(jf(Xpt,!0,xu),jf(Jpt,!0,xu)),2&n&&(Vf(a=Zf())&&(e.annotationContainer=a.first),Vf(a=Zf())&&(e.clipPathElement=a.first))},hostVars:2,hostBindings:function t(n,e){1&n&&cp("resize",(function t(){return e.onResize()}),!1,er),2&n&&Dp("selected-row",e.selected)},inputs:{data:"data",maxCount:"maxCount",selectedAnnotations:"selectedAnnotations",flaggedAnnotations:"flaggedAnnotations",hiddenAnnotations:"hiddenAnnotations",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",showCounts:"showCounts",annotation:"annotation",runHeight:"runHeight",hasEmbedding:"hasEmbedding",sort:"sort",sidebarWidth:"sidebarWidth",colorScale:"colorScale",runIdToRuns:"runIdToRuns"},outputs:{onShowSimilarAnnotations:"onShowSimilarAnnotations"},features:[pr],decls:14,vars:10,consts:[[1,"annotation-title"],[1,"annotation-checkbox",3,"checked","click"],[1,"annotation-button",3,"ngClass","click"],["class","flagged-icon","svgIcon","flag_24px",4,"ngIf"],["class","hidden-icon","svgIcon","visibility_off_24px",4,"ngIf"],["class","annotation-icon",3,"svgIcon","ngClass",4,"ngIf"],[1,"chart-div"],["chart",""],[1,"chart-svg"],["id","hint-clip"],["hintClip",""],["x","0","y","0"],["svgIcon","flag_24px",1,"flagged-icon"],["svgIcon","visibility_off_24px",1,"hidden-icon"],[1,"annotation-icon",3,"svgIcon","ngClass"]],template:function t(n,e){1&n&&(Kg(0,"div",0),Kg(1,"mat-checkbox",1),cp("click",(function t(n){return n.preventDefault()})),$g(),Kg(2,"button",2),cp("click",(function t(n){return e.similaritySort(n)})),Jp(3),$g(),Yg(4,Qpt,1,0,"mat-icon",3),Yg(5,Kpt,1,0,"mat-icon",4),Yg(6,$pt,1,2,"mat-icon",5),$g(),Kg(7,"div",6,7),ui(),Kg(9,"svg",8),Kg(10,"defs"),Kg(11,"clipPath",9,10),tp(13,"rect",11),$g(),$g(),$g(),$g()),2&n&&(Dp("flagged-annotation",e.flaggedAnnotations.includes(e.annotation))("hidden-annotation",e.hiddenAnnotations.includes(e.annotation)&&!e.flaggedAnnotations.includes(e.annotation)),ws(1),Jg("checked",e.selectedAnnotations.includes(e.annotation)),ws(1),Jg("ngClass",e.hasEmbedding?"clickable-annotation":""),ws(1),Kp(" ",e.annotation," "),ws(1),Jg("ngIf",e.flaggedAnnotations.includes(e.annotation)),ws(1),Jg("ngIf",e.hiddenAnnotations.includes(e.annotation)),ws(1),Jg("ngIf",e.annotation===e.sort.metric))},directives:[rV,HM,WM,BB],styles:['.mat-badge-content{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small .mat-badge-content{font-size:9px}.mat-badge-large .mat-badge-content{font-size:24px}.mat-h1,.mat-headline,.mat-typography h1{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2,.mat-title,.mat-typography h2{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3,.mat-subheading-2,.mat-typography h3{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4,.mat-subheading-1,.mat-typography h4{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5,.mat-typography h5{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6,.mat-typography h6{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong,.mat-body-2{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body,.mat-body-1,.mat-typography{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body p,.mat-body-1 p,.mat-typography p{margin:0 0 12px}.mat-small,.mat-caption{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4,.mat-typography .mat-display-4{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3,.mat-typography .mat-display-3{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2,.mat-typography .mat-display-2{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1,.mat-typography .mat-display-1{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button,.mat-raised-button,.mat-icon-button,.mat-stroked-button,.mat-flat-button,.mat-fab,.mat-mini-fab{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title{font-size:24px;font-weight:500}.mat-card-header .mat-card-title{font-size:20px}.mat-card-subtitle,.mat-card-content{font-size:14px}.mat-checkbox{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout .mat-checkbox-label{line-height:24px}.mat-chip{font-size:14px;font-weight:500}.mat-chip .mat-chip-trailing-icon.mat-icon,.mat-chip .mat-chip-remove.mat-icon{font-size:18px}.mat-table{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell{font-size:12px;font-weight:500}.mat-cell,.mat-footer-cell{font-size:14px}.mat-calendar{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body{font-size:13px}.mat-calendar-body-label,.mat-calendar-period-button{font-size:14px;font-weight:500}.mat-calendar-table-header th{font-size:11px;font-weight:400}.mat-dialog-title{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper{padding-bottom:1.34375em}.mat-form-field-prefix .mat-icon,.mat-form-field-suffix .mat-icon{font-size:150%;line-height:1.125}.mat-form-field-prefix .mat-icon-button,.mat-form-field-suffix .mat-icon-button{height:1.5em;width:1.5em}.mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field-suffix .mat-icon-button .mat-icon{height:1.125em;line-height:1.125}.mat-form-field-infix{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper{top:-0.84375em;padding-top:.84375em}.mat-form-field-label{top:1.34375em}.mat-form-field-underline{bottom:1.34375em}.mat-form-field-subscript-wrapper{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy .mat-form-field-wrapper{padding-bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-infix{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy .mat-form-field-label{top:1.28125em}.mat-form-field-appearance-legacy .mat-form-field-underline{bottom:1.25em}.mat-form-field-appearance-legacy .mat-form-field-subscript-wrapper{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-form-field-autofill-control:-webkit-autofill+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill .mat-form-field-infix{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill .mat-form-field-label{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline .mat-form-field-infix{padding:1em 0 1em 0}.mat-form-field-appearance-outline .mat-form-field-label{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float .mat-form-field-label,.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server:focus+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float .mat-input-server[label]:not(:label-shown)+.mat-form-field-label-wrapper .mat-form-field-label{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header,.mat-grid-tile-footer{font-size:14px}.mat-grid-tile-header .mat-line,.mat-grid-tile-footer .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header .mat-line:nth-child(n+2),.mat-grid-tile-footer .mat-line:nth-child(n+2){font-size:12px}input.mat-input-element{margin-top:-0.0625em}.mat-menu-item{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger{height:1.125em}.mat-slide-toggle-content{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical,.mat-stepper-horizontal{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label{font-size:14px;font-weight:400}.mat-step-sub-label-error{font-weight:normal}.mat-step-label-error{font-size:14px}.mat-step-label-selected{font-size:14px;font-weight:500}.mat-tab-group{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label,.mat-tab-link{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar,.mat-toolbar h1,.mat-toolbar h2,.mat-toolbar h3,.mat-toolbar h4,.mat-toolbar h5,.mat-toolbar h6{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base .mat-list-item{font-size:16px}.mat-list-base .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-item .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-list-option{font-size:16px}.mat-list-base .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base .mat-list-option .mat-line:nth-child(n+2){font-size:14px}.mat-list-base .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense] .mat-list-item{font-size:12px}.mat-list-base[dense] .mat-list-item .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-item .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-list-option{font-size:12px}.mat-list-base[dense] .mat-list-option .mat-line{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense] .mat-list-option .mat-line:nth-child(n+2){font-size:12px}.mat-list-base[dense] .mat-subheader{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node,.mat-nested-tree-node{font-weight:400;font-size:14px}.mat-ripple{overflow:hidden;position:relative}.mat-ripple:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded{overflow:visible}.mat-ripple-element{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active .mat-ripple-element{display:none}.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.6}}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop,.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing{opacity:0}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{/*!*/}@keyframes cdk-text-field-autofill-end{/*!*/}.cdk-text-field-autofill-monitored:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize{resize:none}textarea.cdk-textarea-autosize-measuring{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator{position:relative}.mat-mdc-focus-indicator{position:relative}.mat-ripple-element{background-color:rgba(0,0,0,.1)}.mat-option{color:#212121}.mat-option:hover:not(.mat-option-disabled),.mat-option:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled{color:rgba(0,0,0,.38)}.mat-primary .mat-option.mat-selected:not(.mat-option-disabled){color:#f57c00}.mat-accent .mat-option.mat-selected:not(.mat-option-disabled){color:#ff9800}.mat-warn .mat-option.mat-selected:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label{color:#616161}.mat-optgroup-disabled .mat-optgroup-label{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox{color:#616161}.mat-pseudo-checkbox::after{color:#fafafa}.mat-pseudo-checkbox-disabled{color:#b0b0b0}.mat-primary .mat-pseudo-checkbox-checked,.mat-primary .mat-pseudo-checkbox-indeterminate{background:#f57c00}.mat-pseudo-checkbox-checked,.mat-pseudo-checkbox-indeterminate,.mat-accent .mat-pseudo-checkbox-checked,.mat-accent .mat-pseudo-checkbox-indeterminate{background:#ff9800}.mat-warn .mat-pseudo-checkbox-checked,.mat-warn .mat-pseudo-checkbox-indeterminate{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled,.mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled{background:#b0b0b0}.mat-app-background{background-color:#fafafa;color:#212121}.mat-elevation-z0{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker{display:none}.mat-autocomplete-panel{background:#fff;color:#212121}.mat-autocomplete-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel .mat-option.mat-selected:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content{color:#fff;background:#f57c00}.cdk-high-contrast-active .mat-badge-content{outline:solid 1px;border-radius:0}.mat-badge-accent .mat-badge-content{background:#ff9800;color:#fff}.mat-badge-warn .mat-badge-content{color:#fff;background:#f44336}.mat-badge{position:relative}.mat-badge-hidden .mat-badge-content{display:none}.mat-badge-disabled .mat-badge-content{background:#b9b9b9;color:#757575}.mat-badge-content{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled .mat-badge-content,.mat-badge-content._mat-animation-noopable{transition:none}.mat-badge-content.mat-badge-active{transform:none}.mat-badge-small .mat-badge-content{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above .mat-badge-content{top:-8px}.mat-badge-small.mat-badge-below .mat-badge-content{bottom:-8px}.mat-badge-small.mat-badge-before .mat-badge-content{left:-16px}[dir=rtl] .mat-badge-small.mat-badge-before .mat-badge-content{left:auto;right:-16px}.mat-badge-small.mat-badge-after .mat-badge-content{right:-16px}[dir=rtl] .mat-badge-small.mat-badge-after .mat-badge-content{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-8px}[dir=rtl] .mat-badge-small.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-8px}.mat-badge-medium .mat-badge-content{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above .mat-badge-content{top:-11px}.mat-badge-medium.mat-badge-below .mat-badge-content{bottom:-11px}.mat-badge-medium.mat-badge-before .mat-badge-content{left:-22px}[dir=rtl] .mat-badge-medium.mat-badge-before .mat-badge-content{left:auto;right:-22px}.mat-badge-medium.mat-badge-after .mat-badge-content{right:-22px}[dir=rtl] .mat-badge-medium.mat-badge-after .mat-badge-content{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-11px}[dir=rtl] .mat-badge-medium.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-11px}.mat-badge-large .mat-badge-content{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above .mat-badge-content{top:-14px}.mat-badge-large.mat-badge-below .mat-badge-content{bottom:-14px}.mat-badge-large.mat-badge-before .mat-badge-content{left:-28px}[dir=rtl] .mat-badge-large.mat-badge-before .mat-badge-content{left:auto;right:-28px}.mat-badge-large.mat-badge-after .mat-badge-content{right:-28px}[dir=rtl] .mat-badge-large.mat-badge-after .mat-badge-content{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-before .mat-badge-content{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:-14px}[dir=rtl] .mat-badge-large.mat-badge-overlap.mat-badge-after .mat-badge-content{right:auto;left:-14px}.mat-bottom-sheet-container{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button,.mat-icon-button,.mat-stroked-button{color:inherit;background:transparent}.mat-button.mat-primary,.mat-icon-button.mat-primary,.mat-stroked-button.mat-primary{color:#f57c00}.mat-button.mat-accent,.mat-icon-button.mat-accent,.mat-stroked-button.mat-accent{color:#ff9800}.mat-button.mat-warn,.mat-icon-button.mat-warn,.mat-stroked-button.mat-warn{color:#f44336}.mat-button.mat-primary.mat-button-disabled,.mat-button.mat-accent.mat-button-disabled,.mat-button.mat-warn.mat-button-disabled,.mat-button.mat-button-disabled.mat-button-disabled,.mat-icon-button.mat-primary.mat-button-disabled,.mat-icon-button.mat-accent.mat-button-disabled,.mat-icon-button.mat-warn.mat-button-disabled,.mat-icon-button.mat-button-disabled.mat-button-disabled,.mat-stroked-button.mat-primary.mat-button-disabled,.mat-stroked-button.mat-accent.mat-button-disabled,.mat-stroked-button.mat-warn.mat-button-disabled,.mat-stroked-button.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-button.mat-primary .mat-button-focus-overlay,.mat-icon-button.mat-primary .mat-button-focus-overlay,.mat-stroked-button.mat-primary .mat-button-focus-overlay{background-color:#f57c00}.mat-button.mat-accent .mat-button-focus-overlay,.mat-icon-button.mat-accent .mat-button-focus-overlay,.mat-stroked-button.mat-accent .mat-button-focus-overlay{background-color:#ff9800}.mat-button.mat-warn .mat-button-focus-overlay,.mat-icon-button.mat-warn .mat-button-focus-overlay,.mat-stroked-button.mat-warn .mat-button-focus-overlay{background-color:#f44336}.mat-button.mat-button-disabled .mat-button-focus-overlay,.mat-icon-button.mat-button-disabled .mat-button-focus-overlay,.mat-stroked-button.mat-button-disabled .mat-button-focus-overlay{background-color:transparent}.mat-button .mat-ripple-element,.mat-icon-button .mat-ripple-element,.mat-stroked-button .mat-ripple-element{opacity:.1;background-color:currentColor}.mat-button-focus-overlay{background:#000}.mat-stroked-button:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button,.mat-raised-button,.mat-fab,.mat-mini-fab{color:#212121;background-color:#fff}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{color:#fff}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{color:#fff}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary,.mat-raised-button.mat-primary,.mat-fab.mat-primary,.mat-mini-fab.mat-primary{background-color:#f57c00}.mat-flat-button.mat-accent,.mat-raised-button.mat-accent,.mat-fab.mat-accent,.mat-mini-fab.mat-accent{background-color:#ff9800}.mat-flat-button.mat-warn,.mat-raised-button.mat-warn,.mat-fab.mat-warn,.mat-mini-fab.mat-warn{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled,.mat-flat-button.mat-accent.mat-button-disabled,.mat-flat-button.mat-warn.mat-button-disabled,.mat-flat-button.mat-button-disabled.mat-button-disabled,.mat-raised-button.mat-primary.mat-button-disabled,.mat-raised-button.mat-accent.mat-button-disabled,.mat-raised-button.mat-warn.mat-button-disabled,.mat-raised-button.mat-button-disabled.mat-button-disabled,.mat-fab.mat-primary.mat-button-disabled,.mat-fab.mat-accent.mat-button-disabled,.mat-fab.mat-warn.mat-button-disabled,.mat-fab.mat-button-disabled.mat-button-disabled,.mat-mini-fab.mat-primary.mat-button-disabled,.mat-mini-fab.mat-accent.mat-button-disabled,.mat-mini-fab.mat-warn.mat-button-disabled,.mat-mini-fab.mat-button-disabled.mat-button-disabled{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary .mat-ripple-element,.mat-raised-button.mat-primary .mat-ripple-element,.mat-fab.mat-primary .mat-ripple-element,.mat-mini-fab.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent .mat-ripple-element,.mat-raised-button.mat-accent .mat-ripple-element,.mat-fab.mat-accent .mat-ripple-element,.mat-mini-fab.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn .mat-ripple-element,.mat-raised-button.mat-warn .mat-ripple-element,.mat-fab.mat-warn .mat-ripple-element,.mat-mini-fab.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-stroked-button:not([class*=mat-elevation-z]),.mat-flat-button:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not([class*=mat-elevation-z]),.mat-mini-fab:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]),.mat-mini-fab:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled:not([class*=mat-elevation-z]),.mat-mini-fab.mat-button-disabled:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone,.mat-button-toggle-group{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{box-shadow:none}.mat-button-toggle{color:rgba(0,0,0,.38)}.mat-button-toggle .mat-button-toggle-focus-overlay{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard{color:#212121;background:#fff}.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{background-color:#000}.mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl] .mat-button-toggle-group-appearance-standard .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical .mat-button-toggle+.mat-button-toggle{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard{color:#212121}.mat-button-toggle-disabled{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{line-height:48px}.mat-card{background:#fff;color:#212121}.mat-card:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle{color:#616161}.mat-checkbox-frame{border-color:#616161}.mat-checkbox-checkmark{fill:#fafafa}.mat-checkbox-checkmark-path{stroke:#fafafa !important}.mat-checkbox-mixedmark{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary .mat-checkbox-background,.mat-checkbox-checked.mat-primary .mat-checkbox-background{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent .mat-checkbox-background,.mat-checkbox-checked.mat-accent .mat-checkbox-background{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn .mat-checkbox-background,.mat-checkbox-checked.mat-warn .mat-checkbox-background{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked .mat-checkbox-background,.mat-checkbox-disabled.mat-checkbox-indeterminate .mat-checkbox-background{background-color:#b0b0b0}.mat-checkbox-disabled:not(.mat-checkbox-checked) .mat-checkbox-frame{border-color:#b0b0b0}.mat-checkbox-disabled .mat-checkbox-label{color:#616161}.mat-checkbox .mat-ripple-element{background-color:#000}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-primary .mat-ripple-element{background:#f57c00}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-accent .mat-ripple-element{background:#ff9800}.mat-checkbox-checked:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element,.mat-checkbox:active:not(.mat-checkbox-disabled).mat-warn .mat-ripple-element{background:#f44336}.mat-chip.mat-standard-chip{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip .mat-chip-remove{color:#212121;opacity:.4}.mat-chip.mat-standard-chip:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip:not(.mat-chip-disabled) .mat-chip-remove:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled{opacity:.4}.mat-chip.mat-standard-chip::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-chip-remove{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent .mat-ripple-element{background-color:rgba(255,255,255,.1)}.mat-table{background:#fff}.mat-table thead,.mat-table tbody,.mat-table tfoot,mat-header-row,mat-row,mat-footer-row,[mat-header-row],[mat-row],[mat-footer-row],.mat-table-sticky{background:inherit}mat-row,mat-header-row,mat-footer-row,th.mat-header-cell,td.mat-cell,td.mat-footer-cell{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell{color:#616161}.mat-cell,.mat-footer-cell{color:#212121}.mat-calendar-arrow{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle,.mat-datepicker-content .mat-calendar-next-button,.mat-datepicker-content .mat-calendar-previous-button{color:rgba(0,0,0,.54)}.mat-calendar-table-header{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label{color:#616161}.mat-calendar-body-cell-content,.mat-date-range-input-separator{color:#212121;border-color:transparent}.mat-calendar-body-disabled>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled .mat-date-range-input-separator{color:#757575}.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical),.cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview{color:rgba(0,0,0,.24)}.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled>.mat-calendar-body-today:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start::before,[dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end::before,[dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-calendar-body-selected{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-accent [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-accent .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-accent .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-accent .mat-calendar-body-selected{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-start::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-end::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-bridge-end::before,.mat-datepicker-content.mat-warn [dir=rtl] .mat-calendar-body-comparison-bridge-start::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn .mat-calendar-body-in-range>.mat-calendar-body-comparison-identical,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range::after{background:#a8dab5}.mat-datepicker-content.mat-warn .mat-calendar-body-comparison-identical.mat-calendar-body-selected,.mat-datepicker-content.mat-warn .mat-calendar-body-in-comparison-range>.mat-calendar-body-selected{background:#46a35e}.mat-datepicker-content.mat-warn .mat-calendar-body-selected{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn .mat-calendar-body-disabled>.mat-calendar-body-selected{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn .mat-calendar-body-today.mat-calendar-body-selected{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active{color:#f57c00}.mat-datepicker-toggle-active.mat-accent{color:#ff9800}.mat-datepicker-toggle-active.mat-warn{color:#f44336}.mat-date-range-input-inner[disabled]{color:#757575}.mat-dialog-container{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel{background:#fff;color:#212121}.mat-expansion-panel:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel .mat-expansion-panel-header.cdk-keyboard-focused:not([aria-disabled=true]),.mat-expansion-panel .mat-expansion-panel-header.cdk-program-focused:not([aria-disabled=true]),.mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel:not(.mat-expanded):not([aria-disabled=true]) .mat-expansion-panel-header:hover{background:#fff}}.mat-expansion-panel-header-title{color:#212121}.mat-expansion-panel-header-description,.mat-expansion-indicator::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-title,.mat-expansion-panel-header[aria-disabled=true] .mat-expansion-panel-header-description{color:inherit}.mat-expansion-panel-header{height:48px}.mat-expansion-panel-header.mat-expanded{height:64px}.mat-form-field-label{color:rgba(97,97,97,.6)}.mat-hint{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused .mat-form-field-label{color:#f57c00}.mat-form-field.mat-focused .mat-form-field-label.mat-accent{color:#ff9800}.mat-form-field.mat-focused .mat-form-field-label.mat-warn{color:#f44336}.mat-focused .mat-form-field-required-marker{color:#ff9800}.mat-form-field-ripple{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused .mat-form-field-ripple{background-color:#f57c00}.mat-form-field.mat-focused .mat-form-field-ripple.mat-accent{background-color:#ff9800}.mat-form-field.mat-focused .mat-form-field-ripple.mat-warn{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid) .mat-form-field-infix::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-accent .mat-form-field-infix::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused:not(.mat-form-field-invalid).mat-warn .mat-form-field-infix::after{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-label.mat-accent,.mat-form-field.mat-form-field-invalid .mat-form-field-label .mat-form-field-required-marker{color:#f44336}.mat-form-field.mat-form-field-invalid .mat-form-field-ripple,.mat-form-field.mat-form-field-invalid .mat-form-field-ripple.mat-accent{background-color:#f44336}.mat-error{color:#f44336}.mat-form-field-appearance-legacy .mat-form-field-label{color:#616161}.mat-form-field-appearance-legacy .mat-hint{color:#616161}.mat-form-field-appearance-legacy .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard .mat-form-field-underline{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled .mat-form-field-underline{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill .mat-form-field-flex{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-flex{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill .mat-form-field-underline::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled .mat-form-field-underline::before{background-color:transparent}.mat-form-field-appearance-outline .mat-form-field-outline{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline .mat-form-field-outline-thick{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent .mat-form-field-outline-thick{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid .mat-form-field-outline-thick{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-label{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled .mat-form-field-outline{color:rgba(0,0,0,.06)}.mat-icon.mat-primary{color:#f57c00}.mat-icon.mat-accent{color:#ff9800}.mat-icon.mat-warn{color:#f44336}.mat-form-field-type-mat-native-select .mat-form-field-infix::after{color:#616161}.mat-input-element:disabled,.mat-form-field-type-mat-native-select.mat-form-field-disabled .mat-form-field-infix::after{color:#757575}.mat-input-element{caret-color:#f57c00}.mat-input-element::placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent .mat-input-element{caret-color:#ff9800}.mat-form-field.mat-warn .mat-input-element,.mat-form-field-invalid .mat-input-element{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid .mat-form-field-infix::after{color:#f44336}.mat-list-base .mat-list-item{color:#212121}.mat-list-base .mat-list-option{color:#212121}.mat-list-base .mat-subheader{color:#616161}.mat-list-item-disabled{background-color:#eee}.mat-list-option:hover,.mat-list-option:focus,.mat-nav-list .mat-list-item:hover,.mat-nav-list .mat-list-item:focus,.mat-action-list .mat-list-item:hover,.mat-action-list .mat-list-item:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option,.mat-list-single-selected-option:hover,.mat-list-single-selected-option:focus{background:rgba(0,0,0,.12)}.mat-menu-panel{background:#fff}.mat-menu-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item{background:transparent;color:#212121}.mat-menu-item[disabled],.mat-menu-item[disabled]::after{color:rgba(0,0,0,.38)}.mat-menu-item .mat-icon-no-color,.mat-menu-item-submenu-trigger::after{color:rgba(0,0,0,.54)}.mat-menu-item:hover:not([disabled]),.mat-menu-item.cdk-program-focused:not([disabled]),.mat-menu-item.cdk-keyboard-focused:not([disabled]),.mat-menu-item-highlighted:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator{background:#fff}.mat-paginator,.mat-paginator-page-size .mat-select-trigger{color:#616161}.mat-paginator-decrement,.mat-paginator-increment{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first,.mat-paginator-last{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled] .mat-paginator-decrement,.mat-icon-button[disabled] .mat-paginator-increment,.mat-icon-button[disabled] .mat-paginator-first,.mat-icon-button[disabled] .mat-paginator-last{border-color:rgba(0,0,0,.38)}.mat-paginator-container{min-height:56px}.mat-progress-bar-background{fill:#ff9800}.mat-progress-bar-buffer{background-color:#ff9800}.mat-progress-bar-fill::after{background-color:#f57c00}.mat-progress-bar.mat-accent .mat-progress-bar-background{fill:#ff9800}.mat-progress-bar.mat-accent .mat-progress-bar-buffer{background-color:#ff9800}.mat-progress-bar.mat-accent .mat-progress-bar-fill::after{background-color:#ff9800}.mat-progress-bar.mat-warn .mat-progress-bar-background{fill:#ffcdd2}.mat-progress-bar.mat-warn .mat-progress-bar-buffer{background-color:#ffcdd2}.mat-progress-bar.mat-warn .mat-progress-bar-fill::after{background-color:#f44336}.mat-progress-spinner circle,.mat-spinner circle{stroke:#f57c00}.mat-progress-spinner.mat-accent circle,.mat-spinner.mat-accent circle{stroke:#ff9800}.mat-progress-spinner.mat-warn circle,.mat-spinner.mat-warn circle{stroke:#f44336}.mat-radio-outer-circle{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-outer-circle{border-color:#f57c00}.mat-radio-button.mat-primary .mat-radio-inner-circle,.mat-radio-button.mat-primary .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-primary.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-primary:active .mat-radio-persistent-ripple{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-outer-circle{border-color:#ff9800}.mat-radio-button.mat-accent .mat-radio-inner-circle,.mat-radio-button.mat-accent .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-accent.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-accent:active .mat-radio-persistent-ripple{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-outer-circle{border-color:#f44336}.mat-radio-button.mat-warn .mat-radio-inner-circle,.mat-radio-button.mat-warn .mat-radio-ripple .mat-ripple-element:not(.mat-radio-persistent-ripple),.mat-radio-button.mat-warn.mat-radio-checked .mat-radio-persistent-ripple,.mat-radio-button.mat-warn:active .mat-radio-persistent-ripple{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked .mat-radio-outer-circle,.mat-radio-button.mat-radio-disabled .mat-radio-outer-circle{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-ripple .mat-ripple-element,.mat-radio-button.mat-radio-disabled .mat-radio-inner-circle{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled .mat-radio-label-content{color:rgba(0,0,0,.38)}.mat-radio-button .mat-ripple-element{background-color:#000}.mat-select-value{color:#212121}.mat-select-placeholder{color:rgba(97,97,97,.42)}.mat-select-disabled .mat-select-value{color:#757575}.mat-select-arrow{color:#616161}.mat-select-panel{background:#fff}.mat-select-panel:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel .mat-option.mat-selected:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary .mat-select-arrow{color:#f57c00}.mat-form-field.mat-focused.mat-accent .mat-select-arrow{color:#ff9800}.mat-form-field.mat-focused.mat-warn .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-invalid .mat-select-arrow{color:#f44336}.mat-form-field .mat-select.mat-select-disabled .mat-select-arrow{color:#757575}.mat-drawer-container{background-color:#fafafa;color:#212121}.mat-drawer{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push{background-color:#fff}.mat-drawer:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl] .mat-drawer-side.mat-drawer-end{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked .mat-slide-toggle-thumb{background-color:#ff9800}.mat-slide-toggle.mat-checked .mat-slide-toggle-bar{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked .mat-ripple-element{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-thumb{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked .mat-slide-toggle-bar{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked .mat-ripple-element{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-thumb{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked .mat-slide-toggle-bar{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked .mat-ripple-element{background-color:#f44336}.mat-slide-toggle:not(.mat-checked) .mat-ripple-element{background-color:#000}.mat-slide-toggle-thumb{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar{background-color:rgba(0,0,0,.38)}.mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-primary .mat-slider-track-fill,.mat-primary .mat-slider-thumb,.mat-primary .mat-slider-thumb-label{background-color:#f57c00}.mat-primary .mat-slider-thumb-label-text{color:#fff}.mat-primary .mat-slider-focus-ring{background-color:rgba(245,124,0,.2)}.mat-accent .mat-slider-track-fill,.mat-accent .mat-slider-thumb,.mat-accent .mat-slider-thumb-label{background-color:#ff9800}.mat-accent .mat-slider-thumb-label-text{color:#fff}.mat-accent .mat-slider-focus-ring{background-color:rgba(255,152,0,.2)}.mat-warn .mat-slider-track-fill,.mat-warn .mat-slider-thumb,.mat-warn .mat-slider-thumb-label{background-color:#f44336}.mat-warn .mat-slider-thumb-label-text{color:#fff}.mat-warn .mat-slider-focus-ring{background-color:rgba(244,67,54,.2)}.mat-slider:hover .mat-slider-track-background,.cdk-focused .mat-slider-track-background{background-color:rgba(0,0,0,.38)}.mat-slider-disabled .mat-slider-track-background,.mat-slider-disabled .mat-slider-track-fill,.mat-slider-disabled .mat-slider-thumb{background-color:rgba(0,0,0,.26)}.mat-slider-disabled:hover .mat-slider-track-background{background-color:rgba(0,0,0,.26)}.mat-slider-min-value .mat-slider-focus-ring{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb,.mat-slider-min-value.mat-slider-thumb-label-showing .mat-slider-thumb-label{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb,.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused .mat-slider-thumb-label{background-color:rgba(0,0,0,.26)}.mat-slider-min-value:not(.mat-slider-thumb-label-showing) .mat-slider-thumb{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover .mat-slider-thumb,.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused .mat-slider-thumb{border-color:rgba(0,0,0,.38)}.mat-slider-min-value:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled .mat-slider-thumb,.mat-slider-min-value:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled .mat-slider-thumb{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks .mat-slider-wrapper::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal .mat-slider-ticks{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical .mat-slider-ticks{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused,.mat-step-header.cdk-program-focused,.mat-step-header:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header:hover{background:none}}.mat-step-header .mat-step-label,.mat-step-header .mat-step-optional{color:#616161}.mat-step-header .mat-step-icon{background-color:#616161;color:#fff}.mat-step-header .mat-step-icon-selected,.mat-step-header .mat-step-icon-state-done,.mat-step-header .mat-step-icon-state-edit{background-color:#f57c00;color:#fff}.mat-step-header .mat-step-icon-state-error{background-color:transparent;color:#f44336}.mat-step-header .mat-step-label.mat-step-label-active{color:#212121}.mat-step-header .mat-step-label.mat-step-label-error{color:#f44336}.mat-stepper-horizontal,.mat-stepper-vertical{background-color:#fff}.mat-stepper-vertical-line::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header::before,.mat-horizontal-stepper-header::after,.mat-stepper-horizontal-line{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header{height:72px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header,.mat-vertical-stepper-header{padding:24px 24px}.mat-stepper-vertical-line::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::after,.mat-stepper-label-position-bottom .mat-horizontal-stepper-header::before{top:36px}.mat-stepper-label-position-bottom .mat-stepper-horizontal-line{top:36px}.mat-sort-header-arrow{color:#616161}.mat-tab-nav-bar,.mat-tab-header{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header .mat-tab-nav-bar,.mat-tab-group-inverted-header .mat-tab-header{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label,.mat-tab-link{color:#212121}.mat-tab-label.mat-tab-disabled,.mat-tab-link.mat-tab-disabled{color:#757575}.mat-tab-header-pagination-chevron{border-color:#212121}.mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:#757575}.mat-tab-group[class*=mat-background-] .mat-tab-header,.mat-tab-nav-bar[class*=mat-background-]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary .mat-ink-bar{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary .mat-ink-bar,.mat-tab-nav-bar.mat-primary.mat-background-primary .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent .mat-ink-bar{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent .mat-ink-bar,.mat-tab-nav-bar.mat-accent.mat-background-accent .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn .mat-ink-bar{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn .mat-ink-bar,.mat-tab-nav-bar.mat-warn.mat-background-warn .mat-ink-bar{background-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-primary .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary .mat-tab-header,.mat-tab-group.mat-background-primary .mat-tab-links,.mat-tab-group.mat-background-primary .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-primary .mat-tab-header,.mat-tab-nav-bar.mat-background-primary .mat-tab-links,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination{background-color:#f57c00}.mat-tab-group.mat-background-primary .mat-tab-label,.mat-tab-group.mat-background-primary .mat-tab-link,.mat-tab-nav-bar.mat-background-primary .mat-tab-label,.mat-tab-nav-bar.mat-background-primary .mat-tab-link{color:#fff}.mat-tab-group.mat-background-primary .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-primary .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-primary .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-primary .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-primary .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary .mat-ripple-element,.mat-tab-nav-bar.mat-background-primary .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-accent .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent .mat-tab-header,.mat-tab-group.mat-background-accent .mat-tab-links,.mat-tab-group.mat-background-accent .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-accent .mat-tab-header,.mat-tab-nav-bar.mat-background-accent .mat-tab-links,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination{background-color:#ff9800}.mat-tab-group.mat-background-accent .mat-tab-label,.mat-tab-group.mat-background-accent .mat-tab-link,.mat-tab-nav-bar.mat-background-accent .mat-tab-label,.mat-tab-nav-bar.mat-background-accent .mat-tab-link{color:#fff}.mat-tab-group.mat-background-accent .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-accent .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-accent .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-accent .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-accent .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent .mat-ripple-element,.mat-tab-nav-bar.mat-background-accent .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-group.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-label.cdk-program-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-keyboard-focused:not(.mat-tab-disabled),.mat-tab-nav-bar.mat-background-warn .mat-tab-link.cdk-program-focused:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn .mat-tab-header,.mat-tab-group.mat-background-warn .mat-tab-links,.mat-tab-group.mat-background-warn .mat-tab-header-pagination,.mat-tab-nav-bar.mat-background-warn .mat-tab-header,.mat-tab-nav-bar.mat-background-warn .mat-tab-links,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination{background-color:#f44336}.mat-tab-group.mat-background-warn .mat-tab-label,.mat-tab-group.mat-background-warn .mat-tab-link,.mat-tab-nav-bar.mat-background-warn .mat-tab-label,.mat-tab-nav-bar.mat-background-warn .mat-tab-link{color:#fff}.mat-tab-group.mat-background-warn .mat-tab-label.mat-tab-disabled,.mat-tab-group.mat-background-warn .mat-tab-link.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-label.mat-tab-disabled,.mat-tab-nav-bar.mat-background-warn .mat-tab-link.mat-tab-disabled{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination-chevron{border-color:#fff}.mat-tab-group.mat-background-warn .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron,.mat-tab-nav-bar.mat-background-warn .mat-tab-header-pagination-disabled .mat-tab-header-pagination-chevron{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn .mat-ripple-element,.mat-tab-nav-bar.mat-background-warn .mat-ripple-element{background-color:rgba(255,255,255,.12)}.mat-toolbar{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary{background:#f57c00;color:#fff}.mat-toolbar.mat-accent{background:#ff9800;color:#fff}.mat-toolbar.mat-warn{background:#f44336;color:#fff}.mat-toolbar .mat-form-field-underline,.mat-toolbar .mat-form-field-ripple,.mat-toolbar .mat-focused .mat-form-field-ripple{background-color:currentColor}.mat-toolbar .mat-form-field-label,.mat-toolbar .mat-focused .mat-form-field-label,.mat-toolbar .mat-select-value,.mat-toolbar .mat-select-arrow,.mat-toolbar .mat-form-field.mat-focused .mat-select-arrow{color:inherit}.mat-toolbar .mat-input-element{caret-color:currentColor}.mat-toolbar-multiple-rows{min-height:64px}.mat-toolbar-row,.mat-toolbar-single-row{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows{min-height:56px}.mat-toolbar-row,.mat-toolbar-single-row{height:56px}}.mat-tooltip{background:rgba(97,97,97,.9)}.mat-tree{background:#fff}.mat-tree-node,.mat-nested-tree-node{color:#212121}.mat-tree-node{min-height:48px}.mat-snack-bar-container{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action{color:#ff9800}:host{padding-top:5px}.annotation-title{align-items:center;display:flex;font-size:13px;height:20px;padding:0 10px;user-select:none}.selected-row{background-color:#e0e0e0;display:block}.flagged-annotation{color:#f57c00}.hidden-annotation{color:#757575}.annotation-checkbox{padding-right:5px}.flagged-icon{transform:scale(0.6)}.hidden-icon{transform:scale(0.6)}.annotation-icon{transform:scale(0.6)}.chart-div{border-bottom:1px solid #ebebeb}.chart-svg{width:100%;user-select:none}.default-text{fill:#000}.flag-text{fill:#f57c00}.hidden-text{fill:#757575}.clickable-annotation{cursor:pointer}button{all:unset}\n'],encapsulation:2,changeDetection:0});class nbt{constructor(t){this.store=t,this.sort$=this.store.select(Hdt),this.flaggedAnnotations$=this.store.select(Tdt),this.hiddenAnnotations$=this.store.select(Ddt),this.selectedAnnotations$=this.store.select(Rdt),this.showCounts$=this.store.select(Udt),this.sidebarWidth$=this.store.select(Ydt),this.runColorScale$=this.store.select(GD).pipe(ft((t=>n=>{if(!t.hasOwnProperty(n))throw new Error(`[Color scale] unknown runId: ${n}.`);return t[n]}))),this.runIdToRuns$=this.store.select(ND)}showSimilarAnnotations(){this.store.dispatch(dgt({annotation:this.annotation}))}}function ebt(t,n){if(1&t){const t=op();Kg(0,"npmi-annotation",5),cp("click",(function e(a){jr(t);const o=n.$implicit;return gp(2).rowClicked(a,o)})),$g()}if(2&t){const t=n.$implicit,e=gp(2);Jg("data",e.annotations[t])("activeMetrics",e.activeMetrics)("numActiveRuns",e.numActiveRuns)("maxCount",e.maxCount)("annotation",t)("runHeight",e.runHeight)("hasEmbedding",e.embeddingData&&void 0!==e.embeddingData[t])}}function abt(t,n){if(1&t&&(np(0),tp(1,"npmi-annotations-list-legend"),tp(2,"npmi-annotations-list-header",2),Kg(3,"cdk-virtual-scroll-viewport",3),Yg(4,ebt,1,7,"npmi-annotation",4),$g(),ep()),2&t){const t=gp();ws(2),Jg("annotations",t.annotations)("numAnnotations",t.numAnnotations)("activeMetrics",t.activeMetrics),ws(1),_p("itemSize",t.numActiveRuns*t.runHeight+25),ws(1),Jg("cdkVirtualForOf",t.sortedAnnotations)}}nbt.ɵfac=function t(n){return new(n||nbt)(Zg(cv))},nbt.ɵcmp=_o({type:nbt,selectors:[["npmi-annotation"]],inputs:{data:"data",maxCount:"maxCount",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",annotation:"annotation",runHeight:"runHeight",hasEmbedding:"hasEmbedding"},decls:9,vars:31,consts:[[3,"data","maxCount","activeMetrics","numActiveRuns","annotation","runHeight","hasEmbedding","sort","selectedAnnotations","flaggedAnnotations","hiddenAnnotations","showCounts","sidebarWidth","colorScale","runIdToRuns","onShowSimilarAnnotations"]],template:function t(n,e){1&n&&(Kg(0,"annotation-component",0),cp("onShowSimilarAnnotations",(function t(){return e.showSimilarAnnotations()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),$g()),2&n&&Jg("data",e.data)("maxCount",e.maxCount)("activeMetrics",e.activeMetrics)("numActiveRuns",e.numActiveRuns)("annotation",e.annotation)("runHeight",e.runHeight)("hasEmbedding",e.hasEmbedding)("sort",kf(1,15,e.sort$))("selectedAnnotations",kf(2,17,e.selectedAnnotations$))("flaggedAnnotations",kf(3,19,e.flaggedAnnotations$))("hiddenAnnotations",kf(4,21,e.hiddenAnnotations$))("showCounts",kf(5,23,e.showCounts$))("sidebarWidth",kf(6,25,e.sidebarWidth$))("colorScale",kf(7,27,e.runColorScale$))("runIdToRuns",kf(8,29,e.runIdToRuns$))},directives:[tbt],pipes:[oO],encapsulation:2,changeDetection:0});class obt{constructor(){this.onRowClick=new Ef,this.runHeight=30}rowClicked(t,n){if(t.shiftKey){let t=this.sortedAnnotations.indexOf(n);if(0===this.selectedAnnotations.length)this.onRowClick.emit(this.sortedAnnotations.slice(0,t+1));else{const n=this.sortedAnnotations.indexOf(this.selectedAnnotations[this.selectedAnnotations.length-1]);this.onRowClick.emit(n<t?this.sortedAnnotations.slice(n,t+1):this.sortedAnnotations.slice(t,n+1))}}else this.onRowClick.emit([n])}}obt.ɵfac=function t(n){return new(n||obt)},obt.ɵcmp=_o({type:obt,selectors:[["annotations-list-component"]],inputs:{annotations:"annotations",embeddingData:"embeddingData",annotationsExpanded:"annotationsExpanded",numAnnotations:"numAnnotations",annotationSort:"annotationSort",activeMetrics:"activeMetrics",numActiveRuns:"numActiveRuns",sortedAnnotations:"sortedAnnotations",selectedAnnotations:"selectedAnnotations",maxCount:"maxCount"},outputs:{onRowClick:"onRowClick"},decls:2,vars:3,consts:[[3,"numAnnotations","expanded"],[4,"ngIf"],[3,"annotations","numAnnotations","activeMetrics"],["minBufferPx","300","maxBufferPx","600",1,"annotation-rows",3,"itemSize"],[3,"data","activeMetrics","numActiveRuns","maxCount","annotation","runHeight","hasEmbedding","click",4,"cdkVirtualFor","cdkVirtualForOf"],[3,"data","activeMetrics","numActiveRuns","maxCount","annotation","runHeight","hasEmbedding","click"]],template:function t(n,e){1&n&&(tp(0,"npmi-annotations-list-toolbar",0),Yg(1,abt,5,5,"ng-container",1)),2&n&&(Jg("numAnnotations",e.numAnnotations)("expanded",e.annotationsExpanded),ws(1),Jg("ngIf",e.annotationsExpanded))},directives:[Vpt,WM,Wpt,Zpt,PA,fA,yA,nbt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{background-color:#fff;border:1px solid #ebebeb;display:flex;flex-direction:column;height:calc(100% - 2px);width:calc(100% - 2px)}.annotation-rows[_ngcontent-%COMP%]{display:flex;flex-direction:column;flex:1 1;overflow-y:auto}'],changeDetection:0});class rbt{constructor(t){this.store=t,this.annotationsExpanded$=this.store.pipe(lv(Vdt)),this.activeRuns$=this.store.pipe(lv(KD)).pipe(ft((t=>t?Array.from(t.entries()).filter((t=>t[1])).map((t=>t[0])):[]))),this.embeddingData$=this.store.pipe(lv(zdt)),this.numActiveRuns$=this.activeRuns$.pipe(ft((t=>t.length))),this.activeMetrics$=Et([this.store.select(Adt),this.activeRuns$,this.store.select(Ldt)]).pipe(ft((([t,n,e])=>{let a=[];for(const e of n)t[e]&&(a=a.concat(t[e].filter((t=>ygt(t)))));return a=[...new Set([...Object.keys(e),...a])],a}))),this.visibleAnnotations$=Et([this.store.select(Edt),this.store.select(Ddt),this.store.select(Wdt)]).pipe(ft((([t,n,e])=>dpt(t,n,e)))),this.filteredAnnotations$=Et([this.visibleAnnotations$,this.store.select(Fdt),this.store.select(Ldt),this.activeRuns$,this.activeMetrics$,this.store.select(Idt)]).pipe(ft((([t,n,e,a,o,r])=>(function i(t,n,e,a,o,r){const i={},c=new Set(n),s=new Set(o.map((t=>kgt(t)))),l=new RegExp(r,"i");return Object.entries(t).forEach((t=>{if(!l.test(t[0]))return;let n=t[1];n=n.filter((t=>c.has(t.run)&&s.has(t.metric))),(function o(t,n,e){return t.every((t=>{if(t.kind===xdt.OPERATOR)return!0;const a=n[t.metric];return void 0===a||e.some((n=>n.metric===kgt(t.metric)&&(null===n.nPMIValue?a.includeNaN:n.nPMIValue<=a.max&&n.nPMIValue>=a.min)))}))})(e,a,n)&&0!==n.length&&(i[t[0]]=n)})),i})(t,a,n,e,o,r)))).pipe(ee()),this.numAnnotations$=this.filteredAnnotations$.pipe(ft((t=>Object.keys(t).length))),this.sortedAnnotations$=Et([this.filteredAnnotations$,this.store.pipe(lv(Hdt)),this.embeddingData$]).pipe(ft((([t,n,e])=>(function a(t,n,e){const a=Object.keys(t),o=n.order===kdt.DISSIMILAR||n.order===kdt.SIMILAR;return""===n.metric||(void 0===e||void 0===e.points[n.metric])&&o?a:(function c(t,n,e){return t.sort(e?(t,e)=>n[t]-n[e]:(t,e)=>n[e]-n[t])})(a,o?(function r(t,n,e){const a={};let o=Number.POSITIVE_INFINITY,r=Number.NEGATIVE_INFINITY;e.order===kdt.SIMILAR&&(o=Number.NEGATIVE_INFINITY,r=Number.POSITIVE_INFINITY);for(const i of t)a[i]=i===e.metric?o:void 0===n.points[i]?r:n.points[i].vector?Cpt(n.points[e.metric].vector,n.points[i].vector,r):r;return a})(a,e,n):(function i(t,n,e){const a=kgt(e.metric),o={};if(e.order===kdt.DESCENDING)for(const e of t)o[e]=Math.max(...n[e].filter((t=>t.metric===a)).map((t=>null===t.nPMIValue?-1/0:t.nPMIValue)));else for(const e of t)o[e]=Math.min(...n[e].filter((t=>t.metric===a)).map((t=>null===t.nPMIValue?1/0:t.nPMIValue)));return o})(a,t,n),n.order===kdt.ASCENDNG||n.order===kdt.SIMILAR)})(t,n,e)))),this.selectedAnnotations$=this.store.pipe(lv(Rdt)),this.maxCount$=this.filteredAnnotations$.pipe(ft((t=>{let n=0;return Object.values(t).forEach((t=>{t.forEach((t=>{t.countValue&&(n=Math.max(n,t.countValue))}))})),n})))}rowClicked(t){this.store.dispatch(tgt({annotations:t}))}}rbt.ɵfac=function t(n){return new(n||rbt)(Zg(cv))},rbt.ɵcmp=_o({type:rbt,selectors:[["npmi-annotations-list"]],decls:10,vars:27,consts:[[3,"annotations","embeddingData","annotationsExpanded","numAnnotations","activeMetrics","numActiveRuns","sortedAnnotations","selectedAnnotations","maxCount","onRowClick"]],template:function t(n,e){1&n&&(Kg(0,"annotations-list-component",0),cp("onRowClick",(function t(n){return e.rowClicked(n)})),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async"),yf(8,"async"),yf(9,"async"),$g()),2&n&&Jg("annotations",kf(1,9,e.filteredAnnotations$))("embeddingData",kf(2,11,e.embeddingData$))("annotationsExpanded",kf(3,13,e.annotationsExpanded$))("numAnnotations",kf(4,15,e.numAnnotations$))("activeMetrics",kf(5,17,e.activeMetrics$))("numActiveRuns",kf(6,19,e.numActiveRuns$))("sortedAnnotations",kf(7,21,e.sortedAnnotations$))("selectedAnnotations",kf(8,23,e.selectedAnnotations$))("maxCount",kf(9,25,e.maxCount$))},directives:[obt],pipes:[oO],encapsulation:2,changeDetection:0});const ibt=["chart"];class cbt{constructor(){this.width=0,this.chartWidth=0,this.height=300,this.margin={top:20,right:40,bottom:20,left:40},this.chartHeight=this.height-this.margin.top-this.margin.bottom}onResize(t){this.redraw()}ngAfterViewInit(){this.svg=j1(this.svgElement.nativeElement),this.mainContainer=this.svg.append("g").attr("transform",`translate(${this.margin.left}, ${this.margin.top})`),this.coordinatesGroup=this.mainContainer.append("g"),this.labelsGroup=this.mainContainer.append("g"),this.axisGroup=this.mainContainer.append("g"),this.xScale=p6().padding(.1),this.yScale=k6().range([this.chartHeight,0]),this.yAxis=(function t(n){return v0(2,n)})(this.yScale),this.redraw()}ngOnChanges(t){this.svg&&this.redraw()}redraw(){this.updateDimensions(),this.updateAxes(),this.draw()}updateDimensions(){this.width=this.svgElement.nativeElement.clientWidth||10,this.chartWidth=this.width-this.margin.left-this.margin.right}updateAxes(){this.xScale.rangeRound([0,this.chartWidth]).domain(this.activeMetrics),this.yScale.domain([this.coordinateData.extremes.min,this.coordinateData.extremes.max])}draw(){this.drawAxes(),this.drawAxisLabels(),this.drawCoordinates(),this.drawLabels()}drawAxes(){const t=this.axisGroup.selectAll(".axis-y").data(this.activeMetrics);t.enter().append("g").attr("class","axis-y").merge(t).attr("transform",function(t){return`translate(${this.xScale(t)}, 0)`}.bind(this)).call(this.yAxis),t.exit().remove()}drawAxisLabels(){const t=this.axisGroup.selectAll(".axis-bg-text").data(this.activeMetrics);t.enter().append("text").attr("class","axis-bg-text").attr("font-size","13px").attr("stroke-width",2).attr("stroke-linejoin","round").attr("stroke","white").merge(t).text((t=>t)).attr("transform",function(t){return`translate(${this.xScale(t)-5}, ${this.yScale(this.coordinateData.extremes.min)}) rotate(-90)`}.bind(this)),t.exit().remove();const n=this.axisGroup.selectAll(".axis-text").data(this.activeMetrics);n.enter().append("text").attr("font-size","13px").attr("class","axis-text").merge(n).text((t=>t)).attr("transform",function(t){return`translate(${this.xScale(t)-5}, ${this.yScale(this.coordinateData.extremes.min)}) rotate(-90)`}.bind(this)),n.exit().remove()}drawCoordinates(){const t=this.coordinatesGroup.selectAll(".coord").data(this.coordinateData.coordinates);t.enter().append("path").attr("class","coord").attr("fill","none").merge(t).attr("d",this.path.bind(this)).attr("stroke",function(t){return this.colorScale(t.runId)}.bind(this)),t.exit().remove();const n=this.coordinatesGroup.selectAll(".hiddenCoord").data(this.coordinateData.coordinates);n.enter().append("path").attr("class","hiddenCoord").attr("stroke-width","10px").attr("fill","none").attr("stroke","rgba(0, 0, 0, 0.0)").on("mouseover",this.handleCoordinateMouseOver.bind(this)).on("mouseout",this.handleCoordinateMouseOut.bind(this)).merge(n).attr("d",this.path.bind(this)),n.exit().remove()}path(t){return t.values.sort(((t,n)=>this.activeMetrics.indexOf(t.metric)-this.activeMetrics.indexOf(n.metric))),L8()(t.values.map(function(t){let n=this.yScale(t.nPMIValue);return[this.xScale(t.metric),n]}.bind(this)))}handleCoordinateMouseOver(t,n){this.labelsGroup.selectAll(".coordinate-label").filter((function(n){return!(n.annotation===t.annotation)})).style("opacity",.1),this.coordinatesGroup.selectAll(".coord").filter((function(n){return!(n.annotation===t.annotation)})).style("opacity",.1)}handleCoordinateMouseOut(){this.labelsGroup.selectAll(".coordinate-label").style("opacity",1),this.coordinatesGroup.selectAll(".coord").style("opacity",1)}drawLabels(){const t=30/this.xScale.step(),n=this.coordinateData.coordinates.length<30?this.coordinateData.coordinates:[],e=this.labelsGroup.selectAll(".coordinate-label").data(n);e.enter().append("text").attr("class","coordinate-label").attr("font-size","10px").merge(e).text((function(t){return t.annotation})).attr("x",this.xScale(this.activeMetrics[0])+30).attr("y",function(n){const e=this.yScale(n.values[0].nPMIValue?n.values[0].nPMIValue:0),a=this.yScale(n.values[1].nPMIValue?n.values[1].nPMIValue:0);return(1-t)*e+t*a}.bind(this)),e.exit().remove()}}cbt.ɵfac=function t(n){return new(n||cbt)},cbt.ɵcmp=_o({type:cbt,selectors:[["parallel-coordinates-component"]],viewQuery:function t(n,e){var a;1&n&&jf(ibt,!0,xu),2&n&&Vf(a=Zf())&&(e.svgElement=a.first)},hostBindings:function t(n,e){1&n&&cp("resize",(function t(n){return e.onResize(n)}),!1,er)},inputs:{activeMetrics:"activeMetrics",coordinateData:"coordinateData",sidebarWidth:"sidebarWidth",colorScale:"colorScale"},features:[pr],decls:2,vars:0,consts:[[1,"pc-chart"],["chart",""]],template:function t(n,e){1&n&&(ui(),tp(0,"svg",0,1))},styles:[".pc-chart[_ngcontent-%COMP%]{height:300px;width:100%}"],changeDetection:0});class sbt{constructor(t){this.store=t,this.activeRuns$=this.store.pipe(lv(KD)).pipe(ft((t=>t?Array.from(t.entries()).filter((t=>t[1])).map((t=>t[0])):[]))),this.activeMetrics$=Et(this.store.select(Adt),this.activeRuns$,this.store.select(Ldt)).pipe(ft((([t,n,e])=>{let a=[];for(const e of n)t[e]&&(a=a.concat(t[e].filter((t=>ygt(t)))));return a=[...new Set([...Object.keys(e),...a])],a.map((t=>kgt(t)))}))),this.coordinateData$=Et([this.store.select(Edt),this.store.select(Rdt),this.activeRuns$,this.activeMetrics$]).pipe(ft((([t,n,e,a])=>(function o(t,n,e,a){const o=[],r={max:-1,min:1},i=new Set(e),c=new Set(a);return 0===i.size||0===c.size||0===Object.keys(t).length?{coordinates:[],extremes:{min:-1,max:1}}:(n.forEach((n=>{const e={};t[n].forEach((t=>{i.has(t.run)&&c.has(t.metric)&&(e[t.run]?e[t.run].push(t):e[t.run]=[t],null!==t.nPMIValue?(r.max=Math.max(r.max,t.nPMIValue),r.min=Math.min(r.min,t.nPMIValue)):(r.max=Math.max(r.max,0),r.min=Math.min(r.min,0)))}));for(const t of Object.keys(e))o.push({annotation:n,runId:t,values:e[t]})})),r.max<r.min&&(r.max=1,r.min=-1),{coordinates:o,extremes:r})})(t,n,e,a)))),this.sidebarWidth$=this.store.select(Ydt),this.runColorScale$=this.store.select(GD).pipe(ft((t=>n=>{if(!t.hasOwnProperty(n))throw new Error(`[Color scale] unknown runId: ${n}.`);return t[n]})))}}function lbt(t,n){1&t&&tp(0,"mat-icon",11)}function mbt(t,n){1&t&&tp(0,"mat-icon",12)}function dbt(t,n){1&t&&tp(0,"npmi-parallel-coordinates")}sbt.ɵfac=function t(n){return new(n||sbt)(Zg(cv))},sbt.ɵcmp=_o({type:sbt,selectors:[["npmi-parallel-coordinates"]],decls:5,vars:12,consts:[[3,"activeMetrics","coordinateData","sidebarWidth","colorScale"]],template:function t(n,e){1&n&&(tp(0,"parallel-coordinates-component",0),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async")),2&n&&Jg("activeMetrics",kf(1,4,e.activeMetrics$))("coordinateData",kf(2,6,e.coordinateData$))("sidebarWidth",kf(3,8,e.sidebarWidth$))("colorScale",kf(4,10,e.runColorScale$))},directives:[cbt],pipes:[oO],encapsulation:2,changeDetection:0});class gbt{constructor(){this.onClearSelectedAnnotations=new Ef,this.onToggleExpanded=new Ef}}gbt.ɵfac=function t(n){return new(n||gbt)},gbt.ɵcmp=_o({type:gbt,selectors:[["selected-annotations-component"]],inputs:{pcExpanded:"pcExpanded",selectedAnnotations:"selectedAnnotations"},outputs:{onClearSelectedAnnotations:"onClearSelectedAnnotations",onToggleExpanded:"onToggleExpanded"},decls:13,vars:4,consts:function(){return[[1,"pc-container"],[1,"pc-toolbar"],[1,"pc-title"],["mat-icon-button","","title","Deselects all selected annotations.",1,"clear-button",3,"disabled","click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Clear Annotation Selection"):$localize`:Label for a button that clears the annotation selection.␟2b52289f2c4b7f5b182ed23c9154722ecd46a2d4␟2494660520341308830:Clear Annotation Selection`],["svgIcon","clear_24px"],["mat-icon-button","",1,"expand-button",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Expand/Hide Selected Annotations"):$localize`:Label for a button that expands or hides selected annotations.␟8f4ad305c19e3655f3189e3e264e83fb76f7bb95␟5670797784070952095:Expand/Hide Selected Annotations`],["svgIcon","expand_less_24px","class","expand-less-icon",4,"ngIf","ngIfElse"],["notExpanded",""],[4,"ngIf"],["svgIcon","expand_less_24px",1,"expand-less-icon"],["svgIcon","expand_more_24px",1,"expand-icon"]]},template:function t(n,e){if(1&n&&(Kg(0,"div",0),Kg(1,"div",1),Kg(2,"h3",2),Jp(3,"Selected Annotations"),$g(),Kg(4,"button",3),lu(5,4),cp("click",(function t(){return e.onClearSelectedAnnotations.emit()})),tp(6,"mat-icon",5),$g(),Kg(7,"button",6),lu(8,7),cp("click",(function t(){return e.onToggleExpanded.emit()})),Yg(9,lbt,1,0,"mat-icon",8),Yg(10,mbt,1,0,"ng-template",null,9,Kf),$g(),$g(),Yg(12,dbt,1,0,"npmi-parallel-coordinates",10),$g()),2&n){const t=qg(11);ws(4),Jg("disabled",0===e.selectedAnnotations.length),ws(5),Jg("ngIf",e.pcExpanded)("ngIfElse",t),ws(3),Jg("ngIf",e.pcExpanded)}},directives:[eA,BB,WM,sbt],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}.pc-container[_ngcontent-%COMP%]{background-color:#fff;border:1px solid #ebebeb}.pc-toolbar[_ngcontent-%COMP%]{align-items:center;border-bottom:1px solid #ebebeb;display:flex;height:42px;padding:0 16px}.pc-title[_ngcontent-%COMP%]{font-size:14px;font-weight:500;display:inline;flex:1 1}'],changeDetection:0});class pbt{constructor(t){this.store=t,this.pcExpanded$=this.store.pipe(lv(Bdt)),this.selectedAnnotations$=this.store.select(Rdt)}clearSelectedAnnotations(){this.store.dispatch(egt())}toggleExpanded(){this.store.dispatch(ggt())}}function bbt(t,n){1&t&&(Kg(0,"div",6),Kg(1,"div",7),tp(2,"npmi-violin-filters",8),Kg(3,"div",9),tp(4,"runs-selector"),$g(),$g(),$g()),2&t&&Tp("width",gp().sidebarWidth,"px")}function ubt(t,n){if(1&t){const t=op();Kg(0,"div",10),cp("mousedown",(function n(){return jr(t),gp().resizeGrabbed.emit()})),$g()}}function fbt(t,n){1&t&&(Kg(0,"div",11),tp(1,"npmi-annotations-list",12),tp(2,"npmi-selected-annotations"),$g())}function hbt(t,n){1&t&&(Kg(0,"div",13),Jp(1,"You need to select at least one run."),$g())}function _bt(t,n){if(1&t){const t=op();Kg(0,"div",14),Kg(1,"button",15),lu(2,16),cp("click",(function n(){return jr(t),gp().toggleSidebarExpanded.emit()})),tp(3,"mat-icon",17),$g(),$g()}}pbt.ɵfac=function t(n){return new(n||pbt)(Zg(cv))},pbt.ɵcmp=_o({type:pbt,selectors:[["npmi-selected-annotations"]],decls:3,vars:6,consts:[[3,"pcExpanded","selectedAnnotations","onClearSelectedAnnotations","onToggleExpanded"]],template:function t(n,e){1&n&&(Kg(0,"selected-annotations-component",0),cp("onClearSelectedAnnotations",(function t(){return e.clearSelectedAnnotations()}))("onToggleExpanded",(function t(){return e.toggleExpanded()})),yf(1,"async"),yf(2,"async"),$g()),2&n&&Jg("pcExpanded",kf(1,2,e.pcExpanded$))("selectedAnnotations",kf(2,4,e.selectedAnnotations$))},directives:[gbt],pipes:[oO],encapsulation:2,changeDetection:0});class Cbt{constructor(){this.toggleSidebarExpanded=new Ef,this.resizeTriggered=new Ef,this.resizeGrabbed=new Ef,this.resizeReleased=new Ef}}Cbt.ɵfac=function t(n){return new(n||Cbt)},Cbt.ɵcmp=_o({type:Cbt,selectors:[["main-component"]],inputs:{runActive:"runActive",sidebarExpanded:"sidebarExpanded",sidebarWidth:"sidebarWidth"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded",resizeTriggered:"resizeTriggered",resizeGrabbed:"resizeGrabbed",resizeReleased:"resizeReleased"},decls:8,vars:5,consts:function(){return[[1,"content",3,"mouseup","mousemove"],["class","sidebar-container",3,"width",4,"ngIf"],["class","grabber",3,"mousedown",4,"ngIf"],["class","analysis-container",4,"ngIf","ngIfElse"],["noRun",""],["class","side-toggle",4,"ngIf"],[1,"sidebar-container"],[1,"sidebar-contents"],[1,"violin-filters"],[1,"run-selector"],[1,"grabber",3,"mousedown"],[1,"analysis-container"],[1,"annotations-list"],[1,"noRun"],[1,"side-toggle"],["mat-icon-button","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle Sidebar"):$localize`:Label for a button that toggles the sidebar.␟f63b57932d179cca62ac9fcae63dd7f5e6fa389f␟4485009347444704878:Toggle Sidebar`],["svgIcon","chevron_right_24px"]]},template:function t(n,e){if(1&n&&(tp(0,"npmi-data-selection"),Kg(1,"div",0),cp("mouseup",(function t(){return e.resizeReleased.emit()}))("mousemove",(function t(n){return e.resizeTriggered.emit(n)})),Yg(2,bbt,5,2,"div",1),Yg(3,ubt,1,0,"div",2),Yg(4,fbt,3,0,"div",3),Yg(5,hbt,2,0,"ng-template",null,4,Kf),$g(),Yg(7,_bt,4,0,"div",5)),2&n){const t=qg(6);ws(2),Jg("ngIf",e.sidebarExpanded),ws(1),Jg("ngIf",e.sidebarExpanded),ws(1),Jg("ngIf",!0===e.runActive)("ngIfElse",t),ws(3),Jg("ngIf",!e.sidebarExpanded)}},directives:[mpt,WM,_pt,rK,rbt,pbt,eA,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.content[_ngcontent-%COMP%]{display:flex;flex:1;min-height:0px;width:100%}.sidebar-container[_ngcontent-%COMP%]{height:100%;overflow:hidden}.sidebar-contents[_ngcontent-%COMP%]{height:100%;display:flex;flex-direction:column;min-width:150px}.analysis-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;height:100%;flex:1 1}.run-selector[_ngcontent-%COMP%]{max-height:100%;width:100%}.violin-filters[_ngcontent-%COMP%]{min-height:0px;width:100%}.side-toggle[_ngcontent-%COMP%]{width:30px;height:30px;position:absolute;left:10px;bottom:10px;border:1px solid #ebebeb;border-radius:3px;display:flex;align-items:center;justify-content:center}.grabber[_ngcontent-%COMP%]{content:"";cursor:ew-resize;height:100%;width:3px;overflow:hidden;background-color:rgba(0,0,0,.12)}.annotations-list[_ngcontent-%COMP%]{width:100%;min-height:0px;flex:1 1}'],changeDetection:0});class Mbt{constructor(t){this.store=t,this.runActive$=this.store.pipe(lv(KD)).pipe(ft((t=>!!t&&[...t.values()].includes(!0)))),this.sidebarExpanded$=this.store.pipe(lv(jdt)),this.sidebarWidth$=this.store.pipe(lv(Ydt)),this.resizing=!1}onToggleSidebarExpanded(){this.store.dispatch(bgt())}onResizeTriggered(t){this.resizing&&this.store.dispatch(_gt({sidebarWidth:t.clientX}))}onResizeGrabbed(){this.resizing=!0}onResizeReleased(){this.resizing=!1}}function Obt(t,n){1&t&&(Kg(0,"div",6),Kg(1,"div",7),Kg(2,"div",8),tp(3,"runs-selector"),$g(),$g(),$g()),2&t&&Tp("width",gp().sidebarWidth,"px")}function Pbt(t,n){if(1&t){const t=op();Kg(0,"div",9),cp("mousedown",(function n(){return jr(t),gp().resizeGrabbed.emit()})),$g()}}function xbt(t,n){1&t&&(Kg(0,"div",10),tp(1,"npmi-annotations-list",11),tp(2,"npmi-selected-annotations"),$g())}function ybt(t,n){1&t&&(Kg(0,"div",12),Jp(1,"You need to select at least one run."),$g())}function kbt(t,n){if(1&t){const t=op();Kg(0,"div",13),Kg(1,"button",14),lu(2,15),cp("click",(function n(){return jr(t),gp().toggleSidebarExpanded.emit()})),tp(3,"mat-icon",16),$g(),$g()}}Mbt.ɵfac=function t(n){return new(n||Mbt)(Zg(cv))},Mbt.ɵcmp=_o({type:Mbt,selectors:[["npmi-main"]],decls:4,vars:9,consts:[[3,"runActive","sidebarExpanded","sidebarWidth","toggleSidebarExpanded","resizeTriggered","resizeGrabbed","resizeReleased"]],template:function t(n,e){1&n&&(Kg(0,"main-component",0),cp("toggleSidebarExpanded",(function t(){return e.onToggleSidebarExpanded()}))("resizeTriggered",(function t(n){return e.onResizeTriggered(n)}))("resizeGrabbed",(function t(){return e.onResizeGrabbed()}))("resizeReleased",(function t(){return e.onResizeReleased()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("runActive",kf(1,3,e.runActive$))("sidebarExpanded",kf(2,5,e.sidebarExpanded$))("sidebarWidth",kf(3,7,e.sidebarWidth$))},directives:[Cbt],pipes:[oO],encapsulation:2,changeDetection:0});class vbt{constructor(){this.toggleSidebarExpanded=new Ef,this.resizeTriggered=new Ef,this.resizeGrabbed=new Ef,this.resizeReleased=new Ef}}vbt.ɵfac=function t(n){return new(n||vbt)},vbt.ɵcmp=_o({type:vbt,selectors:[["embeddings-component"]],inputs:{runActive:"runActive",sidebarExpanded:"sidebarExpanded",sidebarWidth:"sidebarWidth"},outputs:{toggleSidebarExpanded:"toggleSidebarExpanded",resizeTriggered:"resizeTriggered",resizeGrabbed:"resizeGrabbed",resizeReleased:"resizeReleased"},decls:8,vars:5,consts:function(){return[[1,"content",3,"mouseup","mousemove"],["class","sidebar-container",3,"width",4,"ngIf"],["class","grabber",3,"mousedown",4,"ngIf"],["class","analysis-container",4,"ngIf","ngIfElse"],["noRun",""],["class","side-toggle",4,"ngIf"],[1,"sidebar-container"],[1,"sidebar-contents"],[1,"run-selector"],[1,"grabber",3,"mousedown"],[1,"analysis-container"],[1,"annotations-list"],[1,"noRun"],[1,"side-toggle"],["mat-icon-button","",3,"click",6,"aria-label"],["aria-label","undefined"!=typeof ngI18nClosureMode&&ngI18nClosureMode?goog.getMsg("Toggle Sidebar"):$localize`:Label for a button that toggles the sidebar.␟f63b57932d179cca62ac9fcae63dd7f5e6fa389f␟4485009347444704878:Toggle Sidebar`],["svgIcon","chevron_right_24px"]]},template:function t(n,e){if(1&n&&(tp(0,"npmi-data-selection"),Kg(1,"div",0),cp("mouseup",(function t(){return e.resizeReleased.emit()}))("mousemove",(function t(n){return e.resizeTriggered.emit(n)})),Yg(2,Obt,4,2,"div",1),Yg(3,Pbt,1,0,"div",2),Yg(4,xbt,3,0,"div",3),Yg(5,ybt,2,0,"ng-template",null,4,Kf),$g(),Yg(7,kbt,4,0,"div",5)),2&n){const t=qg(6);ws(2),Jg("ngIf",e.sidebarExpanded),ws(1),Jg("ngIf",e.sidebarExpanded),ws(1),Jg("ngIf",!0===e.runActive)("ngIfElse",t),ws(3),Jg("ngIf",!e.sidebarExpanded)}},directives:[mpt,WM,rK,rbt,pbt,eA,BB],styles:['.mat-badge-content[_ngcontent-%COMP%]{font-weight:600;font-size:12px;font-family:Roboto, "Helvetica Neue", sans-serif}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:9px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{font-size:24px}.mat-h1[_ngcontent-%COMP%], .mat-headline[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%]{font:400 24px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h2[_ngcontent-%COMP%], .mat-title[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h3[_ngcontent-%COMP%], .mat-subheading-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%]{font:400 16px/28px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h4[_ngcontent-%COMP%], .mat-subheading-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%]{font:400 15px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 16px}.mat-h5[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%]{font:400 calc(14px * 0.83)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-h6[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:400 calc(14px * 0.67)/20px Roboto, "Helvetica Neue", sans-serif;margin:0 0 12px}.mat-body-strong[_ngcontent-%COMP%], .mat-body-2[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-body[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-body-1[_ngcontent-%COMP%]   p[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   p[_ngcontent-%COMP%]{margin:0 0 12px}.mat-small[_ngcontent-%COMP%], .mat-caption[_ngcontent-%COMP%]{font:400 12px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-display-4[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-4[_ngcontent-%COMP%]{font:300 112px/112px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.05em;margin:0 0 56px}.mat-display-3[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-3[_ngcontent-%COMP%]{font:400 56px/56px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.02em;margin:0 0 64px}.mat-display-2[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-2[_ngcontent-%COMP%]{font:400 45px/48px Roboto, "Helvetica Neue", sans-serif;letter-spacing:-0.005em;margin:0 0 64px}.mat-display-1[_ngcontent-%COMP%], .mat-typography[_ngcontent-%COMP%]   .mat-display-1[_ngcontent-%COMP%]{font:400 34px/40px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0 0 64px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%], .mat-flat-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-button-toggle[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-card-title[_ngcontent-%COMP%]{font-size:24px;font-weight:500}.mat-card-header[_ngcontent-%COMP%]   .mat-card-title[_ngcontent-%COMP%]{font-size:20px}.mat-card-subtitle[_ngcontent-%COMP%], .mat-card-content[_ngcontent-%COMP%]{font-size:14px}.mat-checkbox[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-checkbox-layout[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{line-height:24px}.mat-chip[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-chip[_ngcontent-%COMP%]   .mat-chip-trailing-icon.mat-icon[_ngcontent-%COMP%], .mat-chip[_ngcontent-%COMP%]   .mat-chip-remove.mat-icon[_ngcontent-%COMP%]{font-size:18px}.mat-table[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-header-cell[_ngcontent-%COMP%]{font-size:12px;font-weight:500}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{font-size:14px}.mat-calendar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-calendar-body[_ngcontent-%COMP%]{font-size:13px}.mat-calendar-body-label[_ngcontent-%COMP%], .mat-calendar-period-button[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-calendar-table-header[_ngcontent-%COMP%]   th[_ngcontent-%COMP%]{font-size:11px;font-weight:400}.mat-dialog-title[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-expansion-panel-header[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:15px;font-weight:400}.mat-expansion-panel-content[_ngcontent-%COMP%]{font:400 14px/20px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field[_ngcontent-%COMP%]{font-size:inherit;font-weight:400;line-height:1.125;font-family:Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.34375em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{font-size:150%;line-height:1.125}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]{height:1.5em;width:1.5em}.mat-form-field-prefix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%], .mat-form-field-suffix[_ngcontent-%COMP%]   .mat-icon-button[_ngcontent-%COMP%]   .mat-icon[_ngcontent-%COMP%]{height:1.125em;line-height:1.125}.mat-form-field-infix[_ngcontent-%COMP%]{padding:.5em 0;border-top:.84375em solid transparent}.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34375em) scale(0.75);width:133.3333333333%}.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.34374em) scale(0.75);width:133.3333433333%}.mat-form-field-label-wrapper[_ngcontent-%COMP%]{top:-0.84375em;padding-top:.84375em}.mat-form-field-label[_ngcontent-%COMP%]{top:1.34375em}.mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.34375em}.mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{font-size:75%;margin-top:.6666666667em;top:calc(100% - 1.7916666667em)}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-wrapper[_ngcontent-%COMP%]{padding-bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.4375em 0}.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.001px);-ms-transform:translateY(-1.28125em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00101px);-ms-transform:translateY(-1.28124em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28125em) scale(0.75) perspective(100px) translateZ(0.00102px);-ms-transform:translateY(-1.28123em) scale(0.75);width:133.3333533333%}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.28125em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{bottom:1.25em}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-subscript-wrapper[_ngcontent-%COMP%]{margin-top:.5416666667em;top:calc(100% - 1.6666666667em)}@media print{.mat-form-field-appearance-legacy.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28122em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-form-field-autofill-control[_ngcontent-%COMP%]:-webkit-autofill + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.28121em) scale(0.75)}.mat-form-field-appearance-legacy.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.2812em) scale(0.75)}}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:.25em 0 .75em 0}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.09375em;margin-top:-0.5em}.mat-form-field-appearance-fill.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-fill.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-0.59374em) scale(0.75);width:133.3333433333%}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]{padding:1em 0 1em 0}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{top:1.84375em;margin-top:-0.25em}.mat-form-field-appearance-outline.mat-form-field-can-float.mat-form-field-should-float[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[_ngcontent-%COMP%]:focus + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59375em) scale(0.75);width:133.3333333333%}.mat-form-field-appearance-outline.mat-form-field-can-float[_ngcontent-%COMP%]   .mat-input-server[label][_ngcontent-%COMP%]:not(:label-shown) + .mat-form-field-label-wrapper[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{transform:translateY(-1.59374em) scale(0.75);width:133.3333433333%}.mat-grid-tile-header[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]{font-size:14px}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%], .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-grid-tile-header[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2), .mat-grid-tile-footer[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}input.mat-input-element[_ngcontent-%COMP%]{margin-top:-0.0625em}.mat-menu-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:400}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px}.mat-radio-button[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-select-trigger[_ngcontent-%COMP%]{height:1.125em}.mat-slide-toggle-content[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-slider-thumb-label-text[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-stepper-vertical[_ngcontent-%COMP%], .mat-stepper-horizontal[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-step-label[_ngcontent-%COMP%]{font-size:14px;font-weight:400}.mat-step-sub-label-error[_ngcontent-%COMP%]{font-weight:normal}.mat-step-label-error[_ngcontent-%COMP%]{font-size:14px}.mat-step-label-selected[_ngcontent-%COMP%]{font-size:14px;font-weight:500}.mat-tab-group[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-toolbar[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h1[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h2[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h3[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h4[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h5[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   h6[_ngcontent-%COMP%]{font:500 20px/32px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal;margin:0}.mat-tooltip[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:10px;padding-top:6px;padding-bottom:6px}.mat-tooltip-handset[_ngcontent-%COMP%]{font-size:14px;padding-top:8px;padding-bottom:8px}.mat-list-item[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:16px}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:14px}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px;font-weight:500}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:block;box-sizing:border-box}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]   .mat-line[_ngcontent-%COMP%]:nth-child(n+2){font-size:12px}.mat-list-base[dense][_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:12px;font-weight:500}.mat-option[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:16px}.mat-optgroup-label[_ngcontent-%COMP%]{font:500 14px/24px Roboto, "Helvetica Neue", sans-serif;letter-spacing:normal}.mat-simple-snackbar[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif;font-size:14px}.mat-simple-snackbar-action[_ngcontent-%COMP%]{line-height:1;font-family:inherit;font-size:inherit;font-weight:500}.mat-tree[_ngcontent-%COMP%]{font-family:Roboto, "Helvetica Neue", sans-serif}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{font-weight:400;font-size:14px}.mat-ripple[_ngcontent-%COMP%]{overflow:hidden;position:relative}.mat-ripple[_ngcontent-%COMP%]:not(:empty){transform:translateZ(0)}.mat-ripple.mat-ripple-unbounded[_ngcontent-%COMP%]{overflow:visible}.mat-ripple-element[_ngcontent-%COMP%]{position:absolute;border-radius:50%;pointer-events:none;transition:opacity,transform 0ms cubic-bezier(0, 0, 0.2, 1);transform:scale(0)}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{display:none}.cdk-visually-hidden[_ngcontent-%COMP%]{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;outline:0;-webkit-appearance:none;-moz-appearance:none}.cdk-overlay-container[_ngcontent-%COMP%], .cdk-global-overlay-wrapper[_ngcontent-%COMP%]{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container[_ngcontent-%COMP%]{position:fixed;z-index:1000}.cdk-overlay-container[_ngcontent-%COMP%]:empty{display:none}.cdk-global-overlay-wrapper[_ngcontent-%COMP%]{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane[_ngcontent-%COMP%]{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000;display:flex;max-width:100%;max-height:100%}.cdk-overlay-backdrop[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;-webkit-tap-highlight-color:transparent;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:1}@media screen and (-ms-high-contrast: active){.cdk-overlay-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:.6}}.cdk-overlay-dark-backdrop[_ngcontent-%COMP%]{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop[_ngcontent-%COMP%], .cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing[_ngcontent-%COMP%]{opacity:0}.cdk-overlay-connected-position-bounding-box[_ngcontent-%COMP%]{position:absolute;z-index:1000;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-global-scrollblock[_ngcontent-%COMP%]{position:fixed;width:100%;overflow-y:scroll}@keyframes cdk-text-field-autofill-start{}@keyframes cdk-text-field-autofill-end{}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:-webkit-autofill{animation:cdk-text-field-autofill-start 0s 1ms}.cdk-text-field-autofill-monitored[_ngcontent-%COMP%]:not(:-webkit-autofill){animation:cdk-text-field-autofill-end 0s 1ms}textarea.cdk-textarea-autosize[_ngcontent-%COMP%]{resize:none}textarea.cdk-textarea-autosize-measuring[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:auto !important;overflow:hidden !important}textarea.cdk-textarea-autosize-measuring-firefox[_ngcontent-%COMP%]{padding:2px 0 !important;box-sizing:content-box !important;height:0 !important}.mat-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-mdc-focus-indicator[_ngcontent-%COMP%]{position:relative}.mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1)}.mat-option[_ngcontent-%COMP%]{color:#212121}.mat-option[_ngcontent-%COMP%]:hover:not(.mat-option-disabled), .mat-option[_ngcontent-%COMP%]:focus:not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple):not(.mat-option-disabled){background:rgba(0,0,0,.04)}.mat-option.mat-active[_ngcontent-%COMP%]{background:rgba(0,0,0,.04);color:#212121}.mat-option.mat-option-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-primary[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f57c00}.mat-accent[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-disabled){color:#f44336}.mat-optgroup-label[_ngcontent-%COMP%]{color:#616161}.mat-optgroup-disabled[_ngcontent-%COMP%]   .mat-optgroup-label[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-pseudo-checkbox[_ngcontent-%COMP%]{color:#616161}.mat-pseudo-checkbox[_ngcontent-%COMP%]::after{color:#fafafa}.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{color:#b0b0b0}.mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f57c00}.mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#ff9800}.mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-checked[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-pseudo-checkbox-indeterminate[_ngcontent-%COMP%]{background:#f44336}.mat-pseudo-checkbox-checked.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%], .mat-pseudo-checkbox-indeterminate.mat-pseudo-checkbox-disabled[_ngcontent-%COMP%]{background:#b0b0b0}.mat-app-background[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-elevation-z0[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z1[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z2[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z3[_ngcontent-%COMP%]{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z4[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z5[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 5px 8px 0px rgba(0, 0, 0, 0.14),0px 1px 14px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z6[_ngcontent-%COMP%]{box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-elevation-z7[_ngcontent-%COMP%]{box-shadow:0px 4px 5px -2px rgba(0, 0, 0, 0.2),0px 7px 10px 1px rgba(0, 0, 0, 0.14),0px 2px 16px 1px rgba(0, 0, 0, 0.12)}.mat-elevation-z8[_ngcontent-%COMP%]{box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z9[_ngcontent-%COMP%]{box-shadow:0px 5px 6px -3px rgba(0, 0, 0, 0.2),0px 9px 12px 1px rgba(0, 0, 0, 0.14),0px 3px 16px 2px rgba(0, 0, 0, 0.12)}.mat-elevation-z10[_ngcontent-%COMP%]{box-shadow:0px 6px 6px -3px rgba(0, 0, 0, 0.2),0px 10px 14px 1px rgba(0, 0, 0, 0.14),0px 4px 18px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z11[_ngcontent-%COMP%]{box-shadow:0px 6px 7px -4px rgba(0, 0, 0, 0.2),0px 11px 15px 1px rgba(0, 0, 0, 0.14),0px 4px 20px 3px rgba(0, 0, 0, 0.12)}.mat-elevation-z12[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z13[_ngcontent-%COMP%]{box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 13px 19px 2px rgba(0, 0, 0, 0.14),0px 5px 24px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z14[_ngcontent-%COMP%]{box-shadow:0px 7px 9px -4px rgba(0, 0, 0, 0.2),0px 14px 21px 2px rgba(0, 0, 0, 0.14),0px 5px 26px 4px rgba(0, 0, 0, 0.12)}.mat-elevation-z15[_ngcontent-%COMP%]{box-shadow:0px 8px 9px -5px rgba(0, 0, 0, 0.2),0px 15px 22px 2px rgba(0, 0, 0, 0.14),0px 6px 28px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z16[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z17[_ngcontent-%COMP%]{box-shadow:0px 8px 11px -5px rgba(0, 0, 0, 0.2),0px 17px 26px 2px rgba(0, 0, 0, 0.14),0px 6px 32px 5px rgba(0, 0, 0, 0.12)}.mat-elevation-z18[_ngcontent-%COMP%]{box-shadow:0px 9px 11px -5px rgba(0, 0, 0, 0.2),0px 18px 28px 2px rgba(0, 0, 0, 0.14),0px 7px 34px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z19[_ngcontent-%COMP%]{box-shadow:0px 9px 12px -6px rgba(0, 0, 0, 0.2),0px 19px 29px 2px rgba(0, 0, 0, 0.14),0px 7px 36px 6px rgba(0, 0, 0, 0.12)}.mat-elevation-z20[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 20px 31px 3px rgba(0, 0, 0, 0.14),0px 8px 38px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z21[_ngcontent-%COMP%]{box-shadow:0px 10px 13px -6px rgba(0, 0, 0, 0.2),0px 21px 33px 3px rgba(0, 0, 0, 0.14),0px 8px 40px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z22[_ngcontent-%COMP%]{box-shadow:0px 10px 14px -6px rgba(0, 0, 0, 0.2),0px 22px 35px 3px rgba(0, 0, 0, 0.14),0px 8px 42px 7px rgba(0, 0, 0, 0.12)}.mat-elevation-z23[_ngcontent-%COMP%]{box-shadow:0px 11px 14px -7px rgba(0, 0, 0, 0.2),0px 23px 36px 3px rgba(0, 0, 0, 0.14),0px 9px 44px 8px rgba(0, 0, 0, 0.12)}.mat-elevation-z24[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12)}.mat-theme-loaded-marker[_ngcontent-%COMP%]{display:none}.mat-autocomplete-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-autocomplete-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover){background:#fff}.mat-autocomplete-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-active):not(:hover):not(.mat-option-disabled){color:#212121}.mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f57c00}.cdk-high-contrast-active[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{outline:solid 1px;border-radius:0}.mat-badge-accent[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-badge-warn[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{color:#fff;background:#f44336}.mat-badge[_ngcontent-%COMP%]{position:relative}.mat-badge-hidden[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{display:none}.mat-badge-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{background:#b9b9b9;color:#757575}.mat-badge-content[_ngcontent-%COMP%]{position:absolute;text-align:center;display:inline-block;border-radius:50%;transition:transform 200ms ease-in-out;transform:scale(0.6);overflow:hidden;white-space:nowrap;text-overflow:ellipsis;pointer-events:none}.ng-animate-disabled[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%], .mat-badge-content._mat-animation-noopable[_ngcontent-%COMP%]{transition:none}.mat-badge-content.mat-badge-active[_ngcontent-%COMP%]{transform:none}.mat-badge-small[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:16px;height:16px;line-height:16px}.mat-badge-small.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-8px}.mat-badge-small.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-8px}.mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-16px}.mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-16px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-16px}.mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-8px}.mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-8px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-small.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-8px}.mat-badge-medium[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:22px;height:22px;line-height:22px}.mat-badge-medium.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-11px}.mat-badge-medium.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-11px}.mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-22px}.mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-22px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-22px}.mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-11px}.mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-11px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-medium.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-11px}.mat-badge-large[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{width:28px;height:28px;line-height:28px}.mat-badge-large.mat-badge-above[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{top:-14px}.mat-badge-large.mat-badge-below[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{bottom:-14px}.mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-28px}.mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-28px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-28px}.mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-before[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{left:auto;right:-14px}.mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:-14px}[dir=rtl][_ngcontent-%COMP%]   .mat-badge-large.mat-badge-overlap.mat-badge-after[_ngcontent-%COMP%]   .mat-badge-content[_ngcontent-%COMP%]{right:auto;left:-14px}.mat-bottom-sheet-container[_ngcontent-%COMP%]{box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-button[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]{color:inherit;background:transparent}.mat-button.mat-primary[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-primary[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f57c00}.mat-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-accent[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#ff9800}.mat-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-warn[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:#f44336}.mat-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-icon-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%], .mat-stroked-button.mat-button-disabled[_ngcontent-%COMP%]   .mat-button-focus-overlay[_ngcontent-%COMP%]{background-color:transparent}.mat-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-icon-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-stroked-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{opacity:.1;background-color:currentColor}.mat-button-focus-overlay[_ngcontent-%COMP%]{background:#000}.mat-stroked-button[_ngcontent-%COMP%]:not(.mat-button-disabled){border-color:rgba(0,0,0,.12)}.mat-flat-button[_ngcontent-%COMP%], .mat-raised-button[_ngcontent-%COMP%], .mat-fab[_ngcontent-%COMP%], .mat-mini-fab[_ngcontent-%COMP%]{color:#212121;background-color:#fff}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{color:#fff}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-flat-button.mat-primary[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00}.mat-flat-button.mat-accent[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-flat-button.mat-warn[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-flat-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-flat-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-raised-button.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-primary.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-accent.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-warn.mat-button-disabled[_ngcontent-%COMP%], .mat-mini-fab.mat-button-disabled.mat-button-disabled[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-flat-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-flat-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-raised-button.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-mini-fab.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-stroked-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-flat-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-raised-button[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 5px 5px -3px rgba(0, 0, 0, 0.2),0px 8px 10px 1px rgba(0, 0, 0, 0.14),0px 3px 14px 2px rgba(0, 0, 0, 0.12)}.mat-raised-button.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]), .mat-mini-fab[_ngcontent-%COMP%]:not(.mat-button-disabled):active:not([class*=mat-elevation-z]){box-shadow:0px 7px 8px -4px rgba(0, 0, 0, 0.2),0px 12px 17px 2px rgba(0, 0, 0, 0.14),0px 5px 22px 4px rgba(0, 0, 0, 0.12)}.mat-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]), .mat-mini-fab.mat-button-disabled[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone[_ngcontent-%COMP%], .mat-button-toggle-group[_ngcontent-%COMP%]{box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{box-shadow:none}.mat-button-toggle[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-button-toggle[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121;background:#fff}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-focus-overlay[_ngcontent-%COMP%]{background-color:#000}.mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12)}[dir=rtl][_ngcontent-%COMP%]   .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-group-appearance-standard.mat-button-toggle-vertical[_ngcontent-%COMP%]   .mat-button-toggle[_ngcontent-%COMP%] + .mat-button-toggle[_ngcontent-%COMP%]{border-left:none;border-right:none;border-top:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#616161}.mat-button-toggle-checked.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{color:#212121}.mat-button-toggle-disabled[_ngcontent-%COMP%]{color:rgba(0,0,0,.26);background-color:#eee}.mat-button-toggle-disabled.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]{background:#fff}.mat-button-toggle-disabled.mat-button-toggle-checked[_ngcontent-%COMP%]{background-color:#bdbdbd}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard[_ngcontent-%COMP%], .mat-button-toggle-group-appearance-standard[_ngcontent-%COMP%]{border:solid 1px rgba(0,0,0,.12)}.mat-button-toggle-appearance-standard[_ngcontent-%COMP%]   .mat-button-toggle-label-content[_ngcontent-%COMP%]{line-height:48px}.mat-card[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-card[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12)}.mat-card.mat-card-flat[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-card-subtitle[_ngcontent-%COMP%]{color:#616161}.mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#616161}.mat-checkbox-checkmark[_ngcontent-%COMP%]{fill:#fafafa}.mat-checkbox-checkmark-path[_ngcontent-%COMP%]{stroke:#fafafa !important}.mat-checkbox-mixedmark[_ngcontent-%COMP%]{background-color:#fafafa}.mat-checkbox-indeterminate.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-primary[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f57c00}.mat-checkbox-indeterminate.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-accent[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#ff9800}.mat-checkbox-indeterminate.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-checked.mat-warn[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#f44336}.mat-checkbox-disabled.mat-checkbox-checked[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%], .mat-checkbox-disabled.mat-checkbox-indeterminate[_ngcontent-%COMP%]   .mat-checkbox-background[_ngcontent-%COMP%]{background-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]:not(.mat-checkbox-checked)   .mat-checkbox-frame[_ngcontent-%COMP%]{border-color:#b0b0b0}.mat-checkbox-disabled[_ngcontent-%COMP%]   .mat-checkbox-label[_ngcontent-%COMP%]{color:#616161}.mat-checkbox[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-primary   .mat-ripple-element[_ngcontent-%COMP%]{background:#f57c00}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-accent   .mat-ripple-element[_ngcontent-%COMP%]{background:#ff9800}.mat-checkbox-checked[_ngcontent-%COMP%]:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%], .mat-checkbox[_ngcontent-%COMP%]:active:not(.mat-checkbox-disabled).mat-warn   .mat-ripple-element[_ngcontent-%COMP%]{background:#f44336}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]{background-color:#e0e0e0;color:#212121}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#212121;opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled):active{box-shadow:0px 3px 3px -2px rgba(0, 0, 0, 0.2),0px 3px 4px 0px rgba(0, 0, 0, 0.14),0px 1px 8px 0px rgba(0, 0, 0, 0.12)}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]:not(.mat-chip-disabled)   .mat-chip-remove[_ngcontent-%COMP%]:hover{opacity:.54}.mat-chip.mat-standard-chip.mat-chip-disabled[_ngcontent-%COMP%]{opacity:.4}.mat-chip.mat-standard-chip[_ngcontent-%COMP%]::after{background:#000}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-chip-remove[_ngcontent-%COMP%]{color:#fff;opacity:.4}.mat-chip.mat-standard-chip.mat-chip-selected.mat-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.1)}.mat-table[_ngcontent-%COMP%]{background:#fff}.mat-table[_ngcontent-%COMP%]   thead[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tbody[_ngcontent-%COMP%], .mat-table[_ngcontent-%COMP%]   tfoot[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], [mat-header-row][_ngcontent-%COMP%], [mat-row][_ngcontent-%COMP%], [mat-footer-row][_ngcontent-%COMP%], .mat-table-sticky[_ngcontent-%COMP%]{background:inherit}mat-row[_ngcontent-%COMP%], mat-header-row[_ngcontent-%COMP%], mat-footer-row[_ngcontent-%COMP%], th.mat-header-cell[_ngcontent-%COMP%], td.mat-cell[_ngcontent-%COMP%], td.mat-footer-cell[_ngcontent-%COMP%]{border-bottom-color:rgba(0,0,0,.12)}.mat-header-cell[_ngcontent-%COMP%]{color:#616161}.mat-cell[_ngcontent-%COMP%], .mat-footer-cell[_ngcontent-%COMP%]{color:#212121}.mat-calendar-arrow[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.54)}.mat-datepicker-toggle[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-next-button[_ngcontent-%COMP%], .mat-datepicker-content[_ngcontent-%COMP%]   .mat-calendar-previous-button[_ngcontent-%COMP%]{color:rgba(0,0,0,.54)}.mat-calendar-table-header[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-calendar-table-header-divider[_ngcontent-%COMP%]::after{background:rgba(0,0,0,.12)}.mat-calendar-body-label[_ngcontent-%COMP%]{color:#616161}.mat-calendar-body-cell-content[_ngcontent-%COMP%], .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#212121;border-color:transparent}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){color:#757575}.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-date-range-input-separator[_ngcontent-%COMP%]{color:#757575}.mat-calendar-body-cell[_ngcontent-%COMP%]:not(.mat-calendar-body-disabled):hover > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-keyboard-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical), .cdk-program-focused[_ngcontent-%COMP%]   .mat-calendar-body-active[_ngcontent-%COMP%] > .mat-calendar-body-cell-content[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){background-color:rgba(0,0,0,.04)}.mat-calendar-body-in-preview[_ngcontent-%COMP%]{color:rgba(0,0,0,.24)}.mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.38)}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-today[_ngcontent-%COMP%]:not(.mat-calendar-body-selected):not(.mat-calendar-body-comparison-identical){border-color:rgba(0,0,0,.18)}.mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(245,124,0,.2)}.mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(245, 124, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.4)}.mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content[_ngcontent-%COMP%]{box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12);background-color:#fff;color:#212121}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(255,152,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(255, 152, 0, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#ff9800;color:#fff}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.4)}.mat-datepicker-content.mat-accent[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%]::before{background:rgba(244,67,54,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%]::before{background:rgba(249,171,0,.2)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before{background:linear-gradient(to right, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-end[_ngcontent-%COMP%]::before, .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   [dir=rtl][_ngcontent-%COMP%]   .mat-calendar-body-comparison-bridge-start[_ngcontent-%COMP%]::before{background:linear-gradient(to left, rgba(244, 67, 54, 0.2) 50%, rgba(249, 171, 0, 0.2) 50%)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-range[_ngcontent-%COMP%] > .mat-calendar-body-comparison-identical[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range.mat-calendar-body-in-range[_ngcontent-%COMP%]::after{background:#a8dab5}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-comparison-identical.mat-calendar-body-selected[_ngcontent-%COMP%], .mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-in-comparison-range[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background:#46a35e}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:#f44336;color:#fff}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-disabled[_ngcontent-%COMP%] > .mat-calendar-body-selected[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.4)}.mat-datepicker-content.mat-warn[_ngcontent-%COMP%]   .mat-calendar-body-today.mat-calendar-body-selected[_ngcontent-%COMP%]{box-shadow:inset 0 0 0 1px #fff}.mat-datepicker-content-touch[_ngcontent-%COMP%]{box-shadow:0px 0px 0px 0px rgba(0, 0, 0, 0.2),0px 0px 0px 0px rgba(0, 0, 0, 0.14),0px 0px 0px 0px rgba(0, 0, 0, 0.12)}.mat-datepicker-toggle-active[_ngcontent-%COMP%]{color:#f57c00}.mat-datepicker-toggle-active.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-datepicker-toggle-active.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-date-range-input-inner[disabled][_ngcontent-%COMP%]{color:#757575}.mat-dialog-container[_ngcontent-%COMP%]{box-shadow:0px 11px 15px -7px rgba(0, 0, 0, 0.2),0px 24px 38px 3px rgba(0, 0, 0, 0.14),0px 9px 46px 8px rgba(0, 0, 0, 0.12);background:#fff;color:#212121}.mat-divider[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-divider-vertical[_ngcontent-%COMP%]{border-right-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]{background:#fff;color:#212121}.mat-expansion-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 3px 1px -2px rgba(0, 0, 0, 0.2),0px 2px 2px 0px rgba(0, 0, 0, 0.14),0px 1px 5px 0px rgba(0, 0, 0, 0.12)}.mat-action-row[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-keyboard-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]   .mat-expansion-panel-header.cdk-program-focused[_ngcontent-%COMP%]:not([aria-disabled=true]), .mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded)   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover:not([aria-disabled=true]){background:rgba(0,0,0,.04)}@media(hover: none){.mat-expansion-panel[_ngcontent-%COMP%]:not(.mat-expanded):not([aria-disabled=true])   .mat-expansion-panel-header[_ngcontent-%COMP%]:hover{background:#fff}}.mat-expansion-panel-header-title[_ngcontent-%COMP%]{color:#212121}.mat-expansion-panel-header-description[_ngcontent-%COMP%], .mat-expansion-indicator[_ngcontent-%COMP%]::after{color:#616161}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]{color:rgba(0,0,0,.26)}.mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-title[_ngcontent-%COMP%], .mat-expansion-panel-header[aria-disabled=true][_ngcontent-%COMP%]   .mat-expansion-panel-header-description[_ngcontent-%COMP%]{color:inherit}.mat-expansion-panel-header[_ngcontent-%COMP%]{height:48px}.mat-expansion-panel-header.mat-expanded[_ngcontent-%COMP%]{height:64px}.mat-form-field-label[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-hint[_ngcontent-%COMP%]{color:rgba(97,97,97,.6)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-label.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-focused[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-ripple[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#ff9800}.mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-warn[_ngcontent-%COMP%]{background-color:#f44336}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid)   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f57c00}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-accent   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#ff9800}.mat-form-field-type-mat-native-select.mat-focused[_ngcontent-%COMP%]:not(.mat-form-field-invalid).mat-warn   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label.mat-accent[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]   .mat-form-field-required-marker[_ngcontent-%COMP%]{color:#f44336}.mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-form-field.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-ripple.mat-accent[_ngcontent-%COMP%]{background-color:#f44336}.mat-error[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-hint[_ngcontent-%COMP%]{color:#616161}.mat-form-field-appearance-legacy[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-legacy.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-standard[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-standard.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]{background-image:linear-gradient(to right, rgba(0, 0, 0, 0.42) 0%, rgba(0, 0, 0, 0.42) 33%, transparent 0%);background-size:4px 100%;background-repeat:repeat-x}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.04)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-flex[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.02)}.mat-form-field-appearance-fill[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:rgba(0,0,0,.42)}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-fill.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%]::before{background-color:transparent}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.12)}.mat-form-field-appearance-outline[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:rgba(0,0,0,.87)}.mat-form-field-appearance-outline.mat-focused[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field-appearance-outline.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field-appearance-outline.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-invalid.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-outline-thick[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%]{color:#757575}.mat-form-field-appearance-outline.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-outline[_ngcontent-%COMP%]{color:rgba(0,0,0,.06)}.mat-icon.mat-primary[_ngcontent-%COMP%]{color:#f57c00}.mat-icon.mat-accent[_ngcontent-%COMP%]{color:#ff9800}.mat-icon.mat-warn[_ngcontent-%COMP%]{color:#f44336}.mat-form-field-type-mat-native-select[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#616161}.mat-input-element[_ngcontent-%COMP%]:disabled, .mat-form-field-type-mat-native-select.mat-form-field-disabled[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#757575}.mat-input-element[_ngcontent-%COMP%]{caret-color:#f57c00}.mat-input-element[_ngcontent-%COMP%]::placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-moz-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]::-webkit-input-placeholder{color:rgba(97,97,97,.42)}.mat-input-element[_ngcontent-%COMP%]:-ms-input-placeholder{color:rgba(97,97,97,.42)}.mat-form-field.mat-accent[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#ff9800}.mat-form-field.mat-warn[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%], .mat-form-field-invalid[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:#f44336}.mat-form-field-type-mat-native-select.mat-form-field-invalid[_ngcontent-%COMP%]   .mat-form-field-infix[_ngcontent-%COMP%]::after{color:#f44336}.mat-list-base[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-list-option[_ngcontent-%COMP%]{color:#212121}.mat-list-base[_ngcontent-%COMP%]   .mat-subheader[_ngcontent-%COMP%]{color:#616161}.mat-list-item-disabled[_ngcontent-%COMP%]{background-color:#eee}.mat-list-option[_ngcontent-%COMP%]:hover, .mat-list-option[_ngcontent-%COMP%]:focus, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-nav-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:hover, .mat-action-list[_ngcontent-%COMP%]   .mat-list-item[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.04)}.mat-list-single-selected-option[_ngcontent-%COMP%], .mat-list-single-selected-option[_ngcontent-%COMP%]:hover, .mat-list-single-selected-option[_ngcontent-%COMP%]:focus{background:rgba(0,0,0,.12)}.mat-menu-panel[_ngcontent-%COMP%]{background:#fff}.mat-menu-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-menu-item[_ngcontent-%COMP%]{background:transparent;color:#212121}.mat-menu-item[disabled][_ngcontent-%COMP%], .mat-menu-item[disabled][_ngcontent-%COMP%]::after{color:rgba(0,0,0,.38)}.mat-menu-item[_ngcontent-%COMP%]   .mat-icon-no-color[_ngcontent-%COMP%], .mat-menu-item-submenu-trigger[_ngcontent-%COMP%]::after{color:rgba(0,0,0,.54)}.mat-menu-item[_ngcontent-%COMP%]:hover:not([disabled]), .mat-menu-item.cdk-program-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item.cdk-keyboard-focused[_ngcontent-%COMP%]:not([disabled]), .mat-menu-item-highlighted[_ngcontent-%COMP%]:not([disabled]){background:rgba(0,0,0,.04)}.mat-paginator[_ngcontent-%COMP%]{background:#fff}.mat-paginator[_ngcontent-%COMP%], .mat-paginator-page-size[_ngcontent-%COMP%]   .mat-select-trigger[_ngcontent-%COMP%]{color:#616161}.mat-paginator-decrement[_ngcontent-%COMP%], .mat-paginator-increment[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54);border-right:2px solid rgba(0,0,0,.54)}.mat-paginator-first[_ngcontent-%COMP%], .mat-paginator-last[_ngcontent-%COMP%]{border-top:2px solid rgba(0,0,0,.54)}.mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-decrement[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-increment[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-first[_ngcontent-%COMP%], .mat-icon-button[disabled][_ngcontent-%COMP%]   .mat-paginator-last[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-paginator-container[_ngcontent-%COMP%]{min-height:56px}.mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f57c00}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ff9800}.mat-progress-bar.mat-accent[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#ff9800}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-background[_ngcontent-%COMP%]{fill:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-buffer[_ngcontent-%COMP%]{background-color:#ffcdd2}.mat-progress-bar.mat-warn[_ngcontent-%COMP%]   .mat-progress-bar-fill[_ngcontent-%COMP%]::after{background-color:#f44336}.mat-progress-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f57c00}.mat-progress-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-accent[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#ff9800}.mat-progress-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%], .mat-spinner.mat-warn[_ngcontent-%COMP%]   circle[_ngcontent-%COMP%]{stroke:#f44336}.mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#616161}.mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f57c00}.mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-primary.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-primary[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f57c00}.mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#ff9800}.mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-accent.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-accent[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#ff9800}.mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:#f44336}.mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]:not(.mat-radio-persistent-ripple), .mat-radio-button.mat-warn.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-persistent-ripple[_ngcontent-%COMP%], .mat-radio-button.mat-warn[_ngcontent-%COMP%]:active   .mat-radio-persistent-ripple[_ngcontent-%COMP%]{background-color:#f44336}.mat-radio-button.mat-radio-disabled.mat-radio-checked[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-outer-circle[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-ripple[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-inner-circle[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-radio-button.mat-radio-disabled[_ngcontent-%COMP%]   .mat-radio-label-content[_ngcontent-%COMP%]{color:rgba(0,0,0,.38)}.mat-radio-button[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-select-value[_ngcontent-%COMP%]{color:#212121}.mat-select-placeholder[_ngcontent-%COMP%]{color:rgba(97,97,97,.42)}.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%]{color:#757575}.mat-select-arrow[_ngcontent-%COMP%]{color:#616161}.mat-select-panel[_ngcontent-%COMP%]{background:#fff}.mat-select-panel[_ngcontent-%COMP%]:not([class*=mat-elevation-z]){box-shadow:0px 2px 4px -1px rgba(0, 0, 0, 0.2),0px 4px 5px 0px rgba(0, 0, 0, 0.14),0px 1px 10px 0px rgba(0, 0, 0, 0.12)}.mat-select-panel[_ngcontent-%COMP%]   .mat-option.mat-selected[_ngcontent-%COMP%]:not(.mat-option-multiple){background:rgba(0,0,0,.12)}.mat-form-field.mat-focused.mat-primary[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f57c00}.mat-form-field.mat-focused.mat-accent[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#ff9800}.mat-form-field.mat-focused.mat-warn[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-invalid[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#f44336}.mat-form-field[_ngcontent-%COMP%]   .mat-select.mat-select-disabled[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:#757575}.mat-drawer-container[_ngcontent-%COMP%]{background-color:#fafafa;color:#212121}.mat-drawer[_ngcontent-%COMP%]{background-color:#fff;color:#212121}.mat-drawer.mat-drawer-push[_ngcontent-%COMP%]{background-color:#fff}.mat-drawer[_ngcontent-%COMP%]:not(.mat-drawer-side){box-shadow:0px 8px 10px -5px rgba(0, 0, 0, 0.2),0px 16px 24px 2px rgba(0, 0, 0, 0.14),0px 6px 30px 5px rgba(0, 0, 0, 0.12)}.mat-drawer-side[_ngcontent-%COMP%]{border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side[_ngcontent-%COMP%]{border-left:solid 1px rgba(0,0,0,.12);border-right:none}[dir=rtl][_ngcontent-%COMP%]   .mat-drawer-side.mat-drawer-end[_ngcontent-%COMP%]{border-left:none;border-right:solid 1px rgba(0,0,0,.12)}.mat-drawer-backdrop.mat-drawer-shown[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.6)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.54)}.mat-slide-toggle.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#ff9800}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.54)}.mat-slide-toggle.mat-primary.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f57c00}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-thumb[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.54)}.mat-slide-toggle.mat-warn.mat-checked[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#f44336}.mat-slide-toggle[_ngcontent-%COMP%]:not(.mat-checked)   .mat-ripple-element[_ngcontent-%COMP%]{background-color:#000}.mat-slide-toggle-thumb[_ngcontent-%COMP%]{box-shadow:0px 2px 1px -1px rgba(0, 0, 0, 0.2),0px 1px 1px 0px rgba(0, 0, 0, 0.14),0px 1px 3px 0px rgba(0, 0, 0, 0.12);background-color:#fafafa}.mat-slide-toggle-bar[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-primary[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f57c00}.mat-primary[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-primary[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(245,124,0,.2)}.mat-accent[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#ff9800}.mat-accent[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-accent[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(255,152,0,.2)}.mat-warn[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:#f44336}.mat-warn[_ngcontent-%COMP%]   .mat-slider-thumb-label-text[_ngcontent-%COMP%]{color:#fff}.mat-warn[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(244,67,54,.2)}.mat-slider[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%], .cdk-focused[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.38)}.mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-background[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-track-fill[_ngcontent-%COMP%], .mat-slider-disabled[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-disabled[_ngcontent-%COMP%]:hover   .mat-slider-track-background[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]   .mat-slider-focus-ring[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.12)}.mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.87)}.mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value.mat-slider-thumb-label-showing.cdk-focused[_ngcontent-%COMP%]   .mat-slider-thumb-label[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.26)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing)   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26);background-color:transparent}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.38)}.mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing):hover.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%], .mat-slider-min-value[_ngcontent-%COMP%]:not(.mat-slider-thumb-label-showing).cdk-focused.mat-slider-disabled   .mat-slider-thumb[_ngcontent-%COMP%]{border-color:rgba(0,0,0,.26)}.mat-slider-has-ticks[_ngcontent-%COMP%]   .mat-slider-wrapper[_ngcontent-%COMP%]::after{border-color:rgba(0,0,0,.7)}.mat-slider-horizontal[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to right, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent);background-image:-moz-repeating-linear-gradient(0.0001deg, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-slider-vertical[_ngcontent-%COMP%]   .mat-slider-ticks[_ngcontent-%COMP%]{background-image:repeating-linear-gradient(to bottom, rgba(0, 0, 0, 0.7), rgba(0, 0, 0, 0.7) 2px, transparent 0, transparent)}.mat-step-header.cdk-keyboard-focused[_ngcontent-%COMP%], .mat-step-header.cdk-program-focused[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.04)}@media(hover: none){.mat-step-header[_ngcontent-%COMP%]:hover{background:none}}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-optional[_ngcontent-%COMP%]{color:#616161}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon[_ngcontent-%COMP%]{background-color:#616161;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-selected[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-done[_ngcontent-%COMP%], .mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-edit[_ngcontent-%COMP%]{background-color:#f57c00;color:#fff}.mat-step-header[_ngcontent-%COMP%]   .mat-step-icon-state-error[_ngcontent-%COMP%]{background-color:transparent;color:#f44336}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-active[_ngcontent-%COMP%]{color:#212121}.mat-step-header[_ngcontent-%COMP%]   .mat-step-label.mat-step-label-error[_ngcontent-%COMP%]{color:#f44336}.mat-stepper-horizontal[_ngcontent-%COMP%], .mat-stepper-vertical[_ngcontent-%COMP%]{background-color:#fff}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{border-left-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]::before, .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-horizontal-line[_ngcontent-%COMP%]{border-top-color:rgba(0,0,0,.12)}.mat-horizontal-stepper-header[_ngcontent-%COMP%]{height:72px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%], .mat-vertical-stepper-header[_ngcontent-%COMP%]{padding:24px 24px}.mat-stepper-vertical-line[_ngcontent-%COMP%]::before{top:-16px;bottom:-16px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::after, .mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-horizontal-stepper-header[_ngcontent-%COMP%]::before{top:36px}.mat-stepper-label-position-bottom[_ngcontent-%COMP%]   .mat-stepper-horizontal-line[_ngcontent-%COMP%]{top:36px}.mat-sort-header-arrow[_ngcontent-%COMP%]{color:#616161}.mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-header[_ngcontent-%COMP%]{border-bottom:1px solid rgba(0,0,0,.12)}.mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-nav-bar[_ngcontent-%COMP%], .mat-tab-group-inverted-header[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%]{border-top:1px solid rgba(0,0,0,.12);border-bottom:none}.mat-tab-label[_ngcontent-%COMP%], .mat-tab-link[_ngcontent-%COMP%]{color:#212121}.mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:#757575}.mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#212121}.mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#757575}.mat-tab-group[class*=mat-background-][_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar[class*=mat-background-][_ngcontent-%COMP%]{border-bottom:none;border-top:none}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-primary.mat-background-primary[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-accent.mat-background-accent[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-warn.mat-background-warn[_ngcontent-%COMP%]   .mat-ink-bar[_ngcontent-%COMP%]{background-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f57c00}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-primary[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,152,0,.3)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#ff9800}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-accent[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-keyboard-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled), .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.cdk-program-focused[_ngcontent-%COMP%]:not(.mat-tab-disabled){background-color:rgba(255,205,210,.3)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-links[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination[_ngcontent-%COMP%]{background-color:#f44336}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link[_ngcontent-%COMP%]{color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-label.mat-tab-disabled[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-link.mat-tab-disabled[_ngcontent-%COMP%]{color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:#fff}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-tab-header-pagination-disabled[_ngcontent-%COMP%]   .mat-tab-header-pagination-chevron[_ngcontent-%COMP%]{border-color:rgba(255,255,255,.4)}.mat-tab-group.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%], .mat-tab-nav-bar.mat-background-warn[_ngcontent-%COMP%]   .mat-ripple-element[_ngcontent-%COMP%]{background-color:rgba(255,255,255,.12)}.mat-toolbar[_ngcontent-%COMP%]{background:#f5f5f5;color:#212121}.mat-toolbar.mat-primary[_ngcontent-%COMP%]{background:#f57c00;color:#fff}.mat-toolbar.mat-accent[_ngcontent-%COMP%]{background:#ff9800;color:#fff}.mat-toolbar.mat-warn[_ngcontent-%COMP%]{background:#f44336;color:#fff}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-underline[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-ripple[_ngcontent-%COMP%]{background-color:currentColor}.mat-toolbar[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-focused[_ngcontent-%COMP%]   .mat-form-field-label[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-value[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%], .mat-toolbar[_ngcontent-%COMP%]   .mat-form-field.mat-focused[_ngcontent-%COMP%]   .mat-select-arrow[_ngcontent-%COMP%]{color:inherit}.mat-toolbar[_ngcontent-%COMP%]   .mat-input-element[_ngcontent-%COMP%]{caret-color:currentColor}.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:64px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:64px}@media(max-width: 599px){.mat-toolbar-multiple-rows[_ngcontent-%COMP%]{min-height:56px}.mat-toolbar-row[_ngcontent-%COMP%], .mat-toolbar-single-row[_ngcontent-%COMP%]{height:56px}}.mat-tooltip[_ngcontent-%COMP%]{background:rgba(97,97,97,.9)}.mat-tree[_ngcontent-%COMP%]{background:#fff}.mat-tree-node[_ngcontent-%COMP%], .mat-nested-tree-node[_ngcontent-%COMP%]{color:#212121}.mat-tree-node[_ngcontent-%COMP%]{min-height:48px}.mat-snack-bar-container[_ngcontent-%COMP%]{color:rgba(255,255,255,.7);background:#323232;box-shadow:0px 3px 5px -1px rgba(0, 0, 0, 0.2),0px 6px 10px 0px rgba(0, 0, 0, 0.14),0px 1px 18px 0px rgba(0, 0, 0, 0.12)}.mat-simple-snackbar-action[_ngcontent-%COMP%]{color:#ff9800}[_nghost-%COMP%]{display:flex;flex-direction:column;height:100%}.content[_ngcontent-%COMP%]{display:flex;flex:1;min-height:0px;width:100%}.sidebar-container[_ngcontent-%COMP%]{height:100%;overflow:hidden}.sidebar-contents[_ngcontent-%COMP%]{height:100%;display:flex;flex-direction:column;min-width:150px}.analysis-container[_ngcontent-%COMP%]{display:flex;flex-direction:column;height:100%;flex:1 1}.run-selector[_ngcontent-%COMP%]{max-height:100%;width:100%}.side-toggle[_ngcontent-%COMP%]{width:30px;height:30px;position:absolute;left:10px;bottom:10px;border:1px solid #ebebeb;border-radius:3px;display:flex;align-items:center;justify-content:center}.grabber[_ngcontent-%COMP%]{content:"";cursor:ew-resize;height:100%;width:3px;overflow:hidden;background-color:rgba(0,0,0,.12)}.annotations-list[_ngcontent-%COMP%]{width:100%;min-height:0px;flex:1 1}'],changeDetection:0});class wbt{constructor(t){this.store=t,this.runActive$=this.store.pipe(lv(KD)).pipe(ft((t=>!!t&&[...t.values()].includes(!0)))),this.sidebarExpanded$=this.store.pipe(lv(Xdt)),this.sidebarWidth$=this.store.pipe(lv(Zdt)),this.resizing=!1}onToggleSidebarExpanded(){this.store.dispatch(Mgt())}onResizeTriggered(t){this.resizing&&this.store.dispatch(Cgt({sidebarWidth:t.clientX}))}onResizeGrabbed(){this.resizing=!0}onResizeReleased(){this.resizing=!1}}function Sbt(t,n){1&t&&tp(0,"npmi-inactive-view")}function Ebt(t,n){1&t&&tp(0,"npmi-main")}function Abt(t,n){1&t&&tp(0,"npmi-embeddings")}function zbt(t,n){if(1&t&&(Yg(0,Ebt,1,0,"npmi-main",3),Yg(1,Abt,1,0,"npmi-embeddings",3)),2&t){const t=gp();Jg("ngIf",t.activeView===t.ViewActive.DEFAULT),ws(1),Jg("ngIf",t.activeView===t.ViewActive.EMBEDDINGS)}}wbt.ɵfac=function t(n){return new(n||wbt)(Zg(cv))},wbt.ɵcmp=_o({type:wbt,selectors:[["npmi-embeddings"]],decls:4,vars:9,consts:[[3,"runActive","sidebarExpanded","sidebarWidth","toggleSidebarExpanded","resizeTriggered","resizeGrabbed","resizeReleased"]],template:function t(n,e){1&n&&(Kg(0,"embeddings-component",0),cp("toggleSidebarExpanded",(function t(){return e.onToggleSidebarExpanded()}))("resizeTriggered",(function t(n){return e.onResizeTriggered(n)}))("resizeGrabbed",(function t(){return e.onResizeGrabbed()}))("resizeReleased",(function t(){return e.onResizeReleased()})),yf(1,"async"),yf(2,"async"),yf(3,"async"),$g()),2&n&&Jg("runActive",kf(1,3,e.runActive$))("sidebarExpanded",kf(2,5,e.sidebarExpanded$))("sidebarWidth",kf(3,7,e.sidebarWidth$))},directives:[vbt],pipes:[oO],encapsulation:2,changeDetection:0});class Rbt{constructor(){this.ViewActive=ydt}}Rbt.ɵfac=function t(n){return new(n||Rbt)},Rbt.ɵcmp=_o({type:Rbt,selectors:[["npmi-component"]],inputs:{runs:"runs",activeView:"activeView"},decls:4,vars:2,consts:[[1,"npmi-container"],[4,"ngIf","ngIfElse"],["dataAvailable",""],[4,"ngIf"]],template:function t(n,e){if(1&n&&(Kg(0,"div",0),Yg(1,Sbt,1,0,"npmi-inactive-view",1),Yg(2,zbt,2,2,"ng-template",null,2,Kf),$g()),2&n){const t=qg(3);ws(1),Jg("ngIf",0===e.runs.size)("ngIfElse",t)}},directives:[WM,vdt,Mbt,wbt],styles:["[_nghost-%COMP%]{display:flex;height:100%}.npmi-container[_ngcontent-%COMP%]{flex:1 1}"],changeDetection:0});class Tbt{constructor(t){this.store=t,this.runs$=this.store.pipe(lv(KD)),this.activeView$=this.store.pipe(lv(Gdt))}ngOnInit(){this.store.dispatch(Jdt())}}Tbt.ɵfac=function t(n){return new(n||Tbt)(Zg(cv))},Tbt.ɵcmp=_o({type:Tbt,selectors:[["npmi"]],decls:3,vars:6,consts:[[3,"runs","activeView"]],template:function t(n,e){1&n&&(tp(0,"npmi-component",0),yf(1,"async"),yf(2,"async")),2&n&&Jg("runs",kf(1,2,e.runs$))("activeView",kf(2,4,e.activeView$))},directives:[Rbt],pipes:[oO],encapsulation:2});var Dbt=yP((function(t,n){var e=xP&&xP.__values||function(t){var n="function"==typeof Symbol&&t[Symbol.iterator],e=0;return n?n.call(t):{next:function(){return t&&e>=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}}};function a(t,n){return Math.floor(n()*t)}function o(t){for(var n=[],e=0;e<t;e++)n.push(void 0);return n}function r(t,n){return o(t).map((function(){return n}))}function i(t){return r(t,0)}function c(t){return t.reduce((function(t,n){return t+n}))}Object.defineProperty(n,"__esModule",{value:!0}),n.tauRandInt=a,n.tauRand=function s(t){return t()},n.norm=function l(t){var n,a,o=0;try{for(var r=e(t),i=r.next();!i.done;i=r.next())o+=Math.pow(i.value,2)}catch(t){n={error:t}}finally{try{i&&!i.done&&(a=r.return)&&a.call(r)}finally{if(n)throw n.error}}return Math.sqrt(o)},n.empty=o,n.range=function m(t){return o(t).map((function(t,n){return n}))},n.filled=r,n.zeros=i,n.ones=function d(t){return r(t,1)},n.linear=function g(t,n,e){return o(e).map((function(a,o){return t+o*((n-t)/(e-1))}))},n.sum=c,n.mean=function p(t){return c(t)/t.length},n.max=function b(t){for(var n=0,e=0;e<t.length;e++)n=t[e]>n?t[e]:n;return n},n.max2d=function u(t){for(var n=0,e=0;e<t.length;e++)for(var a=0;a<t[e].length;a++)n=t[e][a]>n?t[e][a]:n;return n},n.rejectionSample=function f(t,n,e){for(var o=i(t),r=0;r<t;r++)for(var c=!0;c;){for(var s=a(n,e),l=!1,m=0;m<r;m++)if(s===o[m]){l=!0;break}l||(c=!1),o[r]=s}return o},n.reshape2d=function h(t,n,e){var a=[],o=0;if(t.length!==n*e)throw new Error("Array dimensions must match input length.");for(var r=0;r<n;r++){for(var i=[],c=0;c<e;c++)i.push(t[o]),o+=1;a.push(i)}return a}})),Ibt=yP((function(t,n){var e=xP&&xP.__importStar||function(t){if(t&&t.__esModule)return t;var n={};if(null!=t)for(var e in t)Object.hasOwnProperty.call(t,e)&&(n[e]=t[e]);return n.default=t,n};Object.defineProperty(n,"__esModule",{value:!0});var a=e(Dbt);function o(t,n){var e=function(e){return a.empty(t).map((function(){return a.filled(n,e)}))},o=[];return o.push(e(-1)),o.push(e(1/0)),o.push(e(0)),o}function r(t,n,e,a,o){n=Math.floor(n);var r=t[0][n];if(e>=t[1][n][0])return 0;for(var c=0;c<r.length;c++)if(a===r[c])return 0;return i(t,n,e,a,o)}function i(t,n,e,a,o){var r=t[0][n],i=t[1][n],c=t[2][n];if(e>=i[0])return 0;i[0]=e,r[0]=a,c[0]=o;for(var s=0,l=0;;){var m=2*s+1,d=m+1,g=t[0][0].length;if(m>=g)break;if(d>=g){if(!(i[m]>e))break;l=m}else if(i[m]>=i[d]){if(!(e<i[m]))break;l=m}else{if(!(e<i[d]))break;l=d}i[s]=i[l],r[s]=r[l],c[s]=c[l],s=l}return i[s]=e,r[s]=a,c[s]=o,1}function c(t,n,e,a){for(;2*a+1<e;){var o=2*a+1,r=o+1,i=a;if(t[i]<t[o]&&(i=o),r<e&&t[i]<t[r]&&(i=r),i===a)break;var c=t[a];t[a]=t[i],t[i]=c;var s=n[a];n[a]=n[i],n[i]=s,a=i}}n.makeHeap=o,n.rejectionSample=function s(t,n,e){for(var o=a.zeros(t),r=0;r<t;r++){for(var i=!0,c=0;i;){c=a.tauRandInt(n,e);for(var s=!1,l=0;l<r;l++)if(c===o[l]){s=!0;break}s||(i=!1)}o[r]=c}return o},n.heapPush=r,n.uncheckedHeapPush=i,n.buildCandidates=function l(t,n,e,i,c){for(var s=o(n,i),l=0;l<n;l++)for(var m=0;m<e;m++)if(!(t[0][l][m]<0)){var d=t[0][l][m],g=t[2][l][m],p=a.tauRand(c);r(s,l,p,d,g),r(s,d,p,l,g),t[2][l][m]=0}return s},n.deheapSort=function m(t){for(var n=t[0],e=t[1],a=0;a<n.length;a++)for(var o=n[a],r=e[a],i=0;i<o.length-1;i++){var s=o.length-i-1,l=r.length-i-1,m=o[0];o[0]=o[s],o[s]=m;var d=r[0];r[0]=r[l],r[l]=d,c(r,o,l,0)}return{indices:n,weights:e}},n.smallestFlagged=function d(t,n){for(var e=t[0][n],a=t[1][n],o=t[2][n],r=1/0,i=-1,c=0;c>e.length;c++)1===o[c]&&a[c]<r&&(r=a[c],i=c);return i>=0?(o[i]=0,Math.floor(e[i])):-1}})),Nbt=yP((function(t,n){var e,a=xP&&xP.__read||function(t,n){var e="function"==typeof Symbol&&t[Symbol.iterator];if(!e)return t;var a,o,r=e.call(t),i=[];try{for(;(void 0===n||n-- >0)&&!(a=r.next()).done;)i.push(a.value)}catch(t){o={error:t}}finally{try{a&&!a.done&&(e=r.return)&&e.call(r)}finally{if(o)throw o.error}}return i},o=xP&&xP.__values||function(t){var n="function"==typeof Symbol&&t[Symbol.iterator],e=0;return n?n.call(t):{next:function(){return t&&e>=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}}},r=xP&&xP.__importStar||function(t){if(t&&t.__esModule)return t;var n={};if(null!=t)for(var e in t)Object.hasOwnProperty.call(t,e)&&(n[e]=t[e]);return n.default=t,n};Object.defineProperty(n,"__esModule",{value:!0});var i=r(Dbt),c=(function(){function t(t,n,e,a){if(this.entries=new Map,this.nRows=0,this.nCols=0,t.length!==n.length||t.length!==e.length)throw new Error("rows, cols and values arrays must all have the same length");this.nRows=a[0],this.nCols=a[1];for(var o=0;o<e.length;o++){var r=t[o],i=n[o];this.checkDims(r,i);var c=this.makeKey(r,i);this.entries.set(c,{value:e[o],row:r,col:i})}}return t.prototype.makeKey=function(t,n){return t+":"+n},t.prototype.checkDims=function(t,n){if(!(t<this.nRows&&n<this.nCols))throw new Error("row and/or col specified outside of matrix dimensions")},t.prototype.set=function(t,n,e){this.checkDims(t,n);var a=this.makeKey(t,n);this.entries.has(a)?this.entries.get(a).value=e:this.entries.set(a,{value:e,row:t,col:n})},t.prototype.get=function(t,n,e){void 0===e&&(e=0),this.checkDims(t,n);var a=this.makeKey(t,n);return this.entries.has(a)?this.entries.get(a).value:e},t.prototype.getAll=function(t){void 0===t&&(t=!0);var n=[];return this.entries.forEach((function(t){n.push(t)})),t&&n.sort((function(t,n){return t.row===n.row?t.col-n.col:t.row-n.row})),n},t.prototype.getDims=function(){return[this.nRows,this.nCols]},t.prototype.getRows=function(){return Array.from(this.entries,(function(t){return a(t,2)[1].row}))},t.prototype.getCols=function(){return Array.from(this.entries,(function(t){return a(t,2)[1].col}))},t.prototype.getValues=function(){return Array.from(this.entries,(function(t){return a(t,2)[1].value}))},t.prototype.forEach=function(t){this.entries.forEach((function(n){return t(n.value,n.row,n.col)}))},t.prototype.map=function(n){var e=[];this.entries.forEach((function(t){e.push(n(t.value,t.row,t.col))}));var a=[this.nRows,this.nCols];return new t(this.getRows(),this.getCols(),e,a)},t.prototype.toArray=function(){var t=this,n=i.empty(this.nRows).map((function(){return i.zeros(t.nCols)}));return this.entries.forEach((function(t){n[t.row][t.col]=t.value})),n},t})();n.SparseMatrix=c,n.transpose=function s(t){var n=[],e=[],a=[];return t.forEach((function(t,o,r){n.push(o),e.push(r),a.push(t)})),new c(e,n,a,[t.nCols,t.nRows])},n.identity=function l(t){for(var n=a(t,1)[0],e=new c([],[],[],t),o=0;o<n;o++)e.set(o,o,1);return e},n.pairwiseMultiply=function m(t,n){return _(t,n,(function(t,n){return t*n}))},n.add=function d(t,n){return _(t,n,(function(t,n){return t+n}))},n.subtract=function g(t,n){return _(t,n,(function(t,n){return t-n}))},n.maximum=function p(t,n){return _(t,n,(function(t,n){return t>n?t:n}))},n.multiplyScalar=function b(t,n){return t.map((function(t){return t*n}))},n.eliminateZeros=function u(t){for(var n=new Set,e=t.getValues(),a=t.getRows(),o=t.getCols(),r=0;r<e.length;r++)0===e[r]&&n.add(r);var i=function(t,e){return!n.has(e)},s=e.filter(i),l=a.filter(i),m=o.filter(i);return new c(l,m,s,t.getDims())},n.normalize=function f(t,n){var e,a;void 0===n&&(n="l2");var r=h[n],i=new Map;t.forEach((function(t,n,e){var a=i.get(n)||[];a.push(e),i.set(n,a)}));var s=new c([],[],[],t.getDims()),l=function(n){for(var e=i.get(n).sort(),a=e.map((function(e){return t.get(n,e)})),o=r(a),c=0;c<o.length;c++)s.set(n,e[c],o[c])};try{for(var m=o(i.keys()),d=m.next();!d.done;d=m.next())l(d.value)}catch(t){e={error:t}}finally{try{d&&!d.done&&(a=m.return)&&a.call(m)}finally{if(e)throw e.error}}return s};var h=((e={}).max=function(t){for(var n=-1/0,e=0;e<t.length;e++)n=t[e]>n?t[e]:n;return t.map((function(t){return t/n}))},e.l1=function(t){for(var n=0,e=0;e<t.length;e++)n+=t[e];return t.map((function(t){return t/n}))},e.l2=function(t){for(var n=0,e=0;e<t.length;e++)n+=Math.pow(t[e],2);return t.map((function(t){return Math.sqrt(Math.pow(t,2)/n)}))},e);function _(t,n,e){for(var a=new Set,o=[],r=[],i=[],s=function(a,c){o.push(a),r.push(c);var s=e(t.get(a,c),n.get(a,c));i.push(s)},l=t.getValues(),m=t.getRows(),d=t.getCols(),g=0;g<l.length;g++)a.add((f=m[g])+":"+(h=d[g])),s(f,h);var p=n.getValues(),b=n.getRows(),u=n.getCols();for(g=0;g<p.length;g++){var f,h;a.has((f=b[g])+":"+(h=u[g]))||s(f,h)}return new c(o,r,i,[t.nRows,t.nCols])}n.getCSR=function C(t){var n=[];t.forEach((function(t,e,a){n.push({value:t,row:e,col:a})})),n.sort((function(t,n){return t.row===n.row?t.col-n.col:t.row-n.row}));for(var e=[],a=[],o=[],r=-1,i=0;i<n.length;i++){var c=n[i],s=c.row,l=c.col,m=c.value;s!==r&&(r=s,o.push(i)),e.push(l),a.push(m)}return{indices:e,values:a,indptr:o}}})),Fbt=yP((function(t,n){var e=xP&&xP.__read||function(t,n){var e="function"==typeof Symbol&&t[Symbol.iterator];if(!e)return t;var a,o,r=e.call(t),i=[];try{for(;(void 0===n||n-- >0)&&!(a=r.next()).done;)i.push(a.value)}catch(t){o={error:t}}finally{try{a&&!a.done&&(e=r.return)&&e.call(r)}finally{if(o)throw o.error}}return i},a=xP&&xP.__spread||function(){for(var t=[],n=0;n<arguments.length;n++)t=t.concat(e(arguments[n]));return t},o=xP&&xP.__values||function(t){var n="function"==typeof Symbol&&t[Symbol.iterator],e=0;return n?n.call(t):{next:function(){return t&&e>=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}}},r=xP&&xP.__importStar||function(t){if(t&&t.__esModule)return t;var n={};if(null!=t)for(var e in t)Object.hasOwnProperty.call(t,e)&&(n[e]=t[e]);return n.default=t,n};Object.defineProperty(n,"__esModule",{value:!0});var i,c=r(Dbt);function s(t,n,e,a,o){if(void 0===e&&(e=30),n.length>e){var r=(function i(t,n,e){for(var a=t[0].length,o=c.tauRandInt(n.length,e),r=c.tauRandInt(n.length,e),i=n[o],s=n[r=(r+=o===r?1:0)%n.length],l=0,m=c.zeros(a),d=0;d<m.length;d++)m[d]=t[i][d]-t[s][d],l-=m[d]*(t[i][d]+t[s][d])/2;var g=0,p=0,b=c.zeros(n.length);for(d=0;d<n.length;d++){for(var u=l,f=0;f<a;f++)u+=m[f]*t[n[d]][f];0===u?(b[d]=c.tauRandInt(2,e),0===b[d]?g+=1:p+=1):u>0?(b[d]=0,g+=1):(b[d]=1,p+=1)}var h=c.zeros(g),_=c.zeros(p);for(g=0,p=0,d=0;d<b.length;d++)0===b[d]?(h[g]=n[d],g+=1):(_[p]=n[d],p+=1);return{indicesLeft:h,indicesRight:_,hyperplane:m,offset:l}})(t,n,o),l=r.indicesRight,m=r.hyperplane,d=r.offset;return{leftChild:s(t,r.indicesLeft,e,a+1,o),rightChild:s(t,l,e,a+1,o),isLeaf:!1,hyperplane:m,offset:d}}return{indices:n,isLeaf:!0}}function l(t,n,e,o,r,i,c){var s;if(t.isLeaf)return o[i][0]=-c,(s=r[c]).splice.apply(s,a([0,t.indices.length],t.indices)),{nodeNum:i,leafNum:c+=1};n[i]=t.hyperplane,e[i]=t.offset,o[i][0]=i+1;var m=i,d=l(t.leftChild,n,e,o,r,i+1,c);return c=d.leafNum,o[m][1]=(i=d.nodeNum)+1,{nodeNum:(d=l(t.rightChild,n,e,o,r,i+1,c)).nodeNum,leafNum:d.leafNum}}function m(t){return t.isLeaf?1:1+m(t.leftChild)+m(t.rightChild)}function d(t){return t.isLeaf?1:d(t.leftChild)+d(t.rightChild)}function g(t,n,e,a){for(var o=n,r=0;r<e.length;r++)o+=t[r]*e[r];return 0===o?c.tauRandInt(2,a):o>0?0:1}n.FlatTree=i=function i(t,n,e,a){this.hyperplanes=t,this.offsets=n,this.children=e,this.indices=a},n.makeForest=function p(t,n,e,a){var o=Math.max(10,n);return c.range(e).map((function(n,e){return(function r(t,n,e,a){return void 0===n&&(n=30),s(t,c.range(t.length),n,e,a)})(t,o,e,a)})).map((function(t){return(function n(t,e){var a=m(t),o=d(t),r=c.range(a).map((function(){return c.zeros(t.hyperplane?t.hyperplane.length:0)})),s=c.zeros(a),g=c.range(a).map((function(){return[-1,-1]})),p=c.range(o).map((function(){return c.range(e).map((function(){return-1}))}));return l(t,r,s,g,p,0,0),new i(r,s,g,p)})(t,o)}))},n.makeLeafArray=function b(t){var n,e;if(t.length>0){var r=[];try{for(var i=o(t),c=i.next();!c.done;c=i.next())r.push.apply(r,a(c.value.indices))}catch(t){n={error:t}}finally{try{c&&!c.done&&(e=i.return)&&e.call(i)}finally{if(n)throw n.error}}return r}return[[-1]]},n.searchFlatTree=function u(t,n,e){for(var a=0;n.children[a][0]>0;)a=0===g(n.hyperplanes[a],n.offsets[a],t,e)?n.children[a][0]:n.children[a][1];return n.indices[-1*n.children[a][0]]}})),Lbt=yP((function(t,n){var e=xP&&xP.__values||function(t){var n="function"==typeof Symbol&&t[Symbol.iterator],e=0;return n?n.call(t):{next:function(){return t&&e>=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}}},a=xP&&xP.__importStar||function(t){if(t&&t.__esModule)return t;var n={};if(null!=t)for(var e in t)Object.hasOwnProperty.call(t,e)&&(n[e]=t[e]);return n.default=t,n};Object.defineProperty(n,"__esModule",{value:!0});var o=a(Ibt),r=a(Nbt),i=a(Fbt),c=a(Dbt);n.makeNNDescent=function s(t,n){return function e(a,r,i,s,l,m,d,g){void 0===s&&(s=10),void 0===l&&(l=50),void 0===m&&(m=.001),void 0===d&&(d=.5),void 0===g&&(g=!0);for(var p=a.length,b=o.makeHeap(a.length,i),u=0;u<a.length;u++)for(var f=o.rejectionSample(i,a.length,n),h=0;h<f.length;h++){var _=t(a[u],a[f[h]]);o.heapPush(b,u,_,f[h],1),o.heapPush(b,f[h],_,u,1)}if(g)for(var C=0;C<r.length;C++)for(u=0;u<r[C].length&&!(r[C][u]<0);u++)for(h=u+1;h<r[C].length&&!(r[C][h]<0);h++)_=t(a[r[C][u]],a[r[C][h]]),o.heapPush(b,r[C][u],_,r[C][h],1),o.heapPush(b,r[C][h],_,r[C][u],1);for(C=0;C<s;C++){var M=o.buildCandidates(b,p,i,l,n),O=0;for(u=0;u<p;u++)for(h=0;h<l;h++){var P=Math.floor(M[0][u][h]);if(!(P<0||c.tauRand(n)<d))for(var x=0;x<l;x++){var y=Math.floor(M[0][u][x]);y<0||!M[2][u][h]&&!M[2][u][x]||(_=t(a[P],a[y]),O+=o.heapPush(b,P,_,y,1),O+=o.heapPush(b,y,_,P,1))}}if(O<=m*i*a.length)break}return o.deheapSort(b)}},n.makeInitializations=function l(t){return{initFromRandom:function n(e,a,r,i,s){for(var l=0;l<r.length;l++)for(var m=c.rejectionSample(e,a.length,s),d=0;d<m.length;d++)if(!(m[d]<0)){var g=t(a[m[d]],r[l]);o.heapPush(i,l,g,m[d],1)}},initFromTree:function e(n,a,r,c,s){for(var l=0;l<r.length;l++)for(var m=i.searchFlatTree(r[l],n,s),d=0;d<m.length;d++){if(m[d]<0)return;var g=t(a[m[d]],r[l]);o.heapPush(c,l,g,m[d],1)}}}},n.makeInitializedNNSearch=function m(t){return function n(a,i,c,s){for(var l,m,d=r.getCSR(i),g=d.indices,p=d.indptr,b=0;b<s.length;b++)for(var u=new Set(c[0][b]);;){var f=o.smallestFlagged(c,b);if(-1===f)break;var h=g.slice(p[f],p[f+1]);try{for(var _=e(h),C=_.next();!C.done;C=_.next()){var M=C.value;if(M!==f&&-1!==M&&!u.has(M)){var O=t(a[M],s[b]);o.uncheckedHeapPush(c,b,O,M,1),u.add(M)}}}catch(t){l={error:t}}finally{try{C&&!C.done&&(m=_.return)&&m.call(_)}finally{if(l)throw l.error}}}return c}},n.initializeSearch=function d(t,n,a,r,i,c,s){var l,m,d=o.makeHeap(a.length,r);if(i(r,n,a,d,s),t)try{for(var g=e(t),p=g.next();!p.done;p=g.next())c(p.value,n,a,d,s)}catch(t){l={error:t}}finally{try{p&&!p.done&&(m=g.return)&&m.call(g)}finally{if(l)throw l.error}}return d}}));const Hbt=Object.prototype.toString;function Bbt(t){return Hbt.call(t).endsWith("Array]")}function Vbt(t,n,e){let a=0;const o=e(n);for(let n=0;n<t.x.length;n++)a+=Math.abs(t.y[n]-o(t.x[n]));return a}const jbt=Object.prototype.toString;function Ubt(t){return jbt.call(t).endsWith("Array]")}function Wbt(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!Ubt(t))throw new TypeError("input must be an array");if(0===t.length)throw new TypeError("input must not be empty");var e=n.fromIndex,a=void 0===e?0:e,o=n.toIndex,r=void 0===o?t.length:o;if(a<0||a>=t.length||!Number.isInteger(a))throw new Error("fromIndex must be a positive integer smaller than length");if(r<=a||r>t.length||!Number.isInteger(r))throw new Error("toIndex must be an integer greater than fromIndex and at most equal to length");for(var i=t[a],c=a+1;c<r;c++)t[c]>i&&(i=t[c]);return i}function Gbt(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!Ubt(t))throw new TypeError("input must be an array");if(0===t.length)throw new TypeError("input must not be empty");var e=n.fromIndex,a=void 0===e?0:e,o=n.toIndex,r=void 0===o?t.length:o;if(a<0||a>=t.length||!Number.isInteger(a))throw new Error("fromIndex must be a positive integer smaller than length");if(r<=a||r>t.length||!Number.isInteger(r))throw new Error("toIndex must be an integer greater than fromIndex and at most equal to length");for(var i=t[a],c=a+1;c<r;c++)t[c]<i&&(i=t[c]);return i}function Ybt(t){var n,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(!Ubt(t))throw new TypeError("input must be an array");if(0===t.length)throw new TypeError("input must not be empty");if(void 0!==e.output){if(!Ubt(e.output))throw new TypeError("output option must be an array if specified");n=e.output}else n=new Array(t.length);var a=Gbt(t),o=Wbt(t);if(a===o)throw new RangeError("minimum and maximum input values are equal. Cannot rescale a constant array");var r=e.min,i=void 0===r?e.autoMinMax?a:0:r,c=e.max,s=void 0===c?e.autoMinMax?o:1:c;if(i>=s)throw new RangeError("min option must be smaller than max option");for(var l=(s-i)/(o-a),m=0;m<t.length;m++)n[m]=(t[m]-a)*l+i;return n}const qbt=" ".repeat(2),Zbt=" ".repeat(4);function Xbt(t,n={}){const{maxRows:e=15,maxColumns:a=10,maxNumSize:o=8}=n;return`${t.constructor.name} {\n${qbt}[\n${Zbt}${(function r(t,n,e,a){const{rows:o,columns:r}=t,i=Math.min(o,n),c=Math.min(r,e),s=[];for(let n=0;n<i;n++){let e=[];for(let o=0;o<c;o++)e.push(Jbt(t.get(n,o),a));s.push(`${e.join(" ")}`)}return c!==r&&(s[s.length-1]+=` ... ${r-e} more columns`),i!==o&&s.push(`... ${o-n} more rows`),s.join(`\n${Zbt}`)})(t,e,a,o)}\n${qbt}]\n${qbt}rows: ${t.rows}\n${qbt}columns: ${t.columns}\n}`}function Jbt(t,n){const e=String(t);if(e.length<=n)return e.padEnd(n," ");const a=t.toPrecision(n-2);if(a.length<=n)return a;const o=t.toExponential(n-2),r=o.indexOf("e"),i=o.slice(r);return o.slice(0,n-i.length)+i}function Qbt(t,n,e){if(n<0||n>(e?t.rows:t.rows-1))throw new RangeError("Row index out of range")}function Kbt(t,n,e){if(n<0||n>(e?t.columns:t.columns-1))throw new RangeError("Column index out of range")}function $bt(t,n){if(n.to1DArray&&(n=n.to1DArray()),n.length!==t.columns)throw new RangeError("vector size must be the same as the number of columns");return n}function tut(t,n){if(n.to1DArray&&(n=n.to1DArray()),n.length!==t.rows)throw new RangeError("vector size must be the same as the number of rows");return n}function nut(t,n){if("object"!=typeof n)throw new TypeError("unexpected type for row indices");if(n.some((n=>n<0||n>=t.rows)))throw new RangeError("row indices are out of range");return Array.isArray(n)||(n=Array.from(n)),n}function eut(t,n){if("object"!=typeof n)throw new TypeError("unexpected type for column indices");if(n.some((n=>n<0||n>=t.columns)))throw new RangeError("column indices are out of range");return Array.isArray(n)||(n=Array.from(n)),n}function aut(t,n,e,a,o){if(5!==arguments.length)throw new RangeError("expected 4 arguments");if(rut("startRow",n),rut("endRow",e),rut("startColumn",a),rut("endColumn",o),n>e||a>o||n<0||n>=t.rows||e<0||e>=t.rows||a<0||a>=t.columns||o<0||o>=t.columns)throw new RangeError("Submatrix indices are out of range")}function out(t,n=0){let e=[];for(let a=0;a<t;a++)e.push(n);return e}function rut(t,n){if("number"!=typeof n)throw new TypeError(`${t} must be a number`)}function iut(t){if(t.isEmpty())throw new Error("Empty matrix has no elements to index")}class cut{static from1DArray(t,n,e){if(t*n!==e.length)throw new RangeError("data length does not match given dimensions");let a=new mut(t,n);for(let o=0;o<t;o++)for(let t=0;t<n;t++)a.set(o,t,e[o*n+t]);return a}static rowVector(t){let n=new mut(1,t.length);for(let e=0;e<t.length;e++)n.set(0,e,t[e]);return n}static columnVector(t){let n=new mut(t.length,1);for(let e=0;e<t.length;e++)n.set(e,0,t[e]);return n}static zeros(t,n){return new mut(t,n)}static ones(t,n){return new mut(t,n).fill(1)}static rand(t,n,e={}){if("object"!=typeof e)throw new TypeError("options must be an object");const{random:a=Math.random}=e;let o=new mut(t,n);for(let e=0;e<t;e++)for(let t=0;t<n;t++)o.set(e,t,a());return o}static randInt(t,n,e={}){if("object"!=typeof e)throw new TypeError("options must be an object");const{min:a=0,max:o=1e3,random:r=Math.random}=e;if(!Number.isInteger(a))throw new TypeError("min must be an integer");if(!Number.isInteger(o))throw new TypeError("max must be an integer");if(a>=o)throw new RangeError("min must be smaller than max");let i=o-a,c=new mut(t,n);for(let e=0;e<t;e++)for(let t=0;t<n;t++){let n=a+Math.round(r()*i);c.set(e,t,n)}return c}static eye(t,n,e){void 0===n&&(n=t),void 0===e&&(e=1);let a=Math.min(t,n),o=this.zeros(t,n);for(let t=0;t<a;t++)o.set(t,t,e);return o}static diag(t,n,e){let a=t.length;void 0===n&&(n=a),void 0===e&&(e=n);let o=Math.min(a,n,e),r=this.zeros(n,e);for(let n=0;n<o;n++)r.set(n,n,t[n]);return r}static min(t,n){t=this.checkMatrix(t),n=this.checkMatrix(n);let e=t.rows,a=t.columns,o=new mut(e,a);for(let r=0;r<e;r++)for(let e=0;e<a;e++)o.set(r,e,Math.min(t.get(r,e),n.get(r,e)));return o}static max(t,n){t=this.checkMatrix(t),n=this.checkMatrix(n);let e=t.rows,a=t.columns,o=new this(e,a);for(let r=0;r<e;r++)for(let e=0;e<a;e++)o.set(r,e,Math.max(t.get(r,e),n.get(r,e)));return o}static checkMatrix(t){return cut.isMatrix(t)?t:new mut(t)}static isMatrix(t){return null!=t&&"Matrix"===t.klass}get size(){return this.rows*this.columns}apply(t){if("function"!=typeof t)throw new TypeError("callback must be a function");for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)t.call(this,n,e);return this}to1DArray(){let t=[];for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)t.push(this.get(n,e));return t}to2DArray(){let t=[];for(let n=0;n<this.rows;n++){t.push([]);for(let e=0;e<this.columns;e++)t[n].push(this.get(n,e))}return t}toJSON(){return this.to2DArray()}isRowVector(){return 1===this.rows}isColumnVector(){return 1===this.columns}isVector(){return 1===this.rows||1===this.columns}isSquare(){return this.rows===this.columns}isEmpty(){return 0===this.rows||0===this.columns}isSymmetric(){if(this.isSquare()){for(let t=0;t<this.rows;t++)for(let n=0;n<=t;n++)if(this.get(t,n)!==this.get(n,t))return!1;return!0}return!1}isEchelonForm(){let t=0,n=0,e=-1,a=!0,o=!1;for(;t<this.rows&&a;){for(n=0,o=!1;n<this.columns&&!1===o;)0===this.get(t,n)?n++:1===this.get(t,n)&&n>e?(o=!0,e=n):(a=!1,o=!0);t++}return a}isReducedEchelonForm(){let t=0,n=0,e=-1,a=!0,o=!1;for(;t<this.rows&&a;){for(n=0,o=!1;n<this.columns&&!1===o;)0===this.get(t,n)?n++:1===this.get(t,n)&&n>e?(o=!0,e=n):(a=!1,o=!0);for(let e=n+1;e<this.rows;e++)0!==this.get(t,e)&&(a=!1);t++}return a}echelonForm(){let t=this.clone(),n=0,e=0;for(;n<t.rows&&e<t.columns;){let a=n;for(let o=n;o<t.rows;o++)t.get(o,e)>t.get(a,e)&&(a=o);if(0===t.get(a,e))e++;else{t.swapRows(n,a);let o=t.get(n,e);for(let a=e;a<t.columns;a++)t.set(n,a,t.get(n,a)/o);for(let a=n+1;a<t.rows;a++){let o=t.get(a,e)/t.get(n,e);t.set(a,e,0);for(let r=e+1;r<t.columns;r++)t.set(a,r,t.get(a,r)-t.get(n,r)*o)}n++,e++}}return t}reducedEchelonForm(){let t=this.echelonForm(),n=t.columns,e=t.rows,a=e-1;for(;a>=0;)if(0===t.maxRow(a))a--;else{let o=0,r=!1;for(;o<e&&!1===r;)1===t.get(a,o)?r=!0:o++;for(let e=0;e<a;e++){let r=t.get(e,o);for(let i=o;i<n;i++){let n=t.get(e,i)-r*t.get(a,i);t.set(e,i,n)}}a--}return t}set(){throw new Error("set method is unimplemented")}get(){throw new Error("get method is unimplemented")}repeat(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");const{rows:n=1,columns:e=1}=t;if(!Number.isInteger(n)||n<=0)throw new TypeError("rows must be a positive integer");if(!Number.isInteger(e)||e<=0)throw new TypeError("columns must be a positive integer");let a=new mut(this.rows*n,this.columns*e);for(let t=0;t<n;t++)for(let n=0;n<e;n++)a.setSubMatrix(this,this.rows*t,this.columns*n);return a}fill(t){for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,t);return this}neg(){return this.mulS(-1)}getRow(t){Qbt(this,t);let n=[];for(let e=0;e<this.columns;e++)n.push(this.get(t,e));return n}getRowVector(t){return mut.rowVector(this.getRow(t))}setRow(t,n){Qbt(this,t),n=$bt(this,n);for(let e=0;e<this.columns;e++)this.set(t,e,n[e]);return this}swapRows(t,n){Qbt(this,t),Qbt(this,n);for(let e=0;e<this.columns;e++){let a=this.get(t,e);this.set(t,e,this.get(n,e)),this.set(n,e,a)}return this}getColumn(t){Kbt(this,t);let n=[];for(let e=0;e<this.rows;e++)n.push(this.get(e,t));return n}getColumnVector(t){return mut.columnVector(this.getColumn(t))}setColumn(t,n){Kbt(this,t),n=tut(this,n);for(let e=0;e<this.rows;e++)this.set(e,t,n[e]);return this}swapColumns(t,n){Kbt(this,t),Kbt(this,n);for(let e=0;e<this.rows;e++){let a=this.get(e,t);this.set(e,t,this.get(e,n)),this.set(e,n,a)}return this}addRowVector(t){t=$bt(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)+t[e]);return this}subRowVector(t){t=$bt(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)-t[e]);return this}mulRowVector(t){t=$bt(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)*t[e]);return this}divRowVector(t){t=$bt(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)/t[e]);return this}addColumnVector(t){t=tut(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)+t[n]);return this}subColumnVector(t){t=tut(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)-t[n]);return this}mulColumnVector(t){t=tut(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)*t[n]);return this}divColumnVector(t){t=tut(this,t);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.set(n,e,this.get(n,e)/t[n]);return this}mulRow(t,n){Qbt(this,t);for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)*n);return this}mulColumn(t,n){Kbt(this,t);for(let e=0;e<this.rows;e++)this.set(e,t,this.get(e,t)*n);return this}max(){if(this.isEmpty())return NaN;let t=this.get(0,0);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.get(n,e)>t&&(t=this.get(n,e));return t}maxIndex(){iut(this);let t=this.get(0,0),n=[0,0];for(let e=0;e<this.rows;e++)for(let a=0;a<this.columns;a++)this.get(e,a)>t&&(t=this.get(e,a),n[0]=e,n[1]=a);return n}min(){if(this.isEmpty())return NaN;let t=this.get(0,0);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)this.get(n,e)<t&&(t=this.get(n,e));return t}minIndex(){iut(this);let t=this.get(0,0),n=[0,0];for(let e=0;e<this.rows;e++)for(let a=0;a<this.columns;a++)this.get(e,a)<t&&(t=this.get(e,a),n[0]=e,n[1]=a);return n}maxRow(t){if(Qbt(this,t),this.isEmpty())return NaN;let n=this.get(t,0);for(let e=1;e<this.columns;e++)this.get(t,e)>n&&(n=this.get(t,e));return n}maxRowIndex(t){Qbt(this,t),iut(this);let n=this.get(t,0),e=[t,0];for(let a=1;a<this.columns;a++)this.get(t,a)>n&&(n=this.get(t,a),e[1]=a);return e}minRow(t){if(Qbt(this,t),this.isEmpty())return NaN;let n=this.get(t,0);for(let e=1;e<this.columns;e++)this.get(t,e)<n&&(n=this.get(t,e));return n}minRowIndex(t){Qbt(this,t),iut(this);let n=this.get(t,0),e=[t,0];for(let a=1;a<this.columns;a++)this.get(t,a)<n&&(n=this.get(t,a),e[1]=a);return e}maxColumn(t){if(Kbt(this,t),this.isEmpty())return NaN;let n=this.get(0,t);for(let e=1;e<this.rows;e++)this.get(e,t)>n&&(n=this.get(e,t));return n}maxColumnIndex(t){Kbt(this,t),iut(this);let n=this.get(0,t),e=[0,t];for(let a=1;a<this.rows;a++)this.get(a,t)>n&&(n=this.get(a,t),e[0]=a);return e}minColumn(t){if(Kbt(this,t),this.isEmpty())return NaN;let n=this.get(0,t);for(let e=1;e<this.rows;e++)this.get(e,t)<n&&(n=this.get(e,t));return n}minColumnIndex(t){Kbt(this,t),iut(this);let n=this.get(0,t),e=[0,t];for(let a=1;a<this.rows;a++)this.get(a,t)<n&&(n=this.get(a,t),e[0]=a);return e}diag(){let t=Math.min(this.rows,this.columns),n=[];for(let e=0;e<t;e++)n.push(this.get(e,e));return n}norm(t="frobenius"){let n=0;if("max"===t)return this.max();if("frobenius"===t){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)n+=this.get(t,e)*this.get(t,e);return Math.sqrt(n)}throw new RangeError(`unknown norm type: ${t}`)}cumulativeSum(){let t=0;for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)t+=this.get(n,e),this.set(n,e,t);return this}dot(t){cut.isMatrix(t)&&(t=t.to1DArray());let n=this.to1DArray();if(n.length!==t.length)throw new RangeError("vectors do not have the same size");let e=0;for(let a=0;a<n.length;a++)e+=n[a]*t[a];return e}mmul(t){t=mut.checkMatrix(t);let n=this.rows,e=this.columns,a=t.columns,o=new mut(n,a),r=new Float64Array(e);for(let i=0;i<a;i++){for(let n=0;n<e;n++)r[n]=t.get(n,i);for(let t=0;t<n;t++){let n=0;for(let a=0;a<e;a++)n+=this.get(t,a)*r[a];o.set(t,i,n)}}return o}strassen2x2(t){t=mut.checkMatrix(t);let n=new mut(2,2);const e=this.get(0,0),a=t.get(0,0),o=this.get(0,1),r=t.get(0,1),i=this.get(1,0),c=t.get(1,0),s=this.get(1,1),l=t.get(1,1),m=(e+s)*(a+l),d=(i+s)*a,g=e*(r-l),p=s*(c-a),b=(e+o)*l,u=g+b,f=d+p,h=m-d+g+(i-e)*(a+r);return n.set(0,0,m+p-b+(o-s)*(c+l)),n.set(0,1,u),n.set(1,0,f),n.set(1,1,h),n}strassen3x3(t){t=mut.checkMatrix(t);let n=new mut(3,3);const e=this.get(0,0),a=this.get(0,1),o=this.get(0,2),r=this.get(1,0),i=this.get(1,1),c=this.get(1,2),s=this.get(2,0),l=this.get(2,1),m=this.get(2,2),d=t.get(0,0),g=t.get(0,1),p=t.get(0,2),b=t.get(1,0),u=t.get(1,1),f=t.get(1,2),h=t.get(2,0),_=t.get(2,1),C=t.get(2,2),M=(e-r)*(-g+u),O=(-e+r+i)*(d-g+u),P=(r+i)*(-d+g),x=e*d,y=(-e+s+l)*(d-p+f),k=(-e+s)*(p-f),v=(s+l)*(-d+p),w=(-o+l+m)*(u+h-_),S=(o-m)*(u-_),E=o*h,A=(l+m)*(-h+_),z=(-o+i+c)*(f+h-C),R=(o-c)*(f-C),T=(i+c)*(-h+C),D=(e+a+o-r-i-l-m)*u+O+P+x+w+E+A,I=x+y+v+(e+a+o-i-c-s-l)*f+E+z+T,N=M+i*(-d+g+b-u-f-h+C)+O+x+E+z+R,F=M+O+P+x+c*_,L=E+z+R+T+r*p,H=x+y+k+l*(-d+p+b-u-f-h+_)+w+S+E,B=w+S+E+A+s*g,V=x+y+k+v+m*C;return n.set(0,0,x+E+a*b),n.set(0,1,D),n.set(0,2,I),n.set(1,0,N),n.set(1,1,F),n.set(1,2,L),n.set(2,0,H),n.set(2,1,B),n.set(2,2,V),n}mmulStrassen(t){t=mut.checkMatrix(t);let n=this.clone(),e=n.rows,a=n.columns,o=t.rows,r=t.columns;function i(t,n,e){if(t.rows===n&&t.columns===e)return t;{let a=cut.zeros(n,e);return a=a.setSubMatrix(t,0,0),a}}a!==o&&console.warn(`Multiplying ${e} x ${a} and ${o} x ${r} matrix: dimensions do not match.`);let c=Math.max(e,o),s=Math.max(a,r);return n=i(n,c,s),(function t(n,e,a,o){if(a<=512||o<=512)return n.mmul(e);a%2==1&&o%2==1?(n=i(n,a+1,o+1),e=i(e,a+1,o+1)):a%2==1?(n=i(n,a+1,o),e=i(e,a+1,o)):o%2==1&&(n=i(n,a,o+1),e=i(e,a,o+1));let r=parseInt(n.rows/2,10),c=parseInt(n.columns/2,10),s=n.subMatrix(0,r-1,0,c-1),l=e.subMatrix(0,r-1,0,c-1),m=n.subMatrix(0,r-1,c,n.columns-1),d=e.subMatrix(0,r-1,c,e.columns-1),g=n.subMatrix(r,n.rows-1,0,c-1),p=e.subMatrix(r,e.rows-1,0,c-1),b=n.subMatrix(r,n.rows-1,c,n.columns-1),u=e.subMatrix(r,e.rows-1,c,e.columns-1),f=t(cut.add(s,b),cut.add(l,u),r,c),h=t(cut.add(g,b),l,r,c),_=t(s,cut.sub(d,u),r,c),C=t(b,cut.sub(p,l),r,c),M=t(cut.add(s,m),u,r,c),O=t(cut.sub(g,s),cut.add(l,d),r,c),P=t(cut.sub(m,b),cut.add(p,u),r,c),x=cut.add(f,C);x.sub(M),x.add(P);let y=cut.add(_,M),k=cut.add(h,C),v=cut.sub(f,h);v.add(_),v.add(O);let w=cut.zeros(2*x.rows,2*x.columns);return w=w.setSubMatrix(x,0,0),w=w.setSubMatrix(y,x.rows,0),w=w.setSubMatrix(k,0,x.columns),w=w.setSubMatrix(v,x.rows,x.columns),w.subMatrix(0,a-1,0,o-1)})(n,t=i(t,c,s),c,s)}scaleRows(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");const{min:n=0,max:e=1}=t;if(!Number.isFinite(n))throw new TypeError("min must be a number");if(!Number.isFinite(e))throw new TypeError("max must be a number");if(n>=e)throw new RangeError("min must be smaller than max");let a=new mut(this.rows,this.columns);for(let t=0;t<this.rows;t++){const o=this.getRow(t);o.length>0&&Ybt(o,{min:n,max:e,output:o}),a.setRow(t,o)}return a}scaleColumns(t={}){if("object"!=typeof t)throw new TypeError("options must be an object");const{min:n=0,max:e=1}=t;if(!Number.isFinite(n))throw new TypeError("min must be a number");if(!Number.isFinite(e))throw new TypeError("max must be a number");if(n>=e)throw new RangeError("min must be smaller than max");let a=new mut(this.rows,this.columns);for(let t=0;t<this.columns;t++){const o=this.getColumn(t);o.length&&Ybt(o,{min:n,max:e,output:o}),a.setColumn(t,o)}return a}flipRows(){const t=Math.ceil(this.columns/2);for(let n=0;n<this.rows;n++)for(let e=0;e<t;e++){let t=this.get(n,e),a=this.get(n,this.columns-1-e);this.set(n,e,a),this.set(n,this.columns-1-e,t)}return this}flipColumns(){const t=Math.ceil(this.rows/2);for(let n=0;n<this.columns;n++)for(let e=0;e<t;e++){let t=this.get(e,n),a=this.get(this.rows-1-e,n);this.set(e,n,a),this.set(this.rows-1-e,n,t)}return this}kroneckerProduct(t){t=mut.checkMatrix(t);let n=this.rows,e=this.columns,a=t.rows,o=t.columns,r=new mut(n*a,e*o);for(let i=0;i<n;i++)for(let n=0;n<e;n++)for(let e=0;e<a;e++)for(let c=0;c<o;c++)r.set(a*i+e,o*n+c,this.get(i,n)*t.get(e,c));return r}kroneckerSum(t){if(t=mut.checkMatrix(t),!this.isSquare()||!t.isSquare())throw new Error("Kronecker Sum needs two Square Matrices");let n=this.rows,e=t.rows,a=this.kroneckerProduct(mut.eye(e,e)),o=mut.eye(n,n).kroneckerProduct(t);return a.add(o)}transpose(){let t=new mut(this.columns,this.rows);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)t.set(e,n,this.get(n,e));return t}sortRows(t=sut){for(let n=0;n<this.rows;n++)this.setRow(n,this.getRow(n).sort(t));return this}sortColumns(t=sut){for(let n=0;n<this.columns;n++)this.setColumn(n,this.getColumn(n).sort(t));return this}subMatrix(t,n,e,a){aut(this,t,n,e,a);let o=new mut(n-t+1,a-e+1);for(let r=t;r<=n;r++)for(let n=e;n<=a;n++)o.set(r-t,n-e,this.get(r,n));return o}subMatrixRow(t,n,e){if(void 0===n&&(n=0),void 0===e&&(e=this.columns-1),n>e||n<0||n>=this.columns||e<0||e>=this.columns)throw new RangeError("Argument out of range");let a=new mut(t.length,e-n+1);for(let o=0;o<t.length;o++)for(let r=n;r<=e;r++){if(t[o]<0||t[o]>=this.rows)throw new RangeError(`Row index out of range: ${t[o]}`);a.set(o,r-n,this.get(t[o],r))}return a}subMatrixColumn(t,n,e){if(void 0===n&&(n=0),void 0===e&&(e=this.rows-1),n>e||n<0||n>=this.rows||e<0||e>=this.rows)throw new RangeError("Argument out of range");let a=new mut(e-n+1,t.length);for(let o=0;o<t.length;o++)for(let r=n;r<=e;r++){if(t[o]<0||t[o]>=this.columns)throw new RangeError(`Column index out of range: ${t[o]}`);a.set(r-n,o,this.get(r,t[o]))}return a}setSubMatrix(t,n,e){if((t=mut.checkMatrix(t)).isEmpty())return this;aut(this,n,n+t.rows-1,e,e+t.columns-1);for(let a=0;a<t.rows;a++)for(let o=0;o<t.columns;o++)this.set(n+a,e+o,t.get(a,o));return this}selection(t,n){let e=(function a(t,n,e){return{row:nut(t,n),column:eut(t,e)}})(this,t,n),o=new mut(t.length,n.length);for(let t=0;t<e.row.length;t++){let n=e.row[t];for(let a=0;a<e.column.length;a++)o.set(t,a,this.get(n,e.column[a]))}return o}trace(){let t=Math.min(this.rows,this.columns),n=0;for(let e=0;e<t;e++)n+=this.get(e,e);return n}clone(){let t=new mut(this.rows,this.columns);for(let n=0;n<this.rows;n++)for(let e=0;e<this.columns;e++)t.set(n,e,this.get(n,e));return t}sum(t){switch(t){case"row":return(function n(t){let n=out(t.rows);for(let e=0;e<t.rows;++e)for(let a=0;a<t.columns;++a)n[e]+=t.get(e,a);return n})(this);case"column":return(function e(t){let n=out(t.columns);for(let e=0;e<t.rows;++e)for(let a=0;a<t.columns;++a)n[a]+=t.get(e,a);return n})(this);case void 0:return(function a(t){let n=0;for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)n+=t.get(e,a);return n})(this);default:throw new Error(`invalid option: ${t}`)}}product(t){switch(t){case"row":return(function n(t){let n=out(t.rows,1);for(let e=0;e<t.rows;++e)for(let a=0;a<t.columns;++a)n[e]*=t.get(e,a);return n})(this);case"column":return(function e(t){let n=out(t.columns,1);for(let e=0;e<t.rows;++e)for(let a=0;a<t.columns;++a)n[a]*=t.get(e,a);return n})(this);case void 0:return(function a(t){let n=1;for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)n*=t.get(e,a);return n})(this);default:throw new Error(`invalid option: ${t}`)}}mean(t){const n=this.sum(t);switch(t){case"row":for(let t=0;t<this.rows;t++)n[t]/=this.columns;return n;case"column":for(let t=0;t<this.columns;t++)n[t]/=this.rows;return n;case void 0:return n/this.size;default:throw new Error(`invalid option: ${t}`)}}variance(t,n={}){if("object"==typeof t&&(n=t,t=void 0),"object"!=typeof n)throw new TypeError("options must be an object");const{unbiased:e=!0,mean:a=this.mean(t)}=n;if("boolean"!=typeof e)throw new TypeError("unbiased must be a boolean");switch(t){case"row":if(!Array.isArray(a))throw new TypeError("mean must be an array");return(function o(t,n,e){const a=t.rows,o=t.columns,r=[];for(let i=0;i<a;i++){let a=0,c=0,s=0;for(let n=0;n<o;n++)s=t.get(i,n)-e[i],a+=s,c+=s*s;r.push(n?(c-a*a/o)/(o-1):(c-a*a/o)/o)}return r})(this,e,a);case"column":if(!Array.isArray(a))throw new TypeError("mean must be an array");return(function r(t,n,e){const a=t.rows,o=t.columns,r=[];for(let i=0;i<o;i++){let o=0,c=0,s=0;for(let n=0;n<a;n++)s=t.get(n,i)-e[i],o+=s,c+=s*s;r.push(n?(c-o*o/a)/(a-1):(c-o*o/a)/a)}return r})(this,e,a);case void 0:if("number"!=typeof a)throw new TypeError("mean must be a number");return(function i(t,n,e){const a=t.rows,o=t.columns,r=a*o;let i=0,c=0,s=0;for(let n=0;n<a;n++)for(let a=0;a<o;a++)s=t.get(n,a)-e,i+=s,c+=s*s;return n?(c-i*i/r)/(r-1):(c-i*i/r)/r})(this,e,a);default:throw new Error(`invalid option: ${t}`)}}standardDeviation(t,n){"object"==typeof t&&(n=t,t=void 0);const e=this.variance(t,n);if(void 0===t)return Math.sqrt(e);for(let t=0;t<e.length;t++)e[t]=Math.sqrt(e[t]);return e}center(t,n={}){if("object"==typeof t&&(n=t,t=void 0),"object"!=typeof n)throw new TypeError("options must be an object");const{center:e=this.mean(t)}=n;switch(t){case"row":if(!Array.isArray(e))throw new TypeError("center must be an array");return(function a(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)-n[e])})(this,e),this;case"column":if(!Array.isArray(e))throw new TypeError("center must be an array");return(function o(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)-n[a])})(this,e),this;case void 0:if("number"!=typeof e)throw new TypeError("center must be a number");return(function r(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)-n)})(this,e),this;default:throw new Error(`invalid option: ${t}`)}}scale(t,n={}){if("object"==typeof t&&(n=t,t=void 0),"object"!=typeof n)throw new TypeError("options must be an object");let e=n.scale;switch(t){case"row":if(void 0===e)e=(function a(t){const n=[];for(let e=0;e<t.rows;e++){let a=0;for(let n=0;n<t.columns;n++)a+=Math.pow(t.get(e,n),2)/(t.columns-1);n.push(Math.sqrt(a))}return n})(this);else if(!Array.isArray(e))throw new TypeError("scale must be an array");return(function o(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)/n[e])})(this,e),this;case"column":if(void 0===e)e=(function r(t){const n=[];for(let e=0;e<t.columns;e++){let a=0;for(let n=0;n<t.rows;n++)a+=Math.pow(t.get(n,e),2)/(t.rows-1);n.push(Math.sqrt(a))}return n})(this);else if(!Array.isArray(e))throw new TypeError("scale must be an array");return(function i(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)/n[a])})(this,e),this;case void 0:if(void 0===e)e=(function c(t){const n=t.size-1;let e=0;for(let a=0;a<t.columns;a++)for(let o=0;o<t.rows;o++)e+=Math.pow(t.get(o,a),2)/n;return Math.sqrt(e)})(this);else if("number"!=typeof e)throw new TypeError("scale must be a number");return(function s(t,n){for(let e=0;e<t.rows;e++)for(let a=0;a<t.columns;a++)t.set(e,a,t.get(e,a)/n)})(this,e),this;default:throw new Error(`invalid option: ${t}`)}}toString(t){return Xbt(this,t)}}function sut(t,n){return t-n}cut.prototype.klass="Matrix","undefined"!=typeof Symbol&&(cut.prototype[Symbol.for("nodejs.util.inspect.custom")]=function lut(){return Xbt(this)}),cut.random=cut.rand,cut.randomInt=cut.randInt,cut.diagonal=cut.diag,cut.prototype.diagonal=cut.prototype.diag,cut.identity=cut.eye,cut.prototype.negate=cut.prototype.neg,cut.prototype.tensorProduct=cut.prototype.kroneckerProduct;class mut extends cut{constructor(t,n){if(super(),mut.isMatrix(t))return t.clone();if(Number.isInteger(t)&&t>=0){if(this.data=[],!(Number.isInteger(n)&&n>=0))throw new TypeError("nColumns must be a positive integer");for(let e=0;e<t;e++)this.data.push(new Float64Array(n))}else{if(!Array.isArray(t))throw new TypeError("First argument must be a positive number or an array");{const e=t;if("number"!=typeof(n=(t=e.length)?e[0].length:0))throw new TypeError("Data must be a 2D array with at least one element");this.data=[];for(let a=0;a<t;a++){if(e[a].length!==n)throw new RangeError("Inconsistent array dimensions");this.data.push(Float64Array.from(e[a]))}}}this.rows=t,this.columns=n}set(t,n,e){return this.data[t][n]=e,this}get(t,n){return this.data[t][n]}removeRow(t){return Qbt(this,t),this.data.splice(t,1),this.rows-=1,this}addRow(t,n){return void 0===n&&(n=t,t=this.rows),Qbt(this,t,!0),n=Float64Array.from($bt(this,n)),this.data.splice(t,0,n),this.rows+=1,this}removeColumn(t){Kbt(this,t);for(let n=0;n<this.rows;n++){const e=new Float64Array(this.columns-1);for(let a=0;a<t;a++)e[a]=this.data[n][a];for(let a=t+1;a<this.columns;a++)e[a-1]=this.data[n][a];this.data[n]=e}return this.columns-=1,this}addColumn(t,n){void 0===n&&(n=t,t=this.columns),Kbt(this,t,!0),n=tut(this,n);for(let e=0;e<this.rows;e++){const a=new Float64Array(this.columns+1);let o=0;for(;o<t;o++)a[o]=this.data[e][o];for(a[o++]=n[e];o<this.columns+1;o++)a[o]=this.data[e][o-1];this.data[e]=a}return this.columns+=1,this}}!(function dut(t,n){t.prototype.add=function t(n){return"number"==typeof n?this.addS(n):this.addM(n)},t.prototype.addS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)+n);return this},t.prototype.addM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)+e.get(t,n));return this},t.add=function t(e,a){return new n(e).add(a)},t.prototype.sub=function t(n){return"number"==typeof n?this.subS(n):this.subM(n)},t.prototype.subS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)-n);return this},t.prototype.subM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)-e.get(t,n));return this},t.sub=function t(e,a){return new n(e).sub(a)},t.prototype.subtract=t.prototype.sub,t.prototype.subtractS=t.prototype.subS,t.prototype.subtractM=t.prototype.subM,t.subtract=t.sub,t.prototype.mul=function t(n){return"number"==typeof n?this.mulS(n):this.mulM(n)},t.prototype.mulS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)*n);return this},t.prototype.mulM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)*e.get(t,n));return this},t.mul=function t(e,a){return new n(e).mul(a)},t.prototype.multiply=t.prototype.mul,t.prototype.multiplyS=t.prototype.mulS,t.prototype.multiplyM=t.prototype.mulM,t.multiply=t.mul,t.prototype.div=function t(n){return"number"==typeof n?this.divS(n):this.divM(n)},t.prototype.divS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)/n);return this},t.prototype.divM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)/e.get(t,n));return this},t.div=function t(e,a){return new n(e).div(a)},t.prototype.divide=t.prototype.div,t.prototype.divideS=t.prototype.divS,t.prototype.divideM=t.prototype.divM,t.divide=t.div,t.prototype.mod=function t(n){return"number"==typeof n?this.modS(n):this.modM(n)},t.prototype.modS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)%n);return this},t.prototype.modM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)%e.get(t,n));return this},t.mod=function t(e,a){return new n(e).mod(a)},t.prototype.modulus=t.prototype.mod,t.prototype.modulusS=t.prototype.modS,t.prototype.modulusM=t.prototype.modM,t.modulus=t.mod,t.prototype.and=function t(n){return"number"==typeof n?this.andS(n):this.andM(n)},t.prototype.andS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)&n);return this},t.prototype.andM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)&e.get(t,n));return this},t.and=function t(e,a){return new n(e).and(a)},t.prototype.or=function t(n){return"number"==typeof n?this.orS(n):this.orM(n)},t.prototype.orS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)|n);return this},t.prototype.orM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)|e.get(t,n));return this},t.or=function t(e,a){return new n(e).or(a)},t.prototype.xor=function t(n){return"number"==typeof n?this.xorS(n):this.xorM(n)},t.prototype.xorS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)^n);return this},t.prototype.xorM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)^e.get(t,n));return this},t.xor=function t(e,a){return new n(e).xor(a)},t.prototype.leftShift=function t(n){return"number"==typeof n?this.leftShiftS(n):this.leftShiftM(n)},t.prototype.leftShiftS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)<<n);return this},t.prototype.leftShiftM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)<<e.get(t,n));return this},t.leftShift=function t(e,a){return new n(e).leftShift(a)},t.prototype.signPropagatingRightShift=function t(n){return"number"==typeof n?this.signPropagatingRightShiftS(n):this.signPropagatingRightShiftM(n)},t.prototype.signPropagatingRightShiftS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)>>n);return this},t.prototype.signPropagatingRightShiftM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)>>e.get(t,n));return this},t.signPropagatingRightShift=function t(e,a){return new n(e).signPropagatingRightShift(a)},t.prototype.rightShift=function t(n){return"number"==typeof n?this.rightShiftS(n):this.rightShiftM(n)},t.prototype.rightShiftS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,this.get(t,e)>>>n);return this},t.prototype.rightShiftM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,this.get(t,n)>>>e.get(t,n));return this},t.rightShift=function t(e,a){return new n(e).rightShift(a)},t.prototype.zeroFillRightShift=t.prototype.rightShift,t.prototype.zeroFillRightShiftS=t.prototype.rightShiftS,t.prototype.zeroFillRightShiftM=t.prototype.rightShiftM,t.zeroFillRightShift=t.rightShift,t.prototype.not=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,~this.get(t,n));return this},t.not=function t(e){return new n(e).not()},t.prototype.abs=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.abs(this.get(t,n)));return this},t.abs=function t(e){return new n(e).abs()},t.prototype.acos=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.acos(this.get(t,n)));return this},t.acos=function t(e){return new n(e).acos()},t.prototype.acosh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.acosh(this.get(t,n)));return this},t.acosh=function t(e){return new n(e).acosh()},t.prototype.asin=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.asin(this.get(t,n)));return this},t.asin=function t(e){return new n(e).asin()},t.prototype.asinh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.asinh(this.get(t,n)));return this},t.asinh=function t(e){return new n(e).asinh()},t.prototype.atan=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.atan(this.get(t,n)));return this},t.atan=function t(e){return new n(e).atan()},t.prototype.atanh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.atanh(this.get(t,n)));return this},t.atanh=function t(e){return new n(e).atanh()},t.prototype.cbrt=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.cbrt(this.get(t,n)));return this},t.cbrt=function t(e){return new n(e).cbrt()},t.prototype.ceil=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.ceil(this.get(t,n)));return this},t.ceil=function t(e){return new n(e).ceil()},t.prototype.clz32=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.clz32(this.get(t,n)));return this},t.clz32=function t(e){return new n(e).clz32()},t.prototype.cos=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.cos(this.get(t,n)));return this},t.cos=function t(e){return new n(e).cos()},t.prototype.cosh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.cosh(this.get(t,n)));return this},t.cosh=function t(e){return new n(e).cosh()},t.prototype.exp=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.exp(this.get(t,n)));return this},t.exp=function t(e){return new n(e).exp()},t.prototype.expm1=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.expm1(this.get(t,n)));return this},t.expm1=function t(e){return new n(e).expm1()},t.prototype.floor=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.floor(this.get(t,n)));return this},t.floor=function t(e){return new n(e).floor()},t.prototype.fround=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.fround(this.get(t,n)));return this},t.fround=function t(e){return new n(e).fround()},t.prototype.log=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.log(this.get(t,n)));return this},t.log=function t(e){return new n(e).log()},t.prototype.log1p=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.log1p(this.get(t,n)));return this},t.log1p=function t(e){return new n(e).log1p()},t.prototype.log10=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.log10(this.get(t,n)));return this},t.log10=function t(e){return new n(e).log10()},t.prototype.log2=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.log2(this.get(t,n)));return this},t.log2=function t(e){return new n(e).log2()},t.prototype.round=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.round(this.get(t,n)));return this},t.round=function t(e){return new n(e).round()},t.prototype.sign=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.sign(this.get(t,n)));return this},t.sign=function t(e){return new n(e).sign()},t.prototype.sin=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.sin(this.get(t,n)));return this},t.sin=function t(e){return new n(e).sin()},t.prototype.sinh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.sinh(this.get(t,n)));return this},t.sinh=function t(e){return new n(e).sinh()},t.prototype.sqrt=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.sqrt(this.get(t,n)));return this},t.sqrt=function t(e){return new n(e).sqrt()},t.prototype.tan=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.tan(this.get(t,n)));return this},t.tan=function t(e){return new n(e).tan()},t.prototype.tanh=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.tanh(this.get(t,n)));return this},t.tanh=function t(e){return new n(e).tanh()},t.prototype.trunc=function t(){for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.trunc(this.get(t,n)));return this},t.trunc=function t(e){return new n(e).trunc()},t.pow=function t(e,a){return new n(e).pow(a)},t.prototype.pow=function t(n){return"number"==typeof n?this.powS(n):this.powM(n)},t.prototype.powS=function t(n){for(let t=0;t<this.rows;t++)for(let e=0;e<this.columns;e++)this.set(t,e,Math.pow(this.get(t,e),n));return this},t.prototype.powM=function t(e){if(e=n.checkMatrix(e),this.rows!==e.rows||this.columns!==e.columns)throw new RangeError("Matrices dimensions must be equal");for(let t=0;t<this.rows;t++)for(let n=0;n<this.columns;n++)this.set(t,n,Math.pow(this.get(t,n),e.get(t,n)));return this}})(cut,mut);class gut extends cut{constructor(t){super(),this.data=t,this.rows=t.length,this.columns=t[0].length}set(t,n,e){return this.data[t][n]=e,this}get(t,n){return this.data[t][n]}}class put{constructor(t){let n,e,a,o,r,i,c,s,l,m=(t=gut.checkMatrix(t)).clone(),d=m.rows,g=m.columns,p=new Float64Array(d),b=1;for(n=0;n<d;n++)p[n]=n;for(s=new Float64Array(d),e=0;e<g;e++){for(n=0;n<d;n++)s[n]=m.get(n,e);for(n=0;n<d;n++){for(l=Math.min(n,e),r=0,a=0;a<l;a++)r+=m.get(n,a)*s[a];s[n]-=r,m.set(n,e,s[n])}for(o=e,n=e+1;n<d;n++)Math.abs(s[n])>Math.abs(s[o])&&(o=n);if(o!==e){for(a=0;a<g;a++)i=m.get(o,a),m.set(o,a,m.get(e,a)),m.set(e,a,i);c=p[o],p[o]=p[e],p[e]=c,b=-b}if(e<d&&0!==m.get(e,e))for(n=e+1;n<d;n++)m.set(n,e,m.get(n,e)/m.get(e,e))}this.LU=m,this.pivotVector=p,this.pivotSign=b}isSingular(){let t=this.LU,n=t.columns;for(let e=0;e<n;e++)if(0===t.get(e,e))return!0;return!1}solve(t){t=mut.checkMatrix(t);let n=this.LU;if(n.rows!==t.rows)throw new Error("Invalid matrix dimensions");if(this.isSingular())throw new Error("LU matrix is singular");let e,a,o,r=t.columns,i=t.subMatrixRow(this.pivotVector,0,r-1),c=n.columns;for(o=0;o<c;o++)for(e=o+1;e<c;e++)for(a=0;a<r;a++)i.set(e,a,i.get(e,a)-i.get(o,a)*n.get(e,o));for(o=c-1;o>=0;o--){for(a=0;a<r;a++)i.set(o,a,i.get(o,a)/n.get(o,o));for(e=0;e<o;e++)for(a=0;a<r;a++)i.set(e,a,i.get(e,a)-i.get(o,a)*n.get(e,o))}return i}get determinant(){let t=this.LU;if(!t.isSquare())throw new Error("Matrix must be square");let n=this.pivotSign,e=t.columns;for(let a=0;a<e;a++)n*=t.get(a,a);return n}get lowerTriangularMatrix(){let t=this.LU,n=t.rows,e=t.columns,a=new mut(n,e);for(let o=0;o<n;o++)for(let n=0;n<e;n++)a.set(o,n,o>n?t.get(o,n):o===n?1:0);return a}get upperTriangularMatrix(){let t=this.LU,n=t.rows,e=t.columns,a=new mut(n,e);for(let o=0;o<n;o++)for(let n=0;n<e;n++)a.set(o,n,o<=n?t.get(o,n):0);return a}get pivotPermutationVector(){return Array.from(this.pivotVector)}}function but(t,n){let e=0;return Math.abs(t)>Math.abs(n)?(e=n/t,Math.abs(t)*Math.sqrt(1+e*e)):0!==n?(e=t/n,Math.abs(n)*Math.sqrt(1+e*e)):0}class uut{constructor(t){let n,e,a,o,r=(t=gut.checkMatrix(t)).clone(),i=t.rows,c=t.columns,s=new Float64Array(c);for(a=0;a<c;a++){let t=0;for(n=a;n<i;n++)t=but(t,r.get(n,a));if(0!==t){for(r.get(a,a)<0&&(t=-t),n=a;n<i;n++)r.set(n,a,r.get(n,a)/t);for(r.set(a,a,r.get(a,a)+1),e=a+1;e<c;e++){for(o=0,n=a;n<i;n++)o+=r.get(n,a)*r.get(n,e);for(o=-o/r.get(a,a),n=a;n<i;n++)r.set(n,e,r.get(n,e)+o*r.get(n,a))}}s[a]=-t}this.QR=r,this.Rdiag=s}solve(t){t=mut.checkMatrix(t);let n=this.QR,e=n.rows;if(t.rows!==e)throw new Error("Matrix row dimensions must agree");if(!this.isFullRank())throw new Error("Matrix is rank deficient");let a,o,r,i,c=t.columns,s=t.clone(),l=n.columns;for(r=0;r<l;r++)for(o=0;o<c;o++){for(i=0,a=r;a<e;a++)i+=n.get(a,r)*s.get(a,o);for(i=-i/n.get(r,r),a=r;a<e;a++)s.set(a,o,s.get(a,o)+i*n.get(a,r))}for(r=l-1;r>=0;r--){for(o=0;o<c;o++)s.set(r,o,s.get(r,o)/this.Rdiag[r]);for(a=0;a<r;a++)for(o=0;o<c;o++)s.set(a,o,s.get(a,o)-s.get(r,o)*n.get(a,r))}return s.subMatrix(0,l-1,0,c-1)}isFullRank(){let t=this.QR.columns;for(let n=0;n<t;n++)if(0===this.Rdiag[n])return!1;return!0}get upperTriangularMatrix(){let t,n,e=this.QR,a=e.columns,o=new mut(a,a);for(t=0;t<a;t++)for(n=0;n<a;n++)o.set(t,n,t<n?e.get(t,n):t===n?this.Rdiag[t]:0);return o}get orthogonalMatrix(){let t,n,e,a,o=this.QR,r=o.rows,i=o.columns,c=new mut(r,i);for(e=i-1;e>=0;e--){for(t=0;t<r;t++)c.set(t,e,0);for(c.set(e,e,1),n=e;n<i;n++)if(0!==o.get(e,e)){for(a=0,t=e;t<r;t++)a+=o.get(t,e)*c.get(t,n);for(a=-a/o.get(e,e),t=e;t<r;t++)c.set(t,n,c.get(t,n)+a*o.get(t,e))}}return c}}class fut{constructor(t,n={}){if((t=gut.checkMatrix(t)).isEmpty())throw new Error("Matrix must be non-empty");let e=t.rows,a=t.columns;const{computeLeftSingularVectors:o=!0,computeRightSingularVectors:r=!0,autoTranspose:i=!1}=n;let c,s=Boolean(o),l=Boolean(r),m=!1;if(e<a)if(i){c=t.transpose(),e=c.rows,a=c.columns,m=!0;let n=s;s=l,l=n}else c=t.clone(),console.warn("Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose");else c=t.clone();let d=Math.min(e,a),g=Math.min(e+1,a),p=new Float64Array(g),b=new mut(e,d),u=new mut(a,a),f=new Float64Array(a),h=new Float64Array(e),_=new Float64Array(g);for(let t=0;t<g;t++)_[t]=t;let C=Math.min(e-1,a),M=Math.max(0,Math.min(a-2,e)),O=Math.max(C,M);for(let t=0;t<O;t++){if(t<C){p[t]=0;for(let n=t;n<e;n++)p[t]=but(p[t],c.get(n,t));if(0!==p[t]){c.get(t,t)<0&&(p[t]=-p[t]);for(let n=t;n<e;n++)c.set(n,t,c.get(n,t)/p[t]);c.set(t,t,c.get(t,t)+1)}p[t]=-p[t]}for(let n=t+1;n<a;n++){if(t<C&&0!==p[t]){let a=0;for(let o=t;o<e;o++)a+=c.get(o,t)*c.get(o,n);a=-a/c.get(t,t);for(let o=t;o<e;o++)c.set(o,n,c.get(o,n)+a*c.get(o,t))}f[n]=c.get(t,n)}if(s&&t<C)for(let n=t;n<e;n++)b.set(n,t,c.get(n,t));if(t<M){f[t]=0;for(let n=t+1;n<a;n++)f[t]=but(f[t],f[n]);if(0!==f[t]){f[t+1]<0&&(f[t]=0-f[t]);for(let n=t+1;n<a;n++)f[n]/=f[t];f[t+1]+=1}if(f[t]=-f[t],t+1<e&&0!==f[t]){for(let n=t+1;n<e;n++)h[n]=0;for(let n=t+1;n<e;n++)for(let e=t+1;e<a;e++)h[n]+=f[e]*c.get(n,e);for(let n=t+1;n<a;n++){let a=-f[n]/f[t+1];for(let o=t+1;o<e;o++)c.set(o,n,c.get(o,n)+a*h[o])}}if(l)for(let n=t+1;n<a;n++)u.set(n,t,f[n])}}let P=Math.min(a,e+1);if(C<a&&(p[C]=c.get(C,C)),e<P&&(p[P-1]=0),M+1<P&&(f[M]=c.get(M,P-1)),f[P-1]=0,s){for(let t=C;t<d;t++){for(let n=0;n<e;n++)b.set(n,t,0);b.set(t,t,1)}for(let t=C-1;t>=0;t--)if(0!==p[t]){for(let n=t+1;n<d;n++){let a=0;for(let o=t;o<e;o++)a+=b.get(o,t)*b.get(o,n);a=-a/b.get(t,t);for(let o=t;o<e;o++)b.set(o,n,b.get(o,n)+a*b.get(o,t))}for(let n=t;n<e;n++)b.set(n,t,-b.get(n,t));b.set(t,t,1+b.get(t,t));for(let n=0;n<t-1;n++)b.set(n,t,0)}else{for(let n=0;n<e;n++)b.set(n,t,0);b.set(t,t,1)}}if(l)for(let t=a-1;t>=0;t--){if(t<M&&0!==f[t])for(let n=t+1;n<a;n++){let e=0;for(let o=t+1;o<a;o++)e+=u.get(o,t)*u.get(o,n);e=-e/u.get(t+1,t);for(let o=t+1;o<a;o++)u.set(o,n,u.get(o,n)+e*u.get(o,t))}for(let n=0;n<a;n++)u.set(n,t,0);u.set(t,t,1)}let x=P-1,y=Number.EPSILON;for(;P>0;){let t,n;for(t=P-2;t>=-1&&-1!==t;t--){const n=Number.MIN_VALUE+y*Math.abs(p[t]+Math.abs(p[t+1]));if(Math.abs(f[t])<=n||Number.isNaN(f[t])){f[t]=0;break}}if(t===P-2)n=4;else{let e;for(e=P-1;e>=t&&e!==t;e--){let n=(e!==P?Math.abs(f[e]):0)+(e!==t+1?Math.abs(f[e-1]):0);if(Math.abs(p[e])<=y*n){p[e]=0;break}}e===t?n=3:e===P-1?n=1:(n=2,t=e)}switch(t++,n){case 1:{let n=f[P-2];f[P-2]=0;for(let e=P-2;e>=t;e--){let o=but(p[e],n),r=p[e]/o,i=n/o;if(p[e]=o,e!==t&&(n=-i*f[e-1],f[e-1]=r*f[e-1]),l)for(let t=0;t<a;t++)o=r*u.get(t,e)+i*u.get(t,P-1),u.set(t,P-1,-i*u.get(t,e)+r*u.get(t,P-1)),u.set(t,e,o)}break}case 2:{let n=f[t-1];f[t-1]=0;for(let a=t;a<P;a++){let o=but(p[a],n),r=p[a]/o,i=n/o;if(p[a]=o,n=-i*f[a],f[a]=r*f[a],s)for(let n=0;n<e;n++)o=r*b.get(n,a)+i*b.get(n,t-1),b.set(n,t-1,-i*b.get(n,a)+r*b.get(n,t-1)),b.set(n,a,o)}break}case 3:{const n=Math.max(Math.abs(p[P-1]),Math.abs(p[P-2]),Math.abs(f[P-2]),Math.abs(p[t]),Math.abs(f[t])),o=p[P-1]/n,r=p[P-2]/n,i=f[P-2]/n,c=p[t]/n,m=f[t]/n,d=((r+o)*(r-o)+i*i)/2,g=o*i*(o*i);let h=0;0===d&&0===g||(h=d<0?0-Math.sqrt(d*d+g):Math.sqrt(d*d+g),h=g/(d+h));let _=(c+o)*(c-o)+h,C=c*m;for(let n=t;n<P-1;n++){let o=but(_,C);0===o&&(o=Number.MIN_VALUE);let r=_/o,i=C/o;if(n!==t&&(f[n-1]=o),_=r*p[n]+i*f[n],f[n]=r*f[n]-i*p[n],C=i*p[n+1],p[n+1]=r*p[n+1],l)for(let t=0;t<a;t++)o=r*u.get(t,n)+i*u.get(t,n+1),u.set(t,n+1,-i*u.get(t,n)+r*u.get(t,n+1)),u.set(t,n,o);if(o=but(_,C),0===o&&(o=Number.MIN_VALUE),r=_/o,i=C/o,p[n]=o,_=r*f[n]+i*p[n+1],p[n+1]=-i*f[n]+r*p[n+1],C=i*f[n+1],f[n+1]=r*f[n+1],s&&n<e-1)for(let t=0;t<e;t++)o=r*b.get(t,n)+i*b.get(t,n+1),b.set(t,n+1,-i*b.get(t,n)+r*b.get(t,n+1)),b.set(t,n,o)}f[P-2]=_;break}case 4:if(p[t]<=0&&(p[t]=p[t]<0?-p[t]:0,l))for(let n=0;n<=x;n++)u.set(n,t,-u.get(n,t));for(;t<x&&!(p[t]>=p[t+1]);){let n=p[t];if(p[t]=p[t+1],p[t+1]=n,l&&t<a-1)for(let e=0;e<a;e++)n=u.get(e,t+1),u.set(e,t+1,u.get(e,t)),u.set(e,t,n);if(s&&t<e-1)for(let a=0;a<e;a++)n=b.get(a,t+1),b.set(a,t+1,b.get(a,t)),b.set(a,t,n);t++}P--}}if(m){let t=u;u=b,b=t}this.m=e,this.n=a,this.s=p,this.U=b,this.V=u}solve(t){let n=t,e=this.threshold,a=this.s.length,o=mut.zeros(a,a);for(let t=0;t<a;t++)Math.abs(this.s[t])<=e?o.set(t,t,0):o.set(t,t,1/this.s[t]);let r=this.U,i=this.rightSingularVectors,c=i.mmul(o),s=i.rows,l=r.rows,m=mut.zeros(s,l);for(let t=0;t<s;t++)for(let n=0;n<l;n++){let e=0;for(let o=0;o<a;o++)e+=c.get(t,o)*r.get(n,o);m.set(t,n,e)}return m.mmul(n)}solveForDiagonal(t){return this.solve(mut.diag(t))}inverse(){let t=this.V,n=this.threshold,e=t.rows,a=t.columns,o=new mut(e,this.s.length);for(let r=0;r<e;r++)for(let e=0;e<a;e++)Math.abs(this.s[e])>n&&o.set(r,e,t.get(r,e)/this.s[e]);let r=this.U,i=r.rows,c=r.columns,s=new mut(e,i);for(let t=0;t<e;t++)for(let n=0;n<i;n++){let e=0;for(let a=0;a<c;a++)e+=o.get(t,a)*r.get(n,a);s.set(t,n,e)}return s}get condition(){return this.s[0]/this.s[Math.min(this.m,this.n)-1]}get norm2(){return this.s[0]}get rank(){let t=Math.max(this.m,this.n)*this.s[0]*Number.EPSILON,n=0,e=this.s;for(let a=0,o=e.length;a<o;a++)e[a]>t&&n++;return n}get diagonal(){return Array.from(this.s)}get threshold(){return Number.EPSILON/2*Math.max(this.m,this.n)*this.s[0]}get leftSingularVectors(){return this.U}get rightSingularVectors(){return this.V}get diagonalMatrix(){return mut.diag(this.s)}}function hut(t,n,e,a,o){let r=mut.eye(n.length,n.length,e*a*a);const i=o(n);let c=new Float64Array(t.x.length);for(let n=0;n<t.x.length;n++)c[n]=i(t.x[n]);let s=(function l(t,n,e,a,o){const r=e.length,i=t.x.length;let c=new Array(r);for(let s=0;s<r;s++){c[s]=new Array(i);let r=e.slice();r[s]+=a;let l=o(r);for(let e=0;e<i;e++)c[s][e]=n[e]-l(t.x[e])}return new mut(c)})(t,c,n,a,o),m=(function d(t,n){const e=t.x.length;let a=new Array(e);for(let o=0;o<e;o++)a[o]=[t.y[o]-n[o]];return new mut(a)})(t,c),g=(function p(t,n=!1){return t=gut.checkMatrix(t),n?new fut(t).inverse():(function e(t,n,a=!1){return t=gut.checkMatrix(t),n=gut.checkMatrix(n),a?new fut(t).solve(n):t.isSquare()?new put(t).solve(n):new uut(t).solve(n)})(t,mut.eye(t.rows))})(r.add(s.mmul(s.transpose())));return(n=(n=new mut([n])).sub(g.mmul(s).mmul(m).mul(a).transpose())).to1DArray()}var _ut=kP(Object.freeze({__proto__:null,default:function Cut(t,n,e={}){let{maxIterations:a=100,gradientDifference:o=.1,damping:r=0,errorTolerance:i=.01,minValues:c,maxValues:s,initialValues:l}=e;if(r<=0)throw new Error("The damping option must be a positive number");if(!t.x||!t.y)throw new Error("The data parameter must have x and y elements");if(!Bbt(t.x)||t.x.length<2||!Bbt(t.y)||t.y.length<2)throw new Error("The data parameter elements must be an array with more than 2 points");if(t.x.length!==t.y.length)throw new Error("The data parameter elements must have the same size");let m=l||new Array(n.length).fill(1),d=m.length;if(s=s||new Array(d).fill(Number.MAX_SAFE_INTEGER),c=c||new Array(d).fill(Number.MIN_SAFE_INTEGER),s.length!==c.length)throw new Error("minValues and maxValues must be the same size");if(!Bbt(m))throw new Error("initialValues must be an array");let g,p=Vbt(t,m,n),b=p<=i;for(g=0;g<a&&!b;g++){m=hut(t,m,r,o,n);for(let t=0;t<d;t++)m[t]=Math.min(Math.max(c[t],m[t]),s[t]);if(p=Vbt(t,m,n),isNaN(p))break;b=p<=i}return{parameterValues:m,parameterError:p,iterations:g}}})),Mut=yP((function(t,n){var e=xP&&xP.__awaiter||function(t,n,e,a){return new(e||(e=Promise))((function(o,r){function i(t){try{s(a.next(t))}catch(t){r(t)}}function c(t){try{s(a.throw(t))}catch(t){r(t)}}function s(t){t.done?o(t.value):new e((function(n){n(t.value)})).then(i,c)}s((a=a.apply(t,n||[])).next())}))},a=xP&&xP.__generator||function(t,n){var e,a,o,r,i={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return r={next:c(0),throw:c(1),return:c(2)},"function"==typeof Symbol&&(r[Symbol.iterator]=function(){return this}),r;function c(r){return function(c){return(function s(r){if(e)throw new TypeError("Generator is already executing.");for(;i;)try{if(e=1,a&&(o=2&r[0]?a.return:r[0]?a.throw||((o=a.return)&&o.call(a),0):a.next)&&!(o=o.call(a,r[1])).done)return o;switch(a=0,o&&(r=[2&r[0],o.value]),r[0]){case 0:case 1:o=r;break;case 4:return i.label++,{value:r[1],done:!1};case 5:i.label++,a=r[1],r=[0];continue;case 7:r=i.ops.pop(),i.trys.pop();continue;default:if(!((o=(o=i.trys).length>0&&o[o.length-1])||6!==r[0]&&2!==r[0])){i=0;continue}if(3===r[0]&&(!o||r[1]>o[0]&&r[1]<o[3])){i.label=r[1];break}if(6===r[0]&&i.label<o[1]){i.label=o[1],o=r;break}if(o&&i.label<o[2]){i.label=o[2],i.ops.push(r);break}o[2]&&i.ops.pop(),i.trys.pop();continue}r=n.call(t,i)}catch(t){r=[6,t],a=0}finally{e=o=0}if(5&r[0])throw r[1];return{value:r[0]?r[1]:void 0,done:!0}})([r,c])}}},o=xP&&xP.__read||function(t,n){var e="function"==typeof Symbol&&t[Symbol.iterator];if(!e)return t;var a,o,r=e.call(t),i=[];try{for(;(void 0===n||n-- >0)&&!(a=r.next()).done;)i.push(a.value)}catch(t){o={error:t}}finally{try{a&&!a.done&&(e=r.return)&&e.call(r)}finally{if(o)throw o.error}}return i},r=xP&&xP.__spread||function(){for(var t=[],n=0;n<arguments.length;n++)t=t.concat(o(arguments[n]));return t},i=xP&&xP.__importStar||function(t){if(t&&t.__esModule)return t;var n={};if(null!=t)for(var e in t)Object.hasOwnProperty.call(t,e)&&(n[e]=t[e]);return n.default=t,n},c=xP&&xP.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(n,"__esModule",{value:!0});var s=i(Ibt),l=i(Nbt),m=i(Lbt),d=i(Fbt),g=i(Dbt),p=c(_ut),b=1e-5,u=.001,f=(function(){function t(t){void 0===t&&(t={});var n=this;this.learningRate=1,this.localConnectivity=1,this.minDist=.1,this.nComponents=2,this.nEpochs=0,this.nNeighbors=15,this.negativeSampleRate=5,this.random=Math.random,this.repulsionStrength=1,this.setOpMixRatio=1,this.spread=1,this.transformQueueSize=4,this.targetMetric="categorical",this.targetWeight=.5,this.targetNNeighbors=this.nNeighbors,this.distanceFn=h,this.isInitialized=!1,this.rpForest=[],this.embedding=[],this.optimizationState=new C;var e=function(e){void 0!==t[e]&&(n[e]=t[e])};e("distanceFn"),e("learningRate"),e("localConnectivity"),e("minDist"),e("nComponents"),e("nEpochs"),e("nNeighbors"),e("negativeSampleRate"),e("random"),e("repulsionStrength"),e("setOpMixRatio"),e("spread"),e("transformQueueSize")}return t.prototype.fit=function(t){return this.initializeFit(t),this.optimizeLayout(),this.embedding},t.prototype.fitAsync=function(t,n){return void 0===n&&(n=function(){return!0}),e(this,void 0,void 0,(function(){return a(this,(function(e){switch(e.label){case 0:return this.initializeFit(t),[4,this.optimizeLayoutAsync(n)];case 1:return e.sent(),[2,this.embedding]}}))}))},t.prototype.setSupervisedProjection=function(t,n){void 0===n&&(n={}),this.Y=t,this.targetMetric=n.targetMetric||this.targetMetric,this.targetWeight=n.targetWeight||this.targetWeight,this.targetNNeighbors=n.targetNNeighbors||this.targetNNeighbors},t.prototype.setPrecomputedKNN=function(t,n){this.knnIndices=t,this.knnDistances=n},t.prototype.initializeFit=function(t){if(t.length<=this.nNeighbors)throw new Error("Not enough data points ("+t.length+") to create nNeighbors: "+this.nNeighbors+".  Add more data points or adjust the configuration.");if(this.X===t&&this.isInitialized)return this.getNEpochs();if(this.X=t,!this.knnIndices&&!this.knnDistances){var n=this.nearestNeighbors(t);this.knnIndices=n.knnIndices,this.knnDistances=n.knnDistances}this.graph=this.fuzzySimplicialSet(t,this.nNeighbors,this.setOpMixRatio),this.makeSearchFns(),this.searchGraph=this.makeSearchGraph(t),this.processGraphForSupervisedProjection();var e=this.initializeSimplicialSetEmbedding(),a=e.tail,o=e.epochsPerSample;return this.optimizationState.head=e.head,this.optimizationState.tail=a,this.optimizationState.epochsPerSample=o,this.initializeOptimization(),this.prepareForOptimizationLoop(),this.isInitialized=!0,this.getNEpochs()},t.prototype.makeSearchFns=function(){var t=m.makeInitializations(this.distanceFn),n=t.initFromRandom;this.initFromTree=t.initFromTree,this.initFromRandom=n,this.search=m.makeInitializedNNSearch(this.distanceFn)},t.prototype.makeSearchGraph=function(t){for(var n=this.knnIndices,e=this.knnDistances,a=new l.SparseMatrix([],[],[],[t.length,t.length]),o=0;o<n.length;o++)for(var r=n[o],i=e[o],c=0;c<r.length;c++){var s=i[c];s>0&&a.set(o,r[c],s)}var m=l.transpose(a);return l.maximum(a,m)},t.prototype.transform=function(t){var n=this,e=this.X;if(void 0===e||0===e.length)throw new Error("No data has been fit.");var a=Math.floor(this.nNeighbors*this.transformQueueSize);a=Math.min(e.length,a);var o=m.initializeSearch(this.rpForest,e,t,a,this.initFromRandom,this.initFromTree,this.random),r=this.search(e,this.searchGraph,o,t),i=s.deheapSort(r),c=i.indices,d=i.weights;c=c.map((function(t){return t.slice(0,n.nNeighbors)})),d=d.map((function(t){return t.slice(0,n.nNeighbors)}));var p=Math.max(0,this.localConnectivity-1),b=this.smoothKNNDistance(d,this.nNeighbors,p),u=this.computeMembershipStrengths(c,d,b.sigmas,b.rhos),f=new l.SparseMatrix(u.rows,u.cols,u.vals,[t.length,e.length]),h=l.normalize(f,"l1"),_=l.getCSR(h),C=t.length,M=k(g.reshape2d(_.indices,C,this.nNeighbors),g.reshape2d(_.values,C,this.nNeighbors),this.embedding),O=this.nEpochs?this.nEpochs/3:f.nRows<=1e4?100:30,P=f.getValues().reduce((function(t,n){return n>t?n:t}),0);f=f.map((function(t){return t<P/O?0:t})),f=l.eliminateZeros(f);var x=this.makeEpochsPerSample(f.getValues(),O),y=f.getRows(),v=f.getCols();return this.assignOptimizationStateParameters({headEmbedding:M,tailEmbedding:this.embedding,head:y,tail:v,currentEpoch:0,nEpochs:O,nVertices:f.getDims()[1],epochsPerSample:x}),this.prepareForOptimizationLoop(),this.optimizeLayout()},t.prototype.processGraphForSupervisedProjection=function(){var t=this.Y;if(t){if(t.length!==this.X.length)throw new Error("Length of X and y must be equal");"categorical"===this.targetMetric&&(this.graph=this.categoricalSimplicialSetIntersection(this.graph,t,this.targetWeight<1?1/(1-this.targetWeight)*2.5:1e12))}},t.prototype.step=function(){var t=this.optimizationState.currentEpoch;return t<this.getNEpochs()&&this.optimizeLayoutStep(t),this.optimizationState.currentEpoch},t.prototype.getEmbedding=function(){return this.embedding},t.prototype.nearestNeighbors=function(t){var n,e=this.nNeighbors,a=m.makeNNDescent(this.distanceFn,this.random),o=5+Math.floor(.5==(n=Math.pow(t.length,.5)/20)?0:Math.round(n)),r=Math.max(5,Math.floor(Math.round((function(t){return Math.log(t)/Math.log(2)})(t.length))));this.rpForest=d.makeForest(t,e,o,this.random);var i=a(t,d.makeLeafArray(this.rpForest),e,r);return{knnIndices:i.indices,knnDistances:i.weights}},t.prototype.fuzzySimplicialSet=function(t,n,e){void 0===e&&(e=1);var a=this,o=a.knnIndices,r=void 0===o?[]:o,i=a.knnDistances,c=void 0===i?[]:i,s=this.smoothKNNDistance(c,n,a.localConnectivity),m=this.computeMembershipStrengths(r,c,s.sigmas,s.rhos),d=new l.SparseMatrix(m.rows,m.cols,m.vals,[t.length,t.length]),g=l.transpose(d),p=l.pairwiseMultiply(d,g),b=l.subtract(l.add(d,g),p),u=l.multiplyScalar(b,e),f=l.multiplyScalar(p,1-e);return l.add(u,f)},t.prototype.categoricalSimplicialSetIntersection=function(t,n,e,a){void 0===a&&(a=1);var o=x(t,n,a,e);return y(o=l.eliminateZeros(o))},t.prototype.smoothKNNDistance=function(t,n,e,a,o){void 0===e&&(e=1),void 0===a&&(a=64),void 0===o&&(o=1);for(var r=Math.log(n)/Math.log(2)*o,i=g.zeros(t.length),c=g.zeros(t.length),s=0;s<t.length;s++){var l=0,m=1/0,d=1,p=t[s],f=p.filter((function(t){return t>0}));if(f.length>=e){var h=Math.floor(e),_=e-h;h>0?(i[s]=f[h-1],_>b&&(i[s]+=_*(f[h]-f[h-1]))):i[s]=_*f[0]}else f.length>0&&(i[s]=g.max(f));for(var C=0;C<a;C++){for(var M=0,O=1;O<t[s].length;O++){var P=t[s][O]-i[s];M+=P>0?Math.exp(-P/d):1}if(Math.abs(M-r)<b)break;M>r?d=(l+(m=d))/2:(l=d,m===1/0?d*=2:d=(l+m)/2)}if(c[s]=d,i[s]>0){var x=g.mean(p);c[s]<u*x&&(c[s]=u*x)}else{var y=g.mean(t.map(g.mean));c[s]<u*y&&(c[s]=u*y)}}return{sigmas:c,rhos:i}},t.prototype.computeMembershipStrengths=function(t,n,e,a){for(var o=t.length,r=t[0].length,i=g.zeros(o*r),c=g.zeros(o*r),s=g.zeros(o*r),l=0;l<o;l++)for(var m=0;m<r;m++){var d=0;-1!==t[l][m]&&(d=t[l][m]===l?0:n[l][m]-a[l]<=0?1:Math.exp(-(n[l][m]-a[l])/e[l]),i[l*r+m]=l,c[l*r+m]=t[l][m],s[l*r+m]=d)}return{rows:i,cols:c,vals:s}},t.prototype.initializeSimplicialSetEmbedding=function(){for(var t=this,n=this.getNEpochs(),e=this.nComponents,a=this.graph.getValues(),o=0,r=0;r<a.length;r++)o<a[r]&&(o=a[r]);var i=this.graph.map((function(t){return t<o/n?0:t}));this.embedding=g.zeros(i.nRows).map((function(){return g.zeros(e).map((function(){return 20*g.tauRand(t.random)-10}))}));var c=[],s=[],l=[],m=i.getAll();for(r=0;r<m.length;r++){var d=m[r];d.value&&(c.push(d.value),l.push(d.row),s.push(d.col))}return{head:s,tail:l,epochsPerSample:this.makeEpochsPerSample(c,n)}},t.prototype.makeEpochsPerSample=function(t,n){var e=g.filled(t.length,-1),a=g.max(t),o=t.map((function(t){return t/a*n}));return o.forEach((function(t,a){t>0&&(e[a]=n/o[a])})),e},t.prototype.assignOptimizationStateParameters=function(t){Object.assign(this.optimizationState,t)},t.prototype.prepareForOptimizationLoop=function(){var t=this,n=t.repulsionStrength,e=t.learningRate,a=t.negativeSampleRate,o=this.optimizationState,i=o.epochsPerSample,c=o.headEmbedding,s=c[0].length,l=c.length===o.tailEmbedding.length,m=i.map((function(t){return t/a})),d=r(m),g=r(i);this.assignOptimizationStateParameters({epochOfNextSample:g,epochOfNextNegativeSample:d,epochsPerNegativeSample:m,moveOther:l,initialAlpha:e,alpha:e,gamma:n,dim:s})},t.prototype.initializeOptimization=function(){var t=this.embedding,n=this.embedding,e=this.optimizationState,a=e.head,o=e.tail,r=e.epochsPerSample,i=this.getNEpochs(),c=this.graph.nCols,s=P(this.spread,this.minDist);this.assignOptimizationStateParameters({headEmbedding:t,tailEmbedding:n,head:a,tail:o,epochsPerSample:r,a:s.a,b:s.b,nEpochs:i,nVertices:c})},t.prototype.optimizeLayoutStep=function(t){for(var n=this.optimizationState,e=n.head,a=n.tail,o=n.headEmbedding,r=n.tailEmbedding,i=n.epochsPerSample,c=n.epochOfNextSample,s=n.epochOfNextNegativeSample,l=n.epochsPerNegativeSample,m=n.moveOther,d=n.initialAlpha,p=n.alpha,b=n.gamma,u=n.a,f=n.b,h=n.dim,_=n.nEpochs,C=n.nVertices,P=0;P<i.length;P++)if(!(c[P]>t)){var x=e[P],y=o[x],k=r[a[P]],v=O(y,k),w=0;v>0&&(w=-2*u*f*Math.pow(v,f-1),w/=u*Math.pow(v,f)+1);for(var S=0;S<h;S++){var E=M(w*(y[S]-k[S]),4);y[S]+=E*p,m&&(k[S]+=-E*p)}c[P]+=i[P];for(var A=Math.floor((t-s[P])/l[P]),z=0;z<A;z++){var R=g.tauRandInt(C,this.random),T=r[R],D=O(y,T),I=0;if(D>0)I=2*b*f,I/=(.001+D)*(u*Math.pow(D,f)+1);else if(x===R)continue;for(S=0;S<h;S++)E=4,I>0&&(E=M(I*(y[S]-T[S]),4)),y[S]+=E*p}s[P]+=A*l[P]}return n.alpha=d*(1-t/_),n.currentEpoch+=1,o},t.prototype.optimizeLayoutAsync=function(t){var n=this;return void 0===t&&(t=function(){return!0}),new Promise((function(o,r){var i=function(){return e(n,void 0,void 0,(function(){var n,e,c,s,l;return a(this,(function(a){try{if(e=(n=this.optimizationState).nEpochs,this.embedding=this.optimizeLayoutStep(n.currentEpoch),s=!1===t(c=this.optimizationState.currentEpoch),l=c===e,s||l)return[2,o(l)];setTimeout((function(){return i()}),0)}catch(t){r(t)}return[2]}))}))};setTimeout((function(){return i()}),0)}))},t.prototype.optimizeLayout=function(t){void 0===t&&(t=function(){return!0});for(var n=!1,e=[];!n;){var a=this.optimizationState,o=a.nEpochs;e=this.optimizeLayoutStep(a.currentEpoch);var r=this.optimizationState.currentEpoch,i=!1===t(r);n=r===o||i}return e},t.prototype.getNEpochs=function(){if(this.nEpochs>0)return this.nEpochs;var t=this.graph.nRows;return t<=2500?500:t<=5e3?400:t<=7500?300:200},t})();function h(t,n){for(var e=0,a=0;a<t.length;a++)e+=Math.pow(t[a]-n[a],2);return Math.sqrt(e)}n.UMAP=f,n.euclidean=h,n.cosine=function _(t,n){for(var e=0,a=0,o=0,r=0;r<t.length;r++)e+=t[r]*n[r],a+=Math.pow(t[r],2),o+=Math.pow(n[r],2);return 0===a&&0===o?0:0===a||0===o?1:1-e/Math.sqrt(a*o)};var C=function C(){this.currentEpoch=0,this.headEmbedding=[],this.tailEmbedding=[],this.head=[],this.tail=[],this.epochsPerSample=[],this.epochOfNextSample=[],this.epochOfNextNegativeSample=[],this.epochsPerNegativeSample=[],this.moveOther=!0,this.initialAlpha=1,this.alpha=1,this.gamma=1,this.a=1.5769434603113077,this.b=.8950608779109733,this.dim=2,this.nEpochs=500,this.nVertices=0};function M(t,n){return t>n?n:t<-n?-n:t}function O(t,n){for(var e=0,a=0;a<t.length;a++)e+=Math.pow(t[a]-n[a],2);return e}function P(t,n){var e=g.linear(0,3*t,300).map((function(t){return t<n?1:t})),a=g.zeros(e.length).map((function(a,o){return e[o]>=n?Math.exp(-(e[o]-n)/t):a})),r=p.default({x:e,y:a},(function(t){var n=o(t,2),e=n[0],a=n[1];return function(t){return 1/(1+e*Math.pow(t,2*a))}}),{damping:1.5,initialValues:[.5,.5],gradientDifference:.1,maxIterations:100,errorTolerance:.01}).parameterValues,i=o(r,2);return{a:i[0],b:i[1]}}function x(t,n,e,a){return void 0===e&&(e=1),void 0===a&&(a=5),t.map((function(t,o,r){return-1===n[o]||-1===n[r]?t*Math.exp(-e):n[o]!==n[r]?t*Math.exp(-a):t}))}function y(t){t=l.normalize(t,"max");var n=l.transpose(t),e=l.pairwiseMultiply(n,t);return t=l.add(t,l.subtract(n,e)),l.eliminateZeros(t)}function k(t,n,e){for(var a=g.zeros(t.length).map((function(t){return g.zeros(e[0].length)})),o=0;o<t.length;o++)for(var r=0;r<t[0].length;r++)for(var i=0;i<e[0].length;i++)a[o][i]+=n[o][r]*e[t[o][r]][i];return a}n.findABParams=P,n.fastIntersection=x,n.resetLocalConnectivity=y,n.initTransform=k}));function Out(t){let n,e,a=t.length;for(;a;)e=Math.floor(Math.random()*a--),n=t[a],t[a]=t[e],t[e]=n;return t}function Put(t,n){return`${n}/${t}`}yP((function(t,n){Object.defineProperty(n,"__esModule",{value:!0}),n.UMAP=Mut.UMAP}));class xut{constructor(t){this.http=t,this.httpPathPrefix="data/plugin/npmi"}fetchData(t){return Ht(this.fetchAnnotations(t),this.fetchMetrics(t),this.fetchValues(t),this.fetchEmbeddings(t)).pipe(ft((([t,n,e,a])=>{const o={},r={};let i,c=0;for(const i of Object.keys(t))for(const s in t[i]){const l=t[i][s];Object.keys(a).length&&!r[l]&&a[i][s]&&a[i][s].some((t=>0!==t))&&(r[l]={vector:a[i][s],index:c,name:l},c+=1);const m=new Map;for(const t in n[i]){const a=n[i][t],o=kgt(a);let r=m.get(o);r||(r={nPMIValue:null,countValue:null,annotation:l,metric:o,run:i},m.set(o,r)),Pgt(a)?r.countValue=e[i][s][t]:xgt(a)&&(r.nPMIValue=e[i][s][t])}o[l]=[...o[l]?o[l]:[],...m.values()]}return Object.keys(r).length&&(i=(function s(t){const n=Object.keys(t);return{points:t,pointKeys:n,shuffledDataIndices:Out((e=n.length,[...new Array(e)].map(((t,n)=>n)))),hasUmapRun:!1};var e})(r)),{annotationData:o,metrics:n,embeddingDataSet:i}})),on((t=>t instanceof TR&&400<=t.status&&t.status<500?Z({annotationData:{},metrics:{},embeddingDataSet:void 0}):X(t))))}fetchAnnotations(t){return Ht(t.map((t=>this.http.get(`/experiment/${t}/${this.httpPathPrefix}/annotations`).pipe(ft((n=>(function e(t,n){return Object.fromEntries(Object.entries(t).map((([t,e])=>[Put(t,n),e])))})(n,t))))))).pipe(ft((t=>{let n={};for(const e of t)n=Object.assign(Object.assign({},n),e);return n})))}fetchMetrics(t){return Ht(t.map((t=>this.http.get(`/experiment/${t}/${this.httpPathPrefix}/metrics`).pipe(ft((n=>(function e(t,n){return Object.fromEntries(Object.entries(t).map((([t,e])=>[Put(t,n),e])))})(n,t))))))).pipe(ft((t=>{let n={};for(const e of t)n=Object.assign(Object.assign({},n),e);return n})))}fetchValues(t){return Ht(t.map((t=>this.http.get(`/experiment/${t}/${this.httpPathPrefix}/values`).pipe(ft((n=>(function e(t,n){return Object.fromEntries(Object.entries(t).map((([t,e])=>[Put(t,n),e])))})(n,t))))))).pipe(ft((t=>{let n={};for(const e of t)n=Object.assign(Object.assign({},n),e);return n})))}fetchEmbeddings(t){return Ht(t.map((t=>this.http.get(`/experiment/${t}/${this.httpPathPrefix}/embeddings`).pipe(ft((n=>(function e(t,n){return Object.fromEntries(Object.entries(t).map((([t,e])=>[Put(t,n),e])))})(n,t))))))).pipe(ft((t=>{let n={};for(const e of t)n=Object.assign(Object.assign({},n),e);return n})))}}xut.ɵfac=function t(n){return new(n||xut)(Za(mT))},xut.ɵprov=We({token:xut,factory:xut.ɵfac});class yut{}yut.ɵmod=xo({type:yut}),yut.ɵinj=Ge({factory:function t(n){return new(n||yut)},providers:[xut],imports:[[ST]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(yut,{imports:[ST]});class kut{constructor(t,n,e){this.actions$=t,this.store=n,this.dataSource=e,this.loadData$=Yv((()=>Wt(this.loadPluginData()).pipe(ft((()=>({}))))),{dispatch:!1})}loadPluginData(){return this.actions$.pipe(tw(Jdt),ye(this.store.select(Sdt),this.store.select(eR)),Gt((([,t,n])=>t!==fR.LOADING&&null!==n)),he((()=>this.store.dispatch(Qdt()))),Tt((([,,t])=>this.dataSource.fetchData(t).pipe(he((t=>{this.store.dispatch(Kdt(t))})),ft((()=>{})),on((()=>(this.store.dispatch($dt()),U)))))))}}kut.ɵfac=function t(n){return new(n||kut)(Za($v),Za(cv),Za(xut))},kut.ɵprov=We({token:kut,factory:kut.ɵfac});class vut{}vut.ɵmod=xo({type:vut}),vut.ɵinj=Ge({factory:function t(n){return new(n||vut)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(vut,{declarations:[vdt],exports:[vdt]});class wut{}wut.ɵmod=xo({type:wut}),wut.ɵinj=Ge({factory:function t(n){return new(n||wut)},imports:[[PO,VB,xV,P$]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(wut,{declarations:[Egt,Agt],imports:[PO,VB,xV,P$],exports:[Agt]});class Sut{}Sut.ɵmod=xo({type:Sut}),Sut.ɵinj=Ge({factory:function t(n){return new(n||Sut)},imports:[[PO,OH,PH,VB,Qgt,Zq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Sut,{declarations:[ept,apt],imports:[PO,OH,PH,VB,Qgt,Zq],exports:[apt]});class Eut{}Eut.ɵmod=xo({type:Eut}),Eut.ɵinj=Ge({factory:function t(n){return new(n||Eut)},imports:[[PO,Qgt]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Eut,{declarations:[opt],imports:[PO,Qgt],exports:[opt]});class Aut{}Aut.ɵmod=xo({type:Aut}),Aut.ɵinj=Ge({factory:function t(n){return new(n||Aut)},imports:[[PO,Qgt,Sut,Eut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Aut,{declarations:[spt,lpt],imports:[PO,Qgt,Sut,Eut],exports:[lpt]});class zut{}zut.ɵmod=xo({type:zut}),zut.ɵinj=Ge({factory:function t(n){return new(n||zut)},imports:[[PO,VB,oA]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(zut,{declarations:[Tgt,Dgt],imports:[PO,VB,oA],exports:[Dgt]});class Rut{}Rut.ɵmod=xo({type:Rut}),Rut.ɵinj=Ge({factory:function t(n){return new(n||Rut)},imports:[[PO,wut,Aut,zut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Rut,{declarations:[mpt],imports:[PO,wut,Aut,zut],exports:[mpt]});class Tut{}Tut.ɵmod=xo({type:Tut}),Tut.ɵinj=Ge({factory:function t(n){return new(n||Tut)},imports:[[PO,OH,oA,VB]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Tut,{declarations:[ppt,bpt],imports:[PO,OH,oA,VB],exports:[bpt]});class Dut{}Dut.ɵmod=xo({type:Dut}),Dut.ɵinj=Ge({factory:function t(n){return new(n||Dut)},imports:[[PO,OH,VB,oA,Tut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Dut,{declarations:[hpt,_pt],imports:[PO,OH,VB,oA,Tut],exports:[_pt]});class Iut{}Iut.ɵmod=xo({type:Iut}),Iut.ɵinj=Ge({factory:function t(n){return new(n||Iut)},imports:[[PO,OH,VB,xV]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Iut,{declarations:[Npt,Fpt],imports:[PO,OH,VB,xV],exports:[Fpt]});class Nut{}Nut.ɵmod=xo({type:Nut}),Nut.ɵinj=Ge({factory:function t(n){return new(n||Nut)},imports:[[PO,OH,VB,oA,Dpt,Iut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Nut,{declarations:[Bpt,Vpt],imports:[PO,OH,VB,oA,Dpt,Iut],exports:[Vpt]});class Fut{}Fut.ɵmod=xo({type:Fut}),Fut.ɵinj=Ge({factory:function t(n){return new(n||Fut)},imports:[[PO,OH,mV,VB]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Fut,{declarations:[qpt,Zpt],imports:[PO,OH,mV,VB],exports:[Zpt]});class Lut{}Lut.ɵmod=xo({type:Lut}),Lut.ɵinj=Ge({factory:function t(n){return new(n||Lut)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Lut,{declarations:[Upt],imports:[PO],exports:[Upt]});class Hut{}Hut.ɵmod=xo({type:Hut}),Hut.ɵinj=Ge({factory:function t(n){return new(n||Hut)},imports:[[Lut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Hut,{declarations:[Wpt],imports:[Lut],exports:[Wpt]});class But{}But.ɵmod=xo({type:But}),But.ɵinj=Ge({factory:function t(n){return new(n||But)},imports:[[PO,OH,mV,VB,oA]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(But,{declarations:[nbt,tbt],imports:[PO,OH,mV,VB,oA],exports:[nbt]});class Vut{}Vut.ɵmod=xo({type:Vut}),Vut.ɵinj=Ge({factory:function t(n){return new(n||Vut)},imports:[[PO,Nut,Fut,Hut,vA,But]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Vut,{declarations:[obt,rbt],imports:[PO,Nut,Fut,Hut,vA,But],exports:[rbt]});class jut{}jut.ɵmod=xo({type:jut}),jut.ɵinj=Ge({factory:function t(n){return new(n||jut)},imports:[[PO]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(jut,{declarations:[cbt,sbt],imports:[PO],exports:[sbt]});class Uut{}Uut.ɵmod=xo({type:Uut}),Uut.ɵinj=Ge({factory:function t(n){return new(n||Uut)},imports:[[PO,VB,oA,jut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Uut,{declarations:[gbt,pbt],imports:[PO,VB,oA,jut],exports:[pbt]});class Wut{}Wut.ɵmod=xo({type:Wut}),Wut.ɵinj=Ge({factory:function t(n){return new(n||Wut)},imports:[[PO,OH,mV,VB,iK,Rut,oA,Dut,Vut,Uut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Wut,{declarations:[Cbt,Mbt],imports:[PO,OH,mV,VB,iK,Rut,oA,Dut,Vut,Uut],exports:[Mbt]});class Gut{}Gut.ɵmod=xo({type:Gut}),Gut.ɵinj=Ge({factory:function t(n){return new(n||Gut)},imports:[[PO,OH,mV,VB,iK,Rut,oA,Vut,Uut]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Gut,{declarations:[vbt,wbt],imports:[PO,OH,mV,VB,iK,Rut,oA,Vut,Uut],exports:[wbt]});class Yut{}Yut.ɵmod=xo({type:Yut}),Yut.ɵinj=Ge({factory:function t(n){return new(n||Yut)},imports:[[PO,vut,Wut,Gut,yut,Iv.forFeature(Odt,(function qut(t,n){return vgt(t,n)})),fw.forFeature([kut]),gq.forPlugin("npmi",Tbt)]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Yut,{declarations:[Rbt,Tbt],imports:[PO,vut,Wut,Gut,yut,Dv,uw,gq],exports:[Tbt]});class Zut{}Zut.ɵfac=function t(n){return new(n||Zut)},Zut.ɵcmp=_o({type:Zut,selectors:[["text-dashboard"]],decls:1,vars:0,template:function t(n,e){1&n&&Jp(0," This is the text dashboard ")},encapsulation:2,changeDetection:0});class Xut{}Xut.ɵmod=xo({type:Xut}),Xut.ɵinj=Ge({factory:function t(n){return new(n||Xut)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Xut,{declarations:[Zut],exports:[Zut]});class Jut{}Jut.ɵfac=function t(n){return new(n||Jut)},Jut.ɵprov=We({token:Jut,factory:Jut.ɵfac});class Qut{constructor(t){this.http=t,this.httpPathPrefix="data/plugin/text_v2"}fetchRunToTag(){return this.http.get(this.httpPathPrefix+"/tags").pipe(ft((t=>{const n=new Map;return Object.entries(t).forEach((([t,e])=>{n.set(t,e)})),n})))}fetchTextData(t,n){const e=new URLSearchParams({run:t,tag:n});return this.http.get(this.httpPathPrefix+`/text?${e.toString()}`).pipe(ft((t=>t.map((t=>({originalShape:t.original_shape,step:t.step,stringArray:t.string_array,wallTimeInMs:1e3*t.wall_time,truncated:t.truncated}))))))}}Qut.ɵfac=function t(n){return new(n||Qut)(Za(mT))},Qut.ɵprov=We({token:Qut,factory:Qut.ɵfac});class Kut{}Kut.ɵmod=xo({type:Kut}),Kut.ɵinj=Ge({factory:function t(n){return new(n||Kut)},providers:[Qut,{provide:Jut,useExisting:Qut}],imports:[[ST]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Kut,{imports:[ST]});const $ut=Ok("[Text] Text Plugin Loaded"),tft=Ok("[Text] Runs To Tag Loaded",{_as:"props",_p:void 0}),nft=Ok("[Text] Tag Group Visibility Changed",{_as:"props",_p:void 0}),eft=Ok("[Text] Text Data Loaded Loaded",{_as:"props",_p:void 0}),aft="text",oft=uv(aft);pv(oft,(t=>t.runToTags));const rft=pv(oft,(t=>{const n=new Set,e=new Set;for(const a of t.visibleRunTags.values())for(const t of a){const a=JSON.stringify(t);n.has(a)||(n.add(a),e.add(t))}return[...e]})),ift=pv(oft,((t,n)=>{const e=t.data.get(n.run);return e&&e.get(n.tag)||null}));class cft{constructor(t,n,e){this.actions$=t,this.store=n,this.dataSource=e,this.loadRunToTags$=Yv((()=>this.actions$.pipe(tw($ut),se((()=>this.dataSource.fetchRunToTag().pipe(he((t=>{this.store.dispatch(tft({runToTags:t}))})),ft((()=>{}))))))),{dispatch:!1}),this.loadData$=Yv((()=>Wt(this.actions$.pipe(tw(nft),se((({visibleTextCards:t})=>Ht(t.map((({run:t,tag:n})=>this.store.select(ift,{run:t,tag:n}).pipe((function e(t,n){const e=arguments.length>=2;return a=>a.pipe(t?Gt(((n,e)=>t(n,e,a))):b,Un(1),e?pn(n):En((()=>new bt)))})(),ft((e=>({run:t,tag:n,textData:e}))))))).pipe(ft((t=>t.filter((({textData:t})=>null===t)).map((({run:t,tag:n})=>({run:t,tag:n}))))))))),this.actions$.pipe(tw(uI,fI),ye(this.store.select(rft)),ft((([,t])=>t)))).pipe(Tt((t=>Ht(t.map((t=>this.fetchTextData(t)))))))),{dispatch:!1})}fetchTextData(t){const{run:n,tag:e}=t;return this.dataSource.fetchTextData(n,e).pipe(he((t=>{this.store.dispatch(eft({run:n,tag:e,stepData:t}))})),ft((()=>{})))}}cft.ɵfac=function t(n){return new(n||cft)(Za($v),Za(cv),Za(Jut))},cft.ɵprov=We({token:cft,factory:cft.ɵfac});const sft=Uv({runToTags:new Map([["run1",["a/b","a/c"]],["run2",["a/b","a/d"]],["run3",["c","a/b"]]]),data:new Map([["run1",new Map([["a/b",[{originalShape:[3],step:0,stringArray:[["foo","bar","baz"]],wallTimeInMs:15778656e5,truncated:!1},{originalShape:[3],step:1,stringArray:[["foo","baz"]],wallTimeInMs:1577865601e3,truncated:!1}]],["a/c",[{originalShape:[3],step:0,stringArray:[["We conducted an experiment and found the following data:\n\nPounds of chocolate | Happiness\n---|---\n0 | 1\n1 | 4\n2 | 9\n3 | 16\n4 | 25\n5 | 36\n6 | 49\n7 | 64\n8 | 81\n9 | 100\n10 | 121"]],wallTimeInMs:15778656e5,truncated:!1},{originalShape:[3],step:1,stringArray:[["×","**0**","**1**","**2**","**3**","**4**","**5**"],["**0**","0","0","0","0","0","0"],["**1**","0","1","2","3","4","5"],["**2**","0","2","4","6","8","10"],["**3**","0","3","6","9","12","15"],["**4**","0","4","8","12","16","20"],["**5**","0","5","10","15","20","25"]],wallTimeInMs:1577865601e3,truncated:!1}]]])]]),visibleRunTags:new Map});class lft{}lft.ɵmod=xo({type:lft}),lft.ɵinj=Ge({factory:function t(n){return new(n||lft)},imports:[[PO,Xut,gq.forPlugin("text_v2",Zut),Kut,Iv.forFeature(aft,(function mft(t,n){return sft(t,n)})),fw.forFeature([cft])]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(lft,{imports:[PO,Xut,gq,Kut,Dv,uw]});class dft{}var gft;dft.ɵmod=xo({type:dft}),dft.ɵinj=Ge({factory:function t(n){return new(n||dft)},imports:[[pq,hdt,Yut,lft]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(dft,{imports:[pq,hdt,Yut,lft]}),(function(t){t.CUSTOM_ELEMENT="CUSTOM_ELEMENT",t.IFRAME="IFRAME",t.NG_COMPONENT="NG_COMPONENT",t.NONE="NONE"})(gft||(gft={}));const pft=["pluginContainer"],bft=["ngPluginContainer"];function uft(t,n){1&t&&ap(0)}function fft(t,n){if(1&t&&(np(0),Yg(1,uft,1,0,"ng-container",9),ep()),2&t){const t=gp(2),n=qg(6);ws(1),Jg("ngTemplateOutlet",t.environmentFailureNotFoundTemplate?t.environmentFailureNotFoundTemplate:n)}}function hft(t,n){1&t&&ap(0)}function _ft(t,n){if(1&t&&(np(0),Yg(1,hft,1,0,"ng-container",9),ep()),2&t){const t=gp(2),n=qg(6);ws(1),Jg("ngTemplateOutlet",t.environmentFailureUnknownTemplate?t.environmentFailureUnknownTemplate:n)}}function Cft(t,n){if(1&t&&(np(0),Kg(1,"h3",10),Jp(2," There’s no dashboard by the name of “"),Kg(3,"code"),Jp(4),$g(),Jp(5,"”. "),$g(),Kg(6,"p"),Jp(7,"You can select a dashboard from the list above."),$g(),Kg(8,"p"),ap(9,11),$g(),ep()),2&t){const t=gp(2),n=qg(8);ws(4),Qp(t.activePluginId),ws(5),Jg("ngTemplateOutlet",n)}}function Mft(t,n){if(1&t&&(np(0),Kg(1,"h3",12),Jp(2," No dashboards are active for the current data set. "),$g(),Kg(3,"p"),Jp(4,"Probable causes:"),$g(),Kg(5,"ul"),Kg(6,"li"),Jp(7,"You haven’t written any data to your event files."),$g(),Kg(8,"li"),Jp(9,"TensorBoard can’t find your event files."),$g(),$g(),Jp(10," If you’re new to using TensorBoard, and want to find out how to add data and set up your event files, check out the "),Kg(11,"a",13),Jp(12,"README"),$g(),Jp(13," and perhaps the "),Kg(14,"a",14),Jp(15,"TensorBoard tutorial"),$g(),Jp(16,". "),Kg(17,"p"),Jp(18," If you think TensorBoard is configured properly, please see "),Kg(19,"a",15),Jp(20,"the section of the README devoted to missing data problems"),$g(),Jp(21," and consider filing an issue on GitHub. "),$g(),Kg(22,"p"),ap(23,11),$g(),ep()),2&t){gp(2);const t=qg(8);ws(23),Jg("ngTemplateOutlet",t)}}function Oft(t,n){if(1&t&&(Kg(0,"div",6),Kg(1,"div",7),Yg(2,fft,2,1,"ng-container",8),Yg(3,_ft,2,1,"ng-container",8),Yg(4,Cft,10,2,"ng-container",8),Yg(5,Mft,24,1,"ng-container",8),$g(),$g()),2&t){const t=gp();Jg("ngSwitch",t.pluginLoadState),ws(2),Jg("ngSwitchCase",t.PluginLoadState.ENVIRONMENT_FAILURE_NOT_FOUND),ws(1),Jg("ngSwitchCase",t.PluginLoadState.ENVIRONMENT_FAILURE_UNKNOWN),ws(1),Jg("ngSwitchCase",t.PluginLoadState.UNKNOWN_PLUGIN_ID),ws(1),Jg("ngSwitchCase",t.PluginLoadState.NO_ENABLED_PLUGINS)}}function Pft(t,n){if(1&t&&(Kg(0,"h3",16),Jp(1,"Data could not be loaded."),$g(),Kg(2,"p"),Jp(3,"The TensorBoard server may be down or inaccessible."),$g(),Kg(4,"p"),ap(5,11),$g()),2&t){gp();const t=qg(8);ws(5),Jg("ngTemplateOutlet",t)}}function xft(t,n){if(1&t&&(Kg(0,"p",19),Kg(1,"i"),Jp(2,"Log directory: "),Kg(3,"span"),Jp(4),$g(),$g(),$g()),2&t){const t=gp(2);ws(4),Qp(t.dataLocation)}}function yft(t,n){if(1&t&&(Kg(0,"span",17),Jp(1),yf(2,"date"),$g(),Yg(3,xft,5,1,"p",18)),2&t){const t=gp();ws(1),Kp("Last reload: ",vf(2,2,t.lastUpdated,"medium"),""),ws(2),Jg("ngIf",t.dataLocation)}}var kft;!(function(t){t[t.ENVIRONMENT_FAILURE_NOT_FOUND=0]="ENVIRONMENT_FAILURE_NOT_FOUND",t[t.ENVIRONMENT_FAILURE_UNKNOWN=1]="ENVIRONMENT_FAILURE_UNKNOWN",t[t.NO_ENABLED_PLUGINS=2]="NO_ENABLED_PLUGINS",t[t.UNKNOWN_PLUGIN_ID=3]="UNKNOWN_PLUGIN_ID",t[t.LOADED=4]="LOADED",t[t.LOADING=5]="LOADING"})(kft||(kft={}));class vft{constructor(t,n){this.componentFactoryResolver=t,this.pluginRegistry=n,this.experimentPluginHostLib=document.createElement("tf-experimental-plugin-host-lib"),this.PluginLoadState=kft,this.LoadingMechanismType=gft,this.pluginInstances=new Map}ngOnChanges(t){var n;if(!this.isFeatureFlagsLoaded||!this.activeKnownPlugin)return;const e=Boolean(this.activeKnownPlugin&&!this.pluginInstances.has(this.activeKnownPlugin.id));if(t.activeKnownPlugin||t.isFeatureFlagsLoaded){const a=null===(n=t.activeKnownPlugin)||void 0===n?void 0:n.previousValue;if(a&&a.id!==this.activeKnownPlugin.id&&this.hidePlugin(a),e){const t=this.createPlugin(this.activeKnownPlugin);t&&this.pluginInstances.set(this.activeKnownPlugin.id,t)}else this.showPlugin(this.activeKnownPlugin)}(e||t.lastUpdated)&&this.reload(this.activeKnownPlugin,e)}hidePlugin(t){if(!this.pluginInstances.has(t.id))return;const n=this.pluginInstances.get(t.id);Object.assign(n.style,{maxHeight:0,overflow:"hidden",visibility:"hidden",position:"absolute"})}showPlugin(t){if(!this.pluginInstances.has(t.id))return;const n=this.pluginInstances.get(t.id);Object.assign(n.style,{maxHeight:null,overflow:null,visibility:null,position:null})}createPlugin(t){let n=null;switch(t.loading_mechanism.type){case gft.CUSTOM_ELEMENT:n=document.createElement(t.loading_mechanism.element_name),n.reloadOnReady=!1,n.featureFlags=this.featureFlags,this.pluginsContainer.nativeElement.appendChild(n);break;case gft.IFRAME:n=document.createElement("iframe"),n.setAttribute("src",`data/plugin_entry.html?name=${t.id}`),this.experimentPluginHostLib.registerPluginIframe(n,t.id),this.pluginsContainer.nativeElement.appendChild(n);break;case gft.NG_COMPONENT:const e=this.pluginRegistry.getComponent(t.id);if(e){const t=this.componentFactoryResolver.resolveComponentFactory(e);n=this.ngPluginContainer.createComponent(t).location.nativeElement}else console.error(`No registered Angular component for plugin: ${t.id}`);break;case gft.NONE:break;default:console.error("Unexpected plugin")}return n}reload(t,n){if(!n&&t.disable_reload)return;const e=this.pluginInstances.get(t.id);e&&e.reload&&e.reload()}}vft.ɵfac=function t(n){return new(n||vft)(Zg(Pu),Zg(gq))},vft.ɵcmp=_o({type:vft,selectors:[["plugins-component"]],viewQuery:function t(n,e){var a;1&n&&(jf(pft,!0,xu),jf(bft,!0,$u)),2&n&&(Vf(a=Zf())&&(e.pluginsContainer=a.first),Vf(a=Zf())&&(e.ngPluginContainer=a.first))},inputs:{activePluginId:"activePluginId",activeKnownPlugin:"activeKnownPlugin",pluginLoadState:"pluginLoadState",dataLocation:"dataLocation",isFeatureFlagsLoaded:"isFeatureFlagsLoaded",featureFlags:"featureFlags",lastUpdated:"lastUpdated",environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},features:[pr],decls:9,vars:1,consts:[[1,"plugins"],["pluginContainer",""],["ngPluginContainer",""],["class","warning",3,"ngSwitch",4,"ngIf"],["environmentFailureDefaultTemplate",""],["dateAndDataLocation",""],[1,"warning",3,"ngSwitch"],[1,"warning-message"],[4,"ngSwitchCase"],[4,"ngTemplateOutlet"],[1,"unknown-plugin"],[3,"ngTemplateOutlet"],[1,"no-active-plugin"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md"],["href","https://www.tensorflow.org/get_started/summaries_and_tensorboard"],["href","https://github.com/tensorflow/tensorboard/blob/master/README.md#my-tensorboard-isnt-showing-any-data-whats-wrong"],[1,"environment-not-loaded"],[1,"last-reload-time"],["class","data-location",4,"ngIf"],[1,"data-location"]],template:function t(n,e){1&n&&(Kg(0,"div",0,1),ap(2,null,2),$g(),Yg(4,Oft,6,5,"div",3),Yg(5,Pft,6,1,"ng-template",null,4,Kf),Yg(7,yft,4,5,"ng-template",null,5,Kf)),2&n&&(ws(4),Jg("ngIf",e.pluginLoadState!==e.PluginLoadState.LOADED&&e.pluginLoadState!==e.PluginLoadState.LOADING))},directives:[WM,ZM,XM,tO],pipes:[lO],styles:["[_nghost-%COMP%] {\n        display: block;\n        position: relative;\n      }\n      .plugins[_ngcontent-%COMP%] {\n        height: 100%;\n        position: relative;\n      }\n      .warning[_ngcontent-%COMP%] {\n        background-color: #fff;\n        bottom: 0;\n        left: 0;\n        position: absolute;\n        right: 0;\n        top: 0;\n      }\n      .warning-message[_ngcontent-%COMP%] {\n        margin: 80px auto 0;\n        max-width: 540px;\n      }\n      .last-reload-time[_ngcontent-%COMP%] {\n        font-style: italic;\n      }\n      .plugins[_ngcontent-%COMP%]     iframe {\n        border: 0;\n        display: block;\n        height: 100%;\n        width: 100%;\n      }"],changeDetection:0});const wft=pv(FI,NI,((t,n)=>n&&t[n]?Object.assign({id:n},t[n]):null)),Sft=pv(II,(t=>t.lastLoadedTimeInMs));class Eft{constructor(t){this.store=t,this.activeKnownPlugin$=this.store.select(wft),this.activePluginId$=this.store.select(NI),this.pluginLoadState$=Et(this.activeKnownPlugin$,this.activePluginId$,this.store.select(II)).pipe(ft((([t,n,e])=>null!==e.failureCode?e.failureCode===sj.NOT_FOUND?kft.ENVIRONMENT_FAILURE_NOT_FOUND:kft.ENVIRONMENT_FAILURE_UNKNOWN:null!==t?kft.LOADED:null===e.lastLoadedTimeInMs&&e.state===fR.LOADING?kft.LOADING:n?kft.UNKNOWN_PLUGIN_ID:kft.NO_ENABLED_PLUGINS))),this.lastLoadedTimeInMs$=this.store.select(Sft),this.dataLocation$=this.store.select(LI).pipe(ft((t=>t.data_location))),this.isFeatureFlagsLoaded$=this.store.select(mR),this.featureFlags$=this.store.select(dR)}}Eft.ɵfac=function t(n){return new(n||Eft)(Zg(cv))},Eft.ɵcmp=_o({type:Eft,selectors:[["plugins"]],inputs:{environmentFailureNotFoundTemplate:"environmentFailureNotFoundTemplate",environmentFailureUnknownTemplate:"environmentFailureUnknownTemplate"},decls:8,vars:23,consts:[[3,"activeKnownPlugin","activePluginId","dataLocation","lastUpdated","pluginLoadState","isFeatureFlagsLoaded","featureFlags","environmentFailureNotFoundTemplate","environmentFailureUnknownTemplate"]],template:function t(n,e){1&n&&(tp(0,"plugins-component",0),yf(1,"async"),yf(2,"async"),yf(3,"async"),yf(4,"async"),yf(5,"async"),yf(6,"async"),yf(7,"async")),2&n&&Jg("activeKnownPlugin",kf(1,9,e.activeKnownPlugin$))("activePluginId",kf(2,11,e.activePluginId$))("dataLocation",kf(3,13,e.dataLocation$))("lastUpdated",kf(4,15,e.lastLoadedTimeInMs$))("pluginLoadState",kf(5,17,e.pluginLoadState$))("isFeatureFlagsLoaded",kf(6,19,e.isFeatureFlagsLoaded$))("featureFlags",kf(7,21,e.featureFlags$))("environmentFailureNotFoundTemplate",e.environmentFailureNotFoundTemplate)("environmentFailureUnknownTemplate",e.environmentFailureUnknownTemplate)},styles:["plugins-component[_ngcontent-%COMP%] { height: 100%; }"],changeDetection:0});class Aft{}Aft.ɵmod=xo({type:Aft}),Aft.ɵinj=Ge({factory:function t(n){return new(n||Aft)},imports:[[uj,PO,gq]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Aft,{declarations:[Eft,vft],imports:[uj,PO,gq],exports:[Eft]}),Co(Eft,[HM,BM,jM,WM,tO,$M,ZM,XM,JM,QM,KM,Eft,vft],[oO,sO,rO,pO,OO,fO,hO,cO,_O,lO,dO,gO,bO]);class zft{constructor(t,n){this.store=t,this.document=n,this.onVisibilityChange=this.onVisibilityChangeImpl.bind(this),this.reloadEnabled$=this.store.pipe(lv(HI)),this.reloadPeriodInMs$=this.store.pipe(lv(BI)),this.reloadTimerId=null,this.missedAutoReload=!1}ngOnInit(){this.document.addEventListener("visibilitychange",this.onVisibilityChange),Et(this.reloadEnabled$.pipe(vn()),this.reloadPeriodInMs$.pipe(vn())).subscribe((([t,n])=>{this.cancelLoad(),t&&this.load(n)}))}onVisibilityChangeImpl(){"visible"===this.document.visibilityState&&this.missedAutoReload&&(this.missedAutoReload=!1,this.store.dispatch(fI()))}load(t){this.reloadTimerId=setTimeout((()=>{"visible"===this.document.visibilityState?this.store.dispatch(fI()):this.missedAutoReload=!0,this.load(t)}),t)}cancelLoad(){null!==this.reloadTimerId&&clearTimeout(this.reloadTimerId),this.reloadTimerId=null}ngOnDestroy(){this.cancelLoad(),this.document.removeEventListener("visibilitychange",this.onVisibilityChange)}}zft.ɵfac=function t(n){return new(n||zft)(Zg(cv),Zg(zC))},zft.ɵcmp=_o({type:zft,selectors:[["reloader"]],decls:0,vars:0,template:function t(n,e){},encapsulation:2,changeDetection:0});class Rft{}Rft.ɵfac=function t(n){return new(n||Rft)},Rft.ɵcmp=_o({type:Rft,selectors:[["tensorboard-wrapper-component"]],decls:2,vars:0,consts:[[1,"plugins"]],template:function t(n,e){1&n&&(tp(0,"plugins",0),tp(1,"reloader"))},directives:[Eft,zft],styles:["[_nghost-%COMP%] {\n        display: flex;\n        flex-direction: column;\n        height: 100%;\n      }\n\n      .plugins[_ngcontent-%COMP%] {\n        flex: 1 1;\n        overflow: auto;\n        position: relative;\n      }"],changeDetection:0});class Tft{}Tft.ɵfac=function t(n){return new(n||Tft)},Tft.ɵprov=We({token:Tft,factory:Tft.ɵfac});const Dft="smoothing";let Ift=class extends Tft{getMetricsPinnedCards(t){return Et([t.select(iD),t.select(sD)]).pipe(ft((([t,n])=>{if(!t.length&&!n.length)return[];const e=[...t.map((({plugin:t,tag:n,sample:e,runId:a})=>{const o={plugin:t,tag:n};return fT(t)&&(o.runId=a),bT(t)&&(o.sample=e),o})),...n];return[{key:"pinnedCards",value:JSON.stringify(e)}]})))}getFeatureFlagStates(t){return Et([t.select(pR),t.select(gR)]).pipe(ft((([t,n])=>{const e=t.map((t=>({key:vj,value:t})));return void 0!==n.enableGpuChart&&e.push({key:wj,value:String(n.enableGpuChart)}),e})))}serializeStateToQueryParams(t){return Et([this.getMetricsPinnedCards(t),this.getFeatureFlagStates(t),t.select(uD).pipe(ft((t=>t===YT.scalarSmoothing?[]:[{key:Dft,value:String(t)}])))]).pipe(ft((t=>t.flat())))}deserializeQueryParams(t){let n=null,e=null;for(const{key:a,value:o}of t)switch(a){case"pinnedCards":n=Nft(o);break;case Dft:e=Number(o)}return{metrics:{pinnedCards:n||[],smoothing:e}}}};function Nft(t){let n;try{n=JSON.parse(t)}catch(t){return null}if(!Array.isArray(n))return null;const e=[];for(const t of n){const n="string"==typeof t.runId,o="number"==typeof t.sample,r="string"==typeof t.tag,i=n||void 0===t.runId,c=o||void 0===t.sample;if(!("string"==typeof t.plugin&&r&&i&&c))continue;if((a=t.plugin)!==gT.SCALARS&&a!==gT.HISTOGRAMS&&a!==gT.IMAGES)continue;if(!t.tag)continue;if(fT(t.plugin)){if(!t.runId)continue}else if(t.runId)continue;if(o){if(!bT(t.plugin))continue;if(!Number.isInteger(t.sample)||t.sample<0)continue}const s={plugin:t.plugin,tag:t.tag};n&&(s.runId=t.runId),o&&(s.sample=t.sample),e.push(s)}var a;return e}function Fft(t,n){return`${n}/${t}`}Ift=(function Lft(t,n,e,a){var o,r=arguments.length,i=r<3?n:null===a?a=Object.getOwnPropertyDescriptor(n,e):a;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)i=Reflect.decorate(t,n,e,a);else for(var c=t.length-1;c>=0;c--)(o=t[c])&&(i=(r<3?o(i):r>3?o(n,e,i):o(n,e))||i);return r>3&&i&&Object.defineProperty(n,e,i),i})([id()],Ift);class Hft{constructor(t){this.http=t}fetchRuns(t){return this.http.get("data/runs").pipe(ft((n=>n.map((n=>({id:Fft(n,t),name:n,startTime:0}))))))}fetchHparamsMetadata(t){return Z({hparamSpecs:[],metricSpecs:[],runToHparamsAndMetrics:{}})}}Hft.ɵfac=function t(n){return new(n||Hft)(Za(mT))},Hft.ɵprov=We({token:Hft,factory:Hft.ɵfac});class Bft{}Bft.ɵmod=xo({type:Bft}),Bft.ɵinj=Ge({factory:function t(n){return new(n||Bft)},providers:[{provide:SD,useClass:Hft}]});class Vft{constructor(t,n,e){this.actions$=t,this.store=n,this.runsDataSource=e,this.loadRunsOnRunTableShown$=Yv((()=>this.actions$.pipe(tw(XQ),Tt((({experimentIds:t})=>this.getExperimentsWithLoadState(t,(t=>t===fR.FAILED||t===fR.NOT_LOADED)).pipe(Gt((t=>!!t.length)),Tt((n=>this.fetchAllRunsList(t,n)))))))),{dispatch:!1}),this.experimentsWithStaleRunsOnRouteChange$=this.actions$.pipe(tw(KV),ye(this.store.select(aR)),vn((([,t],[,n])=>t===n)),ye(this.store.select(eR)),Gt((([,t])=>!!t)),ft((([,t])=>t)),Tt((t=>this.getExperimentsWithLoadState(t,(t=>t===fR.FAILED||t===fR.NOT_LOADED)).pipe(ft((n=>({experimentIds:t,experimentIdsToBeFetched:n}))))))),this.experimentsWithStaleRunsOnReload$=this.actions$.pipe(tw(fI,uI),ye(this.store.select(eR)),Gt((([,t])=>!!t)),ft((([,t])=>t)),Tt((t=>this.getExperimentsWithLoadState(t,(t=>t!==fR.LOADING)).pipe(ft((n=>({experimentIds:t,experimentIdsToBeFetched:n}))))))),this.loadRunsOnNavigationOrReload$=Yv((()=>Wt(this.experimentsWithStaleRunsOnRouteChange$,this.experimentsWithStaleRunsOnReload$).pipe(Tt((({experimentIds:t,experimentIdsToBeFetched:n})=>this.fetchAllRunsList(t,n))))),{dispatch:!1})}getRunsListLoadState(t){return this.store.select(FD,{experimentId:t}).pipe(Tn(1))}getExperimentsWithLoadState(t,n){return Ht(t.map((t=>this.getRunsListLoadState(t)))).pipe(ft((e=>t.filter(((t,a)=>n(e[a].state))))))}fetchAllRunsList(t,n){return Z({experimentIds:t,experimentIdsToBeFetched:n}).pipe(he((()=>{this.store.dispatch(HQ({experimentIds:t,requestedExperimentIds:n}))})),Tt((()=>{const e=new Set(n);return Ht(t.map((t=>e.has(t)?this.fetchRunsForExperiment(t):this.maybeWaitForRunsAndGetRuns(t))))})),ft((t=>{const n={},e=[];for(const a of t)e.push(...a.runs),a.fromRemote&&(n[a.experimentId]={runs:a.runs,metadata:a.metadata});return{newRunsAndMetadata:n,runsForAllExperiments:e}})),he((({newRunsAndMetadata:n,runsForAllExperiments:e})=>{this.store.dispatch(BQ({experimentIds:t,newRunsAndMetadata:n,runsForAllExperiments:e}))})),on((e=>(this.store.dispatch(VQ({experimentIds:t,requestedExperimentIds:n})),Z(null)))),ft((()=>null)))}maybeWaitForRunsAndGetRuns(t){return this.store.select(FD,{experimentId:t}).pipe(Gt((t=>t.state!==fR.LOADING)),Tn(1),Tt((t=>t.state===fR.FAILED?X(new Error("Pending request failed")):Z(t))),ye(this.store.select(ID,{experimentId:t})),ft((([,n])=>({fromRemote:!1,experimentId:t,runs:n}))))}fetchRunsForExperiment(t){return Ht([this.runsDataSource.fetchRuns(t),this.runsDataSource.fetchHparamsMetadata(t)]).pipe(ft((([n,e])=>({fromRemote:!0,experimentId:t,runs:n,metadata:e}))))}}Vft.ɵfac=function t(n){return new(n||Vft)(Za($v),Za(cv),Za(SD))},Vft.ɵprov=We({token:Vft,factory:Vft.ɵfac});const jft=["#425066","#12b5cb","#e52592","#f9ab00","#9334e6","#7cb342","#e8710a"];let Uft=0;const Wft=Uv({runIds:{},runIdToExpId:{},runMetadata:{},runsLoadState:{},hparamAndMetricSpec:{},selectionState:new Map},jv(HQ,((t,n)=>{const e=Object.assign({},t.runsLoadState);for(const t of n.requestedExperimentIds)e[t]=Object.assign(Object.assign({lastLoadedTimeInMs:null},e[t]),{state:fR.LOADING});return Object.assign(Object.assign({},t),{runsLoadState:e})})),jv(BQ,((t,n)=>{const e=Object.assign({},t.runIds),a=Object.assign({},t.runMetadata),o=Object.assign({},t.runIdToExpId),r=Object.assign({},t.runsLoadState),i=Object.assign({},t.hparamAndMetricSpec),c=new Map(t.selectionState);for(const t of Object.keys(n.newRunsAndMetadata)){const{runs:c,metadata:s}=n.newRunsAndMetadata[t];e[t]=c.map((({id:t})=>t)),r[t]=Object.assign(Object.assign({},r[t]),{lastLoadedTimeInMs:Date.now(),state:fR.LOADED});for(const n of c){const e=s.runToHparamsAndMetrics[n.id];a[n.id]=Object.assign(Object.assign({},n),{hparams:e?e.hparams:null,metrics:e?e.metrics:null}),o[n.id]=t}i[t]={hparams:s.hparamSpecs,metrics:s.metricSpecs}}const s=AD(n.experimentIds);if(c.has(s)){const t=new Map(c.get(s));for(const e of n.runsForAllExperiments)t.has(e.id)||t.set(e.id,!1);c.set(s,t)}else{const t=new Map,e=n.runsForAllExperiments.length<=40;for(const a of n.runsForAllExperiments)t.set(a.id,e);c.set(s,t)}return Object.assign(Object.assign({},t),{runIds:e,runIdToExpId:o,runMetadata:a,runsLoadState:r,hparamAndMetricSpec:i,selectionState:c})})),jv(VQ,((t,n)=>{const e=Object.assign({},t.runsLoadState);for(const t of n.requestedExperimentIds)e[t]=Object.assign(Object.assign({lastLoadedTimeInMs:null},e[t]),{state:fR.FAILED});return Object.assign(Object.assign({},t),{runsLoadState:e})})),jv(jQ,((t,{experimentIds:n,runId:e})=>{var a;const o=AD(n),r=new Map(t.selectionState),i=new Map(null!==(a=r.get(o))&&void 0!==a?a:[]);return i.set(e,!Boolean(i.get(e))),r.set(o,i),Object.assign(Object.assign({},t),{selectionState:r})})),jv(UQ,((t,{experimentIds:n,runIds:e})=>{var a;const o=AD(n),r=new Map(t.selectionState),i=new Map(null!==(a=r.get(o))&&void 0!==a?a:[]),c=!e.every((t=>Boolean(i.get(t))));for(const t of e)i.set(t,c);return r.set(o,i),Object.assign(Object.assign({},t),{selectionState:r})})),jv(WQ,((t,{experimentIds:n})=>{var e;const a=AD(n),o=new Map(t.selectionState),r=new Map(null!==(e=o.get(a))&&void 0!==e?e:[]);for(const e of n)for(const n of t.runIds[e])r.set(n,!0);return o.set(a,r),Object.assign(Object.assign({},t),{selectionState:o})}))),{initialState:Gft,reducers:Yft}=EK({paginationOption:{pageIndex:0,pageSize:10},regexFilter:"",sort:{key:null,direction:GJ.UNSET},hparamFilters:new Map,metricFilters:new Map,runColorOverride:new Map},{hparamDefaultFilters:new Map,metricDefaultFilters:new Map,defaultRunColor:new Map}),qft=zK(Uv(Gft,jv(GQ,((t,{pageSize:n,pageIndex:e})=>Object.assign(Object.assign({},t),{paginationOption:{pageSize:n,pageIndex:e}}))),jv(qQ,((t,n)=>Object.assign(Object.assign({},t),{regexFilter:n.regexString,paginationOption:Object.assign(Object.assign({},t.paginationOption),{pageIndex:0})}))),jv(YQ,((t,n)=>Object.assign(Object.assign({},t),{sort:{key:n.key,direction:n.direction}}))),jv(BQ,((t,n)=>{const e=new Map(t.defaultRunColor);return n.runsForAllExperiments.filter((t=>!Boolean(e.get(t.id)))).forEach((t=>{e.set(t.id,(function n(){const t=jft[Uft];return Uft=(Uft+1)%jft.length,t})())})),Object.assign(Object.assign({},t),{defaultRunColor:e})})),jv(ZQ,((t,{runId:n,newColor:e})=>{const a=new Map(t.runColorOverride);return a.set(n,e),Object.assign(Object.assign({},t),{runColorOverride:a})})),jv(JQ,((t,{hparamName:n,filterValues:e,includeUndefined:a})=>{const o=t.hparamDefaultFilters.get(n);if(!o)throw new Error(`Unknown hparams: ${n}`);if(o.type===wD.INTERVAL)throw new Error("Invariant error: Hparams filter is INTERVAL but got a ' +\n               'DISCRETE change");const r=Object.assign(Object.assign({},o),t.hparamFilters.get(n)),i=new Map(t.hparamFilters);return i.set(n,Object.assign(Object.assign({},r),{includeUndefined:a,filterValues:e})),Object.assign(Object.assign({},t),{hparamFilters:i})})),jv(QQ,((t,n)=>{const{hparamName:e,filterLowerValue:a,filterUpperValue:o,includeUndefined:r}=n,i=t.hparamDefaultFilters.get(e);if(!i)throw new Error(`Unknown hparams: ${e}`);if(i.type===wD.DISCRETE)throw new Error("Invariant error: Hparams filter is DISCRETE but got a ' +\n               'INTERVAL change");const c=Object.assign(Object.assign({},i),t.hparamFilters.get(e)),s=new Map(t.hparamFilters);return s.set(e,Object.assign(Object.assign({},c),{includeUndefined:r,filterLowerValue:a,filterUpperValue:o})),Object.assign(Object.assign({},t),{hparamFilters:s})})),jv(KQ,((t,n)=>{const{metricTag:e,filterLowerValue:a,filterUpperValue:o,includeUndefined:r}=n,i=t.metricDefaultFilters.get(e);if(!i)throw new Error(`Unknown metric: ${e}`);const c=Object.assign(Object.assign({},i),t.metricFilters.get(e)),s=new Map(t.metricFilters);return s.set(e,Object.assign(Object.assign({},c),{filterLowerValue:a,filterUpperValue:o,includeUndefined:r})),Object.assign(Object.assign({},t),{metricFilters:s})})),jv(BQ,((t,n)=>{var e,a,o,r;if(0===Object.keys(n.newRunsAndMetadata).length)return t;const i=new Map,c=new Map,s=new Map,l=new Map,m=new Map,d=new Set;for(const t of Object.keys(n.newRunsAndMetadata)){const{runs:e,metadata:a}=n.newRunsAndMetadata[t];for(const t of e){const n=a.runToHparamsAndMetrics[t.id];if(n)for(const t of n.metrics){const n=m.get(t.tag);m.set(t.tag,{min:n?Math.min(n.min,t.value):t.value,max:n?Math.max(n.max,t.value):t.value})}}for(const{name:t,domain:n}of a.hparamSpecs)if(n.type===wD.DISCRETE){const e=s.get(t)||new Set;for(const t of n.values)e.add(t);s.set(t,e)}else{const e=l.get(t);l.set(t,{minValue:e?Math.min(n.minValue,e.minValue):n.minValue,maxValue:e?Math.max(n.maxValue,e.maxValue):n.maxValue})}for(const t of a.metricSpecs)d.add(t.tag)}for(const[t,n]of s)i.set(t,{type:wD.DISCRETE,includeUndefined:!0,possibleValues:[...n],filterValues:[...n]});for(const[t,{minValue:n,maxValue:e}]of l)i.set(t,{type:wD.INTERVAL,includeUndefined:!0,minValue:n,maxValue:e,filterLowerValue:n,filterUpperValue:e});for(const t of d){const n=m.get(t);c.set(t,{type:wD.INTERVAL,includeUndefined:!0,minValue:null!==(e=null==n?void 0:n.min)&&void 0!==e?e:0,maxValue:null!==(a=null==n?void 0:n.max)&&void 0!==a?a:0,filterLowerValue:null!==(o=null==n?void 0:n.min)&&void 0!==o?o:0,filterUpperValue:null!==(r=null==n?void 0:n.max)&&void 0!==r?r:0})}return Object.assign(Object.assign({},t),{hparamDefaultFilters:i,metricDefaultFilters:c})}))),Yft);class Zft{}function Xft(t){return(n,e)=>{const a=t(n,e);return console.groupCollapsed(e.type),console.log("prev state",n),console.log("action",e),console.log("next state",a),console.groupEnd(),a}}Zft.ɵmod=xo({type:Zft}),Zft.ɵinj=Ge({factory:function t(n){return new(n||Zft)},imports:[[Iv.forFeature(ED,(function Jft(t,n){return qk({data:Wft,ui:qft})(t,n)})),fw.forFeature([Vft]),Bft,Mw.registerAlertActions((function Qft(){return[{actionCreator:VQ,alertFromAction:()=>({localizedMessage:"Failed to fetch runs"})}]}))]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(Zft,{imports:[Dv,uw,Bft,Mw]});const Kft=new Fa("Root reducers token",{factory:()=>({})});class $ft{}$ft.ɵmod=xo({type:$ft}),$ft.ɵinj=Ge({factory:function t(n){return new(n||$ft)},providers:[{provide:Vk,useFactory:function tht(){return _c()?Xft:t=>(n,e)=>t(n,e)},multi:!0}],imports:[[Iv.forRoot(Kft,{runtimeChecks:{strictStateImmutability:!0,strictActionImmutability:!0,strictActionSerializability:!1,strictStateSerializability:!1}}),fw.forRoot([])]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo($ft,{imports:[Tv,bw]});class nht{}nht.ɵmod=xo({type:nht}),nht.ɵinj=Ge({factory:function t(n){return new(n||nht)}}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(nht,{declarations:[zft],exports:[zft]});class eht{}eht.ɵmod=xo({type:eht}),eht.ɵinj=Ge({factory:function t(n){return new(n||eht)},imports:[[PO,Aft,nht]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(eht,{declarations:[Rft],imports:[PO,Aft,nht],exports:[Rft]});class aht{}aht.ɵmod=xo({type:aht,bootstrap:[ZV]}),aht.ɵinj=Ge({factory:function t(n){return new(n||aht)},imports:[[Hj,uP,_k,oj,cj,NV.registerRoutes((function oht(){return[{routeKind:Yz.EXPERIMENT,path:"/",ngComponent:Rft,defaultRoute:!0,deepLinkProvider:new Ift}]})),mI,lI,eht,uj,xj,Cj,Wj,Gj,Mj,Aft,Zft,jj,$ft,dft]]}),("undefined"==typeof ngJitMode||ngJitMode)&&yo(aht,{declarations:[ZV],imports:[Hj,uP,_k,oj,cj,NV,mI,lI,eht,uj,xj,Cj,Wj,Gj,Mj,Aft,Zft,jj,$ft,dft]}),"loading"!==document.readyState?mP().bootstrapModule(aht):window.addEventListener("DOMContentLoaded",(()=>{mP().bootstrapModule(aht)})),(function rht(){if(hc)throw new Error("Cannot enable prod mode after platform setup.");(void 0===typeof ngDevMode||ngDevMode)&&(ma.ngDevMode=!1),fc=!1})()})();
", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript; charset=utf-8" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/icon_bundle.svg": { + "data": "<?xml version="1.0" ?><svg><defs><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_downward_24px"><path fill="#010101" d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="arrow_upward_24px"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="bug_report_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M20 8h-2.81c-.45-.78-1.07-1.45-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5c-.49 0-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="cancel_24px"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_left_24px"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="chevron_right_24px"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="clear_24px"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="close_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="content_copy_24px"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="edit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="error_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_less_24px"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="expand_more_24px"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="filter_alt_24px"><g><path d="M0,0h24 M24,24H0" fill="none"/><path d="M4.25,5.61C6.27,8.2,10,13,10,13v6c0,0.55,0.45,1,1,1h2c0.55,0,1-0.45,1-1v-6c0,0,3.72-4.8,5.74-7.39 C20.25,4.95,19.78,4,18.95,4H5.04C4.21,4,3.74,4.95,4.25,5.61z"/><path d="M0,0h24v24H0V0z" fill="none"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="flag_24px"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="fullscreen_exit_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="get_app_24px"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="group_work_24px"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zM8 17.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zM9.5 8c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5S9.5 9.38 9.5 8zm6.5 9.5c-1.38 0-2.5-1.12-2.5-2.5s1.12-2.5 2.5-2.5 2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="help_outline_24px"><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="image_search_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M0 0h24v24H0V0z" fill="none"/><path d="M18 13v7H4V6h5.02c.05-.71.22-1.38.48-2H4c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-5l-2-2zm-1.5 5h-11l2.75-3.53 1.96 2.36 2.75-3.54zm2.8-9.11c.44-.7.7-1.51.7-2.39C20 4.01 17.99 2 15.5 2S11 4.01 11 6.5s2.01 4.5 4.49 4.5c.88 0 1.7-.26 2.39-.7L21 13.42 22.42 12 19.3 8.89zM15.5 9C14.12 9 13 7.88 13 6.5S14.12 4 15.5 4 18 5.12 18 6.5 16.88 9 15.5 9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="info_outline_24px"><path d="M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 9h2V7h-2v2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M16,9V4l1,0c0.55,0,1-0.45,1-1v0c0-0.55-0.45-1-1-1H7C6.45,2,6,2.45,6,3v0 c0,0.55,0.45,1,1,1l1,0v5c0,1.66-1.34,3-3,3h0v2h5.97v7l1,1l1-1v-7H19v-2h0C17.34,12,16,10.66,16,9z" fill-rule="evenodd"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="keep_outline_24px"><g><rect fill="none" height="24" width="24"/></g><g><path d="M14,4v5c0,1.12,0.37,2.16,1,3H9c0.65-0.86,1-1.9,1-3V4H14 M17,2H7C6.45,2,6,2.45,6,3c0,0.55,0.45,1,1,1c0,0,0,0,0,0l1,0v5 c0,1.66-1.34,3-3,3v2h5.97v7l1,1l1-1v-7H19v-2c0,0,0,0,0,0c-1.66,0-3-1.34-3-3V4l1,0c0,0,0,0,0,0c0.55,0,1-0.45,1-1 C18,2.45,17.55,2,17,2L17,2z"/></g></svg><svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24" id="line_weight_24px"><g><rect fill="none" height="24" width="24" x="0"/></g><g><g><g><path d="M3,17h18v-2H3V17z M3,20h18v-1H3V20z M3,13h18v-3H3V13z M3,4v4h18V4H3z"/></g></g></g></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="more_vert_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="notifications_none_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12 22c1.1 0 2-.9 2-2h-4c0 1.1.9 2 2 2zm6-6v-5c0-3.07-1.63-5.64-4.5-6.32V4c0-.83-.67-1.5-1.5-1.5s-1.5.67-1.5 1.5v.68C7.64 5.36 6 7.92 6 11v5l-2 2v1h16v-1l-2-2zm-2 1H8v-6c0-2.48 1.51-4.5 4-4.5s4 2.02 4 4.5v6z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="refresh_24px"><path d="M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="search_24px"><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="settings_24px"><path d="M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.12-.22-.39-.3-.61-.22l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.23-.09-.49 0-.61.22l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.12.22.39.3.61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.23.09.49 0 .61-.22l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zM12 15.5c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_backup_restore_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M14 12c0-1.1-.9-2-2-2s-2 .9-2 2 .9 2 2 2 2-.9 2-2zm-2-9c-4.97 0-9 4.03-9 9H0l4 4 4-4H5c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.51 0-2.91-.49-4.06-1.3l-1.42 1.44C8.04 20.3 9.94 21 12 21c4.97 0 9-4.03 9-9s-4.03-9-9-9z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="settings_overscan_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M12.01 5.5L10 8h4l-1.99-2.5zM18 10v4l2.5-1.99L18 10zM6 10l-2.5 2.01L6 14v-4zm8 6h-4l2.01 2.5L14 16zm7-13H3c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h18c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16.01H3V4.99h18v14.02z"/></svg><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" id="visibility_off_24px"><path d="M12 7c2.76 0 5 2.24 5 5 0 .65-.13 1.26-.36 1.83l2.92 2.92c1.51-1.26 2.7-2.89 3.43-4.75-1.73-4.39-6-7.5-11-7.5-1.4 0-2.74.25-3.98.7l2.16 2.16C10.74 7.13 11.35 7 12 7zM2 4.27l2.28 2.28.46.46C3.08 8.3 1.78 10.02 1 12c1.73 4.39 6 7.5 11 7.5 1.55 0 3.03-.3 4.38-.84l.42.42L19.73 22 21 20.73 3.27 3 2 4.27zM7.53 9.8l1.55 1.55c-.05.21-.08.43-.08.65 0 1.66 1.34 3 3 3 .22 0 .44-.03.65-.08l1.55 1.55c-.67.33-1.41.53-2.2.53-2.76 0-5-2.24-5-5 0-.79.2-1.53.53-2.2zm4.31-.78l3.15 3.15.02-.16c0-1.66-1.34-3-3-3l-.17.01z"/></svg><svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24" id="warning_24px"><path d="M0 0h24v24H0z" fill="none"/><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/></svg></defs></svg>
", + "ok": true, + "headers": [ + [ + "content-type", + "image/svg+xml; charset=utf-8" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/data/runs": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/data/plugins_listing": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/data/environment": { + "data": "eyJ2ZXJzaW9uIjogIjIuNS4wIiwgImRhdGFfbG9jYXRpb24iOiAiL2dkcml2ZS9NeSBEcml2ZS9Db2xhYiBOb3RlYm9va3Mvc3ZkLy90ZW5zb3Jib2FyZCIsICJ3aW5kb3dfdGl0bGUiOiAiIiwgImV4cGVyaW1lbnRfbmFtZSI6ICIiLCAiZXhwZXJpbWVudF9kZXNjcmlwdGlvbiI6ICIiLCAiY3JlYXRpb25fdGltZSI6IDAuMCwgImRlYnVnIjogeyJkYXRhX3Byb3ZpZGVyIjogIkdycGNEYXRhUHJvdmlkZXIoYWRkcj0nbG9jYWxob3N0OjM4NDE5JykiLCAiZmxhZ3MiOiB7ImxvZ2RpciI6ICIvZ2RyaXZlL015IERyaXZlL0NvbGFiIE5vdGVib29rcy9zdmQvL3RlbnNvcmJvYXJkIiwgImxvZ2Rpcl9zcGVjIjogIiIsICJob3N0IjogbnVsbCwgImJpbmRfYWxsIjogZmFsc2UsICJwb3J0IjogbnVsbCwgInJldXNlX3BvcnQiOiBmYWxzZSwgImxvYWRfZmFzdCI6ICJhdXRvIiwgImV4dHJhX2RhdGFfc2VydmVyX2ZsYWdzIjogIiIsICJncnBjX2NyZWRzX3R5cGUiOiAibG9jYWwiLCAiZ3JwY19kYXRhX3Byb3ZpZGVyIjogIiIsICJwdXJnZV9vcnBoYW5lZF9kYXRhIjogdHJ1ZSwgImRiIjogIiIsICJkYl9pbXBvcnQiOiBmYWxzZSwgImluc3BlY3QiOiBmYWxzZSwgInZlcnNpb25fdGIiOiBmYWxzZSwgInRhZyI6ICIiLCAiZXZlbnRfZmlsZSI6ICIiLCAicGF0aF9wcmVmaXgiOiAiIiwgIndpbmRvd190aXRsZSI6ICIiLCAibWF4X3JlbG9hZF90aHJlYWRzIjogMSwgInJlbG9hZF9pbnRlcnZhbCI6IDUuMCwgInJlbG9hZF90YXNrIjogImF1dG8iLCAicmVsb2FkX211bHRpZmlsZSI6IG51bGwsICJyZWxvYWRfbXVsdGlmaWxlX2luYWN0aXZlX3NlY3MiOiA4NjQwMCwgImdlbmVyaWNfZGF0YSI6ICJhdXRvIiwgInNhbXBsZXNfcGVyX3BsdWdpbiI6IHt9LCAiY3VzdG9tX3ByZWRpY3RfZm4iOiAiIiwgIndpdF9kYXRhX2RpciI6ICIiLCAiX190ZW5zb3Jib2FyZF9zdWJjb21tYW5kIjogInNlcnZlIn19fQ==", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "OK" + }, + "https://localhost:6006/data/plugin/scalars/tags": { + "data": "{"mnist_R45_scaler0_3.0_scaler1_1.0_mse_Th1e-05_date20210713-123505": {"Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - diff(V)": {"displayName": "", "description": "<p>Algorithm2 MSE(v(i), v(i-1)) at refining steps.</p>"}, "Alg2 - diff(U)": {"displayName": "", "description": "<p>Algorithm2 MSE(u(i), u(i-1)) at refining steps.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_2.0_mse_Th1e-05_date20210720-093534": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R32_scaler0_8.0_scaler1_1.0_mse_Th1e-05_date20210713-162742": {"Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.2_scaler1_1.0_mse_Th1e-05_date20210714-112906": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R32_scaler0_8.0_scaler1_1.0_mse_Th1e-05_date20210714-075924": {"Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R16_scaler0_16.0_scaler1_1.0_mse_Th1e-05_date20210713-130929": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-211152": {"Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R32_scaler0_8.0_scaler1_1.0_mse_Th1e-05_date20210713-162910": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R32_scaler0_8.0_scaler1_1.0_mse_Th1e-05_date20210713-164413": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210714-112955": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "cnn-lstm_R25_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-125926": {"Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "cnn-lstm_R8_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-123906": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}}, "mnist_R16_scaler0_8.0_scaler1_2.0_mse_Th1e-05_date20210713-131147": {"Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.4_mse_Th1e-05_date20210720-211453": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_4blocks_R64_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210714-080020": {"Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 3-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 3-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_0.9_mse_Th1e-05_date20210720-211301": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "base_R8_frobenius-norm_Th1e-05_date20210720-093854": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.8_scaler1_1.0_mse_Th1e-05_date20210714-115031": {"Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.4_scaler1_1.0_mse_Th1e-05_date20210713-123020": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - diff(U)": {"displayName": "", "description": "<p>Algorithm2 MSE(u(i), u(i-1)) at refining steps.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - diff(V)": {"displayName": "", "description": "<p>Algorithm2 MSE(v(i), v(i-1)) at refining steps.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_4blocks_R16_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-174047": {"Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 3-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210714-113442": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.4_mse_Th1e-05_date20210720-212321": {"Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "base_R8_frobenius-norm_Th1e-05_date20210720-162038": {"Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}}, "mnist_4blocks_R32_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-174111": {"Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean Original 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.1_mse_Th1e-05_date20210720-211119": {"Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_16.0_scaler1_1.0_mse_Th1e-05_date20210713-130646": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "base_R8_frobenius-norm_Th1e-05_date20210720-093336": {"Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}}, "cnn-lstm_R8_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-123602": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}}, "mnist_R32_scaler0_8.0_scaler1_1.0_mse_Th1e-05_date20210713-131838": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "cnn-lstm_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-120623": {"Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_2.0_scaler1_2.0_mse_Th1e-05_date20210714-115524": {"Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-213928": {"Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_6.0_mse_Th1e-05_date20210714-081034": {"Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}}, "mnist_R16_scaler0_4.0_scaler1_8.0_mse_Th1e-05_date20210713-131110": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_2.0_mse_Th1e-05_date20210720-210928": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "base_R8_frobenius-norm_Th1e-05_date20210713-161520": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}}, "base_R8_frobenius-norm_Th1e-05_date20210714-075723": {"Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.2_scaler1_1.0_mse_Th1e-05_date20210714-113818": {"Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_3.0_scaler1_1.0_mse_Th1e-05_date20210713-130427": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.2_scaler1_1.0_mse_Th1e-05_date20210714-114609": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_4blocks_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-174145": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 3-th sub-matrix.</p>"}, "Alg3 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg2 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R16_scaler0_8.0_scaler1_8.0_mse_Th1e-05_date20210713-131030": {"Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R8_scaler0_16.0_scaler1_1.0_mse_Th1e-05_date20210713-130847": {"Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-130051": {"Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-125608": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_6.0_scaler1_1.0_mse_Th1e-05_date20210714-111743": {"Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_2.0_mse_Th1e-05_date20210720-162251": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_4blocks_R64_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210713-174427": {"Alg2 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean Original 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 2-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 3-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg3 - Mean 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 3-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 2-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 2-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 3-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 3-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_2.0_mse_Th1e-05_date20210720-101733": {"Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_2.0_mse_Th1e-05_date20210720-101602": {"Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.1_mse_Th1e-05_date20210720-211800": {"Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.8_mse_Th1e-05_date20210714-115202": {"Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}}, "mnist_R45_scaler0_1.8_scaler1_1.0_mse_Th1e-05_date20210713-123239": {"Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg2 - diff(V)": {"displayName": "", "description": "<p>Algorithm2 MSE(v(i), v(i-1)) at refining steps.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg2 - diff(U)": {"displayName": "", "description": "<p>Algorithm2 MSE(u(i), u(i-1)) at refining steps.</p>"}}, "mnist_R45_scaler0_1.0_scaler1_1.0_mse_Th1e-05_date20210720-212151": {"Alg3 - Mean Original 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 0-th sub-matrix.</p>"}, "Alg2 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}, "Alg3 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 0-th sub-matrix.</p>"}, "Alg2 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx).</p>"}, "Alg3 - Mean 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - Mean Original 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 Mean(x) of the 1-th sub-matrix.</p>"}, "Alg2 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm2 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 1-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 1-th sub-matrix.</p>"}, "Alg3 - MSE 0-th sub-matrix": {"displayName": "", "description": "<p>Algorithm3 MSE(x, x_approx) of the 0-th sub-matrix.</p>"}}}", + "ok": true, + "headers": [ + [ + "content-type", + "application/json" + ] + ], + "status": 200, + "status_text": "OK" + } + }, + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "w5HA_RoKJ1W6", + "outputId": "06f47ac5-c2bf-4ab2-ff73-e1e652859e1c" + }, + "source": [ + "tensorboard_dir = '/gdrive/My Drive/Colab Notebooks/svd/'\n", + "tensorboard_dir = re.escape(tensorboard_dir) # to include spaces\n", + "# %reload_ext tensorboard\n", + "# %rm -rf $tensorboard_dir/tensorboard/*\n", + "%tensorboard --logdir $tensorboard_dir/tensorboard" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/javascript": [ + "\n", + " (async () => {\n", + " const url = new URL(await google.colab.kernel.proxyPort(6006, {'cache': true}));\n", + " url.searchParams.set('tensorboardColab', 'true');\n", + " const iframe = document.createElement('iframe');\n", + " iframe.src = url;\n", + " iframe.setAttribute('width', '100%');\n", + " iframe.setAttribute('height', '800');\n", + " iframe.setAttribute('frameborder', 0);\n", + " document.body.appendChild(iframe);\n", + " })();\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9EWRUuxXkzxh" + }, + "source": [ + "# Models\n", + "\n", + "Currently, we have the following designs in place:\n", + "\n", + "| Model Name | ID | #LSTMs | Input Size(s) | Hidden Size(s)| Test Accuracy | HW Requirements |\n", + "|---|---|---|---|---|---|---|\n", + "| Dense MNIST | mnist | 0 | 784 | 128 | 98% | |\n", + "| Fashion MNIST | fashion | 0 | 784 | 128 | 88% | |\n", + "| Fashion MNIST - LSTM | fashion-lstm | 2 | 128 | 256 | 86% | |\n", + "| CNN-RNN-UCF101 | cnn-lstm | 2 | 2048 | 256 | 65% |\n", + "| TrafficPredict | traffic-predict | N | ? | ? | ? | |\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LfTVudzjYwdI" + }, + "source": [ + "models = {}" + ], + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1ypgdVm6Oz1M" + }, + "source": [ + "checkpoint_dir = '/gdrive/My Drive/checkpoints/svd/'\n", + "\n", + "def save_model(model_name):\n", + " models[model_name].save(checkpoint_dir + model_name)\n", + " models[model_name].save_weights(checkpoint_dir + model_name + '.h5')\n", + " print(f'Model saved at: {checkpoint_dir + model_name}')\n", + "\n", + "def load_model(model_name):\n", + " if os.path.isdir(checkpoint_dir + model_name):\n", + " models[model_name] = tf.keras.models.load_model(checkpoint_dir + model_name)\n", + " if os.path.isfile(checkpoint_dir + model_name + '.h5'):\n", + " print(f'Model \"{model_name}\" loaded with weights.')\n", + " return True\n", + " else:\n", + " print(f'Model \"{model_name}\" loaded without weights.')\n", + " return False\n", + " else:\n", + " print(f'Model \"{model_name}\" not found in: {checkpoint_dir}')\n", + " return False" + ], + "execution_count": 21, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9qAJGTrJxCUl" + }, + "source": [ + "### MNIST - Dense" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Dp2_3w2ZxGLh", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "eb81bda2-455e-4856-8876-96b297824eaa" + }, + "source": [ + "mnist = tf.keras.datasets.mnist\n", + "\n", + "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0" + ], + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n", + "11493376/11490434 [==============================] - 0s 0us/step\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9gku0jMKxNlR", + "outputId": "0ce442da-227c-4747-df9d-54a7cedfc2f1" + }, + "source": [ + "models['mnist'] = tf.keras.models.Sequential([\n", + " tf.keras.layers.Flatten(input_shape=(28, 28)),\n", + " tf.keras.layers.Dense(128, activation='relu', name='dense_1'),\n", + " tf.keras.layers.Dropout(0.2),\n", + " tf.keras.layers.Dense(10, name='dense_2')\n", + "], name='mnist')\n", + "\n", + "models['mnist'].summary()" + ], + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"mnist\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten (Flatten) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 128) 100480 \n", + "_________________________________________________________________\n", + "dropout (Dropout) (None, 128) 0 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 101,770\n", + "Trainable params: 101,770\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c2yrclDrxi0a", + "outputId": "ecc6f68b-8fd1-4c82-ff52-8913a188c493" + }, + "source": [ + "models['mnist'].compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])\n", + "\n", + "if not load_model('mnist'):\n", + " models['mnist'].fit(x_train, y_train, epochs=5)\n", + " save_model('mnist')" + ], + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model \"mnist\" loaded with weights.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TBEYbgI-x6Py", + "outputId": "e2f6a24c-7359-4333-abc6-3ed12f376791" + }, + "source": [ + "models['mnist'].evaluate(x_test, y_test, verbose=2)" + ], + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "text": [ + "313/313 - 1s - loss: 0.0735 - accuracy: 0.9795\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0.07346832007169724, 0.9794999957084656]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 25 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fxd8syuH4WeS" + }, + "source": [ + "\n", + "## Fashion MNIST - Dense\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3wYmzI6-1prs", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d138db33-9403-450e-99bc-237552e27d82" + }, + "source": [ + "fashion_mnist = tf.keras.datasets.fashion_mnist\n", + "\n", + "(fashion_train_images, fashion_train_labels), (fashion_test_images, fashion_test_labels) = fashion_mnist.load_data()" + ], + "execution_count": 26, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n", + "32768/29515 [=================================] - 0s 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n", + "26427392/26421880 [==============================] - 0s 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n", + "8192/5148 [===============================================] - 0s 0us/step\n", + "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n", + "4423680/4422102 [==============================] - 0s 0us/step\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qOJnAUJKOBrm" + }, + "source": [ + "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n", + " 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "WMGwjBDxORVD", + "outputId": "50cf76eb-a8fc-4c4a-bc12-adec4856bade" + }, + "source": [ + "plt.figure()\n", + "plt.imshow(fashion_train_images[0])\n", + "plt.colorbar()\n", + "plt.grid(False)\n", + "plt.show()" + ], + "execution_count": 28, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0sbj1XatOqIn" + }, + "source": [ + "Scale these values to a range of 0 to 1 before feeding them to the neural network model. To do so, divide the values by 255. It's important that the training set and the testing set be preprocessed in the same way:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "D5ZodZNROeTO" + }, + "source": [ + "fashion_train_images = fashion_train_images / 255.0\n", + "fashion_test_images = fashion_test_images / 255.0" + ], + "execution_count": 29, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "ms2krOx9Os6d", + "outputId": "02605b2f-7420-4ac9-ef04-fabf8fa0c2f8" + }, + "source": [ + "plt.figure(figsize=(10,10))\n", + "for i in range(25):\n", + " plt.subplot(5,5,i+1)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.grid(False)\n", + " plt.imshow(fashion_train_images[i], cmap=plt.cm.binary)\n", + " plt.xlabel(class_names[fashion_train_labels[i]])\n", + "plt.show()" + ], + "execution_count": 30, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j33Mb5iAOvP4", + "outputId": "dcde8279-b8b5-4fb6-c86b-361415c312eb" + }, + "source": [ + "models['fashion'] = tf.keras.Sequential([\n", + " tf.keras.layers.Flatten(input_shape=(28, 28)),\n", + " tf.keras.layers.Dense(128, activation='relu', name='dense_1'),\n", + " tf.keras.layers.Dense(10, name='dense_2')\n", + "], name='fashion_mnist')\n", + "models['fashion'].summary()" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"fashion_mnist\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten_1 (Flatten) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 128) 100480 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 101,770\n", + "Trainable params: 101,770\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Rx6Em41pO4ha" + }, + "source": [ + "models['fashion'].compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])" + ], + "execution_count": 32, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K6F2FqdUO_qg" + }, + "source": [ + "Train the model." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xqWdCHIjO9Z4", + "outputId": "993ffe53-d235-44b9-c45f-6fa4506e1b16" + }, + "source": [ + "train_model = False\n", + "if not load_model('fashion') or train_model:\n", + " models['fashion'].fit(fashion_train_images, fashion_train_labels, epochs=10)\n", + " save_model('fashion')" + ], + "execution_count": 33, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model \"fashion\" loaded with weights.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WMV3QbbVPEt4", + "outputId": "6773da17-783b-4d58-c399-97b3450cac1f" + }, + "source": [ + "test_loss, test_acc = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=2)\n", + "print('\\nTest accuracy:', test_acc)" + ], + "execution_count": 34, + "outputs": [ + { + "output_type": "stream", + "text": [ + "313/313 - 1s - loss: 0.3876 - accuracy: 0.8919\n", + "\n", + "Test accuracy: 0.8919000029563904\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L3OA-HB7gExG" + }, + "source": [ + "## Fashion MNIST - LSTM" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0AyNrEeIPGq_", + "outputId": "eb6468dd-ddfe-4c3e-de0a-89c273fc3d1c" + }, + "source": [ + "batch_size = 32\n", + "num_classes = 10\n", + "epochs = 2\n", + "\n", + "row_hidden = 64\n", + "col_hidden = 64\n", + "\n", + "row, col = fashion_train_images.shape[1:]\n", + "\n", + "input = tf.keras.layers.Input(shape=(row, col))\n", + "\n", + "def lstm_pipe(in_layer, lstm_name=''):\n", + " x = tf.keras.layers.Conv1D(row_hidden, kernel_size=3, padding = 'same')(in_layer)\n", + " x = tf.keras.layers.Conv1D(row_hidden, kernel_size=3, padding = 'same')(x)\n", + " encoded_rows = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(row_hidden, return_sequences = True))(x)\n", + " return tf.keras.layers.LSTM(col_hidden, name='LSTM_' + lstm_name)(encoded_rows)\n", + "# Read it by rows\n", + "row_read = lstm_pipe(input, 'left')\n", + "# Read it by columns\n", + "transpose_read = lstm_pipe(tf.keras.layers.Permute(dims=(1,2))(input), 'right')\n", + "x = tf.concat([row_read, transpose_read], axis=1)\n", + "x = tf.keras.layers.Dropout(0.2)(x)\n", + "# prediction = tf.keras.layers.Dense(num_classes, activation='softmax')(x)\n", + "prediction = tf.keras.layers.Dense(num_classes)(x)\n", + "models['fashion-lstm'] = tf.keras.Model(input, prediction)\n", + "models['fashion-lstm'].compile(optimizer='adam',\n", + " loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n", + " metrics=['accuracy'])\n", + "models['fashion-lstm'].summary()\n", + "\n", + "models['fashion-lstm'].get_layer('LSTM_left').get_weights()[0].shape" + ], + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + "Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + "input_1 (InputLayer) [(None, 28, 28)] 0 \n", + "__________________________________________________________________________________________________\n", + "permute (Permute) (None, 28, 28) 0 input_1[0][0] \n", + "__________________________________________________________________________________________________\n", + "conv1d (Conv1D) (None, 28, 64) 5440 input_1[0][0] \n", + "__________________________________________________________________________________________________\n", + "conv1d_2 (Conv1D) (None, 28, 64) 5440 permute[0][0] \n", + "__________________________________________________________________________________________________\n", + "conv1d_1 (Conv1D) (None, 28, 64) 12352 conv1d[0][0] \n", + "__________________________________________________________________________________________________\n", + "conv1d_3 (Conv1D) (None, 28, 64) 12352 conv1d_2[0][0] \n", + "__________________________________________________________________________________________________\n", + "bidirectional (Bidirectional) (None, 28, 128) 66048 conv1d_1[0][0] \n", + "__________________________________________________________________________________________________\n", + "bidirectional_1 (Bidirectional) (None, 28, 128) 66048 conv1d_3[0][0] \n", + "__________________________________________________________________________________________________\n", + "LSTM_left (LSTM) (None, 64) 49408 bidirectional[0][0] \n", + "__________________________________________________________________________________________________\n", + "LSTM_right (LSTM) (None, 64) 49408 bidirectional_1[0][0] \n", + "__________________________________________________________________________________________________\n", + "tf.concat (TFOpLambda) (None, 128) 0 LSTM_left[0][0] \n", + " LSTM_right[0][0] \n", + "__________________________________________________________________________________________________\n", + "dropout_1 (Dropout) (None, 128) 0 tf.concat[0][0] \n", + "__________________________________________________________________________________________________\n", + "dense (Dense) (None, 10) 1290 dropout_1[0][0] \n", + "==================================================================================================\n", + "Total params: 267,786\n", + "Trainable params: 267,786\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(128, 256)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "26j0DrC2gWWE", + "outputId": "d77668ff-69c6-41e9-d8f7-70e6ebeeedf7" + }, + "source": [ + "if not load_model('fashion-lstm'):\n", + " models['fashion-lstm'].fit(fashion_train_images, fashion_train_labels, epochs=2, batch_size=batch_size)\n", + " save_model('fashion-lstm')" + ], + "execution_count": 36, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model \"fashion-lstm\" loaded with weights.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aQeDXW1ggx5p", + "outputId": "c7a172e3-57e5-41f8-b38f-efb45646c31d" + }, + "source": [ + "test_loss, test_acc = models['fashion-lstm'].evaluate(fashion_test_images, fashion_test_labels, verbose=2)\n", + "print('\\nTest accuracy:', test_acc)" + ], + "execution_count": 37, + "outputs": [ + { + "output_type": "stream", + "text": [ + "313/313 - 9s - loss: 0.3886 - accuracy: 0.8587\n", + "\n", + "Test accuracy: 0.8586999773979187\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pjtqPfHpFOpE" + }, + "source": [ + "## CNN-RNN-UCF101" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "axEkmpz9QoGY", + "outputId": "e15f701c-c0a3-47ff-ab4b-686cc59dd574" + }, + "source": [ + "!pip install -q git+https://github.com/tensorflow/docs" + ], + "execution_count": 38, + "outputs": [ + { + "output_type": "stream", + "text": [ + " Building wheel for tensorflow-docs (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[33m WARNING: Built wheel for tensorflow-docs is invalid: Metadata 1.2 mandates PEP 440 version, but '0.0.0f74e5ccdc126eb2c32cb344a7c134a28e633e9dc-' is not\u001b[0m\n", + " Running setup.py install for tensorflow-docs ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[33m DEPRECATION: tensorflow-docs was installed using the legacy 'setup.py install' method, because a wheel could not be built for it. A possible replacement is to fix the wheel build issue reported above. You can find discussion regarding this at https://github.com/pypa/pip/issues/8368.\u001b[0m\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pQQsKjzmh8Uz" + }, + "source": [ + "!wget -q https://git.io/JGc31 -O /tmp/ucf101_top5.tar.gz\n", + "!tar xf /tmp/ucf101_top5.tar.gz" + ], + "execution_count": 39, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "vf8KPD3XFbsu" + }, + "source": [ + "from tensorflow_docs.vis import embed\n", + "from imutils import paths\n", + "\n", + "import pandas as pd\n", + "import imageio\n", + "import cv2" + ], + "execution_count": 40, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "9gd5eo4fQk6R" + }, + "source": [ + "IMG_SIZE = 224\n", + "BATCH_SIZE = 64\n", + "EPOCHS = 10\n", + "\n", + "MAX_SEQ_LENGTH = 20\n", + "NUM_FEATURES = 2048" + ], + "execution_count": 41, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "DM97Kl5AReMg", + "outputId": "037167b6-e627-46d0-f377-f3e0754e43a7" + }, + "source": [ + "train_df = pd.read_csv(\"train.csv\")\n", + "test_df = pd.read_csv(\"test.csv\")\n", + "\n", + "print(f\"Total videos for training: {len(train_df)}\")\n", + "print(f\"Total videos for testing: {len(test_df)}\")\n", + "\n", + "train_df.sample(10)" + ], + "execution_count": 42, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Total videos for training: 594\n", + "Total videos for testing: 224\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
video_nametag
421v_ShavingBeard_g17_c07.aviShavingBeard
391v_ShavingBeard_g13_c02.aviShavingBeard
464v_ShavingBeard_g24_c01.aviShavingBeard
339v_Punch_g23_c02.aviPunch
474v_ShavingBeard_g25_c04.aviShavingBeard
138v_PlayingCello_g11_c01.aviPlayingCello
363v_ShavingBeard_g08_c05.aviShavingBeard
256v_Punch_g10_c05.aviPunch
402v_ShavingBeard_g15_c01.aviShavingBeard
510v_TennisSwing_g12_c07.aviTennisSwing
\n", + "
" + ], + "text/plain": [ + " video_name tag\n", + "421 v_ShavingBeard_g17_c07.avi ShavingBeard\n", + "391 v_ShavingBeard_g13_c02.avi ShavingBeard\n", + "464 v_ShavingBeard_g24_c01.avi ShavingBeard\n", + "339 v_Punch_g23_c02.avi Punch\n", + "474 v_ShavingBeard_g25_c04.avi ShavingBeard\n", + "138 v_PlayingCello_g11_c01.avi PlayingCello\n", + "363 v_ShavingBeard_g08_c05.avi ShavingBeard\n", + "256 v_Punch_g10_c05.avi Punch\n", + "402 v_ShavingBeard_g15_c01.avi ShavingBeard\n", + "510 v_TennisSwing_g12_c07.avi TennisSwing" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 42 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8kXcyOGURj88" + }, + "source": [ + "# The following two methods are taken from this tutorial:\n", + "# https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub\n", + "\n", + "\n", + "def crop_center_square(frame):\n", + " y, x = frame.shape[0:2]\n", + " min_dim = min(y, x)\n", + " start_x = (x // 2) - (min_dim // 2)\n", + " start_y = (y // 2) - (min_dim // 2)\n", + " return frame[start_y : start_y + min_dim, start_x : start_x + min_dim]\n", + "\n", + "\n", + "def load_video(path, max_frames=0, resize=(IMG_SIZE, IMG_SIZE)):\n", + " cap = cv2.VideoCapture(path)\n", + " frames = []\n", + " try:\n", + " while True:\n", + " ret, frame = cap.read()\n", + " if not ret:\n", + " break\n", + " frame = crop_center_square(frame)\n", + " frame = cv2.resize(frame, resize)\n", + " frame = frame[:, :, [2, 1, 0]]\n", + " frames.append(frame)\n", + "\n", + " if len(frames) == max_frames:\n", + " break\n", + " finally:\n", + " cap.release()\n", + " return np.array(frames)" + ], + "execution_count": 43, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "_ExqycyVR0x9", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "81954a73-7752-414e-8592-a24b072cd064" + }, + "source": [ + "def build_feature_extractor():\n", + " feature_extractor = tf.keras.applications.InceptionV3(\n", + " weights=\"imagenet\",\n", + " include_top=False,\n", + " pooling=\"avg\",\n", + " input_shape=(IMG_SIZE, IMG_SIZE, 3),\n", + " )\n", + " preprocess_input = tf.keras.applications.inception_v3.preprocess_input\n", + "\n", + " inputs = tf.keras.Input((IMG_SIZE, IMG_SIZE, 3))\n", + " preprocessed = preprocess_input(inputs)\n", + "\n", + " outputs = feature_extractor(preprocessed)\n", + " return tf.keras.Model(inputs, outputs, name=\"feature_extractor\")\n", + "\n", + "feature_extractor = build_feature_extractor()" + ], + "execution_count": 44, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5\n", + "87916544/87910968 [==============================] - 1s 0us/step\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3zEsFu5HSyQ2", + "outputId": "3a809197-81dd-4713-eaac-2ec0ba6cc701" + }, + "source": [ + "label_processor = tf.keras.layers.experimental.preprocessing.StringLookup(\n", + " num_oov_indices=0, vocabulary=np.unique(train_df[\"tag\"])\n", + ")\n", + "print(label_processor.get_vocabulary())" + ], + "execution_count": 45, + "outputs": [ + { + "output_type": "stream", + "text": [ + "['', 'CricketShot', 'PlayingCello', 'Punch', 'ShavingBeard', 'TennisSwing']\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YucRb0fBTBHM", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5dfa0e46-fb4a-4587-f648-b35f5e2cc102" + }, + "source": [ + "def prepare_all_videos(df, root_dir):\n", + " num_samples = len(df)\n", + " video_paths = df[\"video_name\"].values.tolist()\n", + " labels = df[\"tag\"].values\n", + " labels = label_processor(labels[..., None]).numpy()\n", + "\n", + " # `frame_masks` and `frame_features` are what we will feed to our sequence model.\n", + " # `frame_masks` will contain a bunch of booleans denoting if a timestep is\n", + " # masked with padding or not.\n", + " frame_masks = np.zeros(shape=(num_samples, MAX_SEQ_LENGTH), dtype=\"bool\")\n", + " frame_features = np.zeros(\n", + " shape=(num_samples, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\"\n", + " )\n", + "\n", + " # For each video.\n", + " for idx, path in enumerate(video_paths):\n", + " # Gather all its frames and add a batch dimension.\n", + " frames = load_video(os.path.join(root_dir, path))\n", + " frames = frames[None, ...]\n", + "\n", + " # Initialize placeholders to store the masks and features of the current video.\n", + " temp_frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype=\"bool\")\n", + " temp_frame_featutes = np.zeros(\n", + " shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\"\n", + " )\n", + "\n", + " # Extract features from the frames of the current video.\n", + " for i, batch in enumerate(frames):\n", + " video_length = batch.shape[1]\n", + " length = min(MAX_SEQ_LENGTH, video_length)\n", + " for j in range(length):\n", + " temp_frame_featutes[i, j, :] = feature_extractor.predict(\n", + " batch[None, j, :]\n", + " )\n", + " temp_frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked\n", + "\n", + " frame_features[idx,] = temp_frame_featutes.squeeze()\n", + " frame_masks[idx,] = temp_frame_mask.squeeze()\n", + "\n", + " return (frame_features, frame_masks), labels\n", + "\n", + "if os.path.isfile(checkpoint_dir + 'cnn-lstm/dataset.npz'):\n", + " dataset = np.load(checkpoint_dir + 'cnn-lstm/dataset.npz')\n", + " train_data = (dataset['train_data_0'], dataset['train_data_1'])\n", + " test_data = (dataset['test_data_0'], dataset['test_data_1'])\n", + " train_labels = dataset['train_labels']\n", + " test_labels = dataset['test_labels']\n", + "else:\n", + " train_data, train_labels = prepare_all_videos(train_df, \"train\")\n", + " test_data, test_labels = prepare_all_videos(test_df, \"test\")\n", + "\n", + "print(f\"Frame features in train set: {train_data[0].shape}\")\n", + "print(f\"Frame masks in train set: {train_data[1].shape}\")" + ], + "execution_count": 46, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Frame features in train set: (594, 20, 2048)\n", + "Frame masks in train set: (594, 20)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WpYSOigtTVxh" + }, + "source": [ + "### The Sequence Model" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-iV2mumoTKJl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "d848afba-a7ab-4783-a573-af924f52c4dc" + }, + "source": [ + "# Utility for our sequence model.\n", + "def get_sequence_model():\n", + " class_vocab = label_processor.get_vocabulary()\n", + "\n", + " frame_features_input = tf.keras.Input((MAX_SEQ_LENGTH, NUM_FEATURES))\n", + " mask_input = tf.keras.Input((MAX_SEQ_LENGTH,), dtype=\"bool\")\n", + "\n", + " # Refer to the following tutorial to understand the significance of using `mask`:\n", + " # https://tf.keras.io/api/layers/recurrent_layers/gru/\n", + " x = tf.keras.layers.LSTM(64, return_sequences=True, name='LSTM_1')(frame_features_input, mask=mask_input)\n", + " x = tf.keras.layers.LSTM(32, name='LSTM_2')(x)\n", + " # x = tf.keras.layers.GRU(16, return_sequences=True)(frame_features_input, mask=mask_input)\n", + " # x = tf.keras.layers.GRU(8)(x)\n", + " x = tf.keras.layers.Dropout(0.4)(x)\n", + " x = tf.keras.layers.Dense(8, activation=\"relu\")(x)\n", + " output = tf.keras.layers.Dense(len(class_vocab), activation=\"softmax\")(x)\n", + "\n", + " rnn_model = tf.keras.Model([frame_features_input, mask_input], output)\n", + "\n", + " rnn_model.compile(\n", + " loss=\"sparse_categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"]\n", + " )\n", + " return rnn_model\n", + "\n", + "# Utility for running experiments.\n", + "def run_experiment():\n", + " filepath = \"/tmp/video_classifier\"\n", + " checkpoint = tf.keras.callbacks.ModelCheckpoint(\n", + " filepath, save_weights_only=True, save_best_only=True, verbose=1\n", + " )\n", + " seq_model = get_sequence_model()\n", + " history = seq_model.fit(\n", + " [train_data[0], train_data[1]],\n", + " train_labels,\n", + " validation_split=0.3,\n", + " epochs=EPOCHS,\n", + " callbacks=[checkpoint],\n", + " )\n", + " seq_model.load_weights(filepath)\n", + " _, accuracy = seq_model.evaluate([test_data[0], test_data[1]], test_labels)\n", + " print(f\"Test accuracy: {round(accuracy * 100, 2)}%\")\n", + " return history, seq_model\n", + "\n", + "train_model = False\n", + "if not load_model('cnn-lstm') or train_model:\n", + " _, models['cnn-lstm'] = run_experiment()\n", + " save_model('cnn-lstm')" + ], + "execution_count": 47, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model \"cnn-lstm\" loaded with weights.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ya5FeHCMTips" + }, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ExJXj3TyTkPc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "31f7cf7a-4e6d-4531-a877-b3b9980c30bc" + }, + "source": [ + "def prepare_single_video(frames):\n", + " frames = frames[None, ...]\n", + " frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype=\"bool\")\n", + " frame_featutes = np.zeros(shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype=\"float32\")\n", + " for i, batch in enumerate(frames):\n", + " video_length = batch.shape[1]\n", + " length = min(MAX_SEQ_LENGTH, video_length)\n", + " for j in range(length):\n", + " frame_featutes[i, j, :] = feature_extractor.predict(batch[None, j, :])\n", + " frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked\n", + " return frame_featutes, frame_mask\n", + "\n", + "def sequence_prediction(path):\n", + " class_vocab = label_processor.get_vocabulary()\n", + "\n", + " frames = load_video(os.path.join(\"test\", path))\n", + " frame_features, frame_mask = prepare_single_video(frames)\n", + " probabilities = models['cnn-lstm'].predict([frame_features, frame_mask])[0]\n", + "\n", + " for i in np.argsort(probabilities)[::-1]:\n", + " print(f\" {class_vocab[i]}: {probabilities[i] * 100:5.2f}%\")\n", + " return frames\n", + "\n", + "# This utility is for visualization.\n", + "# Referenced from:\n", + "# https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub\n", + "def to_gif(images):\n", + " converted_images = images.astype(np.uint8)\n", + " imageio.mimsave(\"animation.gif\", converted_images, fps=10)\n", + " return embed.embed_file(\"animation.gif\")\n", + "\n", + "test_video = np.random.choice(test_df[\"video_name\"].values.tolist())\n", + "print(f\"Test video path: {test_video}\")\n", + "test_frames = sequence_prediction(test_video)\n", + "to_gif(test_frames[:MAX_SEQ_LENGTH])" + ], + "execution_count": 48, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Test video path: v_TennisSwing_g05_c03.avi\n", + " Punch: 36.57%\n", + " ShavingBeard: 26.30%\n", + " CricketShot: 20.38%\n", + " PlayingCello: 10.73%\n", + " : 3.56%\n", + " TennisSwing: 2.46%\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 48 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "48QBTe1JkqDc", + "outputId": "a6046971-942c-498c-85ed-3582c8c76940" + }, + "source": [ + "_, accuracy = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels)\n", + "print(f\"Test accuracy: {round(accuracy * 100, 2)}%\")" + ], + "execution_count": 49, + "outputs": [ + { + "output_type": "stream", + "text": [ + "7/7 [==============================] - 2s 31ms/step - loss: 1.5262 - accuracy: 0.6562\n", + "Test accuracy: 65.62%\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PZlmJpC8j2PT" + }, + "source": [ + "if not os.path.isfile(checkpoint_dir + 'cnn-lstm/dataset.npz'):\n", + " np.savez_compressed(checkpoint_dir + 'cnn-lstm/dataset',\n", + " train_data_0=train_data[0],\n", + " train_data_1=train_data[1],\n", + " train_labels=train_labels,\n", + " test_data_0=test_data[0],\n", + " test_data_1=test_data[1],\n", + " test_labels=test_labels)" + ], + "execution_count": 50, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xKKBt8IfsoZx" + }, + "source": [ + "### Get Weights" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "I3R4weJlstC5", + "outputId": "12e6d252-09c7-4445-9977-e5ce2e7fd2d9" + }, + "source": [ + "models['cnn-lstm'].summary()" + ], + "execution_count": 51, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"model_4\"\n", + "__________________________________________________________________________________________________\n", + "Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + "input_9 (InputLayer) [(None, 20, 2048)] 0 \n", + "__________________________________________________________________________________________________\n", + "input_10 (InputLayer) [(None, 20)] 0 \n", + "__________________________________________________________________________________________________\n", + "LSTM_1 (LSTM) (None, 20, 64) 540928 input_9[0][0] \n", + " input_10[0][0] \n", + "__________________________________________________________________________________________________\n", + "LSTM_2 (LSTM) (None, 32) 12416 LSTM_1[0][0] \n", + "__________________________________________________________________________________________________\n", + "dropout_6 (Dropout) (None, 32) 0 LSTM_2[0][0] \n", + "__________________________________________________________________________________________________\n", + "dense_6 (Dense) (None, 8) 264 dropout_6[0][0] \n", + "__________________________________________________________________________________________________\n", + "dense_7 (Dense) (None, 6) 54 dense_6[0][0] \n", + "==================================================================================================\n", + "Total params: 553,662\n", + "Trainable params: 553,662\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "i9HpitpOtDzO", + "outputId": "85c0a179-fd9e-4f28-8a41-05194adab3e6" + }, + "source": [ + "print(models['cnn-lstm'].get_layer('LSTM_1').get_weights()[0].shape)\n", + "print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[0].shape)" + ], + "execution_count": 52, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(2048, 256)\n", + "(64, 128)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_E2yRW5gySUT" + }, + "source": [ + "# Scaled SVD Approximation" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GbPIVFJ_AeId" + }, + "source": [ + "def get_approx_size(R, k, m, n):\n", + " return R * (m + n + k)" + ], + "execution_count": 53, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "sMPgE_j203Z6" + }, + "source": [ + "def plot_accuracies(model_labels, original_accuracies, approx_accuracies):\n", + " x = np.arange(len(model_labels)) # the label locations\n", + " width = 0.35 # the width of the bars\n", + " fig, ax = plt.subplots()\n", + " rects1 = ax.bar(x - width/2, original_accuracies, width, label='Original')\n", + " rects2 = ax.bar(x + width/2, approx_accuracies, width, label='Approximated')\n", + " # Add some text for labels, title and custom x-axis tick labels, etc.\n", + " ax.set_ylabel('Accuracy')\n", + " ax.set_title('Original Accuracy vs. Approximated.')\n", + " ax.set_xticks(x)\n", + " ax.set_xticklabels(model_labels)\n", + " ax.legend()\n", + " fig.tight_layout()\n", + " plt.show()" + ], + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZHZO0PlTyaLh", + "outputId": "1e81b796-d8a1-48d4-f1e0-4d1b12f67db5" + }, + "source": [ + "models['fashion'].summary()\n", + "mnist_dense = [w1, b1] = models['mnist'].get_layer('dense_1').get_weights()\n", + "fashion_mnist_dense = [w2, b2] = models['fashion'].get_layer('dense_1').get_weights()\n", + "print(w1.shape, w2.shape)" + ], + "execution_count": 55, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"fashion_mnist\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten_1 (Flatten) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 128) 100480 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 101,770\n", + "Trainable params: 101,770\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "(784, 128) (784, 128)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4BMrOjXEy51y" + }, + "source": [ + "R = 45\n", + "metric = 'mse'\n", + "threshold = 1e-5\n", + "scalers = [1., 1.]\n", + "\n", + "def run_alg3_for_mnist(scaler, apply_scaling_at_alg2, log_to_tensorboard=False):\n", + " if log_to_tensorboard:\n", + " logname = 'mnist'\n", + " logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}'\n", + " logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S')\n", + " writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname))\n", + " %reload_ext tensorboard\n", + " else:\n", + " writer = None\n", + "\n", + " [w1, b1] = models['mnist'].get_layer('dense_1').get_weights()\n", + " [w2, b2] = models['fashion'].get_layer('dense_1').get_weights()\n", + " plotdata = {}\n", + " w_approx = algorithm3_inverse(*algorithm3([w1, w2], \\\n", + " num_refinements=R, \\\n", + " num_sub_matrix=1, \\\n", + " decomposition='eigen', \\\n", + " stop_threshold=threshold, \\\n", + " metric=metric, \\\n", + " scaler=scaler, \\\n", + " report_writer=writer, \\\n", + " apply_scaling_at_alg2=apply_scaling_at_alg2, \\\n", + " plotdata=plotdata))\n", + " # Obtain original accuracies.\n", + " _, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + " _, fashion_mnist_acc = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=0)\n", + " print('')\n", + " print('[ORIGINAL] MNIST - Test accuracy: {:.1f}%'.format(100. * mnist_acc))\n", + " print('[ORIGINAL] Fashion MNIST - Test accuracy: {:.1f}%'.format(100. * fashion_mnist_acc))\n", + " \n", + " # Set approximated weights and evaluate.\n", + " models['mnist'].get_layer('dense_1').set_weights([w_approx[0], b1])\n", + " models['fashion'].get_layer('dense_1').set_weights([w_approx[1], b2])\n", + " print('')\n", + "\n", + " _, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + " _, fashion_mnist_acc_approx = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=0)\n", + " print('[APPROX] MNIST - Test accuracy: {:.1f}%'.format(100. * mnist_acc_approx))\n", + " print('[APPROX] Fashion MNIST - Test accuracy: {:.1f}%'.format(100. * fashion_mnist_acc_approx))\n", + "\n", + " print('\\nMNIST - Accuracy drop: {:.1f}%'.format(100. * (mnist_acc - mnist_acc_approx)))\n", + " print('Fashion MNIST - Accuracy drop: {:.1f}%'.format(100. * (fashion_mnist_acc - fashion_mnist_acc_approx)))\n", + " print('')\n", + "\n", + " # Restore original weights and plot.\n", + " models['mnist'].get_layer('dense_1').set_weights([w1, b1])\n", + " models['fashion'].get_layer('dense_1').set_weights([w2, b2])\n", + "\n", + " plot_accuracies(['mnist', 'fashion'], [mnist_acc, fashion_mnist_acc],\n", + " [mnist_acc_approx, fashion_mnist_acc_approx])\n", + " return w_approx[0], w_approx[1], plotdata" + ], + "execution_count": 58, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hBB7um5b28BU" + }, + "source": [ + "## Baseline" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5Jn7ZRWr22W7" + }, + "source": [ + "_, _, plotdata = run_alg3_for_mnist(None, apply_scaling_at_alg2=True)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "id": "uDtgDz6x3CUw", + "outputId": "f2e19dfb-87b6-4ff0-ff4b-d1ae9a6f3d2a" + }, + "source": [ + "for matrix in plotdata:\n", + " plt.plot(plotdata[matrix], label=matrix)\n", + " print(plotdata[matrix][40])\n", + "plt.legend()" + ], + "execution_count": 65, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.02243629066508845\n", + "0.03342261809473339\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 65 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mEmpz_9g3DJo" + }, + "source": [ + "## Applying Scaling at Algorithm 3" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ncWsG3Eb9GF-" + }, + "source": [ + "_, _, plotdata_alg3 = run_alg3_for_mnist([1., 1000.], apply_scaling_at_alg2=False)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 319 + }, + "id": "YAr0LOLV9Kan", + "outputId": "068132a5-2021-4409-b6da-49946471640e" + }, + "source": [ + "for matrix in plotdata_alg3:\n", + " plt.plot(plotdata_alg3[matrix], label=matrix)\n", + " print(plotdata_alg3[matrix][40])\n", + "plt.legend()" + ], + "execution_count": 66, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.025791287281387982\n", + "65961.02744391997\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 66 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H89VoqI63Its" + }, + "source": [ + "## Applying Scaling at Algorithm 2" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 169 + }, + "id": "fSBD29VE9Q_M", + "outputId": "56f656f6-eae0-4afc-9811-d28e7cbc3103" + }, + "source": [ + "_, _, plotdata_alg2 = run_alg3_for_mnist([1., 20.], apply_scaling_at_alg2=True)" + ], + "execution_count": 56, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplotdata2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun_alg3_for_mnist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20.\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mapply_scaling_at_alg2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'run_alg3_for_mnist' is not defined" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "0H6d7l1l9Mhf", + "outputId": "18146a7d-cf3d-4cc9-d657-a81b256a60e1" + }, + "source": [ + "for matrix in plotdata:\n", + " plt.plot(plotdata[matrix], label=matrix)\n", + "plt.legend()" + ], + "execution_count": 126, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 126 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9pw_-N3ZMBpU" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OW4PnHDb9NeQ" + }, + "source": [ + "## Additional Plotting" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 264 + }, + "id": "YkjBk2uk3vh5", + "outputId": "76424b10-61dc-4028-e067-160d48e38d0c" + }, + "source": [ + "plt.subplot(1, 3, 1)\n", + "plt.imshow(w1[:16,:16]) #, cmap=plt.cm.BuPu_r)\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(w1_approx[:16,:16]) #, cmap=plt.cm.BuPu_r)\n", + "plt.subplot(1, 3, 3)\n", + "plt.imshow(w1[:16,:16] - w1_approx[:16,:16]) #, cmap=plt.cm.BuPu_r)\n", + "\n", + "plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9)\n", + "cax = plt.axes([0.85, 0.1, 0.075, 0.8])\n", + "plt.colorbar(cax=cax)\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAD3CAYAAAC0COucAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3Rc1X0v8O9Po9FbliVLtmVbfmIMxryCg6EEF4oBJ2liaHiYpCznXlJuVsNdaXKTQm/apCFpLrlJyfu2McENpCEOCSU4xMExJBRKDNiYhGAb28JPCfkh2bJe1mvmd//QmMzot8fS0Wxpzsjfz1pa1uzZZ2af2XP80zn7d/YWVQUREVE25GW7AUREdOZiECIioqxhECIioqxhECIioqxhECIioqxhECIioqxhECIiOoOIyHIR2Ski9SJyj+P5pSKyVUT6ReSmQc/FROR3iZ91XtrD+4SIiPy4/upSbTkWy2obXnmtZ4OqLnc9JyIRALsAXAugAcBmALep6vakOrMBTADwKQDrVPWnSc91qGqZz/bm+3wxIqIzWcuxGF7eMDOrbYjU7q4+zdOXAqhX1T0AICJrAawA8HYQUtV9iefio9jMtzEIERF5ogDiGJP/u0+nWkS2JD1eraqrE79PB3Aw6bkGAEsCvHZR4rX7Adynqj/LrKkMQkREHilimvUg1Kyqi0fptWepaqOIzAXwaxH5g6q+mckLMggREXkycCYU6nH2RgB1SY9nJMqGRVUbE//uEZFnAVwMgEGIiCgMFIo+zW5iwhA2A5gvInMwEHxWAvjgcDYUkUoAXaraIyLVAK4A8H8zbRCDEBGRR2E+E1LVfhG5C8AGABEAa1R1m4jcC2CLqq4TkXcCeBxAJYD3icjnVfU8AOcC+G4iYSEPA2NC29O81bAxRZuIyJOLLizQZ345OattqJ7e+Moojgl5xzMhIiKPwnwmFEYMQkREniiAGK8uBcIgRETkUdYTtHMMgxARkScKRYyX4wJhECIi8kWBGGNQIAxCRESeDNysSkEwCBEReaIQ9Klkuxk5hUGIiMijGBiEgmAQIiLyRMEgFBSDEBGRR3FejguEQYiIyBOeCQXHIERE5IlCEENetpuRUxiEiIg84uW4YBiEiIg84eW44BiEiIi8EcSUl+OCYBAiIvJEAfQhku1m5BQGISIiT1R5JhQUgxARkUdxjgkFwiBEROTJQGICz4SCYBAiIvKGl+OCYhAiIvJkYCkHBqEgGISIiDyK8WbVQBiEiIg84bQ9wTEIERF5FOeYUCAMQkREnsQh6FXerBoEgxARkUdMTAiGQYiIyBNVMEU7IAYhIiJvhDMmBMQgRETkiYJnQkExCBERecQU7WAYhIiIPFEIV1YNiEGIiMgjngkFwyBEROSJgjerBsUgRETkiULQx5tVA2EQIiLyKMYU7UAYhIiIPFEVXo4LiJ8WEZFHMc3L6s9QRGS5iOwUkXoRucfx/FIR2Soi/SJy06DnVonI7sTPKh+fF8+EiIg8GVjULryX40QkAuA7AK4F0ABgs4isU9XtSdUOAPgwgE8N2rYKwOcALMbArr6S2PZ4Jm1iECIi8ib0y3tfCqBeVfcAgIisBbACwNtBSFX3JZ6LD9r2egAbVfVY4vmNAJYD+FEmDWIQIiLyZCBFO+tnQtUisiXp8WpVXZ34fTqAg0nPNQBYMszXdW07fcStTGAQIiLyKAQ3qzar6uJsN2K4GISIiDzJgWl7GgHUJT2ekSgb7rZXDdr22UwbxCBEROSJKsJ+s+pmAPNFZA4GgspKAB8c5rYbAHxJRCoTj68D8HeZNohBiIjIozCfCalqv4jchYGAEgGwRlW3ici9ALao6joReSeAxwFUAnifiHxeVc9T1WMi8gUMBDIAuPdUkkImGISIiDwZuByX9TGh01LV9QDWDyr7bNLvmzFwqc217RoAa3y2h0GIiMgjTtsTDIMQEZEnIUnRzikMQkRE3oT/clzYMAgREXkU5ml7wohBiIjIE1UgxstxgTAIERF5xMtxwTAIERF5ohD0MwgFwiBEROQJs+OCYxAiIvKIl+OCYRAiIvJFQz+BaegwCBEReRL2lVXDiEGIiMgjngkFwyBEROQJExOCYxAiIvKIQSgYBiEiIk9yYGXV0GEQIiLyRcGbVQNiECIi8oRjQsExCBERecQgFAyDEBGRJxwTCi6ji5cislxEdopIvYjc46tRlDn2TXixb8Y3VcnqT64Z8ZmQiEQAfAfAtQAaAGwWkXWquj3dNpHSUs2vqkp9HU3z+v22LNoeczXEuX28wMZXneR4UQD9vfZjiLY5Gpbnfq+83rgp66m2dSXPvbORE7atYl8yrc7jDc2qWvP2tiPom4KJxVoytTylLHaowFm3v9DuW7wkTUc65OfbftRW91cxVmTL8nptWbTT/YH1lTu+BxFbr6Cx07l9b22pfa8O977Go/Zz6TqWed/kF5dqtCL1uIm7uwZ5PbasoKXbFqY5brTA9oPMcBx3ALq7bCMKHMdNrMD9XtFO+7rdU2x/lRc52g+g+3CxKUuXE+A6ngYfN75wxoRgMrkcdymAelXdAwAishbACgDpD6aqKkz/xN+klOX1ujusqNmWT3uuzZRpvvtb11Fnv6C9q44767bsqzRlMzbag6m/2P1eZQftQVL/V/Z/umhxn3P7iU/a/+jye9z/0UnMlm/66af3DyoK3DclU8ux9IFbUsqOf2WWs27rWfZr03aBIzKkUT3Z0Y8/m+Sse3yh3d+yA7Yfpv623bl9wzXlpqy/zL7m7M9scm5/8K/+xL7XJsf/9ABOTo6aspd/+KmM+yZaUYV5t38ypaxjpjvolu+xn830h3fYigW2rQAQn2b/T867333c7No605TV/cr+odde536vmhft677xyTJTtuw8R/sB7PjKIlPWV+I+RqNd9vPa9BNz3GRMlWNCQWVyOW46gINJjxsSZSlE5E4R2SIiW2Kd7r82ybvAfdPbenLMGneGC37cdPG4ySW8HBfMqCcmqOpqAKsBoLCubvjXbGjUJffNxHMms29CJLlviqfyuMkdTEwIKpMg1AigLunxjEQZZR/7JrzYN+OYAojFebNqEJkEoc0A5ovIHAwcRCsBfPB0GxS0Keo2pl4zjjgG9QFg33vtoOex8xzX9z9wzLl9R6f9a6R/rx37AYCazfZLEyu0f3z2VLj/wumutONPFZtt3YI292iyqH2vjmnuL3Jx87AyFgL3Te/xQux7bF5KWWFlugF4W1a60+5bukHimr9tMWVNt1Y76+Y5htF6r7DjP/Wz7bgaAFT+wdGPfbZvdn/jMuf2tQsOmbKT9ZOddQ+9y9E3PzQlgfsm2hnHlC2pl0unvOyuu3dFoSlrvX6BKZMPH3FuP73M7u/m1+c5agJ1z9v9jbbZDivocP83c2hplSmresn2167/OM+5fckxOxbbdIX7ezDp9QCZPpnQgXEhGr4RByFV7ReRuwBsABABsEZVt3lrGY0Y+ya82DfjH7PjgsloTEhV1wNY76kt5BH7JrzYN+OXAjmZHJBNnDGBiMgbJiYExSBEROQRx4SCYRAiIvKIl+OCGdMg1FsuaLg6NbWq4k133dgEe+d18zV2mo+83e6Mt8pt9oswYb/7rv69K+zHMP/fu0xZ07tKnNtPO/uoKSv+4gRTduxu+5oA0N5hs+tmf9NZFc0XutuQqfJJnbhm1YspZeufcGeMvWfFi6Zs4w9tXdf0OABwcvFcUxbtdP/5GCu2WU2VJTYrasY7bFYXAORdYl9330PzTVndL92zAuy5Zaopm5jnzrQ69377PTjgrBlMf3EeWhamzl9U0O7+vKJtNiXx6Pvt9y6+3Z3h11Vv93fedve0OfvfYzPxzvrH3absxFUXObfvOd+2a97X7TE+7zv2NQHg6TfPNmVzv2pn4wCAg9fZ43E0RuVUGYSC4pkQEZFHHBMKhkGIiMijeJxBKAgGISIiTxS5OX9bNjEIERF5xOS4YMY0CBWeiGP2k6nTj7x1pXugfcIOOzdM8RE70n10sfu9mi+3iQ0acU+bM/1ZO9B8/Fw7pXxp3Qnn9k077CDvZDvLPQB3YkLfSbuvvZVppgiqGZ2/stqbS/Hs6iUpZbGrO5x1m7orTFn5QTugnHatqLh9on2We79KGm2fd++zyw3UL3V/lTta7fer0pEwsXuVnUIGACZvtvv11vXu9XW6ptTawn92Vg0kvzOGyZtTpypqvthOYQUANa/Z7333fpv4cvQK99paPX9m+7yjzR4LADD9N/Y1Wm+4wJSdPMed2FBQb9vVPsd+N15sci8pEonYutLn7pt0STLe5UBigogsB/ANDMzY8T1VvW/Q84UAHgZwCYAWALeq6j4RmQ1gB4CdiaovqupHM20Pz4SIiHwK8anQMBdVvAPAcVU9S0RWAvgygFsTz72pqu50xxHidK9ERB6FfD2htxdVVNVeAKcWVUy2AsBDid9/CuAakTRL8XrAIERE5JFqdn8AVJ9aEDHxc2dS84azqOLbdVS1H8AJAKeWPp4jIq+KyH+KyJU+Pi9ejiMi8iQkE5g2q2qa0fKMNAGYqaotInIJgJ+JyHmq6r5DeJjGNAj1leWZWQei7rFvlBy1yQJ5/fZi68Sz3He6l35voik7Mcf95cjrsyeEXVNs3ZICx+I2AGLNdvv8bjtA2vvzSaYMAGY22bqdU9wjqZVXuGcGyFR8Qgwnr00d/J72b3bgGABat9hEiqZ/cFRMdyyW2b6tes59Ib1vgn2RSLetO/XTPc7tm6+w34POWvua8x+yaxwBwJ5bbcLC9F86q6KrZnQGA/pLImi+MDURoSdN4kqs0B7S1b+3S7d33+hOFpj2eftdfuvqNBdMHLvbUWfr3rjod87N1++1s2wUttpjrO237uNmxia7X0eWuJMozlq2x5TtvNdZNTMKIPtB6HSGs6jiqToNIpIPoAJAi6oqgB4AUNVXRORNAGcD2JJJg3g5jojII41n92cIby+qKCIFGFhUcd2gOusArEr8fhOAX6uqikhNIrEBIjIXwHwANroHxMtxRETehPtm1XSLKorIvQC2qOo6AA8C+IGI1AM4hoFABQBLAdwrIn0A4gA+qqrupa0DYBAiIvIpxCnagHtRRVX9bNLv3QBudmz3GIDHfLeHQYiIyJccuFk1bDIKQiKyD0A7gBiA/lHKyKARYN+EF/tmnAv5mVDY+DgTulpVm4dVMw5EBiXl9LgTX1Cx146wnZhrm1tZ5M6KOrLQ1u2a5Z6qZMrzNj9j6sv2dffMcE/tUnKJnc6ntddObdM1zT1q2Fdu21rU7P4mF97vbkMaw+4b7c/DyROpa9YcutRmwQHArKNTTFnJweHPi9LpmJqlv8T916NrOqDCY46paea4P5c2R0Zk2QHH+08oMmUAMPVF+14Hl7n3dcav3VPGpDHsvhEFIoOSxuJpjtxiR1ZpyyK7b7Mrm5zbH7zcrvXUvsi9DldRi/1+1Lxq6z6+0H2DfemFrabsaLfNZuxa6M7ka4za7M3qP7iP8bb76pzlo4NnQkHwchwRkU88Ewok0xRtBfArEXll0F25bxORO0/duRs72Znh21EAwfqmg30zhgL1TX83+yanaJZ/ckymZ0LvUtVGEZkMYKOIvKGqzyVXUNXVAFYDQPGUuhz8iHJWoL4pnD2DfTN2AvVNaTWPm5wR/ptVQyejMyFVbUz8ewTA4xiYHI9CgH0TXuyb8S3kN6uGzojPhESkFECeqrYnfr8OwGknwhAAMmjsNu989xo9xU/Yst4Jdg2V5o7S4TUYQKTTHXOPXG7/0GzusWsPzXzKPfDcOtcmIZw4304/UrnV/XEX3zD8qXg04mjDhtSHI+mbSJegctB0PJO/556NI2+i3d/Ypx318txHxPQf2alVekvdf+x33m6/H42NE0zZOavd8z/N/oKdMmb3V20y2okF7nWtdv/lv5iy627+sLPuhd/6vSn7r5+nPh5J32gE6B00fdHVN77irLvjnkWmrPQt2w+v75/m3L7A5pxATroTMdrm2r/4T5xlkxWm/sLdt80XF5qy/hn2+z35V+51wI5eYvfrgs/YPgCAp3YttIXrbZEXPBMKJJPLcVMAPJ6Y4TsfwCOq+pSXVlGm2Dfhxb4Z59It5khuIw5CqroHwIUe20KesG/Ci30zzuVockA2MUWbiMgb4eW4gBiEiIh84plQIAxCREQ+MQgFMqZBKBYFOqen9lB0q820AoCu++y0IgXftplwvdvc29fstlk2b7kTgjDvx3aqkfpVNiPItZgaAEzdZBcW7Kq1mXwT693Tn+x/Y7IpK9vvzuQrXHbUWZ6peD5wcnLqZYTI5Gpn3WN/OtOUVZUfMWXRNNlxx6fbPitvdGce3n7WJlP2zc6rTVnnbPdiZr3n2Uy4eKl9rymb3Blgt/zJNabs6MXuTLr/2O6anuYnzrpBxKNA57TU7976Te6pcN71xR2mrHlVjSmreNmRBgdgwn477c2Bv3D3zazPvWTK6r9mF6oranEvBjlvrV2U7sC77bQ9pU3uqbk6Dtnsuud/eImzbuGV7izcUcEgFAjPhIiIfOHNqoExCBEReSQ5eMNoNnF5byIiyhqeCRERecSbVYMZ0yAU6QXKDqZeLy065j537Toy1ZQdu9kOUBa/4d6FvH77Tah9zn2ttqPODnCWV9uBzO5PuwdI39pk21pgcxXw1lL39CPxCpuwUP2asyoaK93JAhkTmGVQ3lox21k10mc/29ZtNrkiHnUfjRWOce54xN039z9/vSkrqbGzSh9c7v5sJ9baNWuKX7ZrD8Xz3d/D9o/Z/eq4u8tZd+537T7sc9YMJq8HmPBmalmh4/sFANtfO8+UtdxtEwMmpPl+ieO4mfZL97pSfdc51uKrscdI+9+4ZwFv/YVdTCziyN05cJ27bysX2SSdmrvcyT875tQ6y0cFx4QC4ZkQEZEvnDEhMAYhIiKfGIQCYRAiIvKIY0LBMAgREfnEIBTI2M6YUAi0zUsdAJaYexCv9IgdKC4ps4Oe5fvSrDVygd21kkPub0flLkfCwaP2rv6iw+47vwv+53Fb+JtKW5ZmwDI60d45vudD7rvyq2panOUZU0AG7V6/uwk4We7YD8e4frr7JSRm+yHuHvtGZIIdaFbH5xitcCeNiOPP0liRLWuf6b5bobTJfgjxmHvHjl5QbAufdVYNJFYEtC5MbfPEHe72TthnP6/O621Z1U73d/HQZbYjig+7j5uJm+w6WHO/a2dnKGhw980b93bb13y+yFHT3dZpZTY747VPzHbWnXWunYFlv7OmBwxCgfBMiIjIE1FA4syOC4JBiIjIJ54JBcIgRETkERMTgmEQIiLyiUEokCGDkIisAfDnAI6o6qJEWRWAHwOYjYGbwm9RVcfoPI2mA19/Em2b6wHg7dvk2Tfh0PD0WrTt3Q6wb84syjOhoIZzJvR9AN8G8HBS2T0AnlHV+0TknsTju4d6ocLjccz7SWomWLzQvY5LZ63Neut+c4Ktt8ydsZZ/1Gb5VO202TgAsP+jNttJ1dYt3eROF4u9aKf9qXi3zRyKfsNOUwIA/fV27aGSUnf2U3fVH6ftqai8EpXvXYY3H7k/ucqI+iavDyg+mnr0iHsZGXSe78h2anOkt6WZHjdWZJ/od3cjPn/Jz03Z3//2BlMWLbLr4ABA6wG7Pg0qbH+72gQAe263Zelm/T1x0R+z0KLFF6GmaAkOff5byVVG1DdFLTHM/0FqJlisxJ1O6DqedIdda2nfCnfn5rfb/0FrXnVPu7P7r+tMWV+N7chpv3JPmTNhk/0kozfYdalqPuvKmAO6fmuny5o1wb1fXZvTLCY2GhiEAhlyFm1VfQ7AsUHFKwA8lPj9IQD2fwUadaUz5iFSZAIj+yYEihbMRV6pSdlm35wJNMs/OWakY0JTVPVU4v0hAO5lGgGIyJ0A7gSAogL3Kqjk1Yj6JlrmuK+JfBvZcRPlcZNLeDkumIzXE1LV08ZfVV2tqotVdXE0apfnptETpG/yi9g3YylI3xTkp7lrmGgcGOmZ0GERqVXVJhGpBWAv5FK2sG/Ci30z3ilXVg1qpEFoHYBVAO5L/PvEcDbSiKCvIjXhoGeiOzGhzDHVR89tdh2Xmi/ZpAAA2PtxO0DaMc0xrQqAwq32hHDa8x12+5nub9eRG2wSQ/8j9kpLpNA9aFq23w78ti6wg8kAMOXl1M/gZHcXdqVWGVHfxMrjaL0ydT/mfs9dt7zRfm323ej4bNKcZ3dPsk8U2GV/AAB//8wH3E8MMuXn7q9yd4V9rxMLHNu/lKZvV9rv0axvpkli+IvUNsTbTJtG1DdQhfSmJl4cv9h9ia5inz1uIufZ6W0WfqzZuf2u+20SQdsc95lY+V5bNvXbb5myY0tnOrePX2cTA6MP2OSdjlnOzVH+1OumrOVDFzjrTt1o2zVqeDkukCEvx4nIjwBsArBARBpE5A4MHETXishuAMsSj2mMvb7zUWx5bTUAFLJvwuXID/4dTd/4FsC+OfOEPDFBRJaLyE4RqU9kaQ5+vlBEfpx4/iURmZ303N8lyneKiF1xcgSGPBNS1dvSPHWNjwbQyC1acAsA4JkX/mGrqiYvc8m+ybLJt/8lAGDvJz/FvjmDCMKdmCAiEQDfAXAtgAYAm0VknapuT6p2B4DjqnqWiKwE8GUAt4rIQgArMXDv2zQAT4vI2aqa5maO4ck4MYGIiJKE+0zoUgD1qrpHVXsBrMXArQPJkm8l+CmAa0REEuVrVbVHVfcCqE+8XkY4bQ8RkS/hmDGhWkS2JD1eraqrE79PB3Aw6bkGAEsGbf92HVXtF5ETACYlyl8ctO30TBs7xusJCdpmpb5l6wJ3j8XLbNNqHqsyZfKlA+73emuyKWu/ud1Zt2eXnYlh3/tsyvKcn9lkBQDofdomEbS+1yYbTHnEfed305X2/dMsPYTWFY4B9BfcdYPIO5mHkj+kJm60zXL3zaRf7DRl0asco/1pDsa+iXYfuqvdCSqTttryiF0eBxO2Njq3L6619z+1zbUD7ccXuN+/v9HW7ap171jRHPf3K1P9pfk4uiR1wL75nWlmPLjlhCmreqDalMnawfefJ97rTXvc9dzmnlnoRL39bE/Mt1kEMzc4OgxAl2PNrSMr7TE2/QH37BBHP2iTELonuQ+c7Z+x6xzhDmfVzGU/CDUPugQcajwTIiLyKftB6HQaASTPtzQjUeaq0yAi+QAqALQMc9vAOCZEROSRaHZ/hrAZwHwRmSMiBRhINFg3qM6pWwkA4CYAv07cXL0OwMpE9twcAPMBvJzp58UzISIiXxTOpe7DIjHGcxeADQAiANao6jYRuRfAFlVdB+BBAD8QkXoMzBu6MrHtNhF5FMB2AP0APpZpZhzAIERE5FUIEhNOS1XXA1g/qOyzSb93A7g5zbb/BOCffLaHQYiIyKeQB6GwGdMgpBGguyo1eyXiWJoGAC6/bLcp23zkXFO2rPKgKQOAXQfsWiN9O2wWGgAsuXqHKdu6fqEp081/cG5/4pMX2vdqt+sh3fp/func/l/XvM+UTdrmXmCntd+uPeRDtD2Oac+mZnd11rmna+m6bJ4pc609lG49okinHYrsqUyTcdZiy4pbHGsHdbu/SHlbbN/2rXyHrXi2e80cPWyneio+5H6v9823l8f/t7NmMP1FQOs5qWXS5x7O/eDMLabs/y16rym7sdpmOALAtnqbcXvyFfc6WP/tA782ZQ+vv9qUFb60y5QBwPn32ozEF353tim7/mu/cW7/6LeWmbKqne4v3ZRXbJk7rzZzYT8TChueCRER+cQgFAiDEBGRL8Ocv43+iEGIiMgTSfzQ8DEIERH5xDOhQMY0CBVV9ODc96QOUr72/Hxn3XdMsMOGDS/Yuv/5+8ud208utH+PHL7CPWi5r81OB1TaaL9Jb371Muf2+bvsIHGxY6aSj73HnUTx1XNs5b5ym9gAABG7dJEXElfk9aZ+Pl017sFvzbcDygV2tpi0iQl9jkVc+8vcR25xi30RzbN92zfHJqIAQH6ZTa7IP2m3j0bdjS3cb/e1v8w9jcwLx2zChg+1E1txz/sfTym7b92NzrrzCw+Zshm/OWnKnnjVDuoDwIyo/Wwar3J/Nnu77HRAZftsvTe+aZMNAAC/t59tuWPaoLtvsElKAPCvly81Za3H3X1Ts3Xs/qtjYkIwPBMiIvIpxDerhhGDEBGRL+GYRTunMAgREfnEIBQIgxARkUc8EwpmyFm0RWSNiBwRkdeTyv5RRBpF5HeJn/eMbjPJpenJtdj99c8CA8vtAmDfhMXv73sGG9//IMC+OfOEe2XV0BnOmdD3AXwbwMODyr+mql8N8mZxFXT1p2Z9FZxwZ9U/+MhyU9ZzjR3xKz7sjqMnp9i6s3/mHjFsumKKKSucaNtVeY5jDhkAJ//LZgl1LrBTuyz96zud21fMtN3QNc39bard9McpawqKL0bkosvw6m+/Obha4L6JFUbQMSd1SiDX4nEAUNJop805do7jq5TugHB0WZ57liLECm3lvD77wpGTaV7AIdJl+7arwS5MCACYYzPDqra7q+4+krRw2mWXYepVS3Hgb787uFrgvumOR/HGydqUsnTHzcfX/ndTFrvBfl4ljWmOm8m27tkPuxfre677fFNWUGnb9e5F25zb/+rZi01Zx/n2uLnu5g87t685y2aQNl/qPsarXjrqLB8NPBMKZsgzIVV9DgPTeVPITKyai2jUzm1G2VeycDYiZeybM062z4JyMABmsqjdXSLyWuJynV2nN0FE7hSRLSKypfeEvV+BRkXgvunrcS9dTt4F7puu1jSz/FI4MQgFMtIg9C8A5gG4CEATgH9OV1FVV6vqYlVdXFDBvwzHwIj6JlqY5nIU+TSivimZWDhW7aMMCUK/smrojCg7TlUPn/pdRB4A8KS3FlFG2Dfhxb45M0g8ByNBFsnA0uFDVBKZDeBJVV2UeFyrqk2J3z8BYImqrhzG6xwFsD/xsBpA88iaHVrZ2KcCAAtVNR9g35zGeOib8dgvQPb2a5aq1gxdbfhKq+v03BWf8PmSgb2y5n+9oqqLs9qIAIY8ExKRHwG4CkC1iDQA+ByAq0TkIgxcgfCb4C0AAAagSURBVNwH4H8M582SO1xEtuTSBzUcY71PSX2j7JvTGw99Mx77BRh/+5WLl8SyacggpKq3OYofHIW2UEDsm/Bi35zBGIQC4YwJREQe8UwomGwGodVZfO/RMl72abzsR7LxsE/jYR9cxtd+MQgFkrUgpKrj64uH8bNP42U/ko2HfRoP++AyrvYrR9Oks4mX44iIfGIQCiSTGRNGRESWi8hOEakXkXvG+v19STOxa5WIbBSR3Yl/094RH0bsm/Bi3+QG3qwa3JgGIRGJAPgOgHcDWAjgNhFZOJZt8Oj7AAbPsnoPgGdUdT6AZxKPcwL7JrzYN7lF4prVn1wz1mdClwKoV9U9qtoLYC2AFWPcBi/STOy6AsBDid8fAnDDmDYqM+yb8GLf5IpszxuXezFozMeEpgM4mPS4AcCSMW7DaJpy6o54AIcA2DUiwot9E17smxwi7tUkKA0mJowSVVWRXLxCO/6xb8JrXPRNbrd+zI315bhGAHVJj2ckysaLwyJSCwzMEwbgSJbbEwT7JrzYNzmEiQnBjHUQ2gxgvojMEZECACsBrBvjNoymdQBWJX5fBeCJLLYlKPZNeLFvcoUCUM3uT44Z08txqtovIncB2AAgAmCNqrrX/g25NBO73gfgURG5AwOzHt+SvRYGw74JL/ZNbsnFs5FsGtZSDkRENLSyyjq96OqPZ7UNLzz+6fG1lAMREQ3PqZtVafgYhIiIfNHcvGE0mxiEiIh8YgwKZMznjiMiGs9yOUV7uPP4iciqRJ3dIrIqqfzZxByHv0v8TB7qPRmEiIh8UQBxze5PZoacx09EqjCQ1bgEA1NKfW5QsPqQql6U+Bnyni8GISIinzTLP5kZzjx+1wPYqKrHVPU4gI2wk9IOG8eEiIg8CkF2XLWIbEl6vDrAwoHDmcfPNZfh9KTH/yYiMQCPAfiiDnEfEIMQEZFP2b/3svl09wmJyNMApjqe+kzygxHO4/chVW0UkXIMBKHbATx8ug0YhIiIPArBmdBpqeqydM+JyGERqVXVptPM49eIgVkvTpkB4NnEazcm/m0XkUcwMGZ02iDEMSEiIl+yPR6UeQAczjx+GwBcJyKViYSE6wBsEJF8EakGABGJAvhzAK87tk/BMyEiIk8EgMRCfip0es55/ERkMYCPqupHVPWYiHwBAxPrAsC9ibJSDASjKAbmOHwawANDvSGDEBGRR5L9MaERU9UWANc4yrcA+EjS4zUA1gyq0wngkqDvySBEROSLn0tiZxQGISIibzQM2XE5hUGIiMijsGfHhQ2DEBGRTzwTCoRBiIjIFwUknu1G5BYGISIin3gmFAiDEBGRT4xBgTAIERF5JHFejwuCQYiIyBcFwBgUCIMQEZEnAs3pGROygUGIiMgnBqFAGISIiHxiEAqEQYiIyBeOCQXGIERE5BHHhIJhECIi8olBKBAGISIibziLdlAMQkREviiA3F5ZdcwxCBERecQxoWAYhIiIfGIQCoRBiIjIFwUQZxAKgkGIiMgbJiYExSBEROQTg1AgDEJERD4xCAXCIERE5AvHhAJjECIi8kYB5eRxQTAIERH5ogBiDEJBMAgREfnEMaFAGISIiHxiEAqEQYiIyBveJxQUgxARkS8KIM4xoSAYhIiIfOKZUCAMQkREPjEIBcIgRETkjfJm1YAYhIiIfFFAebNqIAxCREQ+8WbVQBiEiIh8UWV2XEB52W4AEdG4oprdnwyISJWIbBSR3Yl/K9PUe0pEWkXkyUHlc0TkJRGpF5Efi0jBUO/JIERE5JHG41n9ydA9AJ5R1fkAnkk8dvkKgNsd5V8G8DVVPQvAcQB3DPWGDEJERN5k+Swo8/TwFQAeSvz+EIAbnHup+gyA9uQyEREAfwbgp0Ntn4xjQkREvoRjPaFqEdmS9Hi1qq4e5rZTVLUp8fshAFMCvO8kAK2q2p943ABg+lAbMQgREfmU/RTtZlVdnO5JEXkawFTHU59JfqCqKiKjHlEZhIiIPFEAmv0zodNS1WXpnhORwyJSq6pNIlIL4EiAl24BMFFE8hNnQzMANA61EceEiIh80cTKqtn8ycw6AKsSv68C8MTwd10VwG8A3BRke54JERF5pLFYtpuQifsAPCoidwDYD+AWABCRxQA+qqofSTx+HsA5AMpEpAHAHaq6AcDdANaKyBcBvArgwaHeUJST7REReSEiTwGoznIzmlV1eZbbMGwMQkRElDUcEyIioqxhECIioqxhECIioqxhECIioqxhECIioqxhECIioqz5/yjXx9iz6ApOAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "ROem_bjX6Omt", + "outputId": "37efc5b4-9351-468b-dcc8-552050b6db35" + }, + "source": [ + "n, bins, patches = plt.hist(w1_approx)\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "11hBiLThyDAn", + "outputId": "0d0732a9-bb50-4b99-90cb-d325bd8b77ef" + }, + "source": [ + "print(f'Mean - orig/approx: {w1.mean()} / {w1_approx.mean()}')\n", + "print(f'Standard dev - orig/approx: {w1.std()} / {w1_approx.std()}')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Mean - orig/approx: -0.0028598906937986612 / 4.747437826569501e-05\n", + "Standard dev - orig/approx: 0.16066423058509827 / 0.012329364365807786\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 301 + }, + "id": "CDhyTTdv5wt3", + "outputId": "1a07f185-9ef5-4119-bc71-c892f0b45f25" + }, + "source": [ + "cr = []\n", + "\n", + "m, n = w1.shape\n", + "for r in range(R, (min(m, n))):\n", + " tmp = 2 * m * n / get_approx_size(r, 2, m, n)\n", + " if tmp < 2:\n", + " break\n", + " cr.append(tmp)\n", + "\n", + "print('Current Compression Ratio (CR):', 2 * m * n / get_approx_size(R, 2, m, n))\n", + "plt.plot(cr)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Current Compression Ratio (CR): 6.862144420131291\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 68 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rhuPyqNv5Pxk" + }, + "source": [ + "# More than 2 Matrix Approximation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zY1BfLH75W2l" + }, + "source": [ + "## Dividing weight matrix into 4" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "do28lklc5gLG", + "outputId": "e73d1c51-b0ed-4401-f58c-834a3ee87a27" + }, + "source": [ + "models['fashion'].summary()\n", + "mnist_dense = [w, b] = models['mnist'].get_layer('dense_1').get_weights()\n", + "print(w.shape)\n", + "r, h = w.shape[0] // 2, w.shape[1] // 2\n", + "blocks = np.reshape(w, (4, r, h))\n", + "tmp = np.reshape(blocks, w.shape)\n", + "print(blocks.shape)\n", + "print(np.allclose(w, tmp))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model: \"fashion_mnist\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten_1 (Flatten) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 128) 100480 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 101,770\n", + "Trainable params: 101,770\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "(784, 128)\n", + "(4, 392, 64)\n", + "True\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "I7EF65FC7LR0", + "outputId": "c7b9cc8e-65ba-4140-bba1-8647764bb1e3" + }, + "source": [ + "R = 64\n", + "metric = 'mse'\n", + "threshold = 1e-5\n", + "scaler = [1.] * blocks.shape[0]\n", + "\n", + "logname = 'mnist_4blocks'\n", + "logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}'\n", + "logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S')\n", + "writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname))\n", + "%reload_ext tensorboard\n", + "\n", + "%time w_approx = algorithm3_inverse(*algorithm3(blocks, \\\n", + " num_refinements=R, \\\n", + " num_sub_matrix=1, \\\n", + " decomposition='eigen', \\\n", + " stop_threshold=threshold, \\\n", + " metric=metric, \\\n", + " scaler=scaler, \\\n", + " report_writer=writer))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 36 s, sys: 19.5 s, total: 55.5 s\n", + "Wall time: 28.6 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 404 + }, + "id": "QHpnUNBG8aVe", + "outputId": "05a8f3c4-21ee-43c4-8feb-e46266a7d92c" + }, + "source": [ + "k, m, n = blocks.shape\n", + "print(f'CR: {k * m * n / get_approx_size(R, k, m, n)}')\n", + "\n", + "models['mnist'].get_layer('dense_1').set_weights([w, b])\n", + "_, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + "print('MNIST - Test accuracy:', mnist_acc)\n", + "\n", + "models['mnist'].get_layer('dense_1').set_weights([np.reshape(w_approx, w.shape), b])\n", + "print('')\n", + "\n", + "_, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + "print('MNIST - Test accuracy:', mnist_acc_approx)\n", + "\n", + "print('\\nMNIST - Accuracy drop:', mnist_acc - mnist_acc_approx)\n", + "\n", + "plot_accuracies(['mnist'], [mnist_acc], [mnist_acc_approx])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CR: 3.408695652173913\n", + "MNIST - Test accuracy: 0.9664999842643738\n", + "\n", + "MNIST - Test accuracy: 0.9455999732017517\n", + "\n", + "MNIST - Accuracy drop: 0.02090001106262207\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ukjOI4iC-uZq" + }, + "source": [ + "# Different Sizes Approximation" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9UVwhZqY_c5-", + "outputId": "9b636135-0888-4a9d-b749-6c99818afea6" + }, + "source": [ + "w1 = np.random.randint(9, size=(4, 8))\n", + "w2 = np.random.randint(9, size=(5, 4))\n", + "\n", + "max_shape = max_r, max_c = max(w1.shape[0], w2.shape[0]), max(w1.shape[1], w2.shape[1])\n", + "print(max_shape)\n", + "\n", + "padded_w1 = np.zeros(max_shape)\n", + "padded_w2 = np.zeros(max_shape)\n", + "padded_w1[:w1.shape[0], :w1.shape[1]] = w1\n", + "padded_w2[:w2.shape[0], :w2.shape[1]] = w2\n", + "\n", + "print(w1)\n", + "print(w2)\n", + "print(padded_w1)\n", + "print(padded_w2)\n", + "\n", + "def pad_matrices(matrices):\n", + " max_r = max([m.shape for m in matrices],key=lambda item:item[0])[0]\n", + " max_c = max([m.shape for m in matrices],key=lambda item:item[1])[1]\n", + " padded_matrices = []\n", + " for i in range(len(matrices)):\n", + " z = np.zeros((max_r, max_c))\n", + " z[:matrices[i].shape[0], :matrices[i].shape[1]] = matrices[i]\n", + " padded_matrices.append(z)\n", + " return padded_matrices\n", + "\n", + "pad_matrices([w1, w2])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(5, 8)\n", + "[[7 2 7 6 4 2 4 0]\n", + " [1 2 6 0 7 4 2 8]\n", + " [3 1 0 6 7 1 3 6]\n", + " [1 8 5 8 0 1 1 6]]\n", + "[[4 8 6 1]\n", + " [0 8 8 2]\n", + " [0 7 3 7]\n", + " [6 1 2 1]\n", + " [5 0 8 3]]\n", + "[[7. 2. 7. 6. 4. 2. 4. 0.]\n", + " [1. 2. 6. 0. 7. 4. 2. 8.]\n", + " [3. 1. 0. 6. 7. 1. 3. 6.]\n", + " [1. 8. 5. 8. 0. 1. 1. 6.]\n", + " [0. 0. 0. 0. 0. 0. 0. 0.]]\n", + "[[4. 8. 6. 1. 0. 0. 0. 0.]\n", + " [0. 8. 8. 2. 0. 0. 0. 0.]\n", + " [0. 7. 3. 7. 0. 0. 0. 0.]\n", + " [6. 1. 2. 1. 0. 0. 0. 0.]\n", + " [5. 0. 8. 3. 0. 0. 0. 0.]]\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[array([[7., 2., 7., 6., 4., 2., 4., 0.],\n", + " [1., 2., 6., 0., 7., 4., 2., 8.],\n", + " [3., 1., 0., 6., 7., 1., 3., 6.],\n", + " [1., 8., 5., 8., 0., 1., 1., 6.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0.]]),\n", + " array([[4., 8., 6., 1., 0., 0., 0., 0.],\n", + " [0., 8., 8., 2., 0., 0., 0., 0.],\n", + " [0., 7., 3., 7., 0., 0., 0., 0.],\n", + " [6., 1., 2., 1., 0., 0., 0., 0.],\n", + " [5., 0., 8., 3., 0., 0., 0., 0.]])]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 87 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DPDdcWtdn9YB", + "outputId": "9effbc7a-29b7-46c8-cd7b-2948d0c09f2e" + }, + "source": [ + "import operator\n", + "\n", + "def get_cr_multi_size_matrix(R, matrices):\n", + " max_m = max([m.shape for m in matrices],key=lambda item:item[0])[0]\n", + " max_n = max([m.shape for m in matrices],key=lambda item:item[1])[1]\n", + " approx_size = get_approx_size(R, len(matrices), max_m, max_n)\n", + " orig_size = sum(map(lambda x: operator.mul(*x.shape), matrices))\n", + " return orig_size / approx_size\n", + "\n", + "w1 = np.random.randint(9, size=(4, 8))\n", + "w2 = np.random.randint(9, size=(5, 4))\n", + "\n", + "orig_size = operator.mul(*w1.shape) + operator.mul(*w2.shape)\n", + "print(orig_size)\n", + "get_cr_multi_size_matrix(1, [w1, w2])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "52\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "3.466666666666667" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 97 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "2gm0zUYTsHtz", + "outputId": "f4ef0364-7818-40cb-e4e0-7223d7d1b84a" + }, + "source": [ + "cr = []\n", + "cr_small = []\n", + "cr_big = []\n", + "\n", + "small_size = 128\n", + "medium_size = 512\n", + "large_size = 1024\n", + "w1 = np.random.randint(9, size=(medium_size, small_size))\n", + "w2 = np.random.randint(9, size=(large_size, medium_size))\n", + "\n", + "for r in range(small_size // 4, small_size):\n", + " m, n = w1.shape\n", + " tmp = 2 * m * n / get_approx_size(r, 2, m, n)\n", + " cr_small.append(tmp)\n", + " m, n = w2.shape\n", + " tmp = 2 * m * n / get_approx_size(r, 2, m, n)\n", + " cr_big.append(tmp)\n", + " tmp = get_cr_multi_size_matrix(r, [w1, w2])\n", + " if tmp < 2:\n", + " break\n", + " cr.append(tmp)\n", + "\n", + "plt.plot(cr, label='CR')\n", + "plt.plot(cr_small, label='CR_small')\n", + "plt.plot(cr_big, label='CR_big')\n", + "plt.legend()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 98 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "euTcBc3P_aoN" + }, + "source": [ + "## CNN-LSTM Model" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QzUlHRh0v5Lm", + "outputId": "f0c8f966-4aa7-43c2-8806-f08c6f5ce9e0" + }, + "source": [ + "print(models['cnn-lstm'].get_layer('LSTM_1').get_weights()[0].shape)\n", + "print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[0].shape)\n", + "print(len(models['cnn-lstm'].get_layer('LSTM_1').get_weights()))\n", + "print(len(models['cnn-lstm'].get_layer('LSTM_2').get_weights()))\n", + "\n", + "print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[1].shape)\n", + "\n", + "[w1, r1, b1] = models['cnn-lstm'].get_layer('LSTM_1').get_weights()\n", + "[w2, r2, b2] = models['cnn-lstm'].get_layer('LSTM_2').get_weights()\n", + "\n", + "[w1_pad, w2_pad] = pad_matrices([w1, w2])\n", + "print(w1_pad, w2_pad)\n", + "print(w1_pad.shape)\n", + "print(w2_pad.shape)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(2048, 256)\n", + "(64, 128)\n", + "3\n", + "3\n", + "(32, 128)\n", + "[[ 0.03283332 0.03514677 -0.00596567 ... 0.03670166 -0.00393717\n", + " -0.0284326 ]\n", + " [-0.01096857 -0.0448408 -0.02966657 ... 0.01016361 -0.05727449\n", + " 0.02986955]\n", + " [-0.00811409 -0.0135733 -0.04766004 ... 0.04387834 -0.00304517\n", + " 0.02890401]\n", + " ...\n", + " [-0.00517103 0.01756404 0.01726159 ... -0.04113563 -0.02533144\n", + " 0.04300131]\n", + " [-0.01353051 0.02406969 0.00367547 ... 0.01924247 -0.04716729\n", + " 0.02338111]\n", + " [-0.03106386 -0.03033421 0.03282609 ... 0.0066899 0.00302576\n", + " -0.03358177]] [[-0.05971472 -0.14265421 0.13733262 ... 0. 0.\n", + " 0. ]\n", + " [ 0.02199466 0.14343984 0.07385601 ... 0. 0.\n", + " 0. ]\n", + " [ 0.06103988 0.01135218 0.11987313 ... 0. 0.\n", + " 0. ]\n", + " ...\n", + " [ 0. 0. 0. ... 0. 0.\n", + " 0. ]\n", + " [ 0. 0. 0. ... 0. 0.\n", + " 0. ]\n", + " [ 0. 0. 0. ... 0. 0.\n", + " 0. ]]\n", + "(2048, 256)\n", + "(2048, 256)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yG6MC6NUwvQm", + "outputId": "be2a4d36-d03e-414f-a3e0-cc98fea441a8" + }, + "source": [ + "R = 25\n", + "metric = 'mse'\n", + "threshold = 1e-5\n", + "scaler = [1., 1.]\n", + "\n", + "logname = 'cnn-lstm'\n", + "logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}'\n", + "logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S')\n", + "writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname))\n", + "%reload_ext tensorboard\n", + "\n", + "# %time u, s, v = algorithm3([w1_pad, w2_pad], \\\n", + "# num_refinements=R, \\\n", + "# num_sub_matrix=1, \\\n", + "# decomposition='eigen', \\\n", + "# stop_threshold=threshold, \\\n", + "# metric=metric, \\\n", + "# scaler=scaler, \\\n", + "# report_writer=writer)\n", + "\n", + "%time u, s, v = algorithm3_extra_refinements([w1_pad, w2_pad], u, s, v, \\\n", + " num_refinements=R, \\\n", + " num_sub_matrix=1, \\\n", + " decomposition='eigen', \\\n", + " stop_threshold=threshold, \\\n", + " metric=metric, \\\n", + " scaler=scaler, \\\n", + " report_writer=writer)\n", + "w_approx = algorithm3_inverse(u, s, v)\n", + "\n", + "\n", + "w1_approx, w2_approx = w_approx[0], w_approx[1]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 3min 4s, sys: 26.1 s, total: 3min 30s\n", + "Wall time: 1min 49s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 389 + }, + "id": "Ly_vcfqcw7Be", + "outputId": "bdb3aadf-c61f-42ed-822c-8bca62d0b48a" + }, + "source": [ + "models['cnn-lstm'].get_layer('LSTM_1').set_weights([w1, r1, b1])\n", + "models['cnn-lstm'].get_layer('LSTM_2').set_weights([w2, r2, b2])\n", + "\n", + "_, cnn_lstm_acc = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels, verbose=0)\n", + "print(f'CNN-LSTM - Test accuracy: {cnn_lstm_acc}')\n", + "\n", + "models['cnn-lstm'].get_layer('LSTM_1').set_weights([w1_approx[:w1.shape[0], :w1.shape[1]], r1, b1])\n", + "models['cnn-lstm'].get_layer('LSTM_2').set_weights([w2_approx[:w2.shape[0], :w2.shape[1]], r2, b2])\n", + "\n", + "_, cnn_lstm_approx_acc = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels, verbose=0)\n", + "print(f'\\nCNN-LSTM - Test accuracy: {cnn_lstm_approx_acc} (approx)')\n", + "print(f'\\nAccuracy drop: {cnn_lstm_acc - cnn_lstm_approx_acc}')\n", + "\n", + "plot_accuracies(['cnn_lstm'], [cnn_lstm_acc], [cnn_lstm_approx_acc])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CNN-LSTM - Test accuracy: 0.65625\n", + "\n", + "CNN-LSTM - Test accuracy: 0.34375 (approx)\n", + "\n", + "Accuracy drop: 0.3125\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3wV9Z3/8debAEYEpSrdRVBBK2IQwRLwUi8o2kWtULVasCj0It5oa7fW2tW1VNy2FlfXeqmrq7W2Cigqsi1df10ptWhXCBXLTbagVOJlC3gDESXw+f0xE3qIJ+FEM2SSvJ+PRx6cmfnOzGcmh/POfGfOjCICMzOzvGnX3AWYmZkV44AyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5Q1SNI/SfqPpm5bwrJC0ieaYlnWMkn6taSxzV1HMZLmSPpKc9fR2jmg2hBJ4yQtkrRR0muSfiKpa0PzRMT3I6Kk/4iNadsUJN0rqUZS9521ztZCiRckLW3uWuoTEadExM+aermSeqV/ALVv6mVb03JAtRGSvglcD3wL2AM4Etgf+I2kjvXMk9v/wJJ2A84C3gLG7OR153a/NMJxwMeBAyQNzmolrWRfWTNxQLUBknYHvgd8NSL+KyI2R8Qq4BygF+kHvKSJkqZL+oWkt4Fx6bhfFCzrfEl/kbRO0j9LWiXppIL5f5G+rv0rdayklyStlXRVwXKGSPqDpDclvSrp1vqCsh5nAW8C1wLbdQNJ2lPSTyW9IukNSTMKpo2UtFDS25JWShqejt+2HQ1sy5clvQTMTsc/lB6JviXpSUn9CubfVdK/pvvqLUlz03G/kvTVOvX+SdIZdTcw7eKaUGfcc5LOTI+AbpL013RbFkk6tBH7byzwGDCryP6bI+kHkualy35M0p519sX4dP++KunyOvut7ntoH0kzJb0uaYWkC9K2B6bjPpkO7yNpjaShBXV8JX09TtJT6Ta/mR79HZ2OX53uh7EFdZwm6dm0/tWSJhZs4pPpv29K2iDpqHSeL0lalr5nHpe0f8HyTpb0fPq7vBVQI/a1fVgR4Z9W/gMMB2qA9kWm/QyYkr6eCGwGPkvyx8uu6bhfpNMrgA3AMUBH4Ia0/UkF89e27QUEcFe6nAHAe8Ah6fRBJEdx7dO2y4DLCuoK4BMNbNMTwI+Av0u3bVDBtF8B04CPAR2A49PxQ0iOuE5Ot68H0Dedtqp2OxrYlvuA3YBd0/FfAroAuwD/BiwsmP82YE66jjLg6LTdOcAzBe0GAOuAjkW28XzgqYLhCpJQ3gX4B2AB0JXkw/IQoHuJ74dOwNvAqSRBv7Zw/WndLwOHptv7cJF9MSWd1h9YU+c9UPc99CRwO1AODEzbn5i2vwBYmtb0OHBDnTq+kr4el/6ev5juz+uAl9L9vAvwaWA90DltPzStrR1wGPB/wGfrbEP7gnWNBFak+7E9cDXwdDpt73TZnyN5P30jreUrzf1/u7X/NHsB/tkJv+TkCOm1eqb9EPhN+noi8GSd6RMLPpyuIQ2zdLgT8D4NB1TPgvbzgFH11HEZ8GjBcL0BBewHbAUGpsOPAzenr7un0z5WZL5/B26qZ5mr2HFAHdDAPu6attkj/VB8FxhQpF058AZwUDp8A3B7PcvsArwD7J8O/wtwT/r6ROB/SUK+3Yd4P6xJP4jLSUL7jILpc4AfFgxXpL/nsoJ90bdg+o+Au4u9h4B9gS1Al4JxPwDuLRieCSwC/gTsUqeOwoD6c8G0/mkdf1cwbl3te6LINv9b7e+e4gH1a+DLBcPtgI0k3eDnA/9TME1ANQ6ozH/cxdc2rAX2VvHzAd3T6bVWN7CcfQqnR8RGkg+FhrxW8Hoj0BlAUh9Jv0y7yN4Gvk/yl2opzgOWRcTCdPh+4FxJHUg+EF+PiDeKzLcvsLLEdRSzbdsllUn6YdpN+DZJwEGyDXuTfPB/YF0RsYnk6G6MpHbAaODnxVYWEetJjgZHpaNGk2wrETEbuJXkCOKvku5U0pVbirHAgxFRk9bzMHW6+dj+ffAXkiOHvRuYvk890/Yh+X2sr9O+R8HwXSRHa7dExHsN1P1/Ba/fBYiIuuNq319HSPpt2mX4FnARDb+/9gduTrsP3wReJwmiHnzwfR80/P/EmogDqm34A0n32pmFIyV1Bk4h6S6r1dDt7V8FehbMvyuw14es6SfA8yRHErsD/0Tp/frnk5zcf03Sa8CNJB8+p5J8cOyp4lcnrgYOrGeZ75AcEdb6+yJtCvfNuSTdQieRHDX1SseLJPA3NbCunwFfAIYBGyPiD/W0g6QrbXR6nqQc+O22YiJ+HBGDSI5w+pBcANMgST1Jjr7GFOy/zwGnSir8AN+34PV+JN12axuY/krBcOF+eoXk99GlTvuX03o6kxzd3A1MrD3X1QQeIDky2zci9gDu4G/vr2Lv8dXAhRHRteBn14h4muR9v217JYntt98y4oBqAyLiLZKLJG6RNFxSB0m9gAdJuiqK/gVfxHTg9PTkdEeS7pwPe7K4C8l5kA2S+gIXlzJT+kF9IMn5pIHpz6EkH0jnR8SrJN01t0v6WLqtx6Wz3w18UdIwSe0k9UjXDbAQGJW2ryT50N5R/e+RHEF2IjkCBCAitgL3ADemJ/7LJB0laZd0+h9IuiH/lR3v+1kkf91fC0xLl42kwelRQgeScN2ULnNHziPpGjyYv+2/PiTvg9EF7cZIqpDUKV339IjYUjD9nyV1UnJhyBdJjgo/ICJWA08DP5BULukw4MtA7YU3NwNVkXw94VckQdIUupAcuW2SNITkD4paa0j21QEF4+4AvpNuD5L2kHR2Ou1XQD8lF6e0B75G8T9grIk5oNqIiPgRyVHKDSTB8AzJX43DdtCtUriMJcBXgakkf1VuAP5K8kHdWJeTfGisJ+niKfoBV8RY4LGIWBQRr9X+kHzQfSb9C/w8kr/4n0/ruyytfx7Jh+lNJOddfkfy4Q/wzyTB9wZJmD+wgzruI+mqepnkJP//FNm+RcB8ku6i69n+/9t9JOdRfkED0t/NIyRHaoU17U6y395I61gHTIZtX5j+dT2LHEtyzuu1OvvvDrbv5vs5cC9JF205yYdyod+RXFTwBMmFDf+vgc0YTXKE+QrwKPDdiPhvSSNJLuCp/ePkH4FPSvpCA8sq1SXAtZLWk5w7fbB2Qto1/S/AU2mX3pER8SjJ72hq2mW7mKR3gYhYC5xNcr52HXAQ8FTt8iQdK2lDE9RsdSjpTjVrvLR75k2SbroXm7uelkTS+cD4iDimuWupS9IckgtEPnBXkPTI+0WgQ0TU7NzKrK3xEZQ1iqTT066d3UiOxhbxtwsErARpt9klwJ3NXYtZnjmgrLFGknTVvELS1TEqfBheMkn/QHIO5P/YcTeiWZvmLj4zM8slH0GZmVkutbgbOe69997Rq1ev5i7DzMyayIIFC9ZGRLe641tcQPXq1YuqqqrmLsPMzJqIpL8UG+8uPjMzyyUHlJmZ5ZIDyszMcqnFnYMyMytm8+bNVFdXs2nTpuYuxepRXl5Oz5496dChQ0ntHVBm1ipUV1fTpUsXevXqRXLDccuTiGDdunVUV1fTu3fvkuZxF5+ZtQqbNm1ir732cjjllCT22muvRh3hOqDMrNVwOOVbY38/DigzM8sln4Mys1ap15W/atLlrfrhaTtsU11dzaWXXsrSpUvZunUrn/nMZ5g8eTIdO3bcrt0rr7zC1772NaZPn97g8k499VQeeOABunYt9oDohk2cOJHOnTtz+eWXN3revGiTAdXUb1yzLJTygWj5ERGceeaZXHzxxTz22GNs2bKF8ePHc9VVVzF58uRt7Wpqathnn312GE4As2bNyrLk3HMXn5lZE5g9ezbl5eV88YtfBKCsrIybbrqJe+65h9tvv50RI0Zw4oknMmzYMFatWsWhhx4KwMaNGznnnHOoqKjgjDPO4Igjjth2O7devXqxdu1aVq1axSGHHMIFF1xAv379+PSnP827774LwF133cXgwYMZMGAAZ511Fhs3bmyeHZABB5SZWRNYsmQJgwYN2m7c7rvvzn777UdNTQ1//OMfmT59Or/73e+2a3P77bfzsY99jKVLlzJp0iQWLFhQdPl//vOfufTSS1myZAldu3bl4YcfBuDMM89k/vz5PPfccxxyyCHcfffd2WxgM3BAmZntBCeffDJ77rnnB8bPnTuXUaNGAXDooYdy2GGHFZ2/d+/eDBw4EIBBgwaxatUqABYvXsyxxx5L//79uf/++1myZEk2G9AMHFBmZk2goqLiA0c/b7/9Ni+99BLt27dnt912+0jL32WXXba9Lisro6amBoBx48Zx6623smjRIr773e+2qjtpOKDMzJrAsGHD2LhxI/fddx8AW7Zs4Zvf/Cbjxo2jU6dO9c73qU99igcffBCApUuXsmjRokatd/369XTv3p3Nmzdz//33f/gNyKE2eRWfmbV+O/sqSEk8+uijXHLJJUyaNImtW7dy6qmn8v3vf58pU6bUO98ll1zC2LFjqaiooG/fvvTr14899tij5PVOmjSJI444gm7dunHEEUewfv36pticXFBENHcNjVJZWRkf9YGFvszcWgJfZt44y5Yt45BDDmnuMhpty5YtbN68mfLyclauXMlJJ53E8uXLP/Ddqdai2O9J0oKIqKzb1kdQZmbNaOPGjZxwwgls3ryZiOD2229vteHUWA4oM7Nm1KVLFz5qr1Br5YskzMwslxxQZmaWSw4oMzPLJQeUmZnlki+SMLPWaWLp3yUqbXlvldRsxowZnHHGGSxbtoy+ffs2bQ0lKPVRHqWYMWMGffr0oaKiolHzde7cmQ0bNnzk9fsIysysCU2ZMoVjjjmmwS/nNkbtLY1KVeqjPEoxY8YMli5d2iTL+jAyDShJwyUtl7RC0pX1tDlH0lJJSyQ9kGU9ZmZZ2rBhA3PnzuXuu+9m6tSpAMyZM4fjjjuO0047jYMPPpiLLrqIrVu3AsmRxje+8Q369evHsGHDWLNmDQBDhw7lsssuo7KykptvvpknnniCww8/nP79+/OlL32J9957j/nz53PYYYexadMm3nnnHfr168fixYu3e5THvffey2c/+1lOPvlkevXqxa233sqNN97I4YcfzpFHHsnrr78OFH9kx9NPP83MmTP51re+xcCBA1m5ciUrV65k+PDhDBo0iGOPPZbnn38egBdffJGjjjqK/v37c/XVVzfZ/swsoCSVAbcBpwAVwGhJFXXaHAR8B/hURPQDLsuqHjOzrD322GMMHz6cPn36sNdee227eey8efO45ZZbWLp0KStXruSRRx4B4J133qGyspIlS5Zw/PHH873vfW/bst5//32qqqq49NJLGTduHNOmTWPRokXU1NTwk5/8hMGDBzNixAiuvvpqrrjiCsaMGbMtmAotXryYRx55hPnz53PVVVfRqVMnnn32WY466qht9w0s9siOo48+mhEjRjB58mQWLlzIgQceyPjx47nllltYsGABN9xwA5dccgkAX//617n44otZtGgR3bt3b7L9meUR1BBgRUS8EBHvA1OBkXXaXADcFhFvAETEXzOsx8wsU1OmTNn26IxRo0Zt6+YbMmQIBxxwAGVlZYwePZq5c+cC0K5dOz7/+c8DMGbMmG3jgW3jly9fTu/evenTpw8AY8eO5cknnwTgmmuu4Te/+Q1VVVVcccUVRWs64YQT6NKlC926dWOPPfbg9NNPB6B///6NemTHhg0bePrppzn77LMZOHAgF154Ia+++ioATz31FKNHjwbgvPPO+5B774OyvEiiB7C6YLgaOKJOmz4Akp4CyoCJEfFfdRckaTwwHmC//fbLpFgzs4/i9ddfZ/bs2SxatAhJbNmyBUmcdtppSNqubd3hYuNLeTzHunXr2LBhA5s3b2bTpk1F5yl8TEe7du22Dbdr1267R3bMmDGDAQMGcO+99zJnzpwPLGfr1q107dqVhQsX7rD2ptLcF0m0Bw4ChgKjgbskda3bKCLujIjKiKjs1q3bTi7RzGzHpk+fznnnncdf/vIXVq1axerVq+nduze///3vmTdvHi+++CJbt25l2rRpHHPMMUDyoV97QcMDDzywbXyhgw8+mFWrVrFixQoAfv7zn3P88ccDcOGFFzJp0iS+8IUv8O1vf/tD117fIzu6dOmy7e7ou+++O7179+ahhx4CICJ47rnngOSRIbXn3JrykR9ZHkG9DOxbMNwzHVeoGngmIjYDL0r6X5LAmp9hXWbWFpR4WXhTmTJlygdC4qyzztp2vmjChAmsWLGCE044gTPOOANIjpLmzZvHddddx8c//nGmTZv2geWWl5fz05/+lLPPPpuamhoGDx7MRRddxH333UeHDh0499xz2bJlC0cffTSzZ8/mgAMOaHTt9T2yY9SoUVxwwQX8+Mc/Zvr06dx///1cfPHFXHfddWzevJlRo0YxYMAAbr75Zs4991yuv/56Ro6seybnw8vscRuS2gP/CwwjCab5wLkRsaSgzXBgdESMlbQ38CwwMCLW1bdcP27D2go/bqNx8vq4jTlz5nDDDTfwy1/+8gPTmur7Qi1JYx63kVkXX0TUABOAx4FlwIMRsUTStZJGpM0eB9ZJWgr8FvhWQ+FkZmZtR6Z3koiIWcCsOuOuKXgdwD+mP2Zmrc7QoUMZOnRo0Wlt7eipsZr7IgkzsybT0p4Q3tY09vfjgDKzVqG8vJx169Y5pHIqIli3bh3l5eUlz+ObxZpZq9CzZ0+qq6u33S7I8qe8vJyePXuW3N4BZWatQocOHejdu3dzl2FNyF18ZmaWSw4oMzPLJQeUmZnlkgPKzMxyyQFlZma55IAyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5SZmeWSA8rMzHLJAWVmZrnkgDIzs1xyQJmZWS45oMzMLJccUGZmlksOKDMzyyUHlJmZ5ZIDyszMcskBZWZmuZRpQEkaLmm5pBWSriwyfZykNZIWpj9fybIeMzNrOdpntWBJZcBtwMlANTBf0syIWFqn6bSImJBVHWZm1jJleQQ1BFgRES9ExPvAVGBkhuszM7NWJMuA6gGsLhiuTsfVdZakP0maLmnfYguSNF5SlaSqNWvWZFGrmZnlTHNfJPGfQK+IOAz4DfCzYo0i4s6IqIyIym7duu3UAs3MrHlkGVAvA4VHRD3TcdtExLqIeC8d/A9gUIb1mJlZC5JlQM0HDpLUW1JHYBQws7CBpO4FgyOAZRnWY2ZmLUhmV/FFRI2kCcDjQBlwT0QskXQtUBURM4GvSRoB1ACvA+OyqsfMzFqWzAIKICJmAbPqjLum4PV3gO9kWYOZmbVMzX2RhJmZWVEOKDMzyyUHlJmZ5ZIDyszMcskBZWZmueSAMjOzXHJAmZlZLjmgzMwslxxQZmaWSw4oMzPLJQeUmZnlkgPKzMxyyQFlZma55IAyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5SZmeWSA8rMzHLJAWVmZrnkgDIzs1xyQJmZWS45oMzMLJccUGZmlkuZBpSk4ZKWS1oh6coG2p0lKSRVZlmPmZm1HDsMKEmnS2p0kEkqA24DTgEqgNGSKoq06wJ8HXimseswM7PWq5Tg+TzwZ0k/ktS3EcseAqyIiBci4n1gKjCySLtJwPXApkYs28zMWrkdBlREjAEOB1YC90r6g6Tx6ZFPQ3oAqwuGq9Nx20j6JLBvRPyqoQWl66uSVLVmzZodlWxmZq1ASV13EfE2MJ3kKKg7cAbwR0lf/bArTrsNbwS+WcL674yIyoio7Nat24ddpZmZtSClnIMaIelRYA7QARgSEacAA2g4XF4G9i0Y7pmOq9UFOBSYI2kVcCQw0xdKmJkZQPsS2pwF3BQRTxaOjIiNkr7cwHzzgYMk9SYJplHAuQXzvwXsXTssaQ5weURUlV6+mZm1VqV08U0E5tUOSNpVUi+AiHiivpkiogaYADwOLAMejIglkq6VNOIj1GxmZm1AKUdQDwFHFwxvSccN3tGMETELmFVn3DX1tB1aQi1mZtZGlHIE1T69TByA9HXH7EoyMzMrLaDWFHbJSRoJrM2uJDMzs9K6+C4C7pd0KyCS7zadn2lVZmbW5u0woCJiJXCkpM7p8IbMqzIzszavlCMoJJ0G9APKJQEQEddmWJeZmbVxpXxR9w6S+/F9laSL72xg/4zrMjOzNq6UiySOjojzgTci4nvAUUCfbMsyM7O2rpSAqr3L+EZJ+wCbSe7HZ2ZmlplSzkH9p6SuwGTgj0AAd2ValZmZtXkNBlR6x/EnIuJN4GFJvwTK0/vomZmZZabBLr6I2EryVNza4fccTmZmtjOUcg7qCUlnqfb6cjMzs52glIC6kOTmsO9JelvSeklvZ1yXmZm1caXcSWJHj3Y3syxM3KO5KzDbsYnZnfXZYUBJOq7Y+LoPMDQzM2tKpVxm/q2C1+XAEGABcGImFZmZmVFaF9/phcOS9gX+LbOKzMzMKO0iibqqgUOauhAzM7NCpZyDuoXk7hGQBNpAkjtKmJmZZaaUc1BVBa9rgCkR8VRG9ZiZmQGlBdR0YFNEbAGQVCapU0RszLY0MzNry0q6kwSwa8HwrsB/Z1OOmZlZopSAKi98zHv6ulN2JZmZmZUWUO9I+mTtgKRBwLvZlWRmZlZaQF0GPCTp95LmAtOACaUsXNJwScslrZB0ZZHpF0laJGmhpLmSKhpXvpmZtValfFF3vqS+wMHpqOURsXlH80kqI3lUx8kk352aL2lmRCwtaPZARNyRth8B3AgMb+Q2mJlZK7TDIyhJlwK7RcTiiFgMdJZ0SQnLHgKsiIgXIuJ9YCowsrBBRBTeFX03/vZ9KzMza+NK6eK7IH2iLgAR8QZwQQnz9QBWFwxXp+O2I+lSSSuBHwFfK2G5ZmbWBpQSUGWFDytMu+46NlUBEXFbRBwIfBu4ulgbSeMlVUmqWrNmTVOt2szMcqyUgPovYJqkYZKGAVOAX5cw38vAvgXDPdNx9ZkKfLbYhIi4MyIqI6KyW7duJazazMxaulIC6tvAbOCi9GcR239xtz7zgYMk9ZbUERgFzCxsIOmggsHTgD+XUrSZmbV+pVzFt1XSM8CBwDnA3sDDJcxXI2kC8DhQBtwTEUskXQtURcRMYIKkk4DNwBvA2A+/KWZm1prUG1CS+gCj05+1JN9/IiJOKHXhETELmFVn3DUFr7/eyHrNzKyNaOgI6nng98BnImIFgKRv7JSqzMyszWvoHNSZwKvAbyXdlV4goQbam5mZNZl6AyoiZkTEKKAv8FuSWx59XNJPJH16ZxVoZmZt0w6v4ouIdyLigYg4neRS8WdJruwzMzPLTCmXmW8TEW+k30kallVBZmZm0MiAMjMz21kcUGZmlksOKDMzyyUHlJmZ5ZIDyszMcskBZWZmueSAMjOzXHJAmZlZLjmgzMwslxxQZmaWSw4oMzPLJQeUmZnlkgPKzMxyyQFlZma55IAyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5SZmeVSpgElabik5ZJWSLqyyPR/lLRU0p8kPSFp/yzrMTOzliOzgJJUBtwGnAJUAKMlVdRp9ixQGRGHAdOBH2VVj5mZtSxZHkENAVZExAsR8T4wFRhZ2CAifhsRG9PB/wF6ZliPmZm1IFkGVA9gdcFwdTquPl8Gfl1sgqTxkqokVa1Zs6YJSzQzs7zKxUUSksYAlcDkYtMj4s6IqIyIym7duu3c4szMrFm0z3DZLwP7Fgz3TMdtR9JJwFXA8RHxXob1mJlZC5LlEdR84CBJvSV1BEYBMwsbSDoc+HdgRET8NcNazMyshcksoCKiBpgAPA4sAx6MiCWSrpU0Im02GegMPCRpoaSZ9SzOzMzamCy7+IiIWcCsOuOuKXh9UpbrNzOzlisXF0mYmZnV5YAyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5SZmeWSA8rMzHLJAWVmZrnkgDIzs1xyQJmZWS45oMzMLJccUGZmlksOKDMzyyUHlJmZ5ZIDyszMcskBZWZmueSAMjOzXHJAmZlZLjmgzMwslxxQZmaWSw4oMzPLJQeUmZnlkgPKzMxyyQFlZma5lGlASRouabmkFZKuLDL9OEl/lFQj6XNZ1mJmZi1LZgElqQy4DTgFqABGS6qo0+wlYBzwQFZ1mJlZy9Q+w2UPAVZExAsAkqYCI4GltQ0iYlU6bWuGdZiZWQuUZRdfD2B1wXB1Oq7RJI2XVCWpas2aNU1SnJmZ5VuLuEgiIu6MiMqIqOzWrVtzl2NmZjtBlgH1MrBvwXDPdJyZmdkOZRlQ84GDJPWW1BEYBczMcH1mZtaKZBZQEVEDTAAeB5YBD0bEEknXShoBIGmwpGrgbODfJS3Jqh4zM2tZsryKj4iYBcyqM+6agtfzSbr+zMzMttMiLpIwM7O2xwFlZma55IAyM7NcckCZmVkuOaDMzCyXHFBmZpZLDigzM8slB5SZmeWSA8rMzHLJAWVmZrnkgDIzs1xyQJmZWS45oMzMLJccUGZmlksOKDMzyyUHlJmZ5ZIDyszMcskBZWZmueSAMjOzXHJAmZlZLjmgzMwslxxQZmaWSw4oMzPLJQeUmZnlkgPKzMxyKdOAkjRc0nJJKyRdWWT6LpKmpdOfkdQry3rMzKzlyCygJJUBtwGnABXAaEkVdZp9GXgjIj4B3ARcn1U9ZmbWsmR5BDUEWBERL0TE+8BUYGSdNiOBn6WvpwPDJCnDmszMrIVon+GyewCrC4argSPqaxMRNZLeAvYC1hY2kjQeGJ8ObpC0PJOKzXJEsDd1/i+Y5c73muSYYv9iI7MMqCYTEXcCdzZ3HWY7k6SqiKhs7jrMmkuWXXwvA/sWDPdMxxVtI6k9sAewLsOazMyshcgyoOYDB0nqLakjMAqYWafNTGBs+vpzwOyIiAxrMjOzFiKzLr70nNIE4HGgDLgnIpZIuhaoioiZwN3AzyWtAF4nCTEzS7hb29o0+YDFzMzyyHeSMDOzXHJAmZlZLjmgzMwslxxQZjkmaY6ker8LJWmcpH12Zk1mO4sDyqxlGwc4oKxVahF3kjDLO0nnA5cDAfwJ2AK8DVQCfw9cEYYHdScAAAGVSURBVBHTJQ0FJpLcwuhQYAEwZkff/0tvvnx3urwA7iG5TVglcL+kd4GjgGXAFJKbNNeQ3CLsB8AngMkRcUeTbbRZxhxQZh+RpH7A1cDREbFW0p7AjUB34BigL8mX0qensxwO9ANeAZ4CPgXM3cFqBgI9IuLQdJ1dI+LN9LuGl0dEVToe4KWIGCjpJuDedPnlwGLAAWUthrv4zD66E4GHImItQES8no6fERFbI2Ip8HcF7edFRHVEbAUWAr1KWMcLwAGSbpE0nOTorD61d2xZBDwTEesjYg3wnqSupW+WWfNyQJll572C16pn/BZK6MmIiDeAAcAc4CLgP0pY79Y669payrrM8sIBZfbRzQbOlrQXQNrF16Qk7Q20i4iHSboTP5lOWg90aer1meWB/5oy+4jSe0z+C/A7SVuAZzNYTQ/gp5Jq/6j8TvrvvcAdBRdJmLUavhefmZnlkrv4zMwsl9zFZ5YDkh4FetcZ/e2IeLw56jHLA3fxmZlZLrmLz8zMcskBZWZmueSAMjOzXHJAmZlZLv1/a2R6suh+eE8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ykQbfnSia2rf" + }, + "source": [ + "# Minimization" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IvprTTb8vXiM" + }, + "source": [ + "# Playing with Images" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 335 + }, + "id": "gTMiHnm-wHfV", + "outputId": "329ed68a-6e85-4956-d3c6-3687d63c0265" + }, + "source": [ + "img = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/mugs.jpg') #.convert('L')\n", + "img = img.resize([int(0.8 * s) for s in img.size])\n", + "img_array = np.array(img).transpose([2, 0, 1]).astype('float32')\n", + "num_inputs, input_size, output_size = img_array.shape\n", + "print(img_array.shape)\n", + "img" + ], + "execution_count": 110, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(3, 300, 364)\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 110 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 353 + }, + "id": "oZpmPT3Xvzjb", + "outputId": "86a8e721-10e3-4652-fe5c-906f249ca1aa" + }, + "source": [ + "%time img_approx = algorithm3_inverse(*algorithm3(img_array, num_refinements=64, num_sub_matrix=1, decomposition='eigen')).transpose([1, 2, 0])\n", + "image = img_approx.copy()\n", + "image *= (255.0 / image.max()) # .clip(min=0, max=255.0)\n", + "Image.fromarray(image.astype('uint8'))" + ], + "execution_count": 111, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 12.3 s, sys: 6.01 s, total: 18.3 s\n", + "Wall time: 9.42 s\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 111 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 354 + }, + "id": "2UqfaUomwfNm", + "outputId": "819c8b75-3c03-4882-fd1b-ac91f0d93b61" + }, + "source": [ + "%time img_approx = algorithm3_inverse(*algorithm3(img_array, num_refinements=64, num_sub_matrix=1, decomposition='svd')).transpose([1, 2, 0])\n", + "image = img_approx.copy()\n", + "image *= (255.0 / image.max()) # .clip(min=0, max=255.0)\n", + "Image.fromarray(image.astype('uint8'))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 20.2 s, sys: 12.9 s, total: 33.1 s\n", + "Wall time: 17.7 s\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 40 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "95vRr_e-z4k3" + }, + "source": [ + "### Combine three different images" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ca4XKLO6xNTc", + "outputId": "70d1cedc-7bbf-4cbd-c594-050d0bfe045c" + }, + "source": [ + "cat = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/cat.jpg').convert('LA').resize([512, 256])\n", + "mugs = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/mugs.jpg').convert('LA').resize([512, 256])\n", + "flower = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/sun_flower.png').convert('LA').resize([512, 256])\n", + "\n", + "cat_img = cat = ImageOps.grayscale(cat)\n", + "mugs_img = mugs = ImageOps.grayscale(mugs)\n", + "flower_img = flower = ImageOps.grayscale(flower)\n", + "\n", + "cat = np.array(cat).astype('float32')\n", + "mugs = np.array(mugs).astype('float32')\n", + "flower = np.array(flower).astype('float32')\n", + "\n", + "img_array = np.array([cat, mugs, flower])\n", + "print(img_array.shape)\n", + "\n", + "cat_img, mugs_img, flower_img" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "(3, 256, 512)\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(,\n", + " ,\n", + " )" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DtsG0HAx0ZF2", + "outputId": "baa91174-1101-4da8-9966-5a8fcbbb80a7" + }, + "source": [ + "R = 8\n", + "metric = 'frobenius-norm'\n", + "threshold = 1e-5\n", + "logname = 'base'\n", + "logname += '_R{}_{}_Th{}'.format(R, metric, threshold)\n", + "logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S')\n", + "writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname))\n", + "%reload_ext tensorboard\n", + "\n", + "%time img_approx = algorithm3_inverse(*algorithm3(img_array, \\\n", + " num_refinements=R, \\\n", + " num_sub_matrix=1, \\\n", + " decomposition='eigen', \\\n", + " stop_threshold=threshold, \\\n", + " metric=metric, \\\n", + " report_writer=writer))\n", + "img_approx *= (255.0 / img_approx.max()) # .clip(min=0, max=255.0)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 37.2 s, sys: 19.3 s, total: 56.5 s\n", + "Wall time: 29.1 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 273 + }, + "id": "bAq7iFZr1VNz", + "outputId": "b709c064-c873-4de9-afcb-8a83408f0ed2" + }, + "source": [ + "cat_approx = Image.fromarray(img_approx[0].astype('uint8'))\n", + "cat_approx" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 43 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 273 + }, + "id": "HyjrWdv_1dse", + "outputId": "c67a3738-2195-4264-9bed-ed364055f047" + }, + "source": [ + "mugs_approx = Image.fromarray(img_approx[1].astype('uint8'))\n", + "mugs_approx" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 44 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 273 + }, + "id": "4O3kBCij1fbQ", + "outputId": "a8f55cbe-48e9-4a89-c3ae-3220539d9747" + }, + "source": [ + "flower_approx = Image.fromarray(img_approx[2].astype('uint8'))\n", + "flower_approx" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NBaVEtJI6kZe", + "outputId": "4ac5ccd3-760a-4086-aba8-d4bfdf735b6a" + }, + "source": [ + "def frobenius(x, x_approx):\n", + " return np.sqrt(np.absolute(np.linalg.norm(x - x_approx)))\n", + "\n", + "def mse(x, x_approx):\n", + " return ((x - x_approx)**2).mean()\n", + "\n", + "print(mse(cat, cat_approx))\n", + "print(mse(mugs, mugs_approx))\n", + "print(mse(flower, flower_approx))\n", + "\n", + "# 402.30466\n", + "# 335.3521\n", + "# 365.27515" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1273.5289\n", + "1101.8867\n", + "995.1124\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "BdNuTMPCBezl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "afae78ce-4c5a-47c7-dbe8-0bf813904f49" + }, + "source": [ + "from tensorflow.python.training import gradient_descent\n", + "\n", + "x = tf.Variable(10.0, trainable=True)\n", + "\n", + "@tf.function\n", + "def f_x():\n", + " return 2 * x * x - 5 * x + 4\n", + "\n", + "for _ in range(20):\n", + " print([x.numpy(), f_x().numpy()])\n", + " opt = gradient_descent.GradientDescentOptimizer(0.1).minimize(f_x)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[10.0, 154.0]\n", + "[6.5, 56.0]\n", + "[4.4, 20.720001]\n", + "[3.14, 8.019201]\n", + "[2.384, 3.4469128]\n", + "[1.9304, 1.8008881]\n", + "[1.65824, 1.2083197]\n", + "[1.494944, 0.9949951]\n", + "[1.3969663, 0.9181981]\n", + "[1.3381798, 0.89055157]\n", + "[1.302908, 0.88059855]\n", + "[1.2817447, 0.8770151]\n", + "[1.2690468, 0.8757255]\n", + "[1.2614281, 0.87526155]\n", + "[1.2568569, 0.87509394]\n", + "[1.2541142, 0.87503386]\n", + "[1.2524685, 0.87501216]\n", + "[1.251481, 0.8750043]\n", + "[1.2508886, 0.87500143]\n", + "[1.2505331, 0.8750005]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 302 + }, + "id": "2Dd9tNm2oliL", + "outputId": "b0507c7d-a943-413d-ab20-2bab014b8cf6" + }, + "source": [ + "m, n = w1.shape\n", + "p = 2\n", + "u = tf.Variable([[np.random.rand()] * n], trainable=True)\n", + "v = tf.Variable([[np.random.rand()] * m], trainable=True)\n", + "s = tf.Variable([np.random.rand()] * p, trainable=True)\n", + "w = np.array([w1, w2])\n", + "\n", + "@tf.function\n", + "def f_x():\n", + " # # A = tf.Variable([[tf.constant_initializer(0)] * m] * n, trainable=False)\n", + " # for i in range(p):\n", + " # v_tmp = tf.transpose(v) * w[i].T\n", + " # # print('v_tmp.shape:', v_tmp.shape)\n", + " # A_tmp = v_tmp * u\n", + " # # print('A_tmp.shape:', A_tmp.shape)\n", + " # if i == 0:\n", + " # A = A_tmp * A_tmp\n", + " # else:\n", + " # A = A + (A_tmp * A_tmp)\n", + " # for i in range(p):\n", + " # s = tf.transpose(v) * w[i].T * u\n", + " # w_approx = s * u * tf.transpose(v)\n", + " # print('s.shape:', s.shape)\n", + " # print('w_approx.shape:', w_approx.shape)\n", + " # if i == 0:\n", + " # mse = (w[i].T - w_approx) * (w[i].T - w_approx)\n", + " # else:\n", + " # mse = mse + (w[i].T - w_approx) * (w[i].T - w_approx)\n", + "\n", + " uv = u * tf.transpose(v)\n", + " s_tmp = tf.expand_dims(tf.expand_dims(s, axis=1), axis=2)\n", + " approx = tf.reduce_sum(w - s_tmp * tf.stack([uv] * p), axis=0)\n", + " return -tf.norm(approx, ord='fro', axis=[-2,-1])\n", + "\n", + "norms = []\n", + "for _ in range(100):\n", + " # print([x.numpy(), f_x().numpy()])\n", + " # print(f_x().numpy())\n", + " norms.append(f_x().numpy())\n", + " opt = gradient_descent.GradientDescentOptimizer(0.0001).minimize(f_x)\n", + "\n", + "plt.plot(norms)\n", + "print(u.numpy().mean())\n", + "print(v.numpy().mean())" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0.27518278\n", + "0.6178978\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "weED2euaqB1Z", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 483 + }, + "outputId": "0ebfcde9-61c7-43b7-bed3-5d5438cfedeb" + }, + "source": [ + "models['mnist'].get_layer('dense_1').set_weights([w1, b1])\n", + "models['fashion'].get_layer('dense_1').set_weights([w2, b2])\n", + "_, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + "_, fashion_mnist_acc = models['fashion'].evaluate(test_images, test_labels, verbose=2)\n", + "print('MNIST - Test accuracy:', mnist_acc)\n", + "print('Fashion MNIST - Test accuracy:', fashion_mnist_acc)\n", + "\n", + "A = (u * tf.transpose(v)).numpy()\n", + "w1_approx = s[0].numpy() * A\n", + "w2_approx = s[1].numpy() * A\n", + "\n", + "models['mnist'].get_layer('dense_1').set_weights([w1_approx, b1])\n", + "models['fashion'].get_layer('dense_1').set_weights([w2_approx, b2])\n", + "print('')\n", + "\n", + "_, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0)\n", + "_, fashion_mnist_acc_approx = models['fashion'].evaluate(test_images, test_labels, verbose=2)\n", + "print('MNIST - Test accuracy:', mnist_acc_approx)\n", + "print('Fashion MNIST - Test accuracy:', fashion_mnist_acc_approx)\n", + "\n", + "print('\\nMNIST - Accuracy drop:', mnist_acc - mnist_acc_approx)\n", + "print('Fashion MNIST - Accuracy drop:', fashion_mnist_acc - fashion_mnist_acc_approx)\n", + "\n", + "plot_accuracies(list(models.keys()), [mnist_acc, fashion_mnist_acc],\n", + " [mnist_acc_approx, fashion_mnist_acc_approx])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "313/313 - 0s - loss: 0.3365 - accuracy: 0.8820\n", + "MNIST - Test accuracy: 0.9768999814987183\n", + "Fashion MNIST - Test accuracy: 0.8820000290870667\n", + "\n", + "313/313 - 0s - loss: 181.9923 - accuracy: 0.1000\n", + "MNIST - Test accuracy: 0.10279999673366547\n", + "Fashion MNIST - Test accuracy: 0.10000000149011612\n", + "\n", + "MNIST - Accuracy drop: 0.8740999847650528\n", + "Fashion MNIST - Accuracy drop: 0.7820000275969505\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4YXbwTychb0Q", + "outputId": "4fe386b3-d9e0-4702-c77a-fa7ffb8e6ebf" + }, + "source": [ + "# Use the GitHub version of TFCO\n", + "!pip install git+https://github.com/google-research/tensorflow_constrained_optimization\n", + "import tensorflow_constrained_optimization as tfco" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/google-research/tensorflow_constrained_optimization\n", + " Cloning https://github.com/google-research/tensorflow_constrained_optimization to /tmp/pip-req-build-na3snryk\n", + " Running command git clone -q https://github.com/google-research/tensorflow_constrained_optimization /tmp/pip-req-build-na3snryk\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from tfco-nightly==0.3.dev20210712) (1.19.5)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from tfco-nightly==0.3.dev20210712) (1.4.1)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from tfco-nightly==0.3.dev20210712) (1.15.0)\n", + "Requirement already satisfied: tensorflow>=1.14 in /usr/local/lib/python3.7/dist-packages (from tfco-nightly==0.3.dev20210712) (2.5.0)\n", + "Requirement already satisfied: termcolor~=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.1.0)\n", + "Requirement already satisfied: astunparse~=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.6.3)\n", + "Requirement already satisfied: h5py~=3.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.1.0)\n", + "Requirement already satisfied: keras-nightly~=2.5.0.dev in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2.5.0.dev2021032900)\n", + "Requirement already satisfied: tensorboard~=2.5 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2.5.0)\n", + "Requirement already satisfied: absl-py~=0.10 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.12.0)\n", + "Requirement already satisfied: typing-extensions~=3.7.4 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.7.4.3)\n", + "Requirement already satisfied: gast==0.4.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.4.0)\n", + "Requirement already satisfied: grpcio~=1.34.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.34.1)\n", + "Requirement already satisfied: tensorflow-estimator<2.6.0,>=2.5.0rc0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2.5.0)\n", + "Requirement already satisfied: wrapt~=1.12.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.12.1)\n", + "Requirement already satisfied: opt-einsum~=3.3.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.3.0)\n", + "Requirement already satisfied: protobuf>=3.9.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.17.3)\n", + "Requirement already satisfied: google-pasta~=0.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.2.0)\n", + "Requirement already satisfied: keras-preprocessing~=1.1.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.1.2)\n", + "Requirement already satisfied: flatbuffers~=1.12.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.12)\n", + "Requirement already satisfied: wheel~=0.35 in /usr/local/lib/python3.7/dist-packages (from tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.36.2)\n", + "Requirement already satisfied: cached-property; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from h5py~=3.1.0->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.5.2)\n", + "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (57.0.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.3.4)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.4.4)\n", + "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.32.1)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.0.1)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2.23.0)\n", + "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.6.1)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.8.0)\n", + "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (4.6.0)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.3.0)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (4.2.2)\n", + "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3.6\" in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (4.7.2)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.2.8)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (1.24.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2021.5.30)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.0.4)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.4.1)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (3.1.1)\n", + "Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.7/dist-packages (from rsa<5,>=3.1.4; python_version >= \"3.6\"->google-auth<2,>=1.6.3->tensorboard~=2.5->tensorflow>=1.14->tfco-nightly==0.3.dev20210712) (0.4.8)\n", + "Building wheels for collected packages: tfco-nightly\n", + " Building wheel for tfco-nightly (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for tfco-nightly: filename=tfco_nightly-0.3.dev20210712-cp37-none-any.whl size=199274 sha256=0cf5a984216fd6779870302892eaf9d9d8eab8ee0dc4a74eda6e2fbf9af47c41\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-8lu3v5rh/wheels/c9/b3/c3/78e0691949466af462380554286105216cd95a9ae7cf08ee78\n", + "Successfully built tfco-nightly\n", + "Installing collected packages: tfco-nightly\n", + "Successfully installed tfco-nightly-0.3.dev20210712\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "b9E3y1d01Hle", + "outputId": "3fb9f79c-60d2-44a1-ea4c-9bc7d2497548" + }, + "source": [ + "m, n = w1.shape\n", + "p = 2\n", + "u = tf.Variable([[np.random.rand()] * n], trainable=True)\n", + "v = tf.Variable([[np.random.rand()] * m], trainable=True)\n", + "s = tf.Variable([np.random.rand()] * p, trainable=True)\n", + "w = np.array([w1, w2])\n", + "\n", + "def loss_fn():\n", + " uv = u * tf.transpose(v)\n", + " s_tmp = tf.expand_dims(tf.expand_dims(s, axis=1), axis=2)\n", + " approx = tf.reduce_sum(w - s_tmp * tf.stack([uv] * p), axis=0)\n", + " for i in range(p):\n", + " A_tmp = tf.transpose(v) * w[i].T * u\n", + " if i == 0:\n", + " A = A_tmp * A_tmp\n", + " else:\n", + " A = A + (A_tmp * A_tmp)\n", + " return A - tf.norm(approx, ord='fro', axis=[-2, -1])\n", + "\n", + "class SampleProblem(tfco.ConstrainedMinimizationProblem):\n", + " def __init__(self, loss_fn, weights):\n", + " self._loss_fn = loss_fn\n", + " self._weights = weights\n", + " \n", + " @property\n", + " def num_constraints(self):\n", + " return 2\n", + " \n", + " def objective(self):\n", + " return loss_fn()\n", + " \n", + " def constraints(self):\n", + " u, s, v = self._weights\n", + " u_norm = tf.linalg.norm(u) # tf.math.reduce_euclidean_norm(u)\n", + " v_norm = tf.linalg.norm(v) # tf.math.reduce_euclidean_norm(v)\n", + " u_norm_eq_one = 1 - u_norm\n", + " v_norm_eq_one = 1 - v_norm\n", + " constraints = tf.stack([u_norm_eq_one, v_norm_eq_one])\n", + " # A = (u * tf.transpose(v)).numpy()\n", + " # for i in range(p):\n", + " # rank_eq_one = 1. - tf.Variable(tf.cast(tf.rank(s[i] * A), tf.float32))\n", + " # constraints = tf.stack([constraints, rank_eq_one])\n", + " return constraints\n", + "\n", + "problem = SampleProblem(loss_fn, [u, s, v])\n", + "optimizer = tfco.LagrangianOptimizer(\n", + " optimizer=tf.optimizers.Adagrad(learning_rate=0.1),\n", + " num_constraints=problem.num_constraints)\n", + "\n", + "var_list = [u, s, v] + list(problem.trainable_variables) + optimizer.trainable_variables()\n", + "\n", + "for i in range(1000):\n", + " optimizer.minimize(problem, var_list=var_list)\n", + " if i % 100 == 0:\n", + " print(f'step = {i}')\n", + " print(f'loss = {loss_fn()}')\n", + " # print(f'constraint = {(x + y).numpy()}')\n", + " # print(f'u = {u.numpy()}, v = {v.numpy()}')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "step = 0\n", + "loss = -662.9971313476562\n", + "step = 100\n", + "loss = -79729.0703125\n", + "step = 200\n", + "loss = -217770.546875\n", + "step = 300\n", + "loss = -395476.71875\n", + "step = 400\n", + "loss = -605416.375\n", + "step = 500\n", + "loss = -843243.875\n", + "step = 600\n", + "loss = -1106010.625\n", + "step = 700\n", + "loss = -1391545.0\n", + "step = 800\n", + "loss = -1698159.125\n", + "step = 900\n", + "loss = -2024494.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 483 + }, + "id": "gBBmYLTn2iCD", + "outputId": "7a717cba-5775-4e5e-a276-9d1144d1b5ad" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "313/313 - 0s - loss: 0.3365 - accuracy: 0.8820\n", + "MNIST - Test accuracy: 0.9768999814987183\n", + "Fashion MNIST - Test accuracy: 0.8820000290870667\n", + "\n", + "313/313 - 0s - loss: 5028111.0000 - accuracy: 0.1000\n", + "MNIST - Test accuracy: 0.10279999673366547\n", + "Fashion MNIST - Test accuracy: 0.10000000149011612\n", + "\n", + "MNIST - Accuracy drop: 0.8740999847650528\n", + "Fashion MNIST - Accuracy drop: 0.7820000275969505\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GY92NgoE2zrR" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/python/svd_approximation.py b/python/svd_approximation.py new file mode 100644 index 0000000..b9a2686 --- /dev/null +++ b/python/svd_approximation.py @@ -0,0 +1,1484 @@ +# -*- coding: utf-8 -*- +"""SVD Approximation + +Automatically generated by Colaboratory. + +Original file is located at + https://colab.research.google.com/drive/1qyZtwulkRmO9qBgpNxnUpckRzIg9Q-tu + +# SVD Approximation +""" + +# Commented out IPython magic to ensure Python compatibility. +import tensorflow as tf +import matplotlib.pyplot as plt +import numpy as np +from PIL import Image, ImageOps +from google.colab import drive +import re +from datetime import datetime +import os + +# Load the TensorBoard notebook extension +# %load_ext tensorboard +# %tensorflow_version 2.x +from tensorboard.plugins.hparams import api as hp +# Clear any logs from previous tensorboard runs +!rm -rf /tmp/mylogs +writer = tf.summary.create_file_writer('/tmp/mylogs') + +drive.mount('/gdrive', force_remount=True) + +"""## Algorithm 1 - Stardard SVD Decomposition""" + +def svd1(x_in, Verbose=False, correction_factor=1e-12): + """ + @brief Short-hand for applying SVD and dealing with non-converging SVD. + + @param x input matrix + + @return the U, s, V first components + """ + x = x_in.copy() + m, n = x.shape + not_converged = True + max_tries = 1000 + i = 0 + while not_converged: + try: + u, s, v = np.linalg.svd(x, full_matrices=False) + except np.linalg.linalg.LinAlgError as e: + # ================================================================== + # If SVD didn't converge, add a small error to the matrix and + # repeat, otherwise the heuristic will always generate zero + # components. + # ================================================================== + if Verbose: + print("[WARNING] Exception caught: {}". format(e)) + if np.isnan(x).any(): + print("[WARNING] The provided matrix contains NaNs.") + if np.isinf(x).any(): + print("[WARNING] The provided matrix contains Infs.") + u = np.zeros((m, m)) + s = np.zeros((n,)) + v = np.zeros((n, n)) + x -= correction_factor + if np.any(s): # not all zeros + not_converged = False + # If still not converging and max tries reached, return svd components + # that are close to zero. + if not_converged and i == max_tries: + not_converge = False + u = np.zeros((m, m)) + s = np.zeros((n,)) + v = np.zeros((n, n)) + u += 1e-15 + s += 1e-15 + v += 1e-15 + i += 1 + return u.T[0], s[0], v[0] + +x = np.random.randn(32, 16) +svd1(x) + +"""## Algorithm 2 - Joshua Paper + +Decompose `k` matrices into `r` sub-matrices. +""" + +def mse(a, b): + return ((a - b)**2).mean() + +def avg_abs_diff(a, b): + return np.absolute(a - b).mean() + +def frobenius_norm(a, b): + return np.sqrt(np.absolute(np.linalg.norm(a - b))) + +def frobenius(x): + return (x**2).sum() + +def check_threshold(U, U_step, V, V_step, stop_threshold=0.00005, + config='mse'): + """ + @brief Determines the threshold for stopping vectors refinements + + @param U [] + @param U_step [] + @param V [] + @param V_step [] + + @return whether to stop refinement process + """ + if config == 'mse': + diff_u = mse(U, U_step) + diff_v = mse(V, V_step) + elif config == 'avg': + diff_u = avg_abs_diff(U, U_step) + diff_v = avg_abs_diff(V, V_step) + elif config == 'frobenius-norm': + diff_u = frobenius_norm(U, U_step) + diff_v = frobenius_norm(V, V_step) + elif config == 'norm': + diff_u = np.linalg.norm(U - U_step) + diff_v = np.linalg.norm(V - V_step) + if diff_v < stop_threshold and diff_u < stop_threshold: + return True, diff_u, diff_v + else: + return False, diff_u, diff_v + +def get_vec_from_largest_eig(x): + w, vr = np.linalg.eigh(x) + return vr[:, np.argmax(w)] + +def update_F(F, U, V): + FT = np.transpose(F, axes=(0, 2, 1)) + S = V.T @ FT @ U + A = np.outer(U, V) + F_tmp = np.zeros(F.shape) + for i in range(F.shape[0]): + F_tmp[i] = F[i] - S[i] * A + return F_tmp, S + +def algorithm2(F_in, r=1, stop_threshold=0.0001, hard_stop=100, + decomposition='eigen', truncate=False, metric='mse', + report_writer=None, report_step=0, scaler=None, Verbose=False): + """ + @brief Algorithm from "Synthesis and Optimization + of 2D Filter Designs for Heterogeneous FPGAs" + + @param F_in List or array of matrixes to approximate + (they must have same shape) + @param r The number of sub-matrices + @param Verbose Verbose + + @return the eigenvalues lambda_ij and vectors u and v + """ + if isinstance(F_in, (list,)): + k = len(F_in) + m, n = F_in[0].shape + F = np.zeros((k, m, n)) + for i in range(k): + F[i] = F_in[i].copy() + else: + k, m, n = F_in.shape + F = np.array(F_in, copy=True) + # hard_stop = 100 + # stop_threshold = 0.0001 # F.std() + if truncate: + tot_elem = k * (m * n) + appr_elem = k * (m + n + r) + if appr_elem >= tot_elem: + print('[WARNING] The r value ({}) is too high and will be truncated.'.format(r)) + while appr_elem >= tot_elem: + r -= 1 + appr_elem = k * (m + n + r) + print('[WARNING] r set to {}.'. format(r)) + if scaler is None: + scaler = np.ones((k)) + u_array = np.zeros((r, m)) + s_array = np.zeros((r, k)) + v_array = np.zeros((r, n)) + # NOTE: Given a matrix A, we have that: A @ A.T is symmetrical! Meaning + # that, for the spectral theorem, A has real eigenvalues! + for j in range(r): + # Form the (m x m) matrix Fn: sum[0,k-1](F[i] @ F[i].T) + Fn = np.zeros((m, m)) + for i in range(k): + Fn += scaler[i] * F[i] @ F[i].T # SQUARED + # Calculate the eigenvector u that corresponds to the largest eigenvalue + if decomposition == 'eigen': + u = get_vec_from_largest_eig(Fn) + else: + u, _, _ = svd1(Fn) + # Form the (n x k) matrix: Fb = [F[0].T @ u, F[1].T @ u, ..., F[k-1].T @ u] + Fb = np.zeros((n, k)) + for i in range(k): + Fb[:,i] = scaler[i] * F[i].T @ u + # Calculate the eigenvector v that corresponds to the largest + # eigenvalue of the (n x n) matrix: Fb @ Fb.T + Fb = Fb @ Fb.T + if decomposition == 'eigen': + v = get_vec_from_largest_eig(Fb) + else: + _, _, v = svd1(Fb) + U = u + V = v + for t in range(hard_stop): + # Form the (k x m) matrix Fb = [F[0] @ v, F[1] @ v, ..., F[k-1] @ v].T + FbT = np.zeros((m, k)) + for i in range(k): + FbT[:, i] = scaler[i] * F[i] @ v + Fb = FbT.T + # Calculate the eigenvector u that corresponds to the largest + # eigenvalue of the (m x m) matrix + Fb = FbT @ Fb + if decomposition == 'eigen': + u = get_vec_from_largest_eig(Fb) + else: + u, _, _ = svd1(Fb) + # Form the (n x k) matrix Fb = [F[0].T @ u, F[1].T @ u, ..., F[k-1].T @ u].T + FbT = np.zeros((k, n)) + for i in range(k): + FbT[i] = scaler[i] * F[i].T @ u + Fb = FbT.T + # Calculate the eigenvector v that corresponds to the largest + # eigenvalue of the (n x n) matrix + Fb = Fb @ FbT + if decomposition == 'eigen': + v = get_vec_from_largest_eig(Fb) + else: + _, _, v = svd1(Fb) + # Until u and v vectors change less than a pre-specified + # value that is set by the user + stop_refinement, diff_u, diff_v = check_threshold(u, U, v, V, stop_threshold, metric) + if report_writer is not None: + with report_writer.as_default(): + F_tmp, _ = update_F(F, U, V) + for p, (f_in, f_tmp) in enumerate(zip(F_in, F_tmp)): + tf.summary.scalar(f'Alg2 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), report_step, description=f'Algorithm2 MSE(x, x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg2 - Mean {p}-th sub-matrix',f_tmp.mean(), report_step, description=f'Algorithm2 Mean(x_approx) of the {p}-th sub-matrix.') + report_writer.flush() + # tf.summary.scalar('Alg2 - MSE refining', mse(F_in, F_tmp), report_step, description='Algorithm2 MSE(F, F_approx) at refining steps.') + # tf.summary.scalar('Alg2 - diff(U)', diff_u, report_step, description='Algorithm2 MSE(u(i), u(i-1)) at refining steps.') + # tf.summary.scalar('Alg2 - diff(V)', diff_v, report_step, description='Algorithm2 MSE(v(i), v(i-1)) at refining steps.') + # NOTE: The u and v norms are always equal to 1. + # tf.summary.scalar('Alg2 - norm(U)', np.linalg.norm(u), report_step, description='Algorithm2 norm(u(i)) at refining steps.') + # tf.summary.scalar('Alg2 - norm(V)', np.linalg.norm(v), report_step, description='Algorithm2 norm(v(i)) at refining steps.') + # tf.summary.scalar('Alg2 - ', np.dot(U, u), report_step, description='Algorithm2 : inner-product (orthogonal if 0).') + # tf.summary.scalar('Alg2 - ', np.dot(V, v), report_step, description='Algorithm2 : inner-product (orthogonal if 0).') + report_writer.flush() + report_step += 1 + if stop_refinement: + V, U = v, u + break + V = v #* (1 + 1e-12) + U = u #* (1 + 1e-12) + if report_writer is not None and r > 1: + with report_writer.as_default(): + F_tmp, _ = update_F(F, U, V) + for p, (f_in, f_tmp) in enumerate(zip(F_in, F_tmp)): + tf.summary.scalar(f'Alg2 - Final MSE {p}-th sub-matrix', mse(f_in, f_tmp), report_step, description=f'Algorithm2 MSE(x, x_approx) of the {p}-th sub-matrix.') + report_writer.flush() + report_step += 1 + # F, S = update_F(F, U, V) + FT = np.transpose(F, axes=(0, 2, 1)) + S = V.T @ FT @ U + A = np.outer(U, V) + for i in range(k): + F[i] = F[i] - S[i] * A + u_array[j] = U + s_array[j] = S + v_array[j] = V + return u_array, s_array, v_array + +x = np.random.rand(3, 1024, 512) + +# Commented out IPython magic to ensure Python compatibility. +# %time u_eig, s_eig, v_eig = algorithm2(x, decomposition='eigen', stop_threshold=1e-5) + +# Commented out IPython magic to ensure Python compatibility. +# %time u_svd, s_svd, v_svd = algorithm2(x, decomposition='svd', stop_threshold=1e-5) + +print(mse(u_eig, u_svd)) +print(mse(s_eig, s_svd)) +print(mse(v_eig, v_svd)) + +"""Get approximation error.""" + +def algorithm2_inverse(U, S, V, F=None): + F_tmp = np.einsum('rk, rm, rn->kmn', S, U, V) + if F is None: + F = F_tmp + elif type(F) == list: + k = S.shape[1] + for i in range(k): + F.append(F_tmp[i]) + return F_tmp + +x_svd = algorithm2_inverse(u_svd, s_svd, v_svd) +x_eig = algorithm2_inverse(u_eig, s_eig, v_eig) +print(mse(x, x_svd)) +print(mse(x, x_eig)) + +"""## Algortihm 3 - SVD and Refinement Steps""" + +def algorithm3(x_in, num_refinements=1, num_sub_matrix=1, truncate=False, + stop_threshold=0.0001, hard_stop=100, decomposition='eigen', + metric='mse', scaler=None, report_writer=None, + apply_scaling_at_alg2=True, plotdata=None): + if type(x_in) == list: + x = np.concatenate([a[np.newaxis,:] for a in x_in], axis=0) + else: + x = x_in + k, m, n = x.shape + if truncate: + tot_elem = 2 * (m * n) + appr_elem = num_refinements * (m + n + x.shape[0]) + if appr_elem >= tot_elem: + print(f'[WARNING] The num_refinements value ({num_refinements}) is too high and will be truncated.') + while appr_elem >= tot_elem: + num_refinements -= 1 + appr_elem = num_refinements * (m + n + x.shape[0]) + print(f'[WARNING] num_refinements set to {num_refinements}.') + u = np.zeros((num_refinements, num_sub_matrix, m)) + s = np.zeros((num_refinements, num_sub_matrix, k)) + v = np.zeros((num_refinements, num_sub_matrix, n)) + report_steps = 0 + if apply_scaling_at_alg2: + # ====================================================================== + # Apply scaling at Alogirthm 2 (Default) + # ====================================================================== + x_approx = np.zeros(x.shape) + for i in range(num_refinements): + u[i], s[i], v[i] = algorithm2(x - x_approx, num_sub_matrix, + stop_threshold, hard_stop, decomposition, + truncate, metric, report_writer, + report_steps, scaler) + x_approx += algorithm2_inverse(u[i], s[i], v[i]) + if report_writer is not None: + with report_writer.as_default(): + tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).') + for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.') + report_writer.flush() + if plotdata is not None: + if not plotdata: # If empty, initialize it + for p in range(k): + plotdata[f'MSE(matrix[{p}])'] = [] + for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + plotdata[f'MSE(matrix[{p}])'].append(mse(f_in, f_tmp)) + else: + # ====================================================================== + # Apply scaling at Alogirthm 3 (To be checked) + # ====================================================================== + x_approx = np.zeros(x.shape) + x_scaled = x.copy() + error = x - x_approx + if scaler is None: + scaler = [1.] * k + for j in range(k): + x_scaled[j] *= scaler[j] + error[j] = x_scaled[j] + for i in range(num_refinements): + u[i], s[i], v[i] = algorithm2(error, num_sub_matrix, + stop_threshold, hard_stop, decomposition, + truncate, metric, report_writer, + report_steps, scaler=None) + for j in range(k): + s[j] /= scaler[j] + x_approx += algorithm2_inverse(u[i], s[i], v[i]) + # for j in range(k): + # x_approx[j] *= scaler[j] + error = x_scaled - x_approx + # for j in range(k): + # error[j] *= scaler[j] + if report_writer is not None: + with report_writer.as_default(): + tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).') + for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.') + report_writer.flush() + if plotdata is not None: + if not plotdata: # If empty, initialize it + for p in range(k): + plotdata[f'MSE(matrix[{p}])'] = [] + for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + plotdata[f'MSE(matrix[{p}])'].append(mse(f_in, f_tmp)) + return u, s, v + +def algorithm3_inverse(U, S, V): + """ + @brief Given a list of u, s, v vectors, reconstruct + the two approximated matrixes. + + @param U list of u vectr + @param S list of s vectr + @param V list of v vectr + + @return the reconstructed approximated matrix (concatened) + """ + # NOTE: The shape variables are: + # r := number of refinement steps + # k := number of merged matrixes + # m := "input" dimension of the matrixes + # n := "output" dimension of the matrixes + u, s, v = np.array(U), np.array(S), np.array(V) + F = np.einsum('...rk, ...rm, ...rn', s, u, v) + F = np.einsum('rkmn->kmn', F) + return F + +# Commented out IPython magic to ensure Python compatibility. +x = np.random.rand(3, 1024, 512) +# %time u_eig, s_eig, v_eig = algorithm3(x, 4, decomposition='eigen', stop_threshold=1e-3) + +# Commented out IPython magic to ensure Python compatibility. +# %time u_svd, s_svd, v_svd = algorithm3(x, 4, decomposition='svd', stop_threshold=1e-3) + +x_svd = algorithm3_inverse(u_svd, s_svd, v_svd) +x_eig = algorithm3_inverse(u_eig, s_eig, v_eig) +print(mse(x, x_svd)) +print(mse(x, x_eig)) + +"""### Algorithm 3 - Extra Refinements""" + +def algorithm3_extra_refinements(x_in, u_in, s_in, v_in, num_refinements=1, num_sub_matrix=1, truncate=False, + stop_threshold=0.0001, hard_stop=100, decomposition='eigen', + metric='mse', scaler=None, + report_writer=None): + previous_num_refinements = u_in.shape[0] + assert previous_num_refinements <= num_refinements, f'Previous #Refinements ({previous_num_refinements}) must be less then num_refinements ({num_refinements}).' + if type(x_in) == list: + x = np.concatenate([a[np.newaxis,:] for a in x_in], axis=0) + else: + x = x_in + k, m, n = x.shape + if truncate: + tot_elem = 2 * (m * n) + appr_elem = num_refinements * (m + n + x.shape[0]) + if appr_elem >= tot_elem: + print(f'[WARNING] The num_refinements value ({num_refinements}) is too high and will be truncated.') + while appr_elem >= tot_elem: + num_refinements -= 1 + appr_elem = num_refinements * (m + n + x.shape[0]) + print(f'[WARNING] num_refinements set to {num_refinements}.') + u = np.zeros((num_refinements, num_sub_matrix, m)) + s = np.zeros((num_refinements, num_sub_matrix, k)) + v = np.zeros((num_refinements, num_sub_matrix, n)) + + u[:previous_num_refinements] = u_in + s[:previous_num_refinements] = s_in + v[:previous_num_refinements] = v_in + + report_steps = 0 + # ========================================================================== + # Scaler version + # ========================================================================== + x_approx = algorithm3_inverse(u_in, s_in, v_in) + x_scaled = x.copy() + error = x - x_approx + if scaler is None: + scaler = [1.] * k + for j in range(k): + x_scaled[j] *= scaler[j] + error[j] = x_scaled[j] + for i in range(previous_num_refinements, num_refinements): + u[i], s[i], v[i] = algorithm2(error, num_sub_matrix, + stop_threshold, hard_stop, decomposition, + truncate, metric, report_writer, + report_steps, scaler=None) + for j in range(k): + s[j] /= scaler[j] + x_approx += algorithm2_inverse(u[i], s[i], v[i]) + for j in range(k): + x_approx[j] *= scaler[j] + error = x_scaled - x_approx + # for j in range(k): + # error[j] *= scaler[j] + if report_writer is not None: + with report_writer.as_default(): + tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).') + for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.') + tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.') + report_writer.flush() + # ========================================================================== + # Original version + # ========================================================================== + # x_approx = np.zeros(x.shape) + # for i in range(num_refinements): + # u[i], s[i], v[i] = algorithm2(x - x_approx, num_sub_matrix, + # stop_threshold, hard_stop, decomposition, + # truncate, metric, report_writer, + # report_steps, scaler) + # x_approx += algorithm2_inverse(u[i], s[i], v[i]) + # if report_writer is not None: + # with report_writer.as_default(): + # tf.summary.scalar('Alg3 - MSE', mse(x, x_approx), i, description='Algorithm3 MSE(x, x_approx).') + # for p, (f_in, f_tmp) in enumerate(zip(x, x_approx)): + # tf.summary.scalar(f'Alg3 - MSE {p}-th sub-matrix', mse(f_in, f_tmp), i, description=f'Algorithm3 MSE(x, x_approx) of the {p}-th sub-matrix.') + # tf.summary.scalar(f'Alg3 - Mean {p}-th sub-matrix', f_tmp.mean(), i, description=f'Algorithm3 Mean(x_approx) of the {p}-th sub-matrix.') + # tf.summary.scalar(f'Alg3 - Mean Original {p}-th sub-matrix', f_in.mean(), i, description=f'Algorithm3 Mean(x) of the {p}-th sub-matrix.') + # report_writer.flush() + return u, s, v + +"""## Setup TensorBoard""" + +# Commented out IPython magic to ensure Python compatibility. +tensorboard_dir = '/gdrive/My Drive/Colab Notebooks/svd/' +tensorboard_dir = re.escape(tensorboard_dir) # to include spaces +# %reload_ext tensorboard +# %rm -rf $tensorboard_dir/tensorboard/* +# %tensorboard --logdir $tensorboard_dir/tensorboard + +"""# Models + +Currently, we have the following designs in place: + +| Model Name | ID | #LSTMs | Input Size(s) | Hidden Size(s)| Test Accuracy | HW Requirements | +|---|---|---|---|---|---|---| +| Dense MNIST | mnist | 0 | 784 | 128 | 98% | | +| Fashion MNIST | fashion | 0 | 784 | 128 | 88% | | +| Fashion MNIST - LSTM | fashion-lstm | 2 | 128 | 256 | 86% | | +| CNN-RNN-UCF101 | cnn-lstm | 2 | 2048 | 256 | 65% | +| TrafficPredict | traffic-predict | N | ? | ? | ? | | + +""" + +models = {} + +checkpoint_dir = '/gdrive/My Drive/checkpoints/svd/' + +def save_model(model_name): + models[model_name].save(checkpoint_dir + model_name) + models[model_name].save_weights(checkpoint_dir + model_name + '.h5') + print(f'Model saved at: {checkpoint_dir + model_name}') + +def load_model(model_name): + if os.path.isdir(checkpoint_dir + model_name): + models[model_name] = tf.keras.models.load_model(checkpoint_dir + model_name) + if os.path.isfile(checkpoint_dir + model_name + '.h5'): + print(f'Model "{model_name}" loaded with weights.') + return True + else: + print(f'Model "{model_name}" loaded without weights.') + return False + else: + print(f'Model "{model_name}" not found in: {checkpoint_dir}') + return False + +"""### MNIST - Dense""" + +mnist = tf.keras.datasets.mnist + +(x_train, y_train), (x_test, y_test) = mnist.load_data() +x_train, x_test = x_train / 255.0, x_test / 255.0 + +models['mnist'] = tf.keras.models.Sequential([ + tf.keras.layers.Flatten(input_shape=(28, 28)), + tf.keras.layers.Dense(128, activation='relu', name='dense_1'), + tf.keras.layers.Dropout(0.2), + tf.keras.layers.Dense(10, name='dense_2') +], name='mnist') + +models['mnist'].summary() + +models['mnist'].compile(optimizer='adam', + loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), + metrics=['accuracy']) + +if not load_model('mnist'): + models['mnist'].fit(x_train, y_train, epochs=5) + save_model('mnist') + +models['mnist'].evaluate(x_test, y_test, verbose=2) + +""" +## Fashion MNIST - Dense +""" + +fashion_mnist = tf.keras.datasets.fashion_mnist + +(fashion_train_images, fashion_train_labels), (fashion_test_images, fashion_test_labels) = fashion_mnist.load_data() + +class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', + 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] + +plt.figure() +plt.imshow(fashion_train_images[0]) +plt.colorbar() +plt.grid(False) +plt.show() + +"""Scale these values to a range of 0 to 1 before feeding them to the neural network model. To do so, divide the values by 255. It's important that the training set and the testing set be preprocessed in the same way:""" + +fashion_train_images = fashion_train_images / 255.0 +fashion_test_images = fashion_test_images / 255.0 + +plt.figure(figsize=(10,10)) +for i in range(25): + plt.subplot(5,5,i+1) + plt.xticks([]) + plt.yticks([]) + plt.grid(False) + plt.imshow(fashion_train_images[i], cmap=plt.cm.binary) + plt.xlabel(class_names[fashion_train_labels[i]]) +plt.show() + +models['fashion'] = tf.keras.Sequential([ + tf.keras.layers.Flatten(input_shape=(28, 28)), + tf.keras.layers.Dense(128, activation='relu', name='dense_1'), + tf.keras.layers.Dense(10, name='dense_2') +], name='fashion_mnist') +models['fashion'].summary() + +models['fashion'].compile(optimizer='adam', + loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), + metrics=['accuracy']) + +"""Train the model.""" + +train_model = False +if not load_model('fashion') or train_model: + models['fashion'].fit(fashion_train_images, fashion_train_labels, epochs=10) + save_model('fashion') + +test_loss, test_acc = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=2) +print('\nTest accuracy:', test_acc) + +"""## Fashion MNIST - LSTM""" + +batch_size = 32 +num_classes = 10 +epochs = 2 + +row_hidden = 64 +col_hidden = 64 + +row, col = fashion_train_images.shape[1:] + +input = tf.keras.layers.Input(shape=(row, col)) + +def lstm_pipe(in_layer, lstm_name=''): + x = tf.keras.layers.Conv1D(row_hidden, kernel_size=3, padding = 'same')(in_layer) + x = tf.keras.layers.Conv1D(row_hidden, kernel_size=3, padding = 'same')(x) + encoded_rows = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(row_hidden, return_sequences = True))(x) + return tf.keras.layers.LSTM(col_hidden, name='LSTM_' + lstm_name)(encoded_rows) +# Read it by rows +row_read = lstm_pipe(input, 'left') +# Read it by columns +transpose_read = lstm_pipe(tf.keras.layers.Permute(dims=(1,2))(input), 'right') +x = tf.concat([row_read, transpose_read], axis=1) +x = tf.keras.layers.Dropout(0.2)(x) +# prediction = tf.keras.layers.Dense(num_classes, activation='softmax')(x) +prediction = tf.keras.layers.Dense(num_classes)(x) +models['fashion-lstm'] = tf.keras.Model(input, prediction) +models['fashion-lstm'].compile(optimizer='adam', + loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), + metrics=['accuracy']) +models['fashion-lstm'].summary() + +models['fashion-lstm'].get_layer('LSTM_left').get_weights()[0].shape + +if not load_model('fashion-lstm'): + models['fashion-lstm'].fit(fashion_train_images, fashion_train_labels, epochs=2, batch_size=batch_size) + save_model('fashion-lstm') + +test_loss, test_acc = models['fashion-lstm'].evaluate(fashion_test_images, fashion_test_labels, verbose=2) +print('\nTest accuracy:', test_acc) + +"""## CNN-RNN-UCF101""" + +!pip install -q git+https://github.com/tensorflow/docs + +!wget -q https://git.io/JGc31 -O /tmp/ucf101_top5.tar.gz +!tar xf /tmp/ucf101_top5.tar.gz + +from tensorflow_docs.vis import embed +from imutils import paths + +import pandas as pd +import imageio +import cv2 + +IMG_SIZE = 224 +BATCH_SIZE = 64 +EPOCHS = 10 + +MAX_SEQ_LENGTH = 20 +NUM_FEATURES = 2048 + +train_df = pd.read_csv("train.csv") +test_df = pd.read_csv("test.csv") + +print(f"Total videos for training: {len(train_df)}") +print(f"Total videos for testing: {len(test_df)}") + +train_df.sample(10) + +# The following two methods are taken from this tutorial: +# https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub + + +def crop_center_square(frame): + y, x = frame.shape[0:2] + min_dim = min(y, x) + start_x = (x // 2) - (min_dim // 2) + start_y = (y // 2) - (min_dim // 2) + return frame[start_y : start_y + min_dim, start_x : start_x + min_dim] + + +def load_video(path, max_frames=0, resize=(IMG_SIZE, IMG_SIZE)): + cap = cv2.VideoCapture(path) + frames = [] + try: + while True: + ret, frame = cap.read() + if not ret: + break + frame = crop_center_square(frame) + frame = cv2.resize(frame, resize) + frame = frame[:, :, [2, 1, 0]] + frames.append(frame) + + if len(frames) == max_frames: + break + finally: + cap.release() + return np.array(frames) + +def build_feature_extractor(): + feature_extractor = tf.keras.applications.InceptionV3( + weights="imagenet", + include_top=False, + pooling="avg", + input_shape=(IMG_SIZE, IMG_SIZE, 3), + ) + preprocess_input = tf.keras.applications.inception_v3.preprocess_input + + inputs = tf.keras.Input((IMG_SIZE, IMG_SIZE, 3)) + preprocessed = preprocess_input(inputs) + + outputs = feature_extractor(preprocessed) + return tf.keras.Model(inputs, outputs, name="feature_extractor") + +feature_extractor = build_feature_extractor() + +label_processor = tf.keras.layers.experimental.preprocessing.StringLookup( + num_oov_indices=0, vocabulary=np.unique(train_df["tag"]) +) +print(label_processor.get_vocabulary()) + +def prepare_all_videos(df, root_dir): + num_samples = len(df) + video_paths = df["video_name"].values.tolist() + labels = df["tag"].values + labels = label_processor(labels[..., None]).numpy() + + # `frame_masks` and `frame_features` are what we will feed to our sequence model. + # `frame_masks` will contain a bunch of booleans denoting if a timestep is + # masked with padding or not. + frame_masks = np.zeros(shape=(num_samples, MAX_SEQ_LENGTH), dtype="bool") + frame_features = np.zeros( + shape=(num_samples, MAX_SEQ_LENGTH, NUM_FEATURES), dtype="float32" + ) + + # For each video. + for idx, path in enumerate(video_paths): + # Gather all its frames and add a batch dimension. + frames = load_video(os.path.join(root_dir, path)) + frames = frames[None, ...] + + # Initialize placeholders to store the masks and features of the current video. + temp_frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype="bool") + temp_frame_featutes = np.zeros( + shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype="float32" + ) + + # Extract features from the frames of the current video. + for i, batch in enumerate(frames): + video_length = batch.shape[1] + length = min(MAX_SEQ_LENGTH, video_length) + for j in range(length): + temp_frame_featutes[i, j, :] = feature_extractor.predict( + batch[None, j, :] + ) + temp_frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked + + frame_features[idx,] = temp_frame_featutes.squeeze() + frame_masks[idx,] = temp_frame_mask.squeeze() + + return (frame_features, frame_masks), labels + +if os.path.isfile(checkpoint_dir + 'cnn-lstm/dataset.npz'): + dataset = np.load(checkpoint_dir + 'cnn-lstm/dataset.npz') + train_data = (dataset['train_data_0'], dataset['train_data_1']) + test_data = (dataset['test_data_0'], dataset['test_data_1']) + train_labels = dataset['train_labels'] + test_labels = dataset['test_labels'] +else: + train_data, train_labels = prepare_all_videos(train_df, "train") + test_data, test_labels = prepare_all_videos(test_df, "test") + +print(f"Frame features in train set: {train_data[0].shape}") +print(f"Frame masks in train set: {train_data[1].shape}") + +"""### The Sequence Model""" + +# Utility for our sequence model. +def get_sequence_model(): + class_vocab = label_processor.get_vocabulary() + + frame_features_input = tf.keras.Input((MAX_SEQ_LENGTH, NUM_FEATURES)) + mask_input = tf.keras.Input((MAX_SEQ_LENGTH,), dtype="bool") + + # Refer to the following tutorial to understand the significance of using `mask`: + # https://tf.keras.io/api/layers/recurrent_layers/gru/ + x = tf.keras.layers.LSTM(64, return_sequences=True, name='LSTM_1')(frame_features_input, mask=mask_input) + x = tf.keras.layers.LSTM(32, name='LSTM_2')(x) + # x = tf.keras.layers.GRU(16, return_sequences=True)(frame_features_input, mask=mask_input) + # x = tf.keras.layers.GRU(8)(x) + x = tf.keras.layers.Dropout(0.4)(x) + x = tf.keras.layers.Dense(8, activation="relu")(x) + output = tf.keras.layers.Dense(len(class_vocab), activation="softmax")(x) + + rnn_model = tf.keras.Model([frame_features_input, mask_input], output) + + rnn_model.compile( + loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"] + ) + return rnn_model + +# Utility for running experiments. +def run_experiment(): + filepath = "/tmp/video_classifier" + checkpoint = tf.keras.callbacks.ModelCheckpoint( + filepath, save_weights_only=True, save_best_only=True, verbose=1 + ) + seq_model = get_sequence_model() + history = seq_model.fit( + [train_data[0], train_data[1]], + train_labels, + validation_split=0.3, + epochs=EPOCHS, + callbacks=[checkpoint], + ) + seq_model.load_weights(filepath) + _, accuracy = seq_model.evaluate([test_data[0], test_data[1]], test_labels) + print(f"Test accuracy: {round(accuracy * 100, 2)}%") + return history, seq_model + +train_model = False +if not load_model('cnn-lstm') or train_model: + _, models['cnn-lstm'] = run_experiment() + save_model('cnn-lstm') + +"""### Inference""" + +def prepare_single_video(frames): + frames = frames[None, ...] + frame_mask = np.zeros(shape=(1, MAX_SEQ_LENGTH,), dtype="bool") + frame_featutes = np.zeros(shape=(1, MAX_SEQ_LENGTH, NUM_FEATURES), dtype="float32") + for i, batch in enumerate(frames): + video_length = batch.shape[1] + length = min(MAX_SEQ_LENGTH, video_length) + for j in range(length): + frame_featutes[i, j, :] = feature_extractor.predict(batch[None, j, :]) + frame_mask[i, :length] = 1 # 1 = not masked, 0 = masked + return frame_featutes, frame_mask + +def sequence_prediction(path): + class_vocab = label_processor.get_vocabulary() + + frames = load_video(os.path.join("test", path)) + frame_features, frame_mask = prepare_single_video(frames) + probabilities = models['cnn-lstm'].predict([frame_features, frame_mask])[0] + + for i in np.argsort(probabilities)[::-1]: + print(f" {class_vocab[i]}: {probabilities[i] * 100:5.2f}%") + return frames + +# This utility is for visualization. +# Referenced from: +# https://www.tensorflow.org/hub/tutorials/action_recognition_with_tf_hub +def to_gif(images): + converted_images = images.astype(np.uint8) + imageio.mimsave("animation.gif", converted_images, fps=10) + return embed.embed_file("animation.gif") + +test_video = np.random.choice(test_df["video_name"].values.tolist()) +print(f"Test video path: {test_video}") +test_frames = sequence_prediction(test_video) +to_gif(test_frames[:MAX_SEQ_LENGTH]) + +_, accuracy = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels) +print(f"Test accuracy: {round(accuracy * 100, 2)}%") + +if not os.path.isfile(checkpoint_dir + 'cnn-lstm/dataset.npz'): + np.savez_compressed(checkpoint_dir + 'cnn-lstm/dataset', + train_data_0=train_data[0], + train_data_1=train_data[1], + train_labels=train_labels, + test_data_0=test_data[0], + test_data_1=test_data[1], + test_labels=test_labels) + +"""### Get Weights""" + +models['cnn-lstm'].summary() + +print(models['cnn-lstm'].get_layer('LSTM_1').get_weights()[0].shape) +print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[0].shape) + +"""# Scaled SVD Approximation""" + +def get_approx_size(R, k, m, n): + return R * (m + n + k) + +def plot_accuracies(model_labels, original_accuracies, approx_accuracies): + x = np.arange(len(model_labels)) # the label locations + width = 0.35 # the width of the bars + fig, ax = plt.subplots() + rects1 = ax.bar(x - width/2, original_accuracies, width, label='Original') + rects2 = ax.bar(x + width/2, approx_accuracies, width, label='Approximated') + # Add some text for labels, title and custom x-axis tick labels, etc. + ax.set_ylabel('Accuracy') + ax.set_title('Original Accuracy vs. Approximated.') + ax.set_xticks(x) + ax.set_xticklabels(model_labels) + ax.legend() + fig.tight_layout() + plt.show() + +models['fashion'].summary() +mnist_dense = [w1, b1] = models['mnist'].get_layer('dense_1').get_weights() +fashion_mnist_dense = [w2, b2] = models['fashion'].get_layer('dense_1').get_weights() +print(w1.shape, w2.shape) + +# Commented out IPython magic to ensure Python compatibility. +R = 45 +metric = 'mse' +threshold = 1e-5 +scalers = [1., 1.] + +def run_alg3_for_mnist(scaler, apply_scaling_at_alg2, log_to_tensorboard=False): + if log_to_tensorboard: + logname = 'mnist' + logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}' + logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S') + writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname)) +# %reload_ext tensorboard + else: + writer = None + + [w1, b1] = models['mnist'].get_layer('dense_1').get_weights() + [w2, b2] = models['fashion'].get_layer('dense_1').get_weights() + plotdata = {} + w_approx = algorithm3_inverse(*algorithm3([w1, w2], \ + num_refinements=R, \ + num_sub_matrix=1, \ + decomposition='eigen', \ + stop_threshold=threshold, \ + metric=metric, \ + scaler=scaler, \ + report_writer=writer, \ + apply_scaling_at_alg2=apply_scaling_at_alg2, \ + plotdata=plotdata)) + # Obtain original accuracies. + _, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0) + _, fashion_mnist_acc = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=0) + print('') + print('[ORIGINAL] MNIST - Test accuracy: {:.1f}%'.format(100. * mnist_acc)) + print('[ORIGINAL] Fashion MNIST - Test accuracy: {:.1f}%'.format(100. * fashion_mnist_acc)) + + # Set approximated weights and evaluate. + models['mnist'].get_layer('dense_1').set_weights([w_approx[0], b1]) + models['fashion'].get_layer('dense_1').set_weights([w_approx[1], b2]) + print('') + + _, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0) + _, fashion_mnist_acc_approx = models['fashion'].evaluate(fashion_test_images, fashion_test_labels, verbose=0) + print('[APPROX] MNIST - Test accuracy: {:.1f}%'.format(100. * mnist_acc_approx)) + print('[APPROX] Fashion MNIST - Test accuracy: {:.1f}%'.format(100. * fashion_mnist_acc_approx)) + + print('\nMNIST - Accuracy drop: {:.1f}%'.format(100. * (mnist_acc - mnist_acc_approx))) + print('Fashion MNIST - Accuracy drop: {:.1f}%'.format(100. * (fashion_mnist_acc - fashion_mnist_acc_approx))) + print('') + + # Restore original weights and plot. + models['mnist'].get_layer('dense_1').set_weights([w1, b1]) + models['fashion'].get_layer('dense_1').set_weights([w2, b2]) + + plot_accuracies(['mnist', 'fashion'], [mnist_acc, fashion_mnist_acc], + [mnist_acc_approx, fashion_mnist_acc_approx]) + return w_approx[0], w_approx[1], plotdata + +"""## Baseline""" + +_, _, plotdata = run_alg3_for_mnist(None, apply_scaling_at_alg2=True) + +for matrix in plotdata: + plt.plot(plotdata[matrix], label=matrix) + print(plotdata[matrix][40]) +plt.legend() + +"""## Applying Scaling at Algorithm 3""" + +_, _, plotdata_alg3 = run_alg3_for_mnist([1., 1000.], apply_scaling_at_alg2=False) + +for matrix in plotdata_alg3: + plt.plot(plotdata_alg3[matrix], label=matrix) + print(plotdata_alg3[matrix][40]) +plt.legend() + +"""## Applying Scaling at Algorithm 2""" + +_, _, plotdata_alg2 = run_alg3_for_mnist([1., 20.], apply_scaling_at_alg2=True) + +for matrix in plotdata: + plt.plot(plotdata[matrix], label=matrix) +plt.legend() + + + +"""## Additional Plotting""" + +plt.subplot(1, 3, 1) +plt.imshow(w1[:16,:16]) #, cmap=plt.cm.BuPu_r) +plt.subplot(1, 3, 2) +plt.imshow(w1_approx[:16,:16]) #, cmap=plt.cm.BuPu_r) +plt.subplot(1, 3, 3) +plt.imshow(w1[:16,:16] - w1_approx[:16,:16]) #, cmap=plt.cm.BuPu_r) + +plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9) +cax = plt.axes([0.85, 0.1, 0.075, 0.8]) +plt.colorbar(cax=cax) +plt.show() + +n, bins, patches = plt.hist(w1_approx) +plt.show() + +print(f'Mean - orig/approx: {w1.mean()} / {w1_approx.mean()}') +print(f'Standard dev - orig/approx: {w1.std()} / {w1_approx.std()}') + +cr = [] + +m, n = w1.shape +for r in range(R, (min(m, n))): + tmp = 2 * m * n / get_approx_size(r, 2, m, n) + if tmp < 2: + break + cr.append(tmp) + +print('Current Compression Ratio (CR):', 2 * m * n / get_approx_size(R, 2, m, n)) +plt.plot(cr) + +"""# More than 2 Matrix Approximation + +## Dividing weight matrix into 4 +""" + +models['fashion'].summary() +mnist_dense = [w, b] = models['mnist'].get_layer('dense_1').get_weights() +print(w.shape) +r, h = w.shape[0] // 2, w.shape[1] // 2 +blocks = np.reshape(w, (4, r, h)) +tmp = np.reshape(blocks, w.shape) +print(blocks.shape) +print(np.allclose(w, tmp)) + +# Commented out IPython magic to ensure Python compatibility. +R = 64 +metric = 'mse' +threshold = 1e-5 +scaler = [1.] * blocks.shape[0] + +logname = 'mnist_4blocks' +logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}' +logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S') +writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname)) +# %reload_ext tensorboard + +# %time w_approx = algorithm3_inverse(*algorithm3(blocks, \ + num_refinements=R, \ + num_sub_matrix=1, \ + decomposition='eigen', \ + stop_threshold=threshold, \ + metric=metric, \ + scaler=scaler, \ + report_writer=writer)) + +k, m, n = blocks.shape +print(f'CR: {k * m * n / get_approx_size(R, k, m, n)}') + +models['mnist'].get_layer('dense_1').set_weights([w, b]) +_, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0) +print('MNIST - Test accuracy:', mnist_acc) + +models['mnist'].get_layer('dense_1').set_weights([np.reshape(w_approx, w.shape), b]) +print('') + +_, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0) +print('MNIST - Test accuracy:', mnist_acc_approx) + +print('\nMNIST - Accuracy drop:', mnist_acc - mnist_acc_approx) + +plot_accuracies(['mnist'], [mnist_acc], [mnist_acc_approx]) + +"""# Different Sizes Approximation""" + +w1 = np.random.randint(9, size=(4, 8)) +w2 = np.random.randint(9, size=(5, 4)) + +max_shape = max_r, max_c = max(w1.shape[0], w2.shape[0]), max(w1.shape[1], w2.shape[1]) +print(max_shape) + +padded_w1 = np.zeros(max_shape) +padded_w2 = np.zeros(max_shape) +padded_w1[:w1.shape[0], :w1.shape[1]] = w1 +padded_w2[:w2.shape[0], :w2.shape[1]] = w2 + +print(w1) +print(w2) +print(padded_w1) +print(padded_w2) + +def pad_matrices(matrices): + max_r = max([m.shape for m in matrices],key=lambda item:item[0])[0] + max_c = max([m.shape for m in matrices],key=lambda item:item[1])[1] + padded_matrices = [] + for i in range(len(matrices)): + z = np.zeros((max_r, max_c)) + z[:matrices[i].shape[0], :matrices[i].shape[1]] = matrices[i] + padded_matrices.append(z) + return padded_matrices + +pad_matrices([w1, w2]) + +import operator + +def get_cr_multi_size_matrix(R, matrices): + max_m = max([m.shape for m in matrices],key=lambda item:item[0])[0] + max_n = max([m.shape for m in matrices],key=lambda item:item[1])[1] + approx_size = get_approx_size(R, len(matrices), max_m, max_n) + orig_size = sum(map(lambda x: operator.mul(*x.shape), matrices)) + return orig_size / approx_size + +w1 = np.random.randint(9, size=(4, 8)) +w2 = np.random.randint(9, size=(5, 4)) + +orig_size = operator.mul(*w1.shape) + operator.mul(*w2.shape) +print(orig_size) +get_cr_multi_size_matrix(1, [w1, w2]) + +cr = [] +cr_small = [] +cr_big = [] + +small_size = 128 +medium_size = 512 +large_size = 1024 +w1 = np.random.randint(9, size=(medium_size, small_size)) +w2 = np.random.randint(9, size=(large_size, medium_size)) + +for r in range(small_size // 4, small_size): + m, n = w1.shape + tmp = 2 * m * n / get_approx_size(r, 2, m, n) + cr_small.append(tmp) + m, n = w2.shape + tmp = 2 * m * n / get_approx_size(r, 2, m, n) + cr_big.append(tmp) + tmp = get_cr_multi_size_matrix(r, [w1, w2]) + if tmp < 2: + break + cr.append(tmp) + +plt.plot(cr, label='CR') +plt.plot(cr_small, label='CR_small') +plt.plot(cr_big, label='CR_big') +plt.legend() + +"""## CNN-LSTM Model""" + +print(models['cnn-lstm'].get_layer('LSTM_1').get_weights()[0].shape) +print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[0].shape) +print(len(models['cnn-lstm'].get_layer('LSTM_1').get_weights())) +print(len(models['cnn-lstm'].get_layer('LSTM_2').get_weights())) + +print(models['cnn-lstm'].get_layer('LSTM_2').get_weights()[1].shape) + +[w1, r1, b1] = models['cnn-lstm'].get_layer('LSTM_1').get_weights() +[w2, r2, b2] = models['cnn-lstm'].get_layer('LSTM_2').get_weights() + +[w1_pad, w2_pad] = pad_matrices([w1, w2]) +print(w1_pad, w2_pad) +print(w1_pad.shape) +print(w2_pad.shape) + +# Commented out IPython magic to ensure Python compatibility. +R = 25 +metric = 'mse' +threshold = 1e-5 +scaler = [1., 1.] + +logname = 'cnn-lstm' +logname += f'_R{R}_scaler0_{scaler[0]}_scaler1_{scaler[1]}_{metric}_Th{threshold}' +logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S') +writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname)) +# %reload_ext tensorboard + +# %time u, s, v = algorithm3([w1_pad, w2_pad], \ +# num_refinements=R, \ +# num_sub_matrix=1, \ +# decomposition='eigen', \ +# stop_threshold=threshold, \ +# metric=metric, \ +# scaler=scaler, \ +# report_writer=writer) + +# %time u, s, v = algorithm3_extra_refinements([w1_pad, w2_pad], u, s, v, \ + num_refinements=R, \ + num_sub_matrix=1, \ + decomposition='eigen', \ + stop_threshold=threshold, \ + metric=metric, \ + scaler=scaler, \ + report_writer=writer) +w_approx = algorithm3_inverse(u, s, v) + + +w1_approx, w2_approx = w_approx[0], w_approx[1] + +models['cnn-lstm'].get_layer('LSTM_1').set_weights([w1, r1, b1]) +models['cnn-lstm'].get_layer('LSTM_2').set_weights([w2, r2, b2]) + +_, cnn_lstm_acc = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels, verbose=0) +print(f'CNN-LSTM - Test accuracy: {cnn_lstm_acc}') + +models['cnn-lstm'].get_layer('LSTM_1').set_weights([w1_approx[:w1.shape[0], :w1.shape[1]], r1, b1]) +models['cnn-lstm'].get_layer('LSTM_2').set_weights([w2_approx[:w2.shape[0], :w2.shape[1]], r2, b2]) + +_, cnn_lstm_approx_acc = models['cnn-lstm'].evaluate([test_data[0], test_data[1]], test_labels, verbose=0) +print(f'\nCNN-LSTM - Test accuracy: {cnn_lstm_approx_acc} (approx)') +print(f'\nAccuracy drop: {cnn_lstm_acc - cnn_lstm_approx_acc}') + +plot_accuracies(['cnn_lstm'], [cnn_lstm_acc], [cnn_lstm_approx_acc]) + +"""# Minimization + +# Playing with Images +""" + +img = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/mugs.jpg') #.convert('L') +img = img.resize([int(0.8 * s) for s in img.size]) +img_array = np.array(img).transpose([2, 0, 1]).astype('float32') +num_inputs, input_size, output_size = img_array.shape +print(img_array.shape) +img + +# Commented out IPython magic to ensure Python compatibility. +# %time img_approx = algorithm3_inverse(*algorithm3(img_array, num_refinements=64, num_sub_matrix=1, decomposition='eigen')).transpose([1, 2, 0]) +image = img_approx.copy() +image *= (255.0 / image.max()) # .clip(min=0, max=255.0) +Image.fromarray(image.astype('uint8')) + +# Commented out IPython magic to ensure Python compatibility. +# %time img_approx = algorithm3_inverse(*algorithm3(img_array, num_refinements=64, num_sub_matrix=1, decomposition='svd')).transpose([1, 2, 0]) +image = img_approx.copy() +image *= (255.0 / image.max()) # .clip(min=0, max=255.0) +Image.fromarray(image.astype('uint8')) + +"""### Combine three different images""" + +cat = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/cat.jpg').convert('LA').resize([512, 256]) +mugs = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/mugs.jpg').convert('LA').resize([512, 256]) +flower = Image.open('/gdrive/My Drive/UNIVERSITY - PhD CHALMERS/sun_flower.png').convert('LA').resize([512, 256]) + +cat_img = cat = ImageOps.grayscale(cat) +mugs_img = mugs = ImageOps.grayscale(mugs) +flower_img = flower = ImageOps.grayscale(flower) + +cat = np.array(cat).astype('float32') +mugs = np.array(mugs).astype('float32') +flower = np.array(flower).astype('float32') + +img_array = np.array([cat, mugs, flower]) +print(img_array.shape) + +cat_img, mugs_img, flower_img + +# Commented out IPython magic to ensure Python compatibility. +R = 8 +metric = 'frobenius-norm' +threshold = 1e-5 +logname = 'base' +logname += '_R{}_{}_Th{}'.format(R, metric, threshold) +logname += '_date' + datetime.now().strftime('%Y%m%d-%H%M%S') +writer = tf.summary.create_file_writer(os.path.join('/gdrive/My Drive/Colab Notebooks/svd/tensorboard', logname)) +# %reload_ext tensorboard + +# %time img_approx = algorithm3_inverse(*algorithm3(img_array, \ + num_refinements=R, \ + num_sub_matrix=1, \ + decomposition='eigen', \ + stop_threshold=threshold, \ + metric=metric, \ + report_writer=writer)) +img_approx *= (255.0 / img_approx.max()) # .clip(min=0, max=255.0) + +cat_approx = Image.fromarray(img_approx[0].astype('uint8')) +cat_approx + +mugs_approx = Image.fromarray(img_approx[1].astype('uint8')) +mugs_approx + +flower_approx = Image.fromarray(img_approx[2].astype('uint8')) +flower_approx + +def frobenius(x, x_approx): + return np.sqrt(np.absolute(np.linalg.norm(x - x_approx))) + +def mse(x, x_approx): + return ((x - x_approx)**2).mean() + +print(mse(cat, cat_approx)) +print(mse(mugs, mugs_approx)) +print(mse(flower, flower_approx)) + +# 402.30466 +# 335.3521 +# 365.27515 + +from tensorflow.python.training import gradient_descent + +x = tf.Variable(10.0, trainable=True) + +@tf.function +def f_x(): + return 2 * x * x - 5 * x + 4 + +for _ in range(20): + print([x.numpy(), f_x().numpy()]) + opt = gradient_descent.GradientDescentOptimizer(0.1).minimize(f_x) + +m, n = w1.shape +p = 2 +u = tf.Variable([[np.random.rand()] * n], trainable=True) +v = tf.Variable([[np.random.rand()] * m], trainable=True) +s = tf.Variable([np.random.rand()] * p, trainable=True) +w = np.array([w1, w2]) + +@tf.function +def f_x(): + # # A = tf.Variable([[tf.constant_initializer(0)] * m] * n, trainable=False) + # for i in range(p): + # v_tmp = tf.transpose(v) * w[i].T + # # print('v_tmp.shape:', v_tmp.shape) + # A_tmp = v_tmp * u + # # print('A_tmp.shape:', A_tmp.shape) + # if i == 0: + # A = A_tmp * A_tmp + # else: + # A = A + (A_tmp * A_tmp) + # for i in range(p): + # s = tf.transpose(v) * w[i].T * u + # w_approx = s * u * tf.transpose(v) + # print('s.shape:', s.shape) + # print('w_approx.shape:', w_approx.shape) + # if i == 0: + # mse = (w[i].T - w_approx) * (w[i].T - w_approx) + # else: + # mse = mse + (w[i].T - w_approx) * (w[i].T - w_approx) + + uv = u * tf.transpose(v) + s_tmp = tf.expand_dims(tf.expand_dims(s, axis=1), axis=2) + approx = tf.reduce_sum(w - s_tmp * tf.stack([uv] * p), axis=0) + return -tf.norm(approx, ord='fro', axis=[-2,-1]) + +norms = [] +for _ in range(100): + # print([x.numpy(), f_x().numpy()]) + # print(f_x().numpy()) + norms.append(f_x().numpy()) + opt = gradient_descent.GradientDescentOptimizer(0.0001).minimize(f_x) + +plt.plot(norms) +print(u.numpy().mean()) +print(v.numpy().mean()) + +models['mnist'].get_layer('dense_1').set_weights([w1, b1]) +models['fashion'].get_layer('dense_1').set_weights([w2, b2]) +_, mnist_acc = models['mnist'].evaluate(x_test, y_test, verbose=0) +_, fashion_mnist_acc = models['fashion'].evaluate(test_images, test_labels, verbose=2) +print('MNIST - Test accuracy:', mnist_acc) +print('Fashion MNIST - Test accuracy:', fashion_mnist_acc) + +A = (u * tf.transpose(v)).numpy() +w1_approx = s[0].numpy() * A +w2_approx = s[1].numpy() * A + +models['mnist'].get_layer('dense_1').set_weights([w1_approx, b1]) +models['fashion'].get_layer('dense_1').set_weights([w2_approx, b2]) +print('') + +_, mnist_acc_approx = models['mnist'].evaluate(x_test, y_test, verbose=0) +_, fashion_mnist_acc_approx = models['fashion'].evaluate(test_images, test_labels, verbose=2) +print('MNIST - Test accuracy:', mnist_acc_approx) +print('Fashion MNIST - Test accuracy:', fashion_mnist_acc_approx) + +print('\nMNIST - Accuracy drop:', mnist_acc - mnist_acc_approx) +print('Fashion MNIST - Accuracy drop:', fashion_mnist_acc - fashion_mnist_acc_approx) + +plot_accuracies(list(models.keys()), [mnist_acc, fashion_mnist_acc], + [mnist_acc_approx, fashion_mnist_acc_approx]) + +# Use the GitHub version of TFCO +!pip install git+https://github.com/google-research/tensorflow_constrained_optimization +import tensorflow_constrained_optimization as tfco + +m, n = w1.shape +p = 2 +u = tf.Variable([[np.random.rand()] * n], trainable=True) +v = tf.Variable([[np.random.rand()] * m], trainable=True) +s = tf.Variable([np.random.rand()] * p, trainable=True) +w = np.array([w1, w2]) + +def loss_fn(): + uv = u * tf.transpose(v) + s_tmp = tf.expand_dims(tf.expand_dims(s, axis=1), axis=2) + approx = tf.reduce_sum(w - s_tmp * tf.stack([uv] * p), axis=0) + for i in range(p): + A_tmp = tf.transpose(v) * w[i].T * u + if i == 0: + A = A_tmp * A_tmp + else: + A = A + (A_tmp * A_tmp) + return A - tf.norm(approx, ord='fro', axis=[-2, -1]) + +class SampleProblem(tfco.ConstrainedMinimizationProblem): + def __init__(self, loss_fn, weights): + self._loss_fn = loss_fn + self._weights = weights + + @property + def num_constraints(self): + return 2 + + def objective(self): + return loss_fn() + + def constraints(self): + u, s, v = self._weights + u_norm = tf.linalg.norm(u) # tf.math.reduce_euclidean_norm(u) + v_norm = tf.linalg.norm(v) # tf.math.reduce_euclidean_norm(v) + u_norm_eq_one = 1 - u_norm + v_norm_eq_one = 1 - v_norm + constraints = tf.stack([u_norm_eq_one, v_norm_eq_one]) + # A = (u * tf.transpose(v)).numpy() + # for i in range(p): + # rank_eq_one = 1. - tf.Variable(tf.cast(tf.rank(s[i] * A), tf.float32)) + # constraints = tf.stack([constraints, rank_eq_one]) + return constraints + +problem = SampleProblem(loss_fn, [u, s, v]) +optimizer = tfco.LagrangianOptimizer( + optimizer=tf.optimizers.Adagrad(learning_rate=0.1), + num_constraints=problem.num_constraints) + +var_list = [u, s, v] + list(problem.trainable_variables) + optimizer.trainable_variables() + +for i in range(1000): + optimizer.minimize(problem, var_list=var_list) + if i % 100 == 0: + print(f'step = {i}') + print(f'loss = {loss_fn()}') + # print(f'constraint = {(x + y).numpy()}') + # print(f'u = {u.numpy()}, v = {v.numpy()}') + + + diff --git a/run_hls.tcl b/run_hls.tcl index e8d476a..d3235a4 100644 --- a/run_hls.tcl +++ b/run_hls.tcl @@ -1,80 +1,13 @@ -# -# @brief Find all files in a directory and return them in a list. -# -# @param basedir The directory to start looking in pattern. -# @param pattern A pattern, as defined by the glob command, that -# the files must match. -# @param exclude_dirs_list Ignore searching in specified directories -# -# @return The list of found files. -# -proc findFiles { basedir pattern exclude_dirs_list } { - # Fix the directory name, this ensures the directory name is in the - # native format for the platform and contains a final directory seperator - set basedir [string trimright [file join [file normalize $basedir] { }]] - set fileList {} - # Look in the current directory for matching files, -type {f r} - # means ony readable normal files are looked at, -nocomplain stops - # an error being thrown if the returned list is empty - foreach fileName [glob -nocomplain -type {f r} -path $basedir $pattern] { - lappend fileList $fileName - } - # Now look for any sub direcories in the current directory - foreach dirName [glob -nocomplain -type {d r} -path $basedir *] { - # Recusively call the routine on the sub directory and append any - # new files to the results - if {[lsearch -exact ${exclude_dirs_list} $dirName] == -1} { - set subDirList [findFiles $dirName $pattern $exclude_dirs_list] - if { [llength $subDirList] > 0 } { - foreach subDirFile $subDirList { - lappend fileList $subDirFile - } - } - } - } - return $fileList -} - -# -# @brief Greps a file content and writes matches to a file. -# -# @param re Regular expression -# @param lines Number of lines to report/include after the found match -# @param fin The fin pointer -# @param fout The fout pointer -# -proc grep {re lines fin fout} { - set cnt 0 - set match false - seek $fin 0 - while {[gets $fin line] >= 0} { - if [regexp -- $re $line] { - set cnt 0 - set match true - } - if {$match && ($cnt < $lines)} { - puts $line - puts $fout $line - set cnt [expr {$cnt +1}] - } else { - set match false - } - } -} +source tcl/utils.tcl +source tcl/lstm_params.tcl set PRJ_PATH [pwd] -exec mkdir -p -- ./hls -exec mkdir -p -- ./hls/reports -cd hls +exec mkdir -p -- ./hls_prj +exec mkdir -p -- ./hls_prj/reports +cd hls_prj -# ============================================================================== -# Top function name, testbench file -# ============================================================================== -set TOP "hls_pong" -set TB "test_game" -set SRC_DIR "" ;# Or just leave it empty for including all sub-dirs too. -set SRC_LIST [list ""] ;# If empty, it will include all files in SRC_DIR subdirs +set USE_VITIS 1 # ============================================================================== # Setups # ============================================================================== @@ -86,10 +19,11 @@ set cosim 0 set export 0 set place_and_route 0 set report_info 1 +set set_max_fifo_depth 0 # ============================================================================== # HLS Synthesis Options + Platform Selection # ============================================================================== -set scheduler_effort "medium" +set scheduler_effort "high" ;# medium set relax_ii 0 set use_hlslib 0 set use_zedboard 1 @@ -104,17 +38,30 @@ if {${use_zedboard}} { set board_name "ZCU102" } # ============================================================================== -# Hardware parameters +# Top function name, testbench file # ============================================================================== - +# NOTE: The namespace must also be included. +set TB "test_lstm_svd" +set ARGV "2 4 64 32 2" +set TOP "SvdModel2LstmSDSoCV2" ;# "HlsLstmSvd" ;# "HlsSvdKernel" ;# "HlsDenseSvd" ; #"HlsKernelS" ;# "HlsGemvKernel" ;#"HlsAxisKernelU" ;#"svd::SvdModel2LstmSDSoCV2" +set SRC_DIR "" ;# Or just leave it empty for including all sub-dirs too. +set SRC_LIST [list ""] ;# If empty, it will include all files in SRC_DIR subdirs # ============================================================================== # Project name # ============================================================================== -set PROJECT_NAME "${board_name}_${TOP}" +set prefix ":" +set TOP_NO_NAMESPACE "SvdModel2LstmSDSoCV2" ;# "HlsLstmSvd" ;# "HlsSvdKernel" ;# "HlsDenseSvd" ; #"HlsKernelS" ;# "HlsGemvKernel" ; #"HlsAxisKernelU" ;# [ regsub ***=${prefix} ${TOP} "" string ] +puts ${TOP_NO_NAMESPACE} + +if {${USE_VITIS}} { + set PROJECT_NAME "vitis_${board_name}_${TOP_NO_NAMESPACE}" +} else { + set PROJECT_NAME "hls_${board_name}_${TOP_NO_NAMESPACE}" +} # ============================================================================== # Defines # ============================================================================== -# The HLS_NO_XIL_FPO_LIB flag is used to compile hlaf precision numbers. +# The HLS_NO_XIL_FPO_LIB flag is used to compile half precision numbers. set DEFINES "-DHLS_NO_XIL_FPO_LIB" append DEFINES "" @@ -124,88 +71,109 @@ if {${use_zcu104_pynq}} { } else { append DEFINES " -DAXI_PORT_WIDTH=64" } + +append_lstm_params DEFINES # append DEFINES " -DDEBUG_INTERNAL_STREAMS" # append DEFINES " -DUSE_BLAS" # ============================================================================== # Linker Flags # ============================================================================== -set LDFLAGS "-lpthread -fopenmp" +set LDFLAGS "" +# set LDFLAGS "-lpthread -fopenmp" # append LDFLAGS " /usr/local/lib/libblas.a" # ============================================================================== -# TB arguments -# ============================================================================== -set ARGV "" -# ============================================================================== # CFlags # ============================================================================== # NOTE(21/02/2019): the '-fno-builtin' is suggested by Xilinx when using # the set_directive_resource option. +if {${USE_VITIS}} { + set CXXSTD "-std=c++14" ;#"-std=c++14 -fno-builtin" ; #"-std=c++1y" +} else { + set CXXSTD "-std=c++0x -fno-builtin" +} if {${cosim}} { - set CFLAGS "-O3 -g -std=c++0x -fno-builtin -I${PRJ_PATH}/include/${SRC_DIR}/ -DCOSIM_DESIGN ${DEFINES} -I/usr/local/include" + set CFLAGS "-O3 ${CXXSTD} -I${PRJ_PATH}/include/${SRC_DIR}/ -DCOSIM_DESIGN ${DEFINES} -I/usr/local/include" } else { - set CFLAGS "-O3 -g -std=c++0x -fno-builtin -I${PRJ_PATH}/include/${SRC_DIR}/ ${DEFINES} -I/usr/local/include" + set CFLAGS "-O3 ${CXXSTD} -I${PRJ_PATH}/include/${SRC_DIR}/ ${DEFINES} -I/usr/local/include" } # ============================================================================== # Open Project and Add Files # ============================================================================== if {${reset_project}} { - open_project -reset hls_${PROJECT_NAME} + open_project -reset ${PROJECT_NAME} } else { - open_project hls_${PROJECT_NAME} + open_project ${PROJECT_NAME} } set_top ${TOP} -set HLS_REPORT_PATH "hls_${PROJECT_NAME}/solution_${TOP}/syn/report/" -set REPORT_DIR "${PRJ_PATH}/hls/reports" -set REPORT_FILE_PATH "${PRJ_PATH}/hls/reports/" -set VIVADO_LIB "C:/Xilinx/Vivado/2018.3/include/" +set HLS_REPORT_PATH "${PROJECT_NAME}/solution_${TOP}/syn/report/" +set REPORT_DIR "${PRJ_PATH}/hls_prj/reports" +set REPORT_FILE_PATH "${PRJ_PATH}/hls_prj/reports/" +# set VIVADO_LIB "C:/Xilinx/Vivado/2018.3/include/" set BLAS_LIB "C:/Users/ste/.caffe/dependencies/libraries_v140_x64_py27_1.1.0/libraries/lib/libopenblas.a" set BLAS_LIB_DIR "C:/Users/ste/.caffe/dependencies/libraries_v140_x64_py27_1.1.0/libraries/lib" # Get Source Files (1st argument: regex, 2nd argument: excluded directory) -set src_files [findFiles "${PRJ_PATH}/src/${SRC_DIR}/" "*.cpp" "${PRJ_PATH}/src/tb"] -set include_files [findFiles "${PRJ_PATH}/include/${SRC_DIR}/" "*.h" "${PRJ_PATH}/include/tb"] +set src_files [findFiles "${PRJ_PATH}/src/${SRC_DIR}/" "*.cpp" "${PRJ_PATH}/src/testbenches"] +set include_files [findFiles "${PRJ_PATH}/include/${SRC_DIR}/" "*.h" "${PRJ_PATH}/include/testbenches"] if {${reset_project}} { - foreach f ${src_files} { - add_files ${f} -cflags ${CFLAGS} - } - foreach f ${include_files} { - add_files ${f} -cflags ${CFLAGS} - } - # if {llength $SRC_LIST -eq 0} { - # foreach f ${src_files} { - # add_files ${f} -cflags ${CFLAGS} - # } - # foreach f ${include_files} { + add_files ${PRJ_PATH}/src/kernel/u_kernel.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/kernel/s_kernel.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/kernel/v_kernel.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/kernel/svd_kernel.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/layers/dense/hls/dense_svd.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/layers/lstm/hls/lstm_svd.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/hls_utils/adder_tree.cpp -cflags ${CFLAGS} + add_files ${PRJ_PATH}/src/hls_utils/hls_metaprogramming.cpp -cflags ${CFLAGS} + + add_files ${PRJ_PATH}/include/kernel/u_kernel.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/kernel/s_kernel.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/kernel/v_kernel.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/kernel/svd_kernel.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/layers/dense/hls/dense_svd.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/layers/lstm/hls/lstm_svd.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/math_utils/activation_functions.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/hls_utils/adder_tree.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/hls_utils/hls_metaprogramming.h -cflags ${CFLAGS} + add_files ${PRJ_PATH}/include/dma/svd_parameters.h -cflags ${CFLAGS} + + # foreach f ${include_files} { + # # File svd.h contains main() + # if {${f} eq "${PRJ_PATH}/include/svd.h"} { + # } else { # add_files ${f} -cflags ${CFLAGS} # } - # } else { - # foreach f ${SRC_LIST} { + # } + # foreach f ${src_files} { + # # File svd.cpp contains main() + # if {${f} eq "${PRJ_PATH}/src/svd.cpp"} { + # } else { # add_files ${f} -cflags ${CFLAGS} # } # } - # add_files ${PRJ_PATH}/src/axis_lib.cpp -cflags ${CFLAGS} - # add_files ${PRJ_PATH}/include/axis_lib.h -cflags ${CFLAGS} - # Add Testbench Files if {${csim} || ${cosim}} { # TB Files (to avoid including multiple files with main() in them) - add_files -tb ${PRJ_PATH}/src/tb/${TB}.cpp -cflags ${CFLAGS} - add_files -tb ${PRJ_PATH}/include/tb/${TB}.h -cflags ${CFLAGS} + add_files -tb ${PRJ_PATH}/src/testbenches/${TB}.cpp -cflags ${CFLAGS} + add_files -tb ${PRJ_PATH}/include/testbenches/${TB}.h -cflags ${CFLAGS} } } -open_solution "solution_${TOP}" +if {${USE_VITIS}} { + open_solution -flow_target vivado -reset "solution_${TOP_NO_NAMESPACE}" +} else { + open_solution "solution_${TOP_NO_NAMESPACE}" +} # ============================================================================== # Set Part # ============================================================================== if {${reset_project}} { if {${use_zedboard}} { # ZedBoard - set_part {xc7z020clg484-1} -tool vivado + set_part {xc7z020clg484-1} ;#-tool vivado } else { if {${use_zcu104_pynq}} { # Pynq ZCU104 Board @@ -216,11 +184,11 @@ if {${reset_project}} { create_clock -period 5 -name default } elseif {${use_zcu102_vassilis}} { # Ultrascale+ ZCU102 - set_part {xczu9eg-ffvb1156-2-i} -tool vivado + set_part {xczu9eg-ffvb1156-2-i} ;#-tool vivado create_clock -period 10 -name default } else { # ZedBoard (default) - set_part {xc7z020clg484-1} -tool vivado + set_part {xc7z020clg484-1} ;#-tool vivado create_clock -period 10 -name default } } @@ -234,29 +202,44 @@ if {${reset_project}} { # ============================================================================== # Configure HLS # ============================================================================== +if {${USE_VITIS}} { + config_compile -name_max_length=12 -pipeline_style=frp -enable_auto_rewind=1 +} else { + config_compile -name_max_length=12 +} + if {${relax_ii}} { - config_schedule -effort ${scheduler_effort} -relax_ii_for_timing=0 + config_schedule -effort ${scheduler_effort} -relax_ii_for_timing=1 } else { - config_schedule -effort ${scheduler_effort} + config_schedule -effort ${scheduler_effort} -relax_ii_for_timing=0 } -# config_sdx -target sds ;# -optimization_level 3 +# config_sdx -target sdx ;# -optimization_level 3 -if {${use_zcu104_pynq}} { - config_interface -m_axi_addr64 +if {${use_zedboard}} { + config_interface -m_axi_addr64=0 +} +if {${USE_VITIS}} { + config_interface -m_axi_auto_max_ports=1 -m_axi_offset=slave } config_core DSP48 -latency 3 -config_dataflow -default_channel pingpong +# config_dataflow -default_channel fifo ;#pingpong +if {${set_max_fifo_depth}} { + set MAX_DEPTH 65536 + config_dataflow -fifo_depth=${MAX_DEPTH} -start_fifo_depth=${MAX_DEPTH} \ + -scalar_fifo_depth=${MAX_DEPTH} -task_level_fifo_depth=${MAX_DEPTH} \ + -override_user_fifo_depth=${MAX_DEPTH} +} # ============================================================================== # Start C-Simulation # ============================================================================== if {${csim}} { if {${build_only}} { - csim_design -clean -O -compiler gcc -ldflags ${LDFLAGS} -argv ${ARGV} -setup + csim_design -clean -O -ldflags ${LDFLAGS} -argv ${ARGV} -setup } else { - csim_design -clean -O -compiler gcc -ldflags ${LDFLAGS} -argv ${ARGV} + csim_design -clean -O -ldflags ${LDFLAGS} -argv ${ARGV} } } # ============================================================================== @@ -270,7 +253,7 @@ if {${synth}} { puts "\[INFO\] Reporting information" puts "================================================================" - set FILENAME "${REPORT_FILE_PATH}/${board_name}_${TOP}.rpt" + set FILENAME "${REPORT_FILE_PATH}/${board_name}_${TOP_NO_NAMESPACE}.rpt" set fin [open ${HLS_REPORT_PATH}/${TOP}_csynth.rpt r] set fout [open ${FILENAME} a] @@ -286,15 +269,24 @@ if {${synth}} { # Start Cosimulation # ============================================================================== if {${cosim}} { - cosim_design -trace_level port -ldflags ${LDFLAGS} -argv ${ARGV} ;#-tool auto -wave_debug + + if {${USE_VITIS}} { + cosim_design -trace_level port -ldflags ${LDFLAGS} -argv ${ARGV} \ + -enable_dataflow_profiling=0 -enable_fifo_sizing=0 + # -disable_deadlock_detection + # -disable_dependency_check + } else { + cosim_design -trace_level port -ldflags ${LDFLAGS} -argv ${ARGV} ;#-tool auto -wave_debug + } + if {${report_info}} { puts "================================================================" puts "\[INFO\] Reporting information" puts "================================================================" - set REPORT_FILENAME "${REPORT_FILE_PATH}/${board_name}_${TOP}.rpt" - set HLS_REPORT_PATH "hls_${PROJECT_NAME}/solution_${TOP}/sim/report/" + set REPORT_FILENAME "${REPORT_FILE_PATH}/${board_name}_${TOP_NO_NAMESPACE}.rpt" + set HLS_REPORT_PATH "${PROJECT_NAME}/solution_${TOP_NO_NAMESPACE}/sim/report/" set fin [open ${HLS_REPORT_PATH}/${TOP}_cosim.rpt r] set fout [open ${REPORT_FILENAME} a] @@ -316,7 +308,7 @@ if {${export}} { } puts "================================================================" -puts "\[INFO\] Closing project: ./hls/hls_${PROJECT_NAME}" +puts "\[INFO\] Closing project: ./hls_prj/${PROJECT_NAME}" puts "================================================================" exit diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0820838..ce85d5b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,34 +1,38 @@ cmake_minimum_required(VERSION 3.10) add_subdirectory(dma) add_subdirectory(kernel) -add_subdirectory(lstm) add_subdirectory(math_utils) add_subdirectory(hls_utils) add_subdirectory(testbenches) +# add_subdirectory(lstm) +# add_subdirectory(dense) +add_subdirectory(layers) # NOTE: Each library/object will have an identifier and that identifier will then # be used to link the final executable, i.e. target_link_libraries(ProjectName LibraryName) add_library(SVD_PARAMS STATIC ${CMAKE_SOURCE_DIR}/src/svd_ip.cpp) target_include_directories(SVD_PARAMS PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SVD_PARAMS PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(SVD_PARAMS PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(SVD_PARAMS PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(SVD_PARAMS ${OpenCv_LIBS}) target_compile_options(SVD_PARAMS PRIVATE -fno-builtin) add_library(SVD_IP STATIC ${CMAKE_SOURCE_DIR}/src/svd_ip.cpp) target_include_directories(SVD_IP PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SVD_IP PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(SVD_IP PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(SVD_IP PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(SVD_IP ${OpenCv_LIBS}) -target_link_libraries(SVD_IP SVD_KERNEL) target_compile_options(SVD_IP PRIVATE -fno-builtin) +target_link_libraries(SVD_IP SVD_KERNEL) add_library(SVD STATIC ${CMAKE_SOURCE_DIR}/src/svd.cpp) target_include_directories(SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SVD PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(SVD PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_compile_options(SVD PRIVATE -fno-builtin) target_link_libraries(SVD ${OpenCv_LIBS}) target_link_libraries(SVD SVD_IP) target_link_libraries(SVD LSTM_SVD) -target_compile_options(SVD PRIVATE -fno-builtin) +target_link_libraries(SVD LSTM_SVD_EMULATOR) +target_link_libraries(SVD SOFT_LSTM_SVD) diff --git a/src/dma/CMakeLists.txt b/src/dma/CMakeLists.txt index 7b3291d..30d20b1 100644 --- a/src/dma/CMakeLists.txt +++ b/src/dma/CMakeLists.txt @@ -2,12 +2,17 @@ cmake_minimum_required(VERSION 3.10) add_library(SVD_DMA STATIC ${CMAKE_SOURCE_DIR}/src/dma/svd_dma.cpp) target_include_directories(SVD_DMA PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SVD_DMA PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(SVD_DMA PUBLIC ${HLS_INCLUDE_DIRS}) target_compile_options(SVD_DMA PRIVATE -fno-builtin) target_link_libraries(SVD_DMA SVD_PARAMS) add_library(WIDTH_CONVERTER STATIC ${CMAKE_SOURCE_DIR}/src/dma/width_converter.cpp) target_include_directories(WIDTH_CONVERTER PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(WIDTH_CONVERTER PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(WIDTH_CONVERTER PUBLIC ${HLS_INCLUDE_DIRS}) target_compile_options(WIDTH_CONVERTER PRIVATE -fno-builtin) -target_link_libraries(WIDTH_CONVERTER SVD_PARAMS) \ No newline at end of file +target_link_libraries(WIDTH_CONVERTER SVD_PARAMS) + +add_library(AXIS_LIB STATIC ${CMAKE_SOURCE_DIR}/src/dma/axis_lib.cpp) +target_include_directories(AXIS_LIB PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(AXIS_LIB PUBLIC ${HLS_INCLUDE_DIRS}) +target_compile_options(AXIS_LIB PRIVATE -fno-builtin) \ No newline at end of file diff --git a/src/dma/axis_lib.cpp b/src/dma/axis_lib.cpp new file mode 100644 index 0000000..40a14bf --- /dev/null +++ b/src/dma/axis_lib.cpp @@ -0,0 +1 @@ +#include "dma/axis_lib.h" \ No newline at end of file diff --git a/src/hls_utils/CMakeLists.txt b/src/hls_utils/CMakeLists.txt index e488058..e69fc07 100644 --- a/src/hls_utils/CMakeLists.txt +++ b/src/hls_utils/CMakeLists.txt @@ -2,19 +2,19 @@ cmake_minimum_required(VERSION 3.10) add_library(DOT_PROD_DSP STATIC ${CMAKE_SOURCE_DIR}/src/hls_utils/dot_prod_dsp.cpp) target_include_directories(DOT_PROD_DSP PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(DOT_PROD_DSP PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(DOT_PROD_DSP PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(DOT_PROD_DSP PUBLIC ${OpenCv_INCLUDE_DIRS}) target_compile_options(DOT_PROD_DSP PRIVATE -fno-builtin) # target_link_libraries(DOT_PROD_DSP ${OpenCv_LIBS}) add_library(HW_TIMER STATIC ${CMAKE_SOURCE_DIR}/src/hls_utils/hw_timer.cpp) target_include_directories(HW_TIMER PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(HW_TIMER PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(HW_TIMER PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(HW_TIMER PUBLIC ${OpenCv_INCLUDE_DIRS}) target_compile_options(HW_TIMER PRIVATE -fno-builtin) add_library(ADDER_TREE STATIC ${CMAKE_SOURCE_DIR}/src/hls_utils/adder_tree.cpp) target_include_directories(ADDER_TREE PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(ADDER_TREE PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(ADDER_TREE PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(ADDER_TREE PUBLIC ${OpenCv_INCLUDE_DIRS}) target_compile_options(ADDER_TREE PRIVATE -fno-builtin) \ No newline at end of file diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt index 39798b8..8c6616e 100644 --- a/src/kernel/CMakeLists.txt +++ b/src/kernel/CMakeLists.txt @@ -3,18 +3,19 @@ cmake_minimum_required(VERSION 3.10) add_library(U_KERNEL STATIC ${CMAKE_SOURCE_DIR}/src/kernel/u_kernel.cpp) target_include_directories(U_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) target_include_directories(U_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include/kernel) -target_include_directories(U_KERNEL PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(U_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) target_compile_options(U_KERNEL PRIVATE -fno-builtin) add_library(S_KERNEL STATIC ${CMAKE_SOURCE_DIR}/src/kernel/s_kernel.cpp) target_include_directories(S_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) target_include_directories(S_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include/kernel) -target_include_directories(S_KERNEL PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(S_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) target_compile_options(S_KERNEL PRIVATE -fno-builtin) add_library(V_KERNEL STATIC ${CMAKE_SOURCE_DIR}/src/kernel/v_kernel.cpp) target_include_directories(V_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) target_include_directories(V_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include/kernel) +target_include_directories(V_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) target_compile_options(V_KERNEL PRIVATE -fno-builtin) add_library(SVD_KERNEL STATIC ${CMAKE_SOURCE_DIR}/src/kernel/svd_kernel.cpp) @@ -25,6 +26,15 @@ target_link_libraries(SVD_KERNEL U_KERNEL) target_link_libraries(SVD_KERNEL S_KERNEL) target_link_libraries(SVD_KERNEL V_KERNEL) + +add_library(GEMV_KERNEL STATIC ${CMAKE_SOURCE_DIR}/src/kernel/gemv_kernel.cpp) +target_include_directories(GEMV_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(GEMV_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include/kernel) +target_compile_options(GEMV_KERNEL PRIVATE -fno-builtin) +target_link_libraries(GEMV_KERNEL U_KERNEL) +target_link_libraries(GEMV_KERNEL S_KERNEL) +target_link_libraries(GEMV_KERNEL V_KERNEL) + # add_library(DQNET STATIC ${CMAKE_SOURCE_DIR}/src/kernel/kernel.cpp) # target_include_directories(DQNET PUBLIC ${CMAKE_SOURCE_DIR}/include) # target_include_directories(DQNET PUBLIC ${CMAKE_SOURCE_DIR}/include/kernel) diff --git a/src/kernel/README.md b/src/kernel/README.md new file mode 100644 index 0000000..9791960 --- /dev/null +++ b/src/kernel/README.md @@ -0,0 +1,38 @@ +# Kernels + +## U-Kernel + +### HlsAxisKernelU + +To be used with external DMAs. +```c++ +void HlsAxisKernelU(const int num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port); +``` + +### HlsManySamplingsKernelU + +Compared to the previous implementation, this kernel has a different number of refinements per input. The refinements and inputs must be **ordered**. Meaning that input at index zero has the lowest amount of refinements to process. + +```c++ +void HlsManySamplingsKernelU(const hls::vector num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port); +``` + +### HlsKernelU + +Flaxible Kernel-U. + +```c++ +void HlsKernelU(const int num_active_inputs, + const int input_size, + const hls::vector num_refinements, + const bool pad_output, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port +``` \ No newline at end of file diff --git a/src/kernel/gemv_kernel.cpp b/src/kernel/gemv_kernel.cpp new file mode 100644 index 0000000..1f7c1d6 --- /dev/null +++ b/src/kernel/gemv_kernel.cpp @@ -0,0 +1,49 @@ +#include "kernel/gemv_kernel.h" + +#ifdef __VITIS_HLS__ + +void HlsGemvKernel(const int num_rows, const int num_cols, + hls::stream >& x1_port, + hls::stream >& x2_port, + hls::stream >& w1_port, + hls::stream >& w2_port, + hls::stream& y1_port, + hls::stream& y2_port) { +#pragma HLS INTERFACE s_axilite port=return bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_cols bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_rows bundle=ctrl +#pragma HLS DATAFLOW + + hls::stream > x_streams[testgemv::N]; + hls::stream > w_streams[testgemv::N]; + hls::stream y_streams[testgemv::N]; +#pragma HLS ARRAY_PARTITION variable=x_streams complete +#pragma HLS ARRAY_PARTITION variable=w_streams complete +#pragma HLS ARRAY_PARTITION variable=y_streams complete + + + const int kNumTiles = num_rows / testgemv::T; + + DMA_in: + for (int i = 0; i < kNumTiles; ++i) { + for (int j = 0; j < num_cols; ++j) { +#pragma HLS PIPELINE II=1 + x_streams[0] << x1_port.read(); + x_streams[1] << x2_port.read(); + w_streams[0] << w1_port.read(); + w_streams[1] << w2_port.read(); + } + } + + svd::GemvKernel(num_rows, num_cols, + x_streams, w_streams, y_streams); + + DMA_out: + for (int i = 0; i < num_cols; ++i) { +#pragma HLS PIPELINE II=1 + y1_port.write(y_streams[0].read()); + y2_port.write(y_streams[1].read()); + } +} + +#endif diff --git a/src/kernel/s_kernel.cpp b/src/kernel/s_kernel.cpp index e69de29..12e415d 100644 --- a/src/kernel/s_kernel.cpp +++ b/src/kernel/s_kernel.cpp @@ -0,0 +1,29 @@ +#include "kernel/s_kernel.h" +#include "dma/axis_lib.h" + +#include "hls_stream.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +#ifdef __VITIS_HLS__ +void HlsKernelS(const int num_active_inputs, + const int num_refinements[tests::params::N], + // const hls::vector num_refinements, + hls::stream& xu_port, + hls::stream& s_port, + hls::stream& xus_port) { +#pragma HLS INTERFACE axis port=xu_port +#pragma HLS INTERFACE axis port=s_port +#pragma HLS INTERFACE axis port=xus_port +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_active_inputs +#pragma HLS INTERFACE s_axilite port=num_refinements + svd::KernelS(num_active_inputs, num_refinements, xu_port, + s_port, xus_port); +} +#endif + +namespace svd { + +} // svd \ No newline at end of file diff --git a/src/kernel/svd_kernel.cpp b/src/kernel/svd_kernel.cpp index 7aabb45..74c7bca 100644 --- a/src/kernel/svd_kernel.cpp +++ b/src/kernel/svd_kernel.cpp @@ -1 +1,46 @@ -#include "kernel/svd_kernel.h" \ No newline at end of file +#include "kernel/svd_kernel.h" + +void HlsSvdKernel(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::svd_params::N], + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& y_port) { +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_port +#pragma HLS INTERFACE axis port=s_port +#pragma HLS INTERFACE axis port=v_port +#pragma HLS INTERFACE axis port=y_port +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_active_inputs +#pragma HLS INTERFACE s_axilite port=input_size +#pragma HLS INTERFACE s_axilite port=output_size +#pragma HLS INTERFACE s_axilite port=num_refinements +#pragma HLS DATAFLOW + svd::SvdKernel(num_active_inputs, input_size, output_size, + num_refinements, x_port, u_port, s_port, v_port, y_port); +} + +void HlsSvdKernelFixed( + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& y_port) { +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_port +#pragma HLS INTERFACE axis port=s_port +#pragma HLS INTERFACE axis port=v_port +#pragma HLS INTERFACE axis port=y_port +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS DATAFLOW + const int kNumActiveInputs = svd::svd_params::N; + const int kInputSize = svd::svd_params::I; + const int kOutputSize = svd::svd_params::H; + const int kNumRefinements[svd::svd_params::N] = {svd::svd_params::R}; + svd::SvdKernel(kNumActiveInputs, kInputSize, kOutputSize, + kNumRefinements, x_port, u_port, s_port, v_port, y_port); +} \ No newline at end of file diff --git a/src/kernel/u_kernel.cpp b/src/kernel/u_kernel.cpp index e69de29..4f28bd3 100644 --- a/src/kernel/u_kernel.cpp +++ b/src/kernel/u_kernel.cpp @@ -0,0 +1,292 @@ +#include "kernel/u_kernel.h" +#include "kernel/gemv_kernel.h" +#include "hls_utils/adder_tree.h" +#include "dma/svd_dma.h" +#include "dma/axis_lib.h" + +#include "assert.h" +#include "ap_axi_sdata.h" +#include "hls_stream.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +#ifndef __VITIS_HLS__ +void HlsKernelU(const int num_refinements, + const typename testu::params::ActivationD x_port[testu::params::N][testu::params::I], + const typename testu::params::UPortD u_port[testu::params::R * testu::params::PrunedSizeU], + typename testu::params::ActivationD xu_port[testu::params::N][testu::params::G * testu::params::R]) { +#pragma HLS INTERFACE s_axilite port=return bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_refinements bundle=ctrl +#pragma HLS INTERFACE m_axi port=x_port offset=slave depth=testu::params::I +#pragma HLS INTERFACE m_axi port=u_port offset=slave depth=testu::params::R*testu::params::PrunedSizeU +#pragma HLS INTERFACE m_axi port=xu_port offset=slave depth=testu::params::R +#pragma HLS DATAFLOW + svd::SvdStreams streams; + svd::SvdBuffers buffers; + svd::InputDMA(num_refinements, x_port, streams, buffers); + svd::StreamSplitter(num_refinements * testu::params::G * testu::params::PrunedSizeU, u_port, streams.u_dma); + U_Dispatcher: + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < testu::params::PeU; ++j) { + for (int k = 0; k < testu::params::PrunedSizeU / testu::params::PeU; ++k) { +#pragma HLS PIPELINE II=1 +#pragma HLS LOOP_FLATTEN + for (int g = 0; g < testu::params::G; ++g) { + streams.u[g][j].write(streams.u_dma[g].read()); + } + } + } + } + svd::KernelU(num_refinements, streams); + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < testu::params::N; ++j) { +#pragma HLS PIPELINE II=1 + for (int k = 0; k < testu::params::G; ++k) { + auto tmp = hlsutils::adder_tree(streams.xu[j][k]); + xu_port[j][k * num_refinements + i] = tmp; + } + } + } +} +#else +void HlsVectorKernelU(const int num_refinements, + hls::stream > &x_port, + hls::stream > &u_port, + hls::stream > &xu_port) { + const int R_test = num_refinements; + const int kNumTilesU = testu::params::I / testu::params::Tu; + const int kDepth_X = testu::params::N * kNumTilesU; + const int kDepth_U = num_refinements * kNumTilesU * testu::params::G; + const int kDepth_XU = num_refinements * testu::params::G; + +// #pragma HLS INTERFACE m_axi port=x_port bundle=x offset=slave +// #pragma HLS INTERFACE m_axi port=u_port bundle=u offset=slave +// #pragma HLS INTERFACE m_axi port=xu_port bundle=xu offset=slave +// #pragma HLS INTERFACE s_axilite port=x_port +// #pragma HLS INTERFACE s_axilite port=u_port +// #pragma HLS INTERFACE s_axilite port=xu_port + +#pragma HLS INTERFACE axis port=x_port bundle=x_dmem +#pragma HLS INTERFACE axis port=u_port bundle=u_dmem +#pragma HLS INTERFACE axis port=xu_port bundle=xu_dmem + +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_refinements +#pragma HLS DATAFLOW + typedef typename testu::params::ActivationD ActivationType; + typedef hls::vector VectN_Type; + + hls::stream x_streams[testu::params::N]; + hls::stream u_streams[testu::params::G]; + hls::stream xu_streams[testu::params::N][testu::params::G]; + testu::params::VectTuType x_buffer[testu::params::N][kNumTilesU]; + testu::params::VectTuType xu[testu::params::N][testu::params::G]; +#pragma HLS STREAM variable=x_streams depth=2 +#pragma HLS STREAM variable=u_streams depth=2 +#pragma HLS STREAM variable=xu_streams depth=2 +#pragma HLS ARRAY_PARTITION variable=x_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=u_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=xu_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=1 +#pragma HLS ARRAY_PARTITION variable=xu complete dim=0 + + Store_X_Buffer: + for (int i = 0; i < testu::params::N; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 +#pragma HLS LOOP_FLATTEN + x_buffer[i][j] = x_port.read(); // [i * kNumTilesU + j]; + } + } + Stream_X_Tiles: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 + for (int k = 0; k < testu::params::N; ++k) { + x_streams[k] << x_buffer[k][j]; + } + } + } + U_DMA: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < testu::params::G; ++k) { +#pragma HLS PIPELINE II=1 + int u_idx = i * kNumTilesU * testu::params::G + j * testu::params::G + k; + u_streams[k] << u_port.read(); // [u_idx]; + } + } + } + U_Kernel: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 + testu::params::VectTuType x[testu::params::N]; +#pragma HLS ARRAY_PARTITION variable=x complete dim=0 + for (int ii = 0; ii < testu::params::N; ++ii) { + x[ii] = x_streams[ii].read(); + } + for (int k = 0; k < testu::params::G; ++k) { + testu::params::VectTuType u = u_streams[k].read(); + for (int ii = 0; ii < testu::params::N; ++ii) { + if (j == 0) { + xu[ii][k] = testu::params::VectTuType(0); + } + xu[ii][k] += u * x[ii]; + if (j == kNumTilesU - 1) { + xu_streams[ii][k] << xu[ii][k]; + } + } + } + } + } + XU_DMA: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R +#pragma HLS PIPELINE II=1 + for (int j = 0; j < testu::params::G; ++j) { + VectN_Type xu_out; + for (int k = 0; k < testu::params::N; ++k) { + xu_out[k] = xu_streams[k][j].read().reduce_add(); + } + // xu_port[i * testu::params::G + j] = xu_out; + xu_port << xu_out; + } + } +} + +void HlsAxisKernelU(const int num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port) { + const int R_test = num_refinements; + const int kNumTilesU = testu::params::I / testu::params::Tu; + const int kStreamDepth_X = 2 + kNumTilesU * testu::params::N; + const int kStreamDepth_U = 8 + kNumTilesU * testu::params::N; + const int kStreamDepth_XU = 2 + testu::params::G; +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_port +#pragma HLS INTERFACE axis port=xu_port +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_refinements +#pragma HLS DATAFLOW + typedef typename testu::params::ActivationD ActivationType; + + auto x_axis = svd::AxiStreamPort(x_port); + auto u_axis = svd::AxiStreamPort(u_port); + auto xu_axis = svd::AxiStreamPort(xu_port); + + hls::stream x_streams[testu::params::N]; + hls::stream u_streams[testu::params::G]; + hls::stream xu_streams[testu::params::N][testu::params::G]; + testu::params::VectTuType x_buffer[testu::params::N][kNumTilesU]; +#pragma HLS STREAM variable=x_streams depth=kStreamDepth_X +#pragma HLS STREAM variable=u_streams depth=kStreamDepth_U +#pragma HLS STREAM variable=xu_streams depth=kStreamDepth_XU +#pragma HLS ARRAY_PARTITION variable=x_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=u_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=xu_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=xu_streams complete dim=2 +#pragma HLS ARRAY_PARTITION variable=x_buffer complete dim=1 + + Store_X_Buffer: + for (int i = 0; i < testu::params::N; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 +#pragma HLS LOOP_FLATTEN + x_buffer[i][j] = x_axis.PopVector(); + } + } + Stream_X_Tiles: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 + for (int k = 0; k < testu::params::N; ++k) { + x_streams[k] << x_buffer[k][j]; + } + } + } + + U_DMA: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < testu::params::G; ++k) { +#pragma HLS PIPELINE II=1 + u_streams[k] << u_axis.PopVector(); + } + } + } + + U_Kernel: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R + for (int j = 0; j < kNumTilesU; ++j) { +#pragma HLS PIPELINE II=1 + testu::params::VectTuType x[testu::params::N]; + testu::params::VectTuType xu[testu::params::N][testu::params::G]; +#pragma HLS ARRAY_PARTITION variable=x complete dim=0 +#pragma HLS ARRAY_PARTITION variable=xu complete dim=0 + for (int ii = 0; ii < testu::params::N; ++ii) { + x[ii] = x_streams[ii].read(); + } + for (int k = 0; k < testu::params::G; ++k) { + testu::params::VectTuType u = u_streams[k].read(); + for (int ii = 0; ii < testu::params::N; ++ii) { + if (j == 0) { + xu[ii][k] = testu::params::VectTuType(0); + } + xu[ii][k] += u * x[ii]; + if (j == kNumTilesU - 1) { + xu_streams[ii][k] << xu[ii][k]; + } + } + } + } + } + XU_DMA: + for (int i = 0; i < R_test; ++i) { +#pragma HLS LOOP_TRIPCOUNT min=testu::params::R max=testu::params::R +#pragma HLS PIPELINE II=1 + testu::params::VectGN_Type xu_out; + for (int j = 0; j < testu::params::G; ++j) { + for (int k = 0; k < testu::params::N; ++k) { + xu_out[j * testu::params::N + k] = xu_streams[k][j].read().reduce_add(); + } + } + const bool kIsLast = (i == R_test - 1) ? true : false; + xu_axis.PushVector(xu_out, kIsLast); + } +} + + +void HlsKernelU(const int num_active_inputs, + const int input_size, + const int num_refinements[testu::params::N], + // const hls::vector num_refinements, + const bool pad_output, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& xu_port) { +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_active_inputs +#pragma HLS INTERFACE s_axilite port=input_size +#pragma HLS INTERFACE s_axilite port=num_refinements +#pragma HLS INTERFACE s_axilite port=pad_output +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_port +#pragma HLS INTERFACE axis port=xu_port + svd::KernelU(num_active_inputs, input_size, num_refinements, + pad_output, x_port, u_port, xu_port); +} + +#endif + +namespace svd { + +} // svd \ No newline at end of file diff --git a/src/kernel/v_kernel.cpp b/src/kernel/v_kernel.cpp index e69de29..8d92f5c 100644 --- a/src/kernel/v_kernel.cpp +++ b/src/kernel/v_kernel.cpp @@ -0,0 +1,37 @@ +#include "kernel/v_kernel.h" + +#include "hls_stream.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +#include "assert.h" + +#ifndef __VITIS_HLS__ +#else +void HlsKernelV(const int num_active_inputs, + const int output_size, + const int num_refinements[testv::params::N], + // hls::vector& num_refinements, + hls::stream& xus_port, + hls::stream& v_port, + hls::stream& y_port) { +#pragma HLS INTERFACE axis port=xus_port +#pragma HLS INTERFACE axis port=v_port +#pragma HLS INTERFACE axis port=y_port +#pragma HLS INTERFACE s_axilite port=return +#pragma HLS INTERFACE s_axilite port=num_active_inputs +#pragma HLS INTERFACE s_axilite port=output_size +#pragma HLS INTERFACE s_axilite port=num_refinements +#pragma HLS DATAFLOW +#pragma HLS ARRAY_PARTITION variable=num_refinements complete dim=1 + + + svd::KernelV(num_active_inputs, output_size, + num_refinements, xus_port, v_port, y_port); + + + // svd::KernelV(num_active_inputs, output_size, + // num_refinements, xus_port, v_port, y_port); +} +#endif // end __VITIS_HLS__ diff --git a/src/layers/CMakeLists.txt b/src/layers/CMakeLists.txt new file mode 100644 index 0000000..58f13b7 --- /dev/null +++ b/src/layers/CMakeLists.txt @@ -0,0 +1,4 @@ +cmake_minimum_required(VERSION 3.10) + +add_subdirectory(dense) +add_subdirectory(lstm) \ No newline at end of file diff --git a/src/layers/dense/CMakeLists.txt b/src/layers/dense/CMakeLists.txt new file mode 100644 index 0000000..9e7059b --- /dev/null +++ b/src/layers/dense/CMakeLists.txt @@ -0,0 +1,9 @@ +cmake_minimum_required(VERSION 3.10) +add_subdirectory(hls) +add_subdirectory(sw) + +# add_library(LSTM_DATA_HANDLER STATIC ${CMAKE_SOURCE_DIR}/src/lstm/lstm_data_handler.cpp) +# target_include_directories(LSTM_DATA_HANDLER PUBLIC ${CMAKE_SOURCE_DIR}/include) +# target_include_directories(LSTM_DATA_HANDLER PUBLIC ${HLS_INCLUDE_DIRS}) +# target_include_directories(LSTM_DATA_HANDLER PUBLIC ${OpenCv_INCLUDE_DIRS}) +# target_link_libraries(LSTM_DATA_HANDLER ${OpenCv_LIBS}) \ No newline at end of file diff --git a/src/layers/dense/hls/CMakeLists.txt b/src/layers/dense/hls/CMakeLists.txt new file mode 100644 index 0000000..4e919f3 --- /dev/null +++ b/src/layers/dense/hls/CMakeLists.txt @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 3.10) + +add_library(DENSE_SVD STATIC ${CMAKE_SOURCE_DIR}/src/layers/dense/hls/dense_svd.cpp) +target_include_directories(DENSE_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(DENSE_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(DENSE_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(DENSE_SVD ${OpenCv_LIBS}) + +# add_library(SOFT_LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/lstm/sw/soft_lstm_svd.cpp) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +# target_link_libraries(SOFT_LSTM_SVD ${OpenCv_LIBS}) +# target_link_libraries(SOFT_LSTM_SVD BLAS_UTILS) +# target_link_libraries(SOFT_LSTM_SVD ACTIVATION_FUNCTIONS) diff --git a/src/layers/dense/hls/dense_svd.cpp b/src/layers/dense/hls/dense_svd.cpp new file mode 100644 index 0000000..6ce1ef4 --- /dev/null +++ b/src/layers/dense/hls/dense_svd.cpp @@ -0,0 +1,75 @@ +#include "layers/dense/hls/dense_svd.h" + +#ifndef __VITIS_HLS__ +#else +void HlsDenseSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::dense_params::N], + // const hls::vector num_refinements, + hls::stream& x_port, + hls::stream& u_port, + hls::stream& s_port, + hls::stream& v_port, + hls::stream& bias_port, + hls::stream& y_port) { +#pragma HLS INTERFACE s_axilite port=return bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_active_inputs bundle=ctrl +#pragma HLS INTERFACE s_axilite port=input_size bundle=ctrl +#pragma HLS INTERFACE s_axilite port=output_size bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_refinements bundle=ctrl +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_port +#pragma HLS INTERFACE axis port=s_port +#pragma HLS INTERFACE axis port=v_port +#pragma HLS INTERFACE axis port=bias_port +#pragma HLS INTERFACE axis port=y_port + svd::DenseSvdKernel(num_active_inputs, input_size, + output_size, num_refinements, x_port, u_port, s_port, v_port, bias_port, + y_port); +} + +/** + * @brief HLS Wrapper that calls a DenseSvd accelerator. + * + * Useful in Cosimulation. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param[in] bias The bias array. Shape: (N, G, H) + * @param y The y array. Shape: (N, G, H) + */ +void HlsWrapperDenseSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::dense_params::N], + const typename svd::dense_params::ActivationD* x, + const typename svd::dense_params::ActivationD* u, + const typename svd::dense_params::ActivationD* s, + const typename svd::dense_params::ActivationD* v, + const typename svd::dense_params::ActivationD* bias, + typename svd::dense_params::ActivationD* y) { +#ifdef __VITIS_HLS__ + hls::stream x_port("x_port"); + hls::stream u_port("u_port"); + hls::stream s_port("s_port"); + hls::stream v_port("v_port"); + hls::stream bias_port("bias_port"); + hls::stream y_port("y_port"); + svd::SetDenseSvdInputs(num_active_inputs, input_size, + output_size, num_refinements, x, u, s, v, bias, x_port, u_port, s_port, + v_port, bias_port); + HlsDenseSvd(num_active_inputs, input_size, output_size, num_refinements, + x_port, u_port, s_port, v_port, bias_port, y_port); + svd::GetSvdKernelOutputs(num_active_inputs, output_size, + y_port, y); +#endif // __VITIS_HLS__ +} + +#endif \ No newline at end of file diff --git a/src/layers/dense/sw/CMakeLists.txt b/src/layers/dense/sw/CMakeLists.txt new file mode 100644 index 0000000..0bb5b26 --- /dev/null +++ b/src/layers/dense/sw/CMakeLists.txt @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 3.10) + +# add_library(SOFT_LSTM STATIC ${CMAKE_SOURCE_DIR}/src/lstm/sw/soft_lstm.cpp) +# target_include_directories(SOFT_LSTM PUBLIC ${CMAKE_SOURCE_DIR}/include) +# target_include_directories(SOFT_LSTM PUBLIC ${HLS_INCLUDE_DIRS}) +# target_include_directories(SOFT_LSTM PUBLIC ${OpenCv_INCLUDE_DIRS}) +# target_link_libraries(SOFT_LSTM ${OpenCv_LIBS}) + +# add_library(SOFT_LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/lstm/sw/soft_lstm_svd.cpp) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +# target_include_directories(SOFT_LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +# target_link_libraries(SOFT_LSTM_SVD ${OpenCv_LIBS}) +# target_link_libraries(SOFT_LSTM_SVD BLAS_UTILS) +# target_link_libraries(SOFT_LSTM_SVD ACTIVATION_FUNCTIONS) diff --git a/src/lstm/CMakeLists.txt b/src/layers/lstm/CMakeLists.txt similarity index 63% rename from src/lstm/CMakeLists.txt rename to src/layers/lstm/CMakeLists.txt index 63b7cc5..eea7dd9 100644 --- a/src/lstm/CMakeLists.txt +++ b/src/layers/lstm/CMakeLists.txt @@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.10) add_subdirectory(hls) add_subdirectory(sw) -add_library(LSTM_DATA_HANDLER STATIC ${CMAKE_SOURCE_DIR}/src/lstm/lstm_data_handler.cpp) +add_library(LSTM_DATA_HANDLER STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/lstm_data_handler.cpp) target_include_directories(LSTM_DATA_HANDLER PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(LSTM_DATA_HANDLER PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(LSTM_DATA_HANDLER PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(LSTM_DATA_HANDLER PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(LSTM_DATA_HANDLER ${OpenCv_LIBS}) \ No newline at end of file diff --git a/src/lstm/README.md b/src/layers/lstm/README.md similarity index 100% rename from src/lstm/README.md rename to src/layers/lstm/README.md diff --git a/src/layers/lstm/hls/CMakeLists.txt b/src/layers/lstm/hls/CMakeLists.txt new file mode 100644 index 0000000..fcaa0ca --- /dev/null +++ b/src/layers/lstm/hls/CMakeLists.txt @@ -0,0 +1,30 @@ +cmake_minimum_required(VERSION 3.10) + +add_library(LSTM_HARDWARE STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/hls/lstm_hardware.cpp) +target_include_directories(LSTM_HARDWARE PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(LSTM_HARDWARE PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(LSTM_HARDWARE PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(LSTM_HARDWARE ${OpenCv_LIBS}) + +add_library(LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/hls/lstm_svd.cpp) +target_include_directories(LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(LSTM_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(LSTM_SVD ${OpenCv_LIBS}) +target_link_libraries(LSTM_SVD ${OpenCv_LIBS}) +# target_link_libraries(LSTM_SVD SVD_PARAMS) +# target_link_libraries(LSTM_SVD SVD_DMA) +# target_link_libraries(LSTM_SVD U_KERNEL) +# target_link_libraries(LSTM_SVD S_KERNEL) +# target_link_libraries(LSTM_SVD V_KERNEL) +# target_link_libraries(LSTM_SVD ACTIVATION_FUNCTIONS) +# target_link_libraries(LSTM_SVD HLS_DEBUGGING) + + +set(LSTM_SVD_EMULATOR_H ${CMAKE_SOURCE_DIR}/include/math_utils/activation_functions.h) +add_library(LSTM_SVD_EMULATOR STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/hls/lstm_svd_emulator.cpp ${LSTM_SVD_EMULATOR_H}) +target_include_directories(LSTM_SVD_EMULATOR PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(LSTM_SVD_EMULATOR PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(LSTM_SVD_EMULATOR PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(LSTM_SVD_EMULATOR ${OpenCv_LIBS}) +# target_link_libraries(LSTM_SVD_EMULATOR ACTIVATION_FUNCTIONS) \ No newline at end of file diff --git a/src/lstm/hls/lstm_hardware.cpp b/src/layers/lstm/hls/lstm_hardware.cpp similarity index 99% rename from src/lstm/hls/lstm_hardware.cpp rename to src/layers/lstm/hls/lstm_hardware.cpp index 33939fd..8693aa1 100644 --- a/src/lstm/hls/lstm_hardware.cpp +++ b/src/layers/lstm/hls/lstm_hardware.cpp @@ -36,12 +36,15 @@ * streams * *****************************************************************************/ -#include "lstm/hls/lstm_hardware.h" -#include "dma/svd_dma.h" #include "svd_params.h" +#include "layers/lstm/hls/lstm_hardware.h" +#include "dma/svd_dma.h" #include "hls_math.h" #include "hls_half.h" +#include "assert.h" + +#include template void print_matrix(const svd::ActivationD matrix[BramRows][BramCols]) { @@ -287,11 +290,10 @@ void gemm_kernel(const bool execute, } break; case 1: { +#ifndef __VITIS_HLS__ if (accumulate) { #pragma HLS DATAFLOW ActivationD c_tmp[M][N]; -// #pragma HLS RESOURCE variable=c_tmp core=RAM_2P - hls::matrix_multiply_top(a, b, c); } +#endif } break; case 2: { @@ -1844,11 +1847,11 @@ void svd_fpga_lstm(const svd::ActivationD *x, const svd::ActivationD *c_rec, svd::ActivationD *c_cur, svd::ActivationD *out) { -#ifndef SDS_DESIGN const int kInputDepth = INPUT_SIZE; const int kHiddenDepth = HIDDEN_SIZE; const int kCurGateDepth = 4 * INPUT_SIZE * HIDDEN_SIZE; const int kRecGateDepth = 4 * HIDDEN_SIZE * HIDDEN_SIZE; +#ifndef SDS_DESIGN #pragma HLS INTERFACE s_axilite port=return bundle=ctrl #pragma HLS INTERFACE m_axi port=x depth=kInputDepth #pragma HLS INTERFACE m_axi port=h depth=kHiddenDepth @@ -1869,8 +1872,8 @@ void svd_fpga_lstm(const svd::ActivationD *x, svd::ActivationD rec_y[HIDDEN_SIZE * kNumGates]; #pragma HLS ARRAY_PARTITION variable=cur_y block factor=kNumGates #pragma HLS ARRAY_PARTITION variable=rec_y block factor=kNumGates -#pragma HLS STREAM variable=cur_y depth=HIDDEN_SIZE -#pragma HLS STREAM variable=rec_y depth=HIDDEN_SIZE +#pragma HLS STREAM variable=cur_y depth=kHiddenDepth +#pragma HLS STREAM variable=rec_y depth=kHiddenDepth const bool kWritebackOnce = true; const int kCurM = HIDDEN_SIZE * kNumGates; @@ -2287,7 +2290,7 @@ void dummy_gemm(svd::DmaInterfaceD a[2], svd::DmaInterfaceD b[2], svd::DmaInterf } } -#if 1 +#if 0 void dummy_dispatcher(hls::stream > &x, hls::stream > y[4]) { const int kNumInputElem = 32; const int kNumPE = 4; @@ -2315,7 +2318,9 @@ void test_dispatcher() { x_stream.write(x[i]); } +#ifndef __VITIS_HLS__ std::cout << "[Dispatcher] Running IP. x_stream.size() = " << x_stream.size() << "\n"; +#endif hls::stream > y_stream[kNumPE]; dummy_dispatcher(x_stream, y_stream); diff --git a/src/layers/lstm/hls/lstm_svd.cpp b/src/layers/lstm/hls/lstm_svd.cpp new file mode 100644 index 0000000..8e5d65a --- /dev/null +++ b/src/layers/lstm/hls/lstm_svd.cpp @@ -0,0 +1,511 @@ +#include "layers/lstm/hls/lstm_svd.h" +#include "layers/dense/hls/dense_svd.h" +#include "svd_params.h" +#include "dma/svd_dma.h" +#include "kernel/u_kernel.h" +#include "kernel/s_kernel.h" +#include "kernel/v_kernel.h" +#include "math_utils/activation_functions.h" +#include "hls_utils/hls_debugging.h" + +#include "hls_stream.h" +#include "ap_int.h" +#include "assert.h" + +#include + +namespace svd { + +void SvdModel2LstmSDSoCV2( + const svd::ActivationD x1_port[INPUT_SIZE], + const svd::ActivationD x2_port[INPUT_SIZE], + const svd::ActivationD h_t1_prev_port[HIDDEN_SIZE], + const svd::ActivationD h_t2_prev_port[HIDDEN_SIZE], + const svd::ActivationD c_t1_prev_port[HIDDEN_SIZE], + const svd::ActivationD c_t2_prev_port[HIDDEN_SIZE], + const ap_uint *u_cur_port, // [NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], + const ap_uint *u_rec_port, // [NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], + const ap_uint *v_port, // [NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)], + const ap_uint *s1_port, // [NUM_ITERATIONS*8], + const ap_uint *s2_port, // [NUM_ITERATIONS*8], + const svd::WeightD bias1_port[4 * HIDDEN_SIZE], + const svd::WeightD bias2_port[4 * HIDDEN_SIZE], + const ap_uint nz_v_port[NUM_ITERATIONS * 8], + const ap_uint nz_u_port[NUM_ITERATIONS * 8], + svd::ActivationD h_t1_curr_port[HIDDEN_SIZE], + svd::ActivationD h_t2_curr_port[HIDDEN_SIZE], + svd::ActivationD c_t1_curr_port[HIDDEN_SIZE], + svd::ActivationD c_t2_curr_port[HIDDEN_SIZE] +#ifdef DEBUG_FIFOS + , + svd::CounterD *counters_port, + svd::CounterD *clk_count_port +#endif + ) { + hlsutils::Log(0, "[INFO] Running SvdModel2LstmSDSoCV2."); + const int kNumGates = 8; + const int kNumCurGates = 4; + const int kNumRecGates = 4; + const int kInputLength = INPUT_SIZE; + const int kOutputLength = HIDDEN_SIZE; + const int kNumTilesU = NUM_TILES_U; + const int kNumTilesV = NUM_TILES_V; + const int kNumZeroTilesU = NUM_ZERO_TILES_U; + const int kNumZeroTilesV = NUM_ZERO_TILES_V; + const int kNumIter = NUM_ITERATIONS; + const int kNumTimesteps = NUM_TIMESTEPS; + const int kNumNonZeroTilesU = kNumTilesU - kNumZeroTilesU; + const int kNumNonZeroTilesV = kNumTilesV - kNumZeroTilesV; + const int kTileSizeUCurrent = kInputLength / kNumTilesU; + const int kTileSizeURecur = kOutputLength / kNumTilesU; + const int kTileSizeV = kOutputLength / kNumTilesV; + assert(kNumTilesU % 2 == 0); + assert(kNumTilesV % 2 == 0); + // assert(kNumZeroTilesU % 2 == 0); + // assert(kNumZeroTilesV % 2 == 0); + // assert(kNumIter % 2 == 0); + hlsutils::Log(0, "[INFO] asserts passed."); + + const int kTileSizeU = kInputLength / kNumTilesU; + const int kPrunedLengthU = kInputLength - kNumZeroTilesU * kTileSizeU; + const int kPrunedLengthV = kOutputLength - kNumZeroTilesV * kTileSizeV; + const int kInputLengthPruned = kInputLength - kTileSizeU * kNumZeroTilesU; + const int kOutputLengthPrunedU = kOutputLength - kOutputLength / kNumTilesU * kNumZeroTilesU; + const int kOutputLengthPrunedV = kOutputLength - kOutputLength / kNumTilesV * kNumZeroTilesV; + const int kNumSamples = NUM_SAMPLES; // Used for cosimulation only + const int kNumReadsR = 8 * kNumIter; + const int kNumReadsC = 8 * kNumIter; + const int kAxiDepthR = kInputLength; + const int kAxiPortDepthX = (kInputLength * kNumTimesteps) * kNumSamples; + const int kAxiDepthU = (kNumIter * 8 * kPrunedLengthU) * kNumSamples; + const int kAxiDepthV = (kNumIter * 8 * kPrunedLengthV) * kNumSamples; + const int kAxiDepthS = (kNumIter * 8 * 2) * kNumSamples; + const int kAxiDepthCombinationsR = kNumReadsR * kNumSamples; + const int kAxiDepthCombinationsC = kNumReadsC * kNumSamples; +#ifndef SDS_DESIGN +#pragma HLS INTERFACE s_axilite port=return bundle=ctrl + + const int kUSize = kNumIter*(kNumCurGates * kInputLengthPruned + kNumRecGates * kOutputLengthPrunedU); + const int kVSize = kNumIter*(kNumCurGates * kOutputLengthPrunedV + kNumRecGates * kOutputLengthPrunedV); + const int kSSize = kNumIter * 2 * (kNumCurGates + kNumRecGates); + + const int kUCurSize = kNumIter * kNumCurGates * kInputLengthPruned; + const int kURecSize = kNumIter * kNumRecGates * kOutputLengthPrunedU; + + const int kUcurPortDepth = kUCurSize; + const int kUrecPortDepth = kURecSize; + const int kVportDepth = kVSize; + const int kS1portDepth = kSSize / 2; + const int kS2portDepth = kSSize / 2; +// #pragma HLS INTERFACE m_axi port=u_cur_port offset=slave depth=kUcurPortDepth bundle=u_cur_dmem +// #pragma HLS INTERFACE m_axi port=u_rec_port offset=slave depth=kUrecPortDepth bundle=u_rec_dmem +// #pragma HLS INTERFACE m_axi port=v_port offset=slave depth=kVportDepth bundle=v_dmem +// #pragma HLS INTERFACE m_axi port=s1_port offset=slave depth=kS1portDepth bundle=s1_dmem +// #pragma HLS INTERFACE m_axi port=s2_port offset=slave depth=kS2portDepth bundle=s2_dmem +#pragma HLS INTERFACE axis port=u_cur_port +#pragma HLS INTERFACE axis port=u_rec_port +#pragma HLS INTERFACE axis port=v_port +#pragma HLS INTERFACE axis port=s1_port +#pragma HLS INTERFACE axis port=s2_port + +#pragma HLS INTERFACE axis port=x1_port +#pragma HLS INTERFACE axis port=x2_port +#pragma HLS INTERFACE axis port=bias1_port +#pragma HLS INTERFACE axis port=bias2_port +#pragma HLS INTERFACE axis port=nz_v_port +#pragma HLS INTERFACE axis port=nz_u_port +#pragma HLS INTERFACE axis port=h_t1_prev_port +#pragma HLS INTERFACE axis port=h_t2_prev_port +#pragma HLS INTERFACE axis port=h_t1_curr_port +#pragma HLS INTERFACE axis port=h_t2_curr_port +#pragma HLS INTERFACE axis port=c_t1_prev_port +#pragma HLS INTERFACE axis port=c_t2_prev_port +#pragma HLS INTERFACE axis port=c_t1_curr_port +#pragma HLS INTERFACE axis port=c_t2_curr_port +#endif // SDS_DESIGN + +#pragma HLS DATAFLOW + // =========================================================================== + // Streams Depth Sizing + // =========================================================================== + // NOTE: We divide the FIFO depths by a certain factor to save BRAMs. Be aware + // that a wrong factor could lead to deadlocks! + const int kFIFOdepthDivider = 8; + const int kStreamDepthIter = kNumIter / kFIFOdepthDivider; + const int kFIFOdepthFactor = kNumIter * 2; + const int kStreamDepthUCurrent = kNumIter * kTileSizeUCurrent / kFIFOdepthFactor == 0 ? 2 : kNumIter * kTileSizeUCurrent / kFIFOdepthFactor; + const int kStreamDepthURecurrent = kNumIter * kTileSizeURecur / kFIFOdepthFactor == 0 ? 2 : kNumIter * kTileSizeURecur / kFIFOdepthFactor; + const int kStreamDepthV = kNumIter * kNumTilesV / kFIFOdepthFactor == 0 ? 2 : kNumIter * kNumTilesV / kFIFOdepthFactor; + const int kTileAccStreamDepth = 2; + const int kOutStreamDepth = 2; // kNumIter * kTileSizeV; + // =========================================================================== + // Current streams + // =========================================================================== + svd::WeightStream cur_u_streams[kNumCurGates][kNumNonZeroTilesU]; + svd::WeightStream cur_v_streams[kNumCurGates][kTileSizeV]; // [kNumNonZeroTilesV]; + svd::ActivationStream cur_dot1_streams[kNumCurGates]; + svd::ActivationStream cur_dot2_streams[kNumCurGates]; + svd::ActivationStream cur_out1_streams[kNumCurGates][kNumNonZeroTilesV]; + svd::ActivationStream cur_out2_streams[kNumCurGates][kNumNonZeroTilesV]; + svd::ActivationStream cur_acc1_streams[kNumCurGates][kTileSizeV]; // [kNumTilesV]; + svd::ActivationStream cur_acc2_streams[kNumCurGates][kTileSizeV]; // [kNumTilesV]; + // =========================================================================== + // Recur streams + // =========================================================================== + svd::WeightStream rec_u_streams[kNumRecGates][kNumNonZeroTilesU]; + svd::WeightStream rec_v_streams[kNumRecGates][kTileSizeV]; // [kNumNonZeroTilesV]; + svd::ActivationStream rec_dot1_streams[kNumRecGates]; + svd::ActivationStream rec_dot2_streams[kNumRecGates]; + svd::ActivationStream rec_out1_streams[kNumRecGates][kNumNonZeroTilesV]; + svd::ActivationStream rec_out2_streams[kNumRecGates][kNumNonZeroTilesV]; + svd::ActivationStream rec_acc1_streams[kNumRecGates][kTileSizeV]; // [kNumTilesV]; + svd::ActivationStream rec_acc2_streams[kNumRecGates][kTileSizeV]; // [kNumTilesV]; + // =========================================================================== + // Scalar streams + // =========================================================================== + svd::WeightStream gates_s1_streams[kNumGates]; // used for both curr and recur + svd::WeightStream gates_s2_streams[kNumGates]; // used for both curr and recur + // =========================================================================== + // Current input streams + // =========================================================================== + svd::ActivationStream x1_streams[kNumCurGates][kNumNonZeroTilesU]; + svd::ActivationStream x2_streams[kNumCurGates][kNumNonZeroTilesU]; + // =========================================================================== + // Recurrent input streams + // =========================================================================== + svd::ActivationStream h1_streams[kNumRecGates][kNumNonZeroTilesU]; + svd::ActivationStream h2_streams[kNumRecGates][kNumNonZeroTilesU]; + // =========================================================================== + // Zero Combinations DMA + // =========================================================================== + // NOTE: We divide the FIFO depths by a certain factor to save BRAMs. Be aware + // that a wrong factor could lead to deadlocks! + hls::stream > nz_v_stream1_cur[kNumCurGates]; + hls::stream > nz_v_stream1_rec[kNumRecGates]; + hls::stream > nz_v_stream2_cur[kNumCurGates]; + hls::stream > nz_v_stream2_rec[kNumRecGates]; + hls::stream > nz_u_stream1_cur[kNumCurGates]; + hls::stream > nz_u_stream1_rec[kNumRecGates]; + hls::stream > nz_u_stream2_cur[kNumCurGates]; + hls::stream > nz_u_stream2_rec[kNumRecGates]; +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_v_stream1_cur +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_v_stream1_rec +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_v_stream2_cur +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_v_stream2_rec +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_u_stream1_cur +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_u_stream1_rec +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_u_stream2_cur +#pragma HLS STREAM depth=kStreamDepthIter variable=nz_u_stream2_rec + +#pragma HLS STREAM variable=x1_streams depth=kStreamDepthUCurrent // dim=2 +#pragma HLS STREAM variable=x2_streams depth=kStreamDepthUCurrent // dim=2 +#pragma HLS STREAM variable=h1_streams depth=kStreamDepthURecurrent // dim=2 +#pragma HLS STREAM variable=h2_streams depth=kStreamDepthURecurrent // dim=2 + +#pragma HLS STREAM variable=cur_u_streams depth=kStreamDepthUCurrent // dim=2 +#pragma HLS STREAM variable=rec_u_streams depth=kStreamDepthURecurrent // dim=2 +#pragma HLS STREAM variable=cur_v_streams depth=kStreamDepthV // dim=2 +#pragma HLS STREAM variable=rec_v_streams depth=kStreamDepthV // dim=2 + +#pragma HLS STREAM variable=gates_s1_streams depth=kStreamDepthIter +#pragma HLS STREAM variable=gates_s2_streams depth=kStreamDepthIter + +#pragma HLS STREAM variable=cur_dot1_streams depth=kStreamDepthIter +#pragma HLS STREAM variable=cur_dot2_streams depth=kStreamDepthIter +#pragma HLS STREAM variable=rec_dot1_streams depth=kStreamDepthIter +#pragma HLS STREAM variable=rec_dot2_streams depth=kStreamDepthIter +#pragma HLS STREAM variable=cur_acc1_streams depth=kTileAccStreamDepth // dim=2 +#pragma HLS STREAM variable=cur_acc2_streams depth=kTileAccStreamDepth // dim=2 +#pragma HLS STREAM variable=rec_acc1_streams depth=kTileAccStreamDepth // dim=2 +#pragma HLS STREAM variable=rec_acc2_streams depth=kTileAccStreamDepth // dim=2 + +#pragma HLS STREAM variable=cur_out1_streams depth=kOutStreamDepth // dim=2 +#pragma HLS STREAM variable=cur_out2_streams depth=kOutStreamDepth // dim=2 +#pragma HLS STREAM variable=rec_out1_streams depth=kOutStreamDepth // dim=2 +#pragma HLS STREAM variable=rec_out2_streams depth=kOutStreamDepth // dim=2 + // =========================================================================== + // Partitioning + // =========================================================================== +#ifndef __VITIS_HLS__ +#pragma HLS ARRAY_PARTITION variable=cur_u_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_v_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_dot1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_dot2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_out1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_out2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_acc1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=cur_acc2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_u_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_v_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_dot1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_dot2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_out1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_out2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_acc1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=rec_acc2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=gates_s1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=gates_s2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=x1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=x2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=h1_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=h2_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_v_stream1_cur complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_v_stream1_rec complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_v_stream2_cur complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_v_stream2_rec complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_u_stream1_cur complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_u_stream1_rec complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_u_stream2_cur complete dim=0 +#pragma HLS ARRAY_PARTITION variable=nz_u_stream2_rec complete dim=0 +#endif + hlsutils::Log(0, "Starting ZeroTileCombinationDMA"); + svd::NZIndex2LstmDMA(nz_u_port, + nz_u_stream1_cur, nz_u_stream1_rec, nz_u_stream2_cur, + nz_u_stream2_rec); + svd::NZIndexDMA(nz_v_port, + nz_v_stream1_cur, nz_v_stream1_rec); + // =========================================================================== + // Current Input DMA + // =========================================================================== + hlsutils::Log(0, "Starting InputDMA"); + svd::InputDMA( + x1_port, nz_u_stream1_cur, x1_streams); + svd::InputDMA( + x2_port, nz_u_stream2_cur, x2_streams); + // =========================================================================== + // Recurrent Input DMA + // =========================================================================== + svd::InputDMA( + h_t1_prev_port, nz_u_stream1_rec, h1_streams); + svd::InputDMA( + h_t2_prev_port, nz_u_stream2_rec, h2_streams); + // =========================================================================== + // Gates DMA + // =========================================================================== + const int kUcurSize = kNumGates / 2 * kNumIter * kPrunedLengthU; + const int kUrecSize = kNumGates / 2 * kNumIter * kOutputLengthPrunedU; + const int kSsize = kNumGates * kNumIter; + const int kVsize = kNumGates * kNumIter * kPrunedLengthV; + const int kBitWidthU = FIX_WIDTH * 4; + const int kBitWidthV = FIX_WIDTH * 8; + const int kBitWidthS = FIX_WIDTH * 8; +#ifndef __VITIS_HLS__ + svd::WeightD u_cur_gate_streams[kNumGates / 2][kNumIter * kPrunedLengthU]; + svd::WeightD u_rec_gate_streams[kNumGates / 2][kNumIter * kOutputLengthPrunedU]; + svd::WeightD v_gate_streams[kNumGates][kNumIter * kPrunedLengthV]; +#pragma HLS ARRAY_PARTITION variable=u_cur_gate_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=u_rec_gate_streams complete dim=1 +#pragma HLS ARRAY_PARTITION variable=v_gate_streams complete dim=1 +#pragma HLS STREAM variable=u_cur_gate_streams depth=1 dim=1 +#pragma HLS STREAM variable=u_rec_gate_streams depth=1 dim=1 +#pragma HLS STREAM variable=v_gate_streams depth=1 dim=1 + hlsutils::Log(0, "Starting ArraySplitter"); + svd::ArraySplitter, svd::WeightD, kBitWidthU, FIX_WIDTH, kUcurSize>( + u_cur_port, u_cur_gate_streams); + svd::ArraySplitter, svd::WeightD, kBitWidthU, FIX_WIDTH, kUrecSize>( + u_rec_port, u_rec_gate_streams); + svd::ArraySplitter, svd::WeightD, kBitWidthV, FIX_WIDTH, kVsize>( + v_port, v_gate_streams); +#else + hls::stream u_cur_gate_streams[kNumGates / 2]; + hls::stream u_rec_gate_streams[kNumGates / 2]; + hls::stream v_gate_streams[kNumGates]; +#pragma HLS ARRAY_PARTITION variable=u_cur_gate_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=u_rec_gate_streams complete dim=0 +#pragma HLS ARRAY_PARTITION variable=v_gate_streams complete dim=0 +#pragma HLS STREAM variable=u_cur_gate_streams depth=2 +#pragma HLS STREAM variable=u_rec_gate_streams depth=2 +#pragma HLS STREAM variable=v_gate_streams depth=2 + hlsutils::Log(0, "Starting ArraySplitter"); + svd::StreamSplitter, svd::WeightD, kBitWidthU, FIX_WIDTH>( + kUcurSize, u_cur_port, u_cur_gate_streams); + svd::StreamSplitter, svd::WeightD, kBitWidthU, FIX_WIDTH>( + kUrecSize, u_rec_port, u_rec_gate_streams); + svd::StreamSplitter, svd::WeightD, kBitWidthV, FIX_WIDTH>( + kVsize, v_port, v_gate_streams); +#endif + svd::StreamSplitter, svd::WeightD, kBitWidthS, FIX_WIDTH>( + kSsize, s1_port, gates_s1_streams); + svd::StreamSplitter, svd::WeightD, kBitWidthS, FIX_WIDTH>( + kSsize, s2_port, gates_s2_streams); + const bool kUweights = true; + // =========================================================================== + // Current Dot Product Unit + // =========================================================================== +#ifndef __VITIS_HLS__ + Current_SVD_Kernels: + for (int g = 0; g < kNumCurGates; ++g) { +#pragma HLS UNROLL + svd::DispatchGateFromArray(kUweights, kNumIter, kNumNonZeroTilesU, + kTileSizeUCurrent, u_cur_gate_streams[g], cur_u_streams[g]); + svd::DispatchGateFromArray(!kUweights, kNumIter, kNumNonZeroTilesV, kTileSizeV, + v_gate_streams[g], cur_v_streams[g]); + } +#else + svd::DispatchGateFromStream( + kUweights, kNumIter, kNumNonZeroTilesU, kTileSizeUCurrent, + u_cur_gate_streams, cur_u_streams); + svd::DispatchGateFromStream( + !kUweights, kNumIter, kNumNonZeroTilesV, kTileSizeV, + v_gate_streams, cur_v_streams); +#endif + svd::UDotUnit2Lstm( + x1_streams, x2_streams, cur_u_streams, cur_dot1_streams, + cur_dot2_streams); + svd::VDotUnit2LstmV2( + false, nullptr, nullptr, + cur_dot1_streams, cur_dot2_streams, + gates_s1_streams, gates_s2_streams, + cur_v_streams, nz_v_stream1_cur, + cur_acc1_streams, cur_acc2_streams); + // =========================================================================== + // Recur Dot Product Unit + // =========================================================================== +#ifndef __VITIS_HLS__ + Recurrent_SVD_Kernels: + for (int g = 0; g < kNumRecGates; ++g) { +#pragma HLS UNROLL + svd::DispatchGateFromArray(kUweights, kNumIter, kNumNonZeroTilesU, + kTileSizeURecur, u_rec_gate_streams[g], rec_u_streams[g]); + svd::DispatchGateFromArray(!kUweights, kNumIter, kNumNonZeroTilesV, kTileSizeV, + v_gate_streams[kNumCurGates + g], rec_v_streams[g]); + } +#else + svd::DispatchGateFromStream( + kUweights, kNumIter, kNumNonZeroTilesU, kTileSizeURecur, + u_rec_gate_streams, rec_u_streams); + svd::DispatchGateFromStream( + !kUweights, kNumIter, kNumNonZeroTilesV, kTileSizeV, + &v_gate_streams[kNumRecGates], rec_v_streams); +#endif + svd::UDotUnit2Lstm( + h1_streams, h2_streams, rec_u_streams, rec_dot1_streams, + rec_dot2_streams); + svd::VDotUnit2LstmV2( + false, nullptr, nullptr, rec_dot1_streams, rec_dot2_streams, + &gates_s1_streams[kNumRecGates], &gates_s2_streams[kNumRecGates], + rec_v_streams, nz_v_stream1_rec, rec_acc1_streams, rec_acc2_streams); + // =========================================================================== + // Output Non-Linearities + // =========================================================================== + svd::NonLinearityUnit(c_t1_prev_port, + cur_acc1_streams, rec_acc1_streams, h_t1_curr_port, c_t1_curr_port, true, + bias1_port); + svd::NonLinearityUnit(c_t2_prev_port, + cur_acc2_streams, rec_acc2_streams, h_t2_curr_port, c_t2_curr_port, true, + bias2_port); +} + +} // svd + +#ifndef __VITIS_HLS__ +#else +void HlsLstmSvd(const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::lstm_params::N], + // const hls::vector num_refinements, + // Current Gates + hls::stream& x_port, + hls::stream& u_cur_port, + hls::stream& s_cur_port, + hls::stream& v_cur_port, + // Recurrent Gates + hls::stream& h_prev_port, + hls::stream& u_rec_port, + hls::stream& s_rec_port, + hls::stream& v_rec_port, + // Non-Linearities + hls::stream& bias_port, + hls::stream& c_prev_port, + hls::stream& h_curr_port, + hls::stream& c_curr_port) { +#pragma HLS INTERFACE s_axilite port=return bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_active_inputs bundle=ctrl +#pragma HLS INTERFACE s_axilite port=input_size bundle=ctrl +#pragma HLS INTERFACE s_axilite port=num_refinements bundle=ctrl +#pragma HLS INTERFACE s_axilite port=output_size bundle=ctrl +#pragma HLS INTERFACE axis port=x_port +#pragma HLS INTERFACE axis port=u_cur_port +#pragma HLS INTERFACE axis port=s_cur_port +#pragma HLS INTERFACE axis port=v_cur_port +#pragma HLS INTERFACE axis port=h_prev_port +#pragma HLS INTERFACE axis port=u_rec_port +#pragma HLS INTERFACE axis port=s_rec_port +#pragma HLS INTERFACE axis port=v_rec_port +#pragma HLS INTERFACE axis port=bias_port +#pragma HLS INTERFACE axis port=c_prev_port +#pragma HLS INTERFACE axis port=h_curr_port +#pragma HLS INTERFACE axis port=c_curr_port + svd::LstmSvdKernel(num_active_inputs, input_size, + output_size, num_refinements, x_port, u_cur_port, s_cur_port, v_cur_port, + h_prev_port, u_rec_port, s_rec_port, v_rec_port, bias_port, c_prev_port, + h_curr_port, c_curr_port); +} +#endif // __VITIS_HLS__ + +/** + * @brief HLS Wrapper that calls a DenseSvd accelerator. + * + * Useful in Cosimulation. + * + * @param[in] num_active_inputs The number of active inputs + * @param[in] input_size The input size + * @param[in] output_size The output size + * @param[in] num_refinements The number of refinements + * @param[in] x The input array. Shape: (N, I) + * @param[in] u The u array. Shape: (R, I, G) + * @param[in] s The s array. Shape: (R, N, G) + * @param[in] v The v array. Shape: (R, H, G) + * @param[in] bias The bias array. Shape: (N, G, H) + * @param y The y array. Shape: (H / Tv, N, Tv) + */ +void HlsWrapperLstmSvd( + const int num_active_inputs, + const int input_size, + const int output_size, + const int num_refinements[svd::lstm_params::N], + // Current Gates + const typename svd::lstm_params::ActivationD* x, + const typename svd::lstm_params::ActivationD* u_cur, + const typename svd::lstm_params::ActivationD* s_cur, + const typename svd::lstm_params::ActivationD* v_cur, + // Recurrent Gates + const typename svd::lstm_params::ActivationD* h, + const typename svd::lstm_params::ActivationD* u_rec, + const typename svd::lstm_params::ActivationD* s_rec, + const typename svd::lstm_params::ActivationD* v_rec, + // Non-Linearities + const typename svd::lstm_params::ActivationD* bias, + const typename svd::lstm_params::ActivationD* c_prev, + typename svd::lstm_params::ActivationD* h_curr, + typename svd::lstm_params::ActivationD* c_curr) { +#ifdef __VITIS_HLS__ + // Current Gates + hls::stream x_port; + hls::stream u_cur_port; + hls::stream s_cur_port; + hls::stream v_cur_port; + // Recurrent Gates + hls::stream h_prev_port; + hls::stream u_rec_port; + hls::stream s_rec_port; + hls::stream v_rec_port; + // Non-Linearities + hls::stream bias_port; + hls::stream c_prev_port; + hls::stream h_curr_port; + hls::stream c_curr_port; + svd::SetLstmSvdInputs( + num_active_inputs, input_size, output_size, num_refinements, + x, u_cur, s_cur, v_cur, h, u_rec, s_rec, v_rec, bias, c_prev, + x_port, u_cur_port, s_cur_port, v_cur_port, + h_prev_port, u_rec_port, s_rec_port, v_rec_port, bias_port, c_prev_port); + HlsLstmSvd(num_active_inputs, input_size, output_size, num_refinements, + x_port, u_cur_port, s_cur_port, v_cur_port, + h_prev_port, u_rec_port, s_rec_port, v_rec_port, + bias_port, c_prev_port, h_curr_port, c_curr_port); + svd::GetLstmSvdOutputs(num_active_inputs, + output_size, h_curr, c_curr, h_curr_port, c_curr_port); +#endif // __VITIS_HLS__ +} \ No newline at end of file diff --git a/src/layers/lstm/hls/lstm_svd_emulator.cpp b/src/layers/lstm/hls/lstm_svd_emulator.cpp new file mode 100644 index 0000000..57ae4b4 --- /dev/null +++ b/src/layers/lstm/hls/lstm_svd_emulator.cpp @@ -0,0 +1 @@ +#include "layers/lstm/hls/lstm_svd_emulator.h" \ No newline at end of file diff --git a/src/layers/lstm/lstm_data_handler.cpp b/src/layers/lstm/lstm_data_handler.cpp new file mode 100644 index 0000000..a0e81bf --- /dev/null +++ b/src/layers/lstm/lstm_data_handler.cpp @@ -0,0 +1 @@ +#include "layers/lstm/lstm_data_handler.h" \ No newline at end of file diff --git a/src/layers/lstm/sw/CMakeLists.txt b/src/layers/lstm/sw/CMakeLists.txt new file mode 100644 index 0000000..0f85f74 --- /dev/null +++ b/src/layers/lstm/sw/CMakeLists.txt @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 3.10) + +add_library(SOFT_LSTM STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/sw/soft_lstm.cpp) +target_include_directories(SOFT_LSTM PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(SOFT_LSTM PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(SOFT_LSTM PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(SOFT_LSTM ${OpenCv_LIBS}) + +add_library(SOFT_LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/layers/lstm/sw/soft_lstm_svd.cpp) +target_include_directories(SOFT_LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(SOFT_LSTM_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(SOFT_LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(SOFT_LSTM_SVD ${OpenCv_LIBS}) +target_link_libraries(SOFT_LSTM_SVD BLAS_UTILS) +target_link_libraries(SOFT_LSTM_SVD ACTIVATION_FUNCTIONS) diff --git a/src/lstm/sw/soft_lstm.cpp b/src/layers/lstm/sw/soft_lstm.cpp similarity index 99% rename from src/lstm/sw/soft_lstm.cpp rename to src/layers/lstm/sw/soft_lstm.cpp index c535a6d..253838a 100644 --- a/src/lstm/sw/soft_lstm.cpp +++ b/src/layers/lstm/sw/soft_lstm.cpp @@ -36,7 +36,7 @@ * streams * *****************************************************************************/ -#include "lstm/sw/soft_lstm.h" +#include "layers/lstm/sw/soft_lstm.h" #include "math_utils/blas_utils.h" #include "math_utils/activation_functions.h" diff --git a/src/lstm/sw/soft_lstm_svd.cpp b/src/layers/lstm/sw/soft_lstm_svd.cpp similarity index 96% rename from src/lstm/sw/soft_lstm_svd.cpp rename to src/layers/lstm/sw/soft_lstm_svd.cpp index 0000166..e1ff807 100644 --- a/src/lstm/sw/soft_lstm_svd.cpp +++ b/src/layers/lstm/sw/soft_lstm_svd.cpp @@ -1,4 +1,6 @@ -#include "lstm/sw/soft_lstm_svd.h" +#include "layers/lstm/sw/soft_lstm_svd.h" + +namespace svd { #ifdef __cplusplus extern "C" @@ -959,7 +961,7 @@ void SvdModelSoftwareUnbatched(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmFix8(const int verbose, +void SvdModelLstmFix8(const int verbose, const Fix8D *x, const int num_samples, const int num_timesteps, @@ -995,47 +997,19 @@ void SvdModel2LstmFix8(const int verbose, const Fix8D *bias_c, const Fix8D *bias_o, Fix8D *out) { - SvdModel2LstmTemplatedLatencyCC(verbose, x, - num_samples, - num_timesteps, - n_steps, - input_size, - hidden_size, - cur_i_u, - cur_i_s, - cur_i_v, - cur_f_u, - cur_f_s, - cur_f_v, - cur_c_u, - cur_c_s, - cur_c_v, - cur_o_u, - cur_o_s, - cur_o_v, - rec_i_u, - rec_i_s, - rec_i_v, - rec_f_u, - rec_f_s, - rec_f_v, - rec_c_u, - rec_c_s, - rec_c_v, - rec_o_u, - rec_o_s, - rec_o_v, - bias_i, - bias_f, - bias_c, - bias_o, - out); + SvdModelLstmTemplatedLatencyCC(verbose, x, + num_samples, num_timesteps, n_steps, input_size, hidden_size, + cur_i_u, cur_i_s, cur_i_v, cur_f_u, cur_f_s, cur_f_v, + cur_c_u, cur_c_s, cur_c_v, cur_o_u, cur_o_s, cur_o_v, + rec_i_u, rec_i_s, rec_i_v, rec_f_u, rec_f_s, rec_f_v, + rec_c_u, rec_c_s, rec_c_v, rec_o_u, rec_o_s, rec_o_v, + bias_i, bias_f, bias_c, bias_o, out); } #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmFix16(const int verbose, +void SvdModelLstmFix16(const int verbose, const Fix16D *x, const int num_samples, const int num_timesteps, @@ -1071,47 +1045,19 @@ void SvdModel2LstmFix16(const int verbose, const Fix16D *bias_c, const Fix16D *bias_o, Fix16D *out) { - SvdModel2LstmTemplatedLatencyCC(verbose, x, - num_samples, - num_timesteps, - n_steps, - input_size, - hidden_size, - cur_i_u, - cur_i_s, - cur_i_v, - cur_f_u, - cur_f_s, - cur_f_v, - cur_c_u, - cur_c_s, - cur_c_v, - cur_o_u, - cur_o_s, - cur_o_v, - rec_i_u, - rec_i_s, - rec_i_v, - rec_f_u, - rec_f_s, - rec_f_v, - rec_c_u, - rec_c_s, - rec_c_v, - rec_o_u, - rec_o_s, - rec_o_v, - bias_i, - bias_f, - bias_c, - bias_o, - out); + SvdModelLstmTemplatedLatencyCC(verbose, x, + num_samples, num_timesteps, n_steps, input_size, hidden_size, + cur_i_u, cur_i_s, cur_i_v, cur_f_u, cur_f_s, cur_f_v, + cur_c_u, cur_c_s, cur_c_v, cur_o_u, cur_o_s, cur_o_v, + rec_i_u, rec_i_s, rec_i_v, rec_f_u, rec_f_s, rec_f_v, + rec_c_u, rec_c_s, rec_c_v, rec_o_u, rec_o_s, rec_o_v, + bias_i, bias_f, bias_c, bias_o, out); } #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmHalf(const int verbose, +void SvdModelLstmHalf(const int verbose, const HalfD *x, const int num_samples, const int num_timesteps, @@ -1147,47 +1093,19 @@ void SvdModel2LstmHalf(const int verbose, const HalfD *bias_c, const HalfD *bias_o, HalfD *out) { - SvdModel2LstmTemplatedLatencyCC(verbose, x, - num_samples, - num_timesteps, - n_steps, - input_size, - hidden_size, - cur_i_u, - cur_i_s, - cur_i_v, - cur_f_u, - cur_f_s, - cur_f_v, - cur_c_u, - cur_c_s, - cur_c_v, - cur_o_u, - cur_o_s, - cur_o_v, - rec_i_u, - rec_i_s, - rec_i_v, - rec_f_u, - rec_f_s, - rec_f_v, - rec_c_u, - rec_c_s, - rec_c_v, - rec_o_u, - rec_o_s, - rec_o_v, - bias_i, - bias_f, - bias_c, - bias_o, - out); + SvdModelLstmTemplatedLatencyCC(verbose, x, + num_samples, num_timesteps, n_steps, input_size, hidden_size, + cur_i_u, cur_i_s, cur_i_v, cur_f_u, cur_f_s, cur_f_v, + cur_c_u, cur_c_s, cur_c_v, cur_o_u, cur_o_s, cur_o_v, + rec_i_u, rec_i_s, rec_i_v, rec_f_u, rec_f_s, rec_f_v, + rec_c_u, rec_c_s, rec_c_v, rec_o_u, rec_o_s, rec_o_v, + bias_i, bias_f, bias_c, bias_o, out); } #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmSoftware(const int verbose, +void SvdModelLstmSoftware(const int verbose, const bool use_blas, const int type, // 0:float, 1:fix8, 2:fix16, 3:half16 const float *x, @@ -1329,7 +1247,7 @@ void SvdModel2LstmSoftware(const int verbose, // ===================================================================== // Call function // ===================================================================== - SvdModel2LstmFix8(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, + SvdModelLstmFix8(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, cur_o_s_fix, @@ -1446,7 +1364,7 @@ void SvdModel2LstmSoftware(const int verbose, // ===================================================================== // Call function // ===================================================================== - SvdModel2LstmFix16(verbose, x_fix, num_samples, num_timesteps, n_steps, + SvdModelLstmFix16(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, @@ -1564,8 +1482,8 @@ void SvdModel2LstmSoftware(const int verbose, // ===================================================================== // Call function // ===================================================================== - // std::cout << "Starting SvdModel2LstmHalf\n"; - SvdModel2LstmHalf(verbose, x_fix, num_samples, num_timesteps, n_steps, + // std::cout << "Starting SvdModelLstmHalf\n"; + SvdModelLstmHalf(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, @@ -2741,7 +2659,7 @@ void SvdModelEigenUnbatched(const int verbose, #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmHardware(const int verbose, +void SvdModelLstmHardware(const int verbose, const bool use_blas, const int type, // 0:float, 1:fix8, 2:fix16 const float *x1, @@ -2803,7 +2721,7 @@ void SvdModel2LstmHardware(const int verbose, int Tv, int ZTv, int NumTimesteps - SvdModel2LstmTemplated(x1, + SvdModelLstmTemplated(x1, x2, cur_i_u, cur_i_s, @@ -2942,7 +2860,7 @@ void SvdModel2LstmHardware(const int verbose, // ===================================================================== // Call function // ===================================================================== - SvdModel2LstmFix8(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, + SvdModelLstmFix8(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, cur_o_s_fix, @@ -3059,7 +2977,7 @@ void SvdModel2LstmHardware(const int verbose, // ===================================================================== // Call function // ===================================================================== - SvdModel2LstmFix16(verbose, x_fix, num_samples, num_timesteps, n_steps, + SvdModelLstmFix16(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, @@ -3177,8 +3095,8 @@ void SvdModel2LstmHardware(const int verbose, // ===================================================================== // Call function // ===================================================================== - // std::cout << "Starting SvdModel2LstmHalf\n"; - SvdModel2LstmHalf(verbose, x_fix, num_samples, num_timesteps, n_steps, + // std::cout << "Starting SvdModelLstmHalf\n"; + SvdModelLstmHalf(verbose, x_fix, num_samples, num_timesteps, n_steps, input_size, hidden_size, cur_i_u_fix, cur_i_s_fix, cur_i_v_fix, cur_f_u_fix, cur_f_s_fix, cur_f_v_fix, cur_c_u_fix, cur_c_s_fix, cur_c_v_fix, cur_o_u_fix, @@ -3256,7 +3174,7 @@ void print_vect(const int size, const int num_elem_to_print, T *v) { #ifdef __cplusplus extern "C" #endif -void SvdModel2LstmSoftwareBatched(const int verbose, +void SvdModelLstmSoftwareBatched(const int verbose, const bool use_blas, const float *x, // (num_samples, num_inputs, num_timesteps, input_size) const int num_inputs, @@ -3741,3 +3659,5 @@ void SvdModel2LstmSoftwareBatched(const int verbose, delete[] rec_o_us; } #endif + +} // svd diff --git a/src/lstm/hls/CMakeLists.txt b/src/lstm/hls/CMakeLists.txt deleted file mode 100644 index 0859f22..0000000 --- a/src/lstm/hls/CMakeLists.txt +++ /dev/null @@ -1,13 +0,0 @@ -cmake_minimum_required(VERSION 3.10) - -add_library(LSTM_HARDWARE STATIC ${CMAKE_SOURCE_DIR}/src/lstm/hls/lstm_hardware.cpp) -target_include_directories(LSTM_HARDWARE PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(LSTM_HARDWARE PUBLIC ${VIVADO_INCLUDE_DIRS}) -target_include_directories(LSTM_HARDWARE PUBLIC ${OpenCv_INCLUDE_DIRS}) -target_link_libraries(LSTM_HARDWARE ${OpenCv_LIBS}) - -add_library(LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/lstm/hls/lstm_svd.cpp) -target_include_directories(LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(LSTM_SVD PUBLIC ${VIVADO_INCLUDE_DIRS}) -target_include_directories(LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) -target_link_libraries(LSTM_SVD ${OpenCv_LIBS}) \ No newline at end of file diff --git a/src/lstm/hls/lstm_svd.cpp b/src/lstm/hls/lstm_svd.cpp deleted file mode 100644 index 6b1adc5..0000000 --- a/src/lstm/hls/lstm_svd.cpp +++ /dev/null @@ -1,372 +0,0 @@ -#include "lstm/hls/lstm_svd.h" -#include "svd_params.h" -#include "dma/svd_dma.h" -#include "kernel/u_kernel.h" -#include "kernel/s_kernel.h" -#include "kernel/v_kernel.h" -#include "math_utils/activation_functions.h" -#include "hls_utils/hls_debugging.h" - -#include "hls_stream.h" -#include "ap_int.h" - -void SvdModel2LstmSDSoCV2( - const svd::ActivationD x1_port[INPUT_SIZE], - const svd::ActivationD x2_port[INPUT_SIZE], - const svd::ActivationD h_t1_prev_port[HIDDEN_SIZE], - const svd::ActivationD h_t2_prev_port[HIDDEN_SIZE], - const svd::ActivationD c_t1_prev_port[HIDDEN_SIZE], - const svd::ActivationD c_t2_prev_port[HIDDEN_SIZE], - const ap_uint *u_cur_port, // [NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], - const ap_uint *u_rec_port, // [NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)], - const ap_uint *v_port, // [NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)], - const ap_uint *s1_port, // [NUM_ITERATIONS*8], - const ap_uint *s2_port, // [NUM_ITERATIONS*8], - const svd::WeightD bias1_port[4 * HIDDEN_SIZE], - const svd::WeightD bias2_port[4 * HIDDEN_SIZE], - const ap_uint comb_v_port[NUM_ITERATIONS * 8], - const ap_uint comb_u_port[NUM_ITERATIONS * 8], - svd::ActivationD h_t1_curr_port[HIDDEN_SIZE], - svd::ActivationD h_t2_curr_port[HIDDEN_SIZE], - svd::ActivationD c_t1_curr_port[HIDDEN_SIZE], - svd::ActivationD c_t2_curr_port[HIDDEN_SIZE] -#ifdef DEBUG_FIFOS - , - svd::CounterD *counters_port, - svd::CounterD *clk_count_port -#endif - ) { - std::cout << "[INFO] Running SvdModel2LstmSDSoCV2." << std::endl; - const int kNumGates = 8; - const int kNumCurGates = 4; - const int kNumRecGates = 4; - const int kInputLength = INPUT_SIZE; - const int kOutputLength = HIDDEN_SIZE; - const int kNumTilesU = NUM_TILES_U; - const int kNumTilesV = NUM_TILES_V; - const int kNumZeroTilesU = NUM_ZERO_TILES_U; - const int kNumZeroTilesV = NUM_ZERO_TILES_V; - const int kNumIter = NUM_ITERATIONS; - const int kNumTimesteps = NUM_TIMESTEPS; - const int kNumNonZeroTilesU = kNumTilesU - kNumZeroTilesU; - const int kNumNonZeroTilesV = kNumTilesV - kNumZeroTilesV; - const int kNumElemsTileUCurrent = kInputLength / kNumTilesU; - const int kNumElemsTileURecur = kOutputLength / kNumTilesU; - const int kNumElemsTileV = kOutputLength / kNumTilesV; - assert(kNumTilesU % 2 == 0); - assert(kNumTilesV % 2 == 0); - // assert(kNumZeroTilesU % 2 == 0); - // assert(kNumZeroTilesV % 2 == 0); - assert(kNumIter % 2 == 0); - std::cout << "[INFO] assert passed." << std::endl; - - const int kNumElemsTileU = kInputLength / kNumTilesU; - const int kPrunedLengthU = kInputLength - kNumZeroTilesU * kNumElemsTileU; - const int kPrunedLengthV = kOutputLength - kNumZeroTilesV * kNumElemsTileV; - const int kNumSamples = NUM_SAMPLES; // Used for cosimulation only - const int kNumReadsR = 8 * kNumIter; - const int kNumReadsC = 8 * kNumIter; - const int kAxiDepthR = kInputLength; - const int kAxiPortDepthX = (kInputLength * kNumTimesteps) * kNumSamples; - const int kAxiDepthU = (kNumIter * 8 * kPrunedLengthU) * kNumSamples; - const int kAxiDepthV = (kNumIter * 8 * kPrunedLengthV) * kNumSamples; - const int kAxiDepthS = (kNumIter * 8 * 2) * kNumSamples; - const int kAxiDepthCombinationsR = kNumReadsR * kNumSamples; - const int kAxiDepthCombinationsC = kNumReadsC * kNumSamples; -#ifndef SDS_DESIGN -#pragma HLS INTERFACE s_axilite port=return bundle=ctrl - - const int kInputLengthPruned = kInputLength - kInputLength / kNumTilesU * kNumZeroTilesU; - const int kOutputLengthPrunedU = kOutputLength - kOutputLength / kNumTilesU * kNumZeroTilesU; - const int kOutputLengthPrunedV = kOutputLength - kOutputLength / kNumTilesV * kNumZeroTilesV; - const int kUSize = kNumIter*(kNumCurGates * kInputLengthPruned + kNumRecGates * kOutputLengthPrunedU); - const int kVSize = kNumIter*(kNumCurGates * kOutputLengthPrunedV + kNumRecGates * kOutputLengthPrunedV); - const int kSSize = kNumIter * 2 * (kNumCurGates + kNumRecGates); - - const int kUCurSize = kNumIter * kNumCurGates * kInputLengthPruned; - const int kURecSize = kNumIter * kNumRecGates * kOutputLengthPrunedU; - - const int kUcurPortDepth = kUCurSize; - const int kUrecPortDepth = kURecSize; - const int kVportDepth = kVSize; - const int kS1portDepth = kSSize / 2; - const int kS2portDepth = kSSize / 2; -#pragma HLS INTERFACE m_axi port=u_cur_port offset=slave depth=kUcurPortDepth bundle=u_cur_dmem -#pragma HLS INTERFACE m_axi port=u_rec_port offset=slave depth=kUrecPortDepth bundle=u_rec_dmem -#pragma HLS INTERFACE m_axi port=v_port offset=slave depth=kVportDepth bundle=v_dmem -#pragma HLS INTERFACE m_axi port=s1_port offset=slave depth=kS1portDepth bundle=s1_dmem -#pragma HLS INTERFACE m_axi port=s2_port offset=slave depth=kS2portDepth bundle=s2_dmem - -#pragma HLS INTERFACE ap_fifo port=x1_port -#pragma HLS INTERFACE ap_fifo port=x2_port -#pragma HLS INTERFACE ap_fifo port=bias1_port -#pragma HLS INTERFACE ap_fifo port=bias2_port -#pragma HLS INTERFACE ap_fifo port=comb_v_port -#pragma HLS INTERFACE ap_fifo port=comb_u_port -#pragma HLS INTERFACE ap_fifo port=h_t1_prev_port -#pragma HLS INTERFACE ap_fifo port=h_t2_prev_port -#pragma HLS INTERFACE ap_fifo port=h_t1_curr_port -#pragma HLS INTERFACE ap_fifo port=h_t2_curr_port -#pragma HLS INTERFACE ap_fifo port=c_t1_prev_port -#pragma HLS INTERFACE ap_fifo port=c_t2_prev_port -#pragma HLS INTERFACE ap_fifo port=c_t1_curr_port -#pragma HLS INTERFACE ap_fifo port=c_t2_curr_port -#endif // SDS_DESIGN - -#pragma HLS DATAFLOW - std::cout << "[INFO] DATAFLOW passed." << std::endl; - - // =========================================================================== - // Current streams - // =========================================================================== - svd::WeightStream cur_u_streams[kNumCurGates][kNumNonZeroTilesU]; - svd::WeightStream cur_v_streams[kNumCurGates][kNumElemsTileV]; // [kNumNonZeroTilesV]; - svd::ActivationStream cur_dot1_streams[kNumCurGates]; - svd::ActivationStream cur_dot2_streams[kNumCurGates]; - svd::ActivationStream cur_out1_streams[kNumCurGates][kNumNonZeroTilesV]; - svd::ActivationStream cur_out2_streams[kNumCurGates][kNumNonZeroTilesV]; - svd::ActivationStream cur_acc1_streams[kNumCurGates][kNumElemsTileV]; // [kNumTilesV]; - svd::ActivationStream cur_acc2_streams[kNumCurGates][kNumElemsTileV]; // [kNumTilesV]; -#pragma HLS ARRAY_PARTITION variable=cur_u_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_v_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_dot1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_dot2_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_out1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_out2_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_acc1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=cur_acc2_streams complete dim=0 - // =========================================================================== - // Recur streams - // =========================================================================== - svd::WeightStream rec_u_streams[kNumRecGates][kNumNonZeroTilesU]; - svd::WeightStream rec_v_streams[kNumRecGates][kNumElemsTileV]; // [kNumNonZeroTilesV]; - svd::ActivationStream rec_dot1_streams[kNumRecGates]; - svd::ActivationStream rec_dot2_streams[kNumRecGates]; - svd::ActivationStream rec_out1_streams[kNumRecGates][kNumNonZeroTilesV]; - svd::ActivationStream rec_out2_streams[kNumRecGates][kNumNonZeroTilesV]; - svd::ActivationStream rec_acc1_streams[kNumRecGates][kNumElemsTileV]; // [kNumTilesV]; - svd::ActivationStream rec_acc2_streams[kNumRecGates][kNumElemsTileV]; // [kNumTilesV]; -#pragma HLS ARRAY_PARTITION variable=rec_u_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_v_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_dot1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_dot2_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_out1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_out2_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_acc1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=rec_acc2_streams complete dim=0 - // =========================================================================== - // Scalar streams - // =========================================================================== - svd::WeightStream gates_s1_streams[kNumGates]; // used for both curr and recur - svd::WeightStream gates_s2_streams[kNumGates]; // used for both curr and recur -#pragma HLS ARRAY_PARTITION variable=gates_s1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=gates_s2_streams complete dim=0 - // =========================================================================== - // Current input streams - // =========================================================================== - svd::ActivationStream x1_streams[kNumCurGates][kNumNonZeroTilesU]; - svd::ActivationStream x2_streams[kNumCurGates][kNumNonZeroTilesU]; -#pragma HLS ARRAY_PARTITION variable=x1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=x2_streams complete dim=0 - // =========================================================================== - // Recurrent input streams - // =========================================================================== - svd::ActivationStream h1_streams[kNumRecGates][kNumNonZeroTilesU]; - svd::ActivationStream h2_streams[kNumRecGates][kNumNonZeroTilesU]; -#pragma HLS ARRAY_PARTITION variable=h1_streams complete dim=0 -#pragma HLS ARRAY_PARTITION variable=h2_streams complete dim=0 - // =========================================================================== - // Streams Depth Sizing - // =========================================================================== - // NOTE: We divide the FIFO depths by a certain factor to save BRAMs. Be aware - // that a wrong factor could lead to deadlocks! - const int kFIFOdepthFactor = kNumIter * 2; - const int kStreamDepthUCurrent = kNumIter * kNumElemsTileUCurrent / kFIFOdepthFactor == 0 ? 2 : kNumIter * kNumElemsTileUCurrent / kFIFOdepthFactor; - const int kStreamDepthURecurrent = kNumIter * kNumElemsTileURecur / kFIFOdepthFactor == 0 ? 2 : kNumIter * kNumElemsTileURecur / kFIFOdepthFactor; - const int kStreamDepthV = kNumIter * kNumTilesV / kFIFOdepthFactor == 0 ? 2 : kNumIter * kNumTilesV / kFIFOdepthFactor; - const int kTileAccStreamDepth = 2; -#pragma HLS STREAM variable=x1_streams depth=kStreamDepthUCurrent dim=2 -#pragma HLS STREAM variable=x2_streams depth=kStreamDepthUCurrent dim=2 -#pragma HLS STREAM variable=h1_streams depth=kStreamDepthURecurrent dim=2 -#pragma HLS STREAM variable=h2_streams depth=kStreamDepthURecurrent dim=2 - -#pragma HLS STREAM variable=cur_u_streams depth=kStreamDepthUCurrent dim=2 -#pragma HLS STREAM variable=rec_u_streams depth=kStreamDepthURecurrent dim=2 -#pragma HLS STREAM variable=cur_v_streams depth=kStreamDepthV dim=2 -#pragma HLS STREAM variable=rec_v_streams depth=kStreamDepthV dim=2 - -#pragma HLS STREAM variable=gates_s1_streams depth=kStreamDepthIter -#pragma HLS STREAM variable=gates_s2_streams depth=kStreamDepthIter - -#pragma HLS STREAM variable=cur_dot1_streams depth=kStreamDepthIter -#pragma HLS STREAM variable=cur_dot2_streams depth=kStreamDepthIter -#pragma HLS STREAM variable=rec_dot1_streams depth=kStreamDepthIter -#pragma HLS STREAM variable=rec_dot2_streams depth=kStreamDepthIter -#pragma HLS STREAM variable=cur_acc1_streams depth=kTileAccStreamDepth dim=2 -#pragma HLS STREAM variable=cur_acc2_streams depth=kTileAccStreamDepth dim=2 -#pragma HLS STREAM variable=rec_acc1_streams depth=kTileAccStreamDepth dim=2 -#pragma HLS STREAM variable=rec_acc2_streams depth=kTileAccStreamDepth dim=2 - -#pragma HLS STREAM variable=cur_out1_streams depth=kOutStreamDepth dim=2 -#pragma HLS STREAM variable=cur_out2_streams depth=kOutStreamDepth dim=2 -#pragma HLS STREAM variable=rec_out1_streams depth=kOutStreamDepth dim=2 -#pragma HLS STREAM variable=rec_out2_streams depth=kOutStreamDepth dim=2 - std::cout << "[INFO] Depth sizing passed." << std::endl; - - // =========================================================================== - // Zero Combinations DMA - // =========================================================================== - // NOTE: We divide the FIFO depths by a certain factor to save BRAMs. Be aware - // that a wrong factor could lead to deadlocks! - const int kFIFOdepthDivider = 8; - const int kStreamDepthIter = kNumIter / kFIFOdepthDivider; - std::cout << "[INFO] DATAFLOW passed." << std::endl; - hls::stream > comb_v_stream1_cur[kNumCurGates]; - hls::stream > comb_v_stream1_rec[kNumRecGates]; - hls::stream > comb_v_stream2_cur[kNumCurGates]; - hls::stream > comb_v_stream2_rec[kNumRecGates]; - hls::stream > comb_u_stream1_cur[kNumCurGates]; - hls::stream > comb_u_stream1_rec[kNumRecGates]; - hls::stream > comb_u_stream2_cur[kNumCurGates]; - hls::stream > comb_u_stream2_rec[kNumRecGates]; -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_v_stream1_cur -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_v_stream1_rec -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_v_stream2_cur -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_v_stream2_rec -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_u_stream1_cur -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_u_stream1_rec -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_u_stream2_cur -#pragma HLS STREAM depth=kStreamDepthIter variable=comb_u_stream2_rec -#pragma HLS ARRAY_PARTITION variable=comb_v_stream1_cur complete -#pragma HLS ARRAY_PARTITION variable=comb_v_stream1_rec complete -#pragma HLS ARRAY_PARTITION variable=comb_v_stream2_cur complete -#pragma HLS ARRAY_PARTITION variable=comb_v_stream2_rec complete -#pragma HLS ARRAY_PARTITION variable=comb_u_stream1_cur complete -#pragma HLS ARRAY_PARTITION variable=comb_u_stream1_rec complete -#pragma HLS ARRAY_PARTITION variable=comb_u_stream2_cur complete -#pragma HLS ARRAY_PARTITION variable=comb_u_stream2_rec complete - - std::cout << "Starting ZeroTileCombinationDMA" << std::endl; - hls_utils::Log(0, "Starting ZeroTileCombinationDMA"); - svd::ZeroTileCombination2LstmDMA(comb_u_port, - comb_u_stream1_cur, comb_u_stream1_rec, comb_u_stream2_cur, - comb_u_stream2_rec); - svd::ZeroTileCombinationDMA(comb_v_port, - comb_v_stream1_cur, comb_v_stream1_rec); - // =========================================================================== - // Current Input DMA - // =========================================================================== - hls_utils::Log(0, "Starting InputDMA"); - svd::InputDMA( - x1_port, comb_u_stream1_cur, x1_streams); - svd::InputDMA( - x2_port, comb_u_stream2_cur, x2_streams); - // =========================================================================== - // Recurrent Input DMA - // =========================================================================== - svd::InputDMA( - h_t1_prev_port, comb_u_stream1_rec, h1_streams); - svd::InputDMA( - h_t2_prev_port, comb_u_stream2_rec, h2_streams); - // =========================================================================== - // Gates DMA - // =========================================================================== - svd::WeightD u_cur_gate_streams[kNumGates / 2][kNumIter * kInputLength / kNumTilesU * (kNumTilesU - kNumZeroTilesU)]; - svd::WeightD u_rec_gate_streams[kNumGates / 2][kNumIter * kOutputLength / kNumTilesU * (kNumTilesU - kNumZeroTilesU)]; - svd::WeightD v_gate_streams[kNumGates][kNumIter * kOutputLength / kNumTilesV * (kNumTilesV - kNumZeroTilesV)]; -#pragma HLS STREAM variable=u_cur_gate_streams depth=1 dim=1 -#pragma HLS STREAM variable=u_rec_gate_streams depth=1 dim=1 -#pragma HLS STREAM variable=v_gate_streams depth=1 dim=1 -#pragma HLS ARRAY_PARTITION variable=u_cur_gate_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=u_rec_gate_streams complete dim=1 -#pragma HLS ARRAY_PARTITION variable=v_gate_streams complete dim=1 - - const int kUcurSize = kNumGates / 2 * kNumIter * kInputLength / kNumTilesU * (kNumTilesU - kNumZeroTilesU); - const int kUrecSize = kNumGates / 2 * kNumIter * kOutputLength / kNumTilesU * (kNumTilesU - kNumZeroTilesU); - const int kSsize = kNumGates * kNumIter; - const int kVsize = kNumGates * kNumIter * kOutputLength / kNumTilesV * (kNumTilesV - kNumZeroTilesV); - const int kBitWidthU = FIX_WIDTH * 4; - const int kBitWidthV = FIX_WIDTH * 8; - const int kBitWidthS = FIX_WIDTH * 8; - hls_utils::Log(0, "Starting ArraySplitter"); - svd::ArraySplitter, svd::WeightD, kBitWidthU, FIX_WIDTH, kUcurSize>(u_cur_port, u_cur_gate_streams); - svd::ArraySplitter, svd::WeightD, kBitWidthU, FIX_WIDTH, kUrecSize>(u_rec_port, u_rec_gate_streams); - svd::ArraySplitter, svd::WeightD, kBitWidthV, FIX_WIDTH, kVsize>(v_port, v_gate_streams); - svd::StreamSplitter, svd::WeightD, kBitWidthS, FIX_WIDTH>(kSsize, s1_port, gates_s1_streams); - svd::StreamSplitter, svd::WeightD, kBitWidthS, FIX_WIDTH>(kSsize, s2_port, gates_s2_streams); - const bool kUweights = true; - // =========================================================================== - // Current Dot Product Unit - // =========================================================================== - Current_Gates_Dot_Product_Loop: - for (int g = 0; g < kNumCurGates; ++g) { -#pragma HLS UNROLL - hls_utils::Log(0, std::string("Starting Cur Gate n." + g)); - svd::GateDMA(kUweights, kNumIter, kNumNonZeroTilesU, kNumElemsTileUCurrent, u_cur_gate_streams[g], cur_u_streams[g]); - svd::GateDMA(!kUweights, kNumIter, kNumNonZeroTilesV, kNumElemsTileV, v_gate_streams[g], cur_v_streams[g]); - svd::UDotUnit2Lstm(x1_streams[g], - x2_streams[g], cur_u_streams[g], - cur_dot1_streams[g], cur_dot2_streams[g]); - svd::VDotUnit2LstmV2( - false, - nullptr, - nullptr, - cur_dot1_streams[g], - cur_dot2_streams[g], - gates_s1_streams[g], - gates_s2_streams[g], - cur_v_streams[g], - comb_v_stream1_cur[g], - cur_acc1_streams[g], - cur_acc2_streams[g]); - } - // =========================================================================== - // Recur Dot Product Unit - // =========================================================================== - Recur_Gates_Dot_Product_Loop: - for (int g = 0; g < kNumRecGates; ++g) { -#pragma HLS UNROLL - hls_utils::Log(0, std::string("Starting Rec Gate n." + g)); - svd::GateDMA(kUweights, kNumIter, kNumNonZeroTilesU, kNumElemsTileURecur, u_rec_gate_streams[g], rec_u_streams[g]); - svd::GateDMA(!kUweights, kNumIter, kNumNonZeroTilesV, kNumElemsTileV, v_gate_streams[kNumCurGates + g], rec_v_streams[g]); - svd::UDotUnit2Lstm(h1_streams[g], - h2_streams[g], rec_u_streams[g], - rec_dot1_streams[g], rec_dot2_streams[g]); - svd::VDotUnit2LstmV2( - false, - nullptr, - nullptr, - rec_dot1_streams[g], - rec_dot2_streams[g], - gates_s1_streams[kNumCurGates + g], - gates_s2_streams[kNumCurGates + g], - rec_v_streams[g], - comb_v_stream1_rec[g], - rec_acc1_streams[g], - rec_acc2_streams[g]); - } - // =========================================================================== - // Output Non-Linearities - // =========================================================================== - // NOTE: The output FIFOs in NonLinearityUnit have been resized! Check for deadlocks! - svd::NonLinearityUnit(c_t1_prev_port, - cur_acc1_streams, rec_acc1_streams, h_t1_curr_port, c_t1_curr_port, true, - bias1_port); - svd::NonLinearityUnit(c_t2_prev_port, - cur_acc2_streams, rec_acc2_streams, h_t2_curr_port, c_t2_curr_port, true, - bias2_port); - -#ifdef DEBUG_FIFOS - - const int kNumPEsU = NUM_TILES_U - NUM_ZERO_TILES_U; - const int kNumPEsVCur = INPUT_SIZE / NUM_TILES_V; - const int kNumPEsVRec = HIDDEN_SIZE / NUM_TILES_V; - const int kNumUprobes = kNumGates * kNumPEsU * 3; // one for each: x1, x2, u streams - const int kNumVprobes = kNumGates / 2 * (kNumPEsVCur + kNumPEsVRec); // one for v streams - const int kNumProbes = kNumUprobes + kNumVprobes; - svd::ProbeStream stop_ctrl; - svd::ProbeStream probe_ctrl[kNumUprobes]; - - svd::ClockCounter(probe_ctrl, stop_ctrl, counters_port, clk_count_port); -#endif -} \ No newline at end of file diff --git a/src/lstm/lstm_data_handler.cpp b/src/lstm/lstm_data_handler.cpp deleted file mode 100644 index 5833b8e..0000000 --- a/src/lstm/lstm_data_handler.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "lstm/lstm_data_handler.h" \ No newline at end of file diff --git a/src/lstm/sw/CMakeLists.txt b/src/lstm/sw/CMakeLists.txt deleted file mode 100644 index 24c7190..0000000 --- a/src/lstm/sw/CMakeLists.txt +++ /dev/null @@ -1,13 +0,0 @@ -cmake_minimum_required(VERSION 3.10) - -add_library(SOFT_LSTM STATIC ${CMAKE_SOURCE_DIR}/src/lstm/sw/soft_lstm.cpp) -target_include_directories(SOFT_LSTM PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SOFT_LSTM PUBLIC ${VIVADO_INCLUDE_DIRS}) -target_include_directories(SOFT_LSTM PUBLIC ${OpenCv_INCLUDE_DIRS}) -target_link_libraries(SOFT_LSTM ${OpenCv_LIBS}) - -add_library(SOFT_LSTM_SVD STATIC ${CMAKE_SOURCE_DIR}/src/lstm/sw/soft_lstm_svd.cpp) -target_include_directories(SOFT_LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(SOFT_LSTM_SVD PUBLIC ${VIVADO_INCLUDE_DIRS}) -target_include_directories(SOFT_LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) -target_link_libraries(SOFT_LSTM_SVD ${OpenCv_LIBS}) \ No newline at end of file diff --git a/src/math_utils/CMakeLists.txt b/src/math_utils/CMakeLists.txt index 489c8e7..042ef8d 100644 --- a/src/math_utils/CMakeLists.txt +++ b/src/math_utils/CMakeLists.txt @@ -2,19 +2,19 @@ cmake_minimum_required(VERSION 3.10) add_library(BLAS_UTILS STATIC ${CMAKE_SOURCE_DIR}/src/math_utils/blas_utils.cpp) target_include_directories(BLAS_UTILS PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(BLAS_UTILS PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(BLAS_UTILS PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(BLAS_UTILS PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(BLAS_UTILS ${OpenCv_LIBS}) add_library(ACTIVATION_FUNCTIONS STATIC ${CMAKE_SOURCE_DIR}/src/math_utils/activation_functions.cpp) target_include_directories(ACTIVATION_FUNCTIONS PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(ACTIVATION_FUNCTIONS PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(ACTIVATION_FUNCTIONS PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(ACTIVATION_FUNCTIONS PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(ACTIVATION_FUNCTIONS ${OpenCv_LIBS}) add_library(DATA_HANDLER STATIC ${CMAKE_SOURCE_DIR}/src/math_utils/data_handler.cpp) target_include_directories(DATA_HANDLER PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_include_directories(DATA_HANDLER PUBLIC ${VIVADO_INCLUDE_DIRS}) +target_include_directories(DATA_HANDLER PUBLIC ${HLS_INCLUDE_DIRS}) target_include_directories(DATA_HANDLER PUBLIC ${OpenCv_INCLUDE_DIRS}) target_link_libraries(DATA_HANDLER ${OpenCv_LIBS}) diff --git a/src/svd.cpp b/src/svd.cpp index a392d80..9926a52 100644 --- a/src/svd.cpp +++ b/src/svd.cpp @@ -1,7 +1,9 @@ #include "svd_params.h" #include "svd_ip.h" -#include "lstm/hls/lstm_svd.h" -#include "lstm/lstm_data_handler.h" +#include "layers/lstm/lstm_data_handler.h" +#include "layers/lstm/sw/soft_lstm_svd.h" +#include "layers/lstm/hls/lstm_svd.h" +#include "layers/lstm/hls/lstm_svd_emulator.h" #include "ap_fixed.h" @@ -11,17 +13,7 @@ int main(int argc, char const *argv[]) { std::cout << "Hello SVD!" << std::endl; - typename svd_params::ActivationD x_port[svd_params::N][svd_params::I] = {rand()}; - typename svd_params::UPortD u_port[svd_params::PrunedSizeU] = {rand()}; - typename svd_params::SPortD s_port[svd_params::N][svd_params::R] = {rand()}; - typename svd_params::VPortD v_port[svd_params::PrunedSizeV] = {rand()}; - ap_uint nz_u_port[svd_params::N] = {rand()}; - ap_uint nz_v_port[svd_params::N] = {rand()}; - typename svd_params::ActivationD y_port[svd_params::N][svd_params::G][svd_params::H] = {rand()}; - - std::cout << "Running SvdIp2Inputs." << std::endl; - SvdIp2Inputs(x_port, u_port, s_port, v_port, nz_u_port, nz_v_port, y_port); - + const bool kTestSoftwareAccelerator = false; const int kNumInputs = 2; const int kRefinementSteps = NUM_ITERATIONS; const int kLstmInputSize = INPUT_SIZE; @@ -33,15 +25,22 @@ int main(int argc, char const *argv[]) { const int kNumZeroTilesU = NUM_ZERO_TILES_U; const int kNumTilesV = NUM_TILES_V; const int kNumZeroTilesV = NUM_ZERO_TILES_V; + const int kLutSize = (FIX_WIDTH == 16) ? 512 : 256; std::cout << "Setting AcceleratorBlob." << std::endl; - typedef lstm::AcceleratorBlob AccelDataType; - AccelDataType storage = AccelDataType(kNumInputs, kRefinementSteps, kUCurSize, + typedef svd::AcceleratorBlob AcceleratorStorage; + AcceleratorStorage storage = AcceleratorStorage(kNumInputs, kRefinementSteps, kUCurSize, kURecSize, kVSize, kNumTilesU, kNumZeroTilesU, kNumTilesV, kNumZeroTilesV); - std::cout << "printing stuff..." << std::endl; - std::cout << storage.get_fix_x(0) << std::endl; - std::cout << storage.get_fix_x(0)[234] << std::endl; + std::cout << "Running SvdIp2Inputs." << std::endl; + typename svd::svd_params::ActivationD x_port[svd::svd_params::N][svd::svd_params::I] = {rand()}; + typename svd::svd_params::UPortD u_port[svd::svd_params::R * svd::svd_params::PrunedSizeU] = {rand()}; + typename svd::svd_params::SPortD s_port[svd::svd_params::N][svd::svd_params::R] = {rand()}; + typename svd::svd_params::VPortD v_port[svd::svd_params::R * svd::svd_params::PrunedSizeV] = {rand()}; + ap_uint nz_u_port[svd::svd_params::G * svd::svd_params::R] = {rand()}; + ap_uint nz_v_port[svd::svd_params::G * svd::svd_params::R] = {rand()}; + typename svd::svd_params::ActivationD y_port[svd::svd_params::N][svd::svd_params::G][svd::svd_params::H] = {rand()}; + // SvdIp2Inputs(x_port, u_port, s_port, v_port, nz_u_port, nz_v_port, y_port); std::cout << "reinterpret_cast." << std::endl; @@ -51,38 +50,162 @@ int main(int argc, char const *argv[]) { ap_uint<128>* s1_uint = reinterpret_cast*>(storage.get_fix_s(0)); ap_uint<128>* s2_uint = reinterpret_cast*>(storage.get_fix_s(1)); - std::cout << "Starting accelerator." << std::endl; - assert(storage.get_u_cur_size() == NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)); assert(storage.get_u_rec_size() == NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U)); assert(storage.get_v_size() == NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V)); - - std::cout << (storage.get_u_cur_size() == NUM_ITERATIONS*4*INPUT_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U) ? "true" : "false") << std::endl; - std::cout << (storage.get_u_rec_size() == NUM_ITERATIONS*4*HIDDEN_SIZE / NUM_TILES_U * (NUM_TILES_U - NUM_ZERO_TILES_U) ? "true" : "false") << std::endl; - std::cout << (storage.get_v_size() == NUM_ITERATIONS*4*2*HIDDEN_SIZE / NUM_TILES_V * (NUM_TILES_V - NUM_ZERO_TILES_V) ? "true" : "false") << std::endl; - - SvdModel2LstmSDSoCV2( - storage.get_fix_x(0), - storage.get_fix_x(1), - storage.get_fix_h(0), - storage.get_fix_h(1), - storage.get_fix_c(0), - storage.get_fix_c(1), - u_cur_uint, - u_rec_uint, - v_uint, - s1_uint, - s2_uint, - storage.get_fix_bias(0), - storage.get_fix_bias(1), - storage.get_fix_z_v(), - storage.get_fix_z_u(), - storage.get_fix_h(0), - storage.get_fix_h(1), - storage.get_fix_c(0), - storage.get_fix_c(1)); - + assert(storage.get_s_size() == NUM_ITERATIONS*8); + + svd::ActivationD** h_prev_hls = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** h_curr_hls = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_prev_hls = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_curr_hls = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** h_prev_emulator = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** h_curr_emulator = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_prev_emulator = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_curr_emulator = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** h_prev_sw = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** h_curr_sw = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_prev_sw = new svd::ActivationD*[kNumInputs]; + svd::ActivationD** c_curr_sw = new svd::ActivationD*[kNumInputs]; + for (int i = 0; i < kNumInputs; ++i) { + h_prev_emulator[i] = new svd::ActivationD[kLstmOutputSize]; + h_curr_emulator[i] = new svd::ActivationD[kLstmOutputSize]; + c_prev_emulator[i] = new svd::ActivationD[kLstmOutputSize]; + c_curr_emulator[i] = new svd::ActivationD[kLstmOutputSize]; + h_prev_hls[i] = reinterpret_cast(storage.get_fix_h_prev(i)); + h_curr_hls[i] = reinterpret_cast(storage.get_fix_h_curr(i)); + c_prev_hls[i] = reinterpret_cast(storage.get_fix_c_prev(i)); + c_curr_hls[i] = reinterpret_cast(storage.get_fix_c_curr(i)); + } + for (int i = 0; i < NUM_TIMESTEPS; ++i) { + for (int j = 0; j < kNumInputs; ++j) { + std::swap(h_prev_hls[j], h_curr_hls[j]); + std::swap(c_prev_hls[j], c_curr_hls[j]); + } + std::cout << "Starting accelerator." << std::endl; + svd::SvdModel2LstmSDSoCV2(storage.get_fix_x(0), storage.get_fix_x(1), // [s * NUM_TIMESTEPS + t] samples? + h_prev_hls[0], h_prev_hls[1], c_prev_hls[0], c_prev_hls[1], + u_cur_uint, u_rec_uint, v_uint, s1_uint, s2_uint, + storage.get_fix_bias(0), storage.get_fix_bias(1), + storage.get_fix_nz_v(), storage.get_fix_nz_u(), + h_curr_hls[0], h_curr_hls[1], c_curr_hls[0], c_curr_hls[1]); + for (int j = 0; j < kNumInputs; ++j) { + std::cout << "Starting Emulator: " << j << std::endl; + svd::LstmSvdSoftEmulator( + kLstmInputSize, kLstmOutputSize, kRefinementSteps, + kNumTilesU, kNumZeroTilesU, + kNumTilesV, kNumZeroTilesV, 1, storage.get_fix_x(j), + storage.get_cur_gates("i")->get_u()->fix_pruned_data(), + storage.get_cur_gates("i")->get_s(j).fix_pruned_data(), + storage.get_cur_gates("i")->get_v()->fix_pruned_data(), + storage.get_cur_gates("i")->get_u()->get_nz_idx(), + storage.get_cur_gates("i")->get_v()->get_nz_idx(), + storage.get_cur_gates("f")->get_u()->fix_pruned_data(), + storage.get_cur_gates("f")->get_s(j).fix_pruned_data(), + storage.get_cur_gates("f")->get_v()->fix_pruned_data(), + storage.get_cur_gates("f")->get_u()->get_nz_idx(), + storage.get_cur_gates("f")->get_v()->get_nz_idx(), + storage.get_cur_gates("c")->get_u()->fix_pruned_data(), + storage.get_cur_gates("c")->get_s(j).fix_pruned_data(), + storage.get_cur_gates("c")->get_v()->fix_pruned_data(), + storage.get_cur_gates("c")->get_u()->get_nz_idx(), + storage.get_cur_gates("c")->get_v()->get_nz_idx(), + storage.get_cur_gates("o")->get_u()->fix_pruned_data(), + storage.get_cur_gates("o")->get_s(j).fix_pruned_data(), + storage.get_cur_gates("o")->get_v()->fix_pruned_data(), + storage.get_cur_gates("o")->get_u()->get_nz_idx(), + storage.get_cur_gates("o")->get_v()->get_nz_idx(), + storage.get_rec_gates("i")->get_u()->fix_pruned_data(), + storage.get_rec_gates("i")->get_s(j).fix_pruned_data(), + storage.get_rec_gates("i")->get_v()->fix_pruned_data(), + storage.get_rec_gates("i")->get_u()->get_nz_idx(), + storage.get_rec_gates("i")->get_v()->get_nz_idx(), + storage.get_rec_gates("f")->get_u()->fix_pruned_data(), + storage.get_rec_gates("f")->get_s(j).fix_pruned_data(), + storage.get_rec_gates("f")->get_v()->fix_pruned_data(), + storage.get_rec_gates("f")->get_u()->get_nz_idx(), + storage.get_rec_gates("f")->get_v()->get_nz_idx(), + storage.get_rec_gates("c")->get_u()->fix_pruned_data(), + storage.get_rec_gates("c")->get_s(j).fix_pruned_data(), + storage.get_rec_gates("c")->get_v()->fix_pruned_data(), + storage.get_rec_gates("c")->get_u()->get_nz_idx(), + storage.get_rec_gates("c")->get_v()->get_nz_idx(), + storage.get_rec_gates("o")->get_u()->fix_pruned_data(), + storage.get_rec_gates("o")->get_s(j).fix_pruned_data(), + storage.get_rec_gates("o")->get_v()->fix_pruned_data(), + storage.get_rec_gates("o")->get_u()->get_nz_idx(), + storage.get_rec_gates("o")->get_v()->get_nz_idx(), + storage.get_fix_bias(j), + c_prev_emulator[j], h_prev_emulator[j], + c_curr_emulator[j], h_curr_emulator[j]); + std::cout << "Swapping LSTM outputs." << std::endl; + std::swap(h_prev_emulator[j], h_curr_emulator[j]); + std::swap(c_prev_emulator[j], c_curr_emulator[j]); + } + } + const int num_errors = storage.CountMismatches(h_prev_emulator); + std::cout << "Number of mismatches: " << num_errors << std::endl; + if (kTestSoftwareAccelerator) { + for (int j = 0; j < kNumInputs; ++j) { + const bool kVerbose = true; + const bool kUseBlas = false; + const int kUsaFloat = 0; + const int kNumSamples = 1; + std::cout << "Starting BLAS." << std::endl; + svd::SvdModelLstmSoftware(kVerbose, kUseBlas, kUsaFloat, + storage.get_x(j), kNumSamples, NUM_TIMESTEPS, NUM_ITERATIONS, + INPUT_SIZE, HIDDEN_SIZE, + storage.get_cur_gates("i")->get_u()->data(), + storage.get_cur_gates("i")->get_s(j).data(), + storage.get_cur_gates("i")->get_v()->data(), + storage.get_cur_gates("f")->get_u()->data(), + storage.get_cur_gates("f")->get_s(j).data(), + storage.get_cur_gates("f")->get_v()->data(), + storage.get_cur_gates("c")->get_u()->data(), + storage.get_cur_gates("c")->get_s(j).data(), + storage.get_cur_gates("c")->get_v()->data(), + storage.get_cur_gates("o")->get_u()->data(), + storage.get_cur_gates("o")->get_s(j).data(), + storage.get_cur_gates("o")->get_v()->data(), + storage.get_rec_gates("i")->get_u()->data(), + storage.get_rec_gates("i")->get_s(j).data(), + storage.get_rec_gates("i")->get_v()->data(), + storage.get_rec_gates("f")->get_u()->data(), + storage.get_rec_gates("f")->get_s(j).data(), + storage.get_rec_gates("f")->get_v()->data(), + storage.get_rec_gates("c")->get_u()->data(), + storage.get_rec_gates("c")->get_s(j).data(), + storage.get_rec_gates("c")->get_v()->data(), + storage.get_rec_gates("o")->get_u()->data(), + storage.get_rec_gates("o")->get_s(j).data(), + storage.get_rec_gates("o")->get_v()->data(), + &storage.get_bias(j)[0 * storage.get_lstm_output_size()], + &storage.get_bias(j)[1 * storage.get_lstm_output_size()], + &storage.get_bias(j)[2 * storage.get_lstm_output_size()], + &storage.get_bias(j)[3 * storage.get_lstm_output_size()], + storage.get_h(j)); + } + } + storage.ResetLstmOutputs(); std::cout << "Cleaning up." << std::endl; + delete[] h_prev_hls; + delete[] h_curr_hls; + delete[] c_prev_hls; + delete[] c_curr_hls; + delete[] h_prev_sw; + delete[] h_curr_sw; + delete[] c_prev_sw; + delete[] c_curr_sw; + for (int i = 0; i < kNumInputs; ++i) { + delete[] h_prev_emulator[i]; + delete[] h_curr_emulator[i]; + delete[] c_prev_emulator[i]; + delete[] c_curr_emulator[i]; + } + delete[] h_prev_emulator; + delete[] h_curr_emulator; + delete[] c_prev_emulator; + delete[] c_curr_emulator; return 0; } \ No newline at end of file diff --git a/src/svd_ip.cpp b/src/svd_ip.cpp index 7b9fec5..1150bbb 100644 --- a/src/svd_ip.cpp +++ b/src/svd_ip.cpp @@ -1,12 +1,16 @@ #include "svd_ip.h" +namespace svd { + void SvdIp2Inputs( const typename svd_params::ActivationD x_port[svd_params::N][svd_params::I], - const typename svd_params::UPortD u_port[svd_params::PrunedSizeU], + const typename svd_params::UPortD u_port[svd_params::R * svd_params::PrunedSizeU], const typename svd_params::SPortD s_port[svd_params::N][svd_params::R], - const typename svd_params::VPortD v_port[svd_params::PrunedSizeV], - const ap_uint nz_u_port[svd_params::N], - const ap_uint nz_v_port[svd_params::N], + const typename svd_params::VPortD v_port[svd_params::R * svd_params::PrunedSizeV], + const ap_uint nz_u_port[svd_params::G * svd_params::R], + const ap_uint nz_v_port[svd_params::G * svd_params::R], typename svd_params::ActivationD y_port[svd_params::N][svd_params::G][svd_params::H]) { - SvdIP(x_port, u_port, s_port, v_port, nz_u_port, nz_v_port, y_port); -} \ No newline at end of file + svd::SvdIP(x_port, u_port, s_port, v_port, nz_u_port, nz_v_port, y_port); +} + +} // svd \ No newline at end of file diff --git a/src/testbenches/CMakeLists.txt b/src/testbenches/CMakeLists.txt index 0ee8d0f..74ef6ab 100644 --- a/src/testbenches/CMakeLists.txt +++ b/src/testbenches/CMakeLists.txt @@ -1,51 +1,50 @@ cmake_minimum_required(VERSION 3.10) -# add_executable(OPENCV_TEST ${CMAKE_SOURCE_DIR}/src/tb/test_hdmi.cpp) -# target_include_directories(OPENCV_TEST PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(OPENCV_TEST PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_include_directories(OPENCV_TEST PUBLIC ${OpenCv_INCLUDE_DIRS}) -# target_link_libraries(OPENCV_TEST ${OpenCv_LIBS}) - -# add_executable(TEST_AXIS_LIB ${CMAKE_SOURCE_DIR}/src/tb/test_axis_lib.cpp) -# target_include_directories(TEST_AXIS_LIB PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_AXIS_LIB PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_include_directories(TEST_AXIS_LIB PUBLIC ${OpenCv_INCLUDE_DIRS}) -# target_link_libraries(TEST_AXIS_LIB ${OpenCv_LIBS}) -# target_link_libraries(TEST_AXIS_LIB AXIS_LIB) - -# add_executable(TEST_CONV_LAYER ${CMAKE_SOURCE_DIR}/src/tb/test_conv_layer.cpp) -# target_include_directories(TEST_CONV_LAYER PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_CONV_LAYER PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_link_libraries(TEST_CONV_LAYER CONV_LAYER) - -# add_executable(TEST_DENSE_LAYER ${CMAKE_SOURCE_DIR}/src/tb/test_dense_layer.cpp) -# target_include_directories(TEST_DENSE_LAYER PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_DENSE_LAYER PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_link_libraries(TEST_DENSE_LAYER CONV_LAYER) - -# add_executable(TEST_DQNET ${CMAKE_SOURCE_DIR}/src/tb/test_dqnet.cpp) -# target_include_directories(TEST_DQNET PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_DQNET PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_link_libraries(TEST_DQNET DQNET) - -# add_executable(TEST_GAME ${CMAKE_SOURCE_DIR}/src/tb/test_game.cpp) -# target_include_directories(TEST_GAME PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_GAME PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_include_directories(TEST_GAME PUBLIC ${OpenCv_INCLUDE_DIRS}) -# target_link_libraries(TEST_GAME ${OpenCv_LIBS}) -# target_link_libraries(TEST_GAME GAME) - -# add_executable(TEST_PONG ${CMAKE_SOURCE_DIR}/src/tb/test_pong.cpp) -# target_include_directories(TEST_PONG PUBLIC ${CMAKE_SOURCE_DIR}/include) -# target_include_directories(TEST_PONG PUBLIC ${VIVADO_INCLUDE_DIRS}) -# target_include_directories(TEST_PONG PUBLIC ${OpenCv_INCLUDE_DIRS}) -# target_link_libraries(TEST_PONG ${OpenCv_LIBS}) -# target_link_libraries(TEST_PONG PONG) - -# # add_test(NAME TestOpenCv COMMAND OPENCV_TEST) -# # add_test(NAME TestAxisLib COMMAND TEST_AXIS_LIB) -# # add_test(NAME TestConvLayer COMMAND TEST_CONV_LAYER) -# add_test(NAME TestDenseLayer COMMAND TEST_DENSE_LAYER) -# # add_test(NAME TestDQNet COMMAND TEST_DQNET) -# # add_test(NAME TestGame COMMAND TEST_GAME) -# # add_test(NAME TestPong COMMAND TEST_PONG) \ No newline at end of file +add_executable(TEST_U_KERNEL ${CMAKE_SOURCE_DIR}/src/testbenches/test_u_kernel.cpp) +target_include_directories(TEST_U_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_U_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_U_KERNEL PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_U_KERNEL ${OpenCv_LIBS}) +target_link_libraries(TEST_U_KERNEL U_KERNEL) + +add_executable(TEST_V_KERNEL ${CMAKE_SOURCE_DIR}/src/testbenches/test_v_kernel.cpp) +target_include_directories(TEST_V_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_V_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_V_KERNEL PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_V_KERNEL ${OpenCv_LIBS}) +target_link_libraries(TEST_V_KERNEL V_KERNEL) + +add_executable(TEST_GEMV_KERNEL ${CMAKE_SOURCE_DIR}/src/testbenches/test_gemv_kernel.cpp) +target_include_directories(TEST_GEMV_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_GEMV_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_GEMV_KERNEL PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_GEMV_KERNEL ${OpenCv_LIBS}) +target_link_libraries(TEST_GEMV_KERNEL GEMV_KERNEL) + +add_executable(TEST_DENSE_SVD ${CMAKE_SOURCE_DIR}/src/testbenches/test_dense_svd.cpp) +target_include_directories(TEST_DENSE_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_DENSE_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_DENSE_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_DENSE_SVD ${OpenCv_LIBS}) +target_link_libraries(TEST_DENSE_SVD DENSE_SVD) + +add_executable(TEST_LSTM_SVD ${CMAKE_SOURCE_DIR}/src/testbenches/test_lstm_svd.cpp) +target_include_directories(TEST_LSTM_SVD PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_LSTM_SVD PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_LSTM_SVD PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_LSTM_SVD ${OpenCv_LIBS}) +target_link_libraries(TEST_LSTM_SVD LSTM_SVD) + +add_executable(TEST_SVD_KERNEL ${CMAKE_SOURCE_DIR}/src/testbenches/test_svd_kernel.cpp) +target_include_directories(TEST_SVD_KERNEL PUBLIC ${CMAKE_SOURCE_DIR}/include) +target_include_directories(TEST_SVD_KERNEL PUBLIC ${HLS_INCLUDE_DIRS}) +target_include_directories(TEST_SVD_KERNEL PUBLIC ${OpenCv_INCLUDE_DIRS}) +target_link_libraries(TEST_SVD_KERNEL ${OpenCv_LIBS}) +target_link_libraries(TEST_SVD_KERNEL SVD_KERNEL) + +add_test(NAME TestU_Kernel COMMAND TEST_U_KERNEL) +add_test(NAME TestV_Kernel COMMAND TEST_V_KERNEL) +add_test(NAME TestGemvKernel COMMAND TEST_GEMV_KERNEL) +add_test(NAME TestDenseSvd COMMAND TEST_DENSE_SVD) +add_test(NAME TestLstmSvd COMMAND TEST_LSTM_SVD) +add_test(NAME TestSvdKernel COMMAND TEST_SVD_KERNEL) \ No newline at end of file diff --git a/src/testbenches/test_dense_svd.cpp b/src/testbenches/test_dense_svd.cpp new file mode 100644 index 0000000..851850c --- /dev/null +++ b/src/testbenches/test_dense_svd.cpp @@ -0,0 +1,73 @@ +#include "testbenches/test_dense_svd.h" +#include "dma/axis_lib.h" + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif +#include "ap_int.h" +#include "hls_stream.h" +#include +#include + +int main(int argc, char const *argv[]) { +#ifndef __VITIS_HLS__ + return 0; +#else + std::cout << "[INFO] Starting HlsDenseSvd test." << std::endl; + typedef typename svd::dense_params::ActivationD ActivationType; + const int kG = svd::dense_params::G; + int num_active_inputs = svd::dense_params::N; + int input_size = 16; + int output_size = 16; + int max_R = 1; + int num_tests = 2; + auto get_arg = [&](const int i, const int max_val, int& arg) { + if (argc >= i) { + arg = atoi(argv[i -1]); + arg = (arg > max_val) ? max_val : arg; + } + }; + get_arg(2, svd::dense_params::N, num_active_inputs); + get_arg(3, 512, max_R); + get_arg(4, svd::dense_params::I, input_size); + get_arg(5, svd::dense_params::H, output_size); + get_arg(6, 32, num_tests); + int num_refinements[svd::dense_params::N]; + ActivationType* x = new ActivationType[num_active_inputs * input_size]; + ActivationType* u = new ActivationType[max_R * input_size * kG]; + ActivationType* s = new ActivationType[max_R * num_active_inputs * kG]; + ActivationType* v = new ActivationType[max_R * output_size * kG]; + ActivationType* bias = new ActivationType[num_active_inputs * kG * output_size]; + ActivationType* y = new ActivationType[num_active_inputs * kG * output_size]; + auto init_random = [&](const int size, ActivationType* x) { + for (int i = 0; i < size; ++i) { + if (std::is_same::value) { + x[i] = ActivationType(rand()); + } else { + x[i] = ActivationType(rand() * 0.00001); + } + } + }; + for (int i = 0; i < svd::dense_params::N; ++i) { + num_refinements[i] = max_R; + } + init_random(num_active_inputs * input_size, x); + init_random(max_R * input_size * kG, u); + init_random(max_R * num_active_inputs * kG, s); + init_random(max_R * output_size * kG, v); + init_random(num_active_inputs * kG * output_size, bias); + std::cout << "[INFO] Calling accelerator." << std::endl; + for (int i = 0; i < num_tests; ++i) { + HlsWrapperDenseSvd(num_active_inputs, input_size, output_size, + num_refinements, x, u, s, v, bias, y); + } + delete[] x; + delete[] u; + delete[] s; + delete[] v; + delete[] bias; + delete[] y; + std::cout << "[INFO] Exiting." << std::endl; + return 0; +#endif // end __VITIS_HLS__ +} \ No newline at end of file diff --git a/src/testbenches/test_gemv_kernel.cpp b/src/testbenches/test_gemv_kernel.cpp new file mode 100644 index 0000000..5a8787e --- /dev/null +++ b/src/testbenches/test_gemv_kernel.cpp @@ -0,0 +1,76 @@ +#include "kernel/gemv_kernel.h" + +#include "hls_stream.h" +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif + +int main(int argc, char const *argv[]) { +#ifndef __VITIS_HLS__ + return 0; +#else + typedef hls::vector VectType; + testgemv::DataType x[testgemv::I]; + testgemv::DataType w[testgemv::I][testgemv::R]; + + testgemv::DataType y[testgemv::R] = {0}; + + hls::stream x_port[testgemv::N]; + hls::stream w_port[testgemv::N]; + hls::stream y_port[testgemv::N]; + for (int i = 0; i < testgemv::I; ++i) { + + x[i] = testgemv::DataType(rand() * 0.0001); + for (int j = 0; j < testgemv::R; ++j) { + w[i][j] = testgemv::DataType(rand() * 0.0001); + } + } + + for (int i = 0; i < testgemv::R; ++i) { + for (int j = 0; j < testgemv::I / testgemv::T; ++j) { + VectType tmp; + for (int k = 0; k < testgemv::T; ++k) { + tmp[k] = w[j * testgemv::T + k][i]; + } + for (int ii = 0; ii < testgemv::N; ++ii) { + w_port[ii] << tmp; + } + } + } + + for (int i = 0; i < testgemv::R; ++i) { + for (int j = 0; j < testgemv::I / testgemv::T; ++j) { + VectType tmp; + for (int k = 0; k < testgemv::T; ++k) { + tmp[k] = x[j * testgemv::T + k]; + } + for (int ii = 0; ii < testgemv::N; ++ii) { + x_port[ii] << tmp; + } + } + } + + HlsGemvKernel(testgemv::I, testgemv::R, x_port[0], x_port[1], w_port[0], w_port[1], y_port[0], y_port[1]); + for (int i = 0; i < testgemv::R; ++i) { + y[i] = 0; + for (int j = 0; j < testgemv::I; ++j) { + y[i] += x[j] * w[j][i]; + } + } + + std::cout << "Checking results." << std::endl; + int num_errors = 0; + for (int i = 0; i < testgemv::R; ++i) { + for (int j = 0; j < testgemv::N; ++j) { + auto y_test = y_port[j].read(); + if (y[i] - y_test > testgemv::DataType(0.001)) { + std::cout << i << ") test/gold: " << y_test << " / " + << y[i] << std::endl; + ++num_errors; + } + } + } + std::cout << "[INFO] Number of mismatches: " << num_errors << std::endl; + return 0; // num_errors; +#endif +} \ No newline at end of file diff --git a/src/testbenches/test_lstm_svd.cpp b/src/testbenches/test_lstm_svd.cpp new file mode 100644 index 0000000..7b1bdd0 --- /dev/null +++ b/src/testbenches/test_lstm_svd.cpp @@ -0,0 +1,90 @@ +#include "testbenches/test_lstm_svd.h" + +#include "dma/axis_lib.h" + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif +#include "ap_int.h" +#include "hls_stream.h" +#include +#include + +int main(int argc, char const *argv[]) { +#ifndef __VITIS_HLS__ + return 0; +#else + std::cout << "[INFO] Starting HlsDenseSvd test." << std::endl; + typedef typename svd::lstm_params::ActivationD ActivationType; + const int kG = svd::lstm_params::G; + int num_active_inputs = svd::lstm_params::N; + int input_size = 16; + int output_size = 16; + int max_R = 1; + int num_tests = 2; + auto get_arg = [&](const int i, const int max_val, int& arg) { + if (argc >= i) { + arg = atoi(argv[i -1]); + arg = (arg > max_val) ? max_val : arg; + } + }; + get_arg(2, svd::lstm_params::N, num_active_inputs); + get_arg(3, 512, max_R); + get_arg(4, svd::lstm_params::I, input_size); + get_arg(5, svd::lstm_params::H, output_size); + get_arg(6, 32, num_tests); + int num_refinements[svd::lstm_params::N]; + ActivationType* x = new ActivationType[num_active_inputs * input_size]; + ActivationType* h_prev = new ActivationType[num_active_inputs * output_size]; + ActivationType* c_prev = new ActivationType[num_active_inputs * output_size]; + ActivationType* h_curr = new ActivationType[num_active_inputs * output_size]; + ActivationType* c_curr = new ActivationType[num_active_inputs * output_size]; + ActivationType* u_cur = new ActivationType[max_R * input_size * kG]; + ActivationType* s_cur = new ActivationType[max_R * num_active_inputs * kG]; + ActivationType* v_cur = new ActivationType[max_R * output_size * kG]; + ActivationType* u_rec = new ActivationType[max_R * output_size * kG]; + ActivationType* s_rec = new ActivationType[max_R * num_active_inputs * kG]; + ActivationType* v_rec = new ActivationType[max_R * output_size * kG]; + ActivationType* bias = new ActivationType[num_active_inputs * kG * output_size]; + auto init_random = [&](const int size, ActivationType* x) { + for (int i = 0; i < size; ++i) { + if (std::is_same::value) { + x[i] = ActivationType(rand()); + } else { + x[i] = ActivationType(rand() * 0.00001); + } + } + }; + for (int i = 0; i < svd::lstm_params::N; ++i) { + num_refinements[i] = max_R; + } + init_random(num_active_inputs * input_size, x); + init_random(max_R * input_size * kG, u_cur); + init_random(max_R * num_active_inputs * kG, s_cur); + init_random(max_R * output_size * kG, v_cur); + init_random(max_R * output_size * kG, u_rec); + init_random(max_R * num_active_inputs * kG, s_rec); + init_random(max_R * output_size * kG, v_rec); + init_random(num_active_inputs * kG * output_size, bias); + std::cout << "[INFO] Calling accelerator." << std::endl; + for (int i = 0; i < num_tests; ++i) { + HlsWrapperLstmSvd(num_active_inputs, input_size, output_size, + num_refinements, x, u_cur, s_cur, v_cur, h_prev, u_rec, s_rec, v_rec, + bias, c_prev, h_curr, c_curr); + } + delete[] x; + delete[] h_prev; + delete[] c_prev; + delete[] h_curr; + delete[] c_curr; + delete[] u_cur; + delete[] s_cur; + delete[] v_cur; + delete[] u_rec; + delete[] s_rec; + delete[] v_rec; + delete[] bias; + std::cout << "[INFO] Exiting." << std::endl; + return 0; +#endif // end __VITIS_HLS__ +} \ No newline at end of file diff --git a/src/testbenches/test_svd_kernel.cpp b/src/testbenches/test_svd_kernel.cpp new file mode 100644 index 0000000..20e4f09 --- /dev/null +++ b/src/testbenches/test_svd_kernel.cpp @@ -0,0 +1,85 @@ +#include "testbenches/test_svd_kernel.h" +#include "dma/axis_lib.h" + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif +#include "ap_int.h" +#include "hls_stream.h" +#include +#include + +int main(int argc, char const *argv[]) { +#ifndef __VITIS_HLS__ + return 0; +#else + std::cout << "[INFO] Starting HlsSvdKernel test." << std::endl; + typedef typename svd::svd_params::ActivationD ActivationType; + const int kG = svd::svd_params::G; + int num_active_inputs = svd::svd_params::N; + int input_size = 16; + int output_size = 16; + int max_R = 1; + int num_tests = 2; + auto get_arg = [&](const int i, const int max_val, int& arg) { + if (argc >= i) { + arg = atoi(argv[i -1]); + arg = (arg > max_val) ? max_val : arg; + } + }; + get_arg(2, svd::svd_params::N, num_active_inputs); + get_arg(3, 512, max_R); + get_arg(4, svd::svd_params::I, input_size); + get_arg(5, svd::svd_params::H, output_size); + get_arg(6, 32, num_tests); + int num_refinements[svd::svd_params::N]; + ActivationType* x = new ActivationType[num_active_inputs * input_size]; + ActivationType* u = new ActivationType[max_R * input_size * kG]; + ActivationType* s = new ActivationType[max_R * num_active_inputs * kG]; + ActivationType* v = new ActivationType[max_R * output_size * kG]; + ActivationType* y = new ActivationType[num_active_inputs * kG * output_size]; + hls::stream x_port("x_port"); + hls::stream u_port("u_port"); + hls::stream s_port("s_port"); + hls::stream v_port("v_port"); + hls::stream y_port("y_port"); + auto init_random = [&](const int size, ActivationType* x) { + for (int i = 0; i < size; ++i) { + if (std::is_same::value) { + x[i] = ActivationType(rand()); + } else { + x[i] = ActivationType(rand() * 0.00001); + } + } + }; + auto init_zero = [&](const int size, ActivationType* x) { + for (int i = 0; i < size; ++i) { + x[i] = ActivationType(0); + } + }; + for (int i = 0; i < svd::svd_params::N; ++i) { + num_refinements[i] = max_R; + } + init_random(num_active_inputs * input_size, x); + init_random(num_active_inputs * kG * output_size, y); + init_random(max_R * input_size * kG, u); + init_random(max_R * num_active_inputs * kG, s); + init_random(max_R * output_size * kG, v); + std::cout << "[INFO] Calling accelerator." << std::endl; + for (int i = 0; i < num_tests; ++i) { + svd::SetSvdKernelInputs(num_active_inputs, input_size, + output_size, num_refinements, x, u, s, v, x_port, u_port, s_port, v_port); + HlsSvdKernel(num_active_inputs, input_size, output_size, num_refinements, + x_port, u_port, s_port, v_port, y_port); + svd::GetSvdKernelOutputs(num_active_inputs, output_size, + y_port, y); + } + delete[] x; + delete[] u; + delete[] s; + delete[] v; + delete[] y; + std::cout << "[INFO] Exiting." << std::endl; + return 0; +#endif // end __VITIS_HLS__ +} \ No newline at end of file diff --git a/src/testbenches/test_u_kernel.cpp b/src/testbenches/test_u_kernel.cpp new file mode 100644 index 0000000..0c89d23 --- /dev/null +++ b/src/testbenches/test_u_kernel.cpp @@ -0,0 +1,213 @@ +#include "testbenches/test_u_kernel.h" +#include "dma/axis_lib.h" + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif +#include "ap_int.h" +#include "hls_stream.h" +#include +#include + +int main(int argc, char const *argv[]) { +#ifdef COSIM_DESIGN + srand(1); +#else + srand(time(NULL)); +#endif + std::cout << "[INFO] Starting HlsKernelU test." << std::endl; +#ifndef __VITIS_HLS__ + return 0; +#else + const int num_refinements = testu::params::R; + hls::vector num_refinements_vect = hls::vector(num_refinements); + for (int i = testu::params::N; i >= 0; --i) { + int R_tmp = testu::params::R - 2 * (testu::params::N - i - 1); + num_refinements_vect[i] = R_tmp > 0 ? R_tmp : 1; + } + const int kNumActiveInputs = testu::params::N - 2; + const int kInputSize_tmp = testu::params::I / 1; + const int kInputSize = (kInputSize_tmp > testu::params::I) ? testu::params::I : kInputSize_tmp; + const int kNumTilesU = kInputSize / testu::params::Tu; + typedef typename testu::params::ActivationD ActivationType; + typedef hls::vector VectN_Type; + typedef hls::vector VectG_Type; + typedef hls::vector VectTuAct_Type; + assert(testu::params::I == testu::params::PrunedSizeU); + + ActivationType x[testu::params::N][testu::params::I]; + ActivationType u[num_refinements][testu::params::PrunedSizeU][testu::params::G]; + ActivationType xu[num_refinements][testu::params::N][testu::params::G]; + + hls::stream x_port; //[testu::params::N * kNumTilesU]; + hls::stream u_port; //[num_refinements * kNumTilesU * testu::params::G]; + hls::stream xu_port; //[num_refinements * testu::params::G]; + hls::stream x_axis("x_axis"); + hls::stream u_axis("u_axis"); + hls::stream xu_gn_axis("xu_gn_axis"); + hls::stream xu_n_axis("xu_n_axis"); + hls::stream xu_g_axis("xu_g_axis"); + VectN_Type xu_gold[num_refinements * testu::params::G]; + + auto x_axis_interface = svd::AxiStreamPort(x_axis); + auto u_axis_interface = svd::AxiStreamPort(u_axis); + auto xu_gn_axis_interface = svd::AxiStreamPort(xu_gn_axis); + auto xu_n_axis_interface = svd::AxiStreamPort(xu_n_axis); + auto xu_g_axis_interface = svd::AxiStreamPort(xu_g_axis); + + for (int i = 0; i < testu::params::N; ++i) { + for (int j = 0; j < testu::params::I; ++j) { + x[i][j] = rand(); // * 0.00001; + } + } + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < testu::params::PrunedSizeU; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + u[i][j][k] = rand(); // * 0.00001; + } + } + } + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < testu::params::N; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + xu[i][j][k] = 0; + } + } + } + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < kInputSize; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + for (int ii = 0; ii < testu::params::N; ++ii) { + xu[i][ii][k] += u[i][j][k] * x[ii][j]; + } + } + } + } + + + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < testu::params::N; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + xu_gold[i * testu::params::G + k][j] = xu[i][j][k]; + } + } + } + + const int num_tests = 2; + int num_errors = 0; + + for (int t = 0; t < num_tests; ++t) { + +// #define TEST_OLD_KERNEL_U +#ifdef TEST_OLD_KERNEL_U + for (int i = 0; i < testu::params::N; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { + VectTuAct_Type x_val; + for (int k = 0; k < testu::params::Tu; ++k) { + x_val[k] = x[i][j * testu::params::Tu + k]; + } + x_port << x_val; + x_axis_interface.PushVector(x_val); + } + } + for (int i = 0; i < num_refinements; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + VectTuAct_Type u_val; + for (int ii = 0; ii < testu::params::Tu; ++ii) { + u_val[ii] = u[i][j * testu::params::Tu + ii][k]; + } + u_port << u_val; + u_axis_interface.PushVector(u_val); + } + } + } + + std::cout << "[INFO] Starting HlsVectorKernelU." << std::endl; + HlsVectorKernelU(num_refinements, x_port, u_port, xu_port); + std::cout << "[INFO] Starting HlsAxisKernelU." << std::endl; + HlsAxisKernelU(num_refinements, x_axis, u_axis, xu_gn_axis); + + for (int i = 0; i < num_refinements; ++i) { + auto xu_gn_val = xu_gn_axis_interface.PopVector(); + for (int j = 0; j < testu::params::G; ++j) { + auto tmp = xu_port.read(); + for (int k = 0; k < testu::params::N; ++k) { + std::cout << i << ") test/gold: " << xu_gn_val[j * testu::params::N + k] << " / " + << xu_gold[i * testu::params::G + j][k] << std::endl; + if (xu_gn_val[j * testu::params::N + k] != xu_gold[i * testu::params::G + j][k]) { + ++num_errors; + } + } + } + } + std::cout << "[INFO] Number of mismatches: " << num_errors << std::endl; +#endif + // NOTE: The streaming order differs from before! kNumTilesU is swapped with + // testu::params::N. + for (int j = 0; j < kNumTilesU; ++j) { + for (int i = 0; i < kNumActiveInputs; ++i) { + VectTuAct_Type x_val; + for (int k = 0; k < testu::params::Tu; ++k) { + x_val[k] = x[i][j * testu::params::Tu + k]; + } + x_axis_interface.PushVector(x_val); + } + } + // NOTE: The streaming order differs from before! kNumTilesU is swapped with + // testu::params::G. + for (int i = 0; i < num_refinements_vect[kNumActiveInputs - 1]; ++i) { + for (int j = 0; j < kNumTilesU; ++j) { + for (int k = 0; k < testu::params::G; ++k) { + VectTuAct_Type u_val; + for (int ii = 0; ii < testu::params::Tu; ++ii) { + u_val[ii] = u[i][j * testu::params::Tu + ii][k]; + } + u_axis_interface.PushVector(u_val); + } + } + } + std::cout << "[INFO] Starting HlsKernelU." << std::endl; + + int refinements_tmp[testu::params::N]; + for (int i = 0; i < testu::params::N; ++i) { + refinements_tmp[i] = num_refinements_vect[i]; + } + HlsKernelU(kNumActiveInputs, kInputSize, refinements_tmp, false, x_axis, u_axis, xu_g_axis); + + testu::params::VectG_Type xu_g_val; + int total_cnt = 0; + int last_at = -1; + for (int i = 0; i < num_refinements_vect[kNumActiveInputs - 1]; ++i) { // R_max + for (int j = 0; j < kNumActiveInputs; ++j) { + if (i < num_refinements_vect[j]) { + bool is_last = xu_g_axis_interface.isLastPopVector(xu_g_val); + if (is_last) { + last_at = total_cnt; + std::cout << "[INFO] Last index arrived at iteration: " << last_at << std::endl; + } + ++total_cnt; + // std::cout << "\t[INFO] Reading xu[R." << i << "][N." << j << "]" << std::endl; + for (int k = 0; k < testu::params::G; ++k) { + // VectN_Type xu_gold[num_refinements * testu::params::G]; + std::cout << i << ") test/gold: " << xu_g_val[k] << " / " + << xu[i][j][k] << std::endl; + if (xu_g_val[k] != xu[i][j][k]) { + ++num_errors; + } + } + } + } + } + std::cout << "[INFO] Last index arrived at iteration: " << last_at << std::endl; + std::cout << "[INFO] Total iterations: " << total_cnt << std::endl; + std::cout << "[INFO] Number of mismatches: " << num_errors << std::endl; + + while(!xu_n_axis.empty()) { + auto xu_n_val = xu_n_axis_interface.PopVector(); + } + } + std::cout << "[INFO] Number of mismatches: " << num_errors << std::endl; + return 0; // num_errors; +#endif +} \ No newline at end of file diff --git a/src/testbenches/test_v_kernel.cpp b/src/testbenches/test_v_kernel.cpp new file mode 100644 index 0000000..35981ea --- /dev/null +++ b/src/testbenches/test_v_kernel.cpp @@ -0,0 +1,167 @@ +#include "testbenches/test_v_kernel.h" +#include "dma/axis_lib.h" + +#ifdef __VITIS_HLS__ +#include "hls_vector.h" +#endif +#include "ap_int.h" +#include "hls_stream.h" +#include +#include + +int main(int argc, char const *argv[]) { +#ifdef COSIM_DESIGN + srand(1); +#else + srand(1); + // srand(time(NULL)); +#endif + std::cout << "[INFO] Starting HlsKernelV test." << std::endl; +#ifndef __VITIS_HLS__ + return 0; +#else + int num_active_inputs = testv::params::N; + int output_size = testv::params::H; + int num_refinements = testv::params::R; + if (argc >= 2) { + num_active_inputs = atoi(argv[1]); + } + if (argc >= 3) { + output_size = atoi(argv[2]); + } + if (argc >= 4) { + num_refinements = atoi(argv[3]); + } + const int kMaxRefinements = num_refinements; + typedef hls::vector VectN; + VectN num_refinements_vect = VectN(kMaxRefinements); + const int kNumTests = 2; + const int kNumActiveInputs = (num_active_inputs > testv::params::N) ? testv::params::N : num_active_inputs; + const int kOutputSize = (output_size > testv::params::H) ? testv::params::H : output_size; + const int kNumTilesV = kOutputSize / testv::params::Tv; + for (int i = kNumActiveInputs-1; i >= 0; --i) { + // num_refinements_vect[i] = kMaxRefinements; + int R_tmp = kMaxRefinements - 2 * (kNumActiveInputs - i - 1); + num_refinements_vect[i] = R_tmp > 0 ? R_tmp : 1; + } + typedef typename testv::params::ActivationD ActivationType; + assert(testv::params::H == testv::params::PrunedSizeV); // No pruning. + + ActivationType xus[kMaxRefinements][testv::params::N][testv::params::G] = {ActivationType(0.001)}; + ActivationType v[kMaxRefinements][testv::params::PrunedSizeV][testv::params::G] = {ActivationType(0.001)}; + ActivationType y_gold[testv::params::N][testv::params::G][testv::params::H] = {0}; + + for (int i = 0; i < kMaxRefinements; ++i) { + for (int j = 0; j < testv::params::G; ++j) { + for (int k = 0; k < testv::params::N; ++k) { + if (std::is_same::value) { + xus[i][k][j] = ActivationType(rand()); + } else { + xus[i][k][j] = ActivationType(rand() * 0.00001); + } + } + for (int k = 0; k < testv::params::PrunedSizeV; ++k) { + if (std::is_same::value) { + v[i][k][j] = ActivationType(rand()); + } else { + v[i][k][j] = ActivationType(rand() * 0.00001); + } + } + } + } + + for (int i = 0; i < kMaxRefinements; ++i) { + for (int j = 0; j < kNumActiveInputs; ++j) { + if (i < num_refinements_vect[j]) { + for (int k = 0; k < kOutputSize; ++k) { + for (int ii = 0; ii < testv::params::G; ++ii) { + y_gold[j][ii][k] += v[i][k][ii] * xus[i][j][ii]; + } + } + } + } + } + + hls::stream xus_port("xus_port"); + hls::stream v_port("v_port"); + hls::stream y_port("y_port"); + + auto xus_axis = svd::AxiStreamPort(xus_port); + auto v_axis = svd::AxiStreamPort(v_port); + auto y_axis = svd::AxiStreamPort(y_port); + + int num_errors = 0; + std::cout << "[INFO] Pushing into FIFOs." << std::endl; + for (int t = 0; t < kNumTests; ++t) { + std::cout << "[INFO] Pushing into XUS." << std::endl; + typename testv::params::VectG_Type xus_val; + for (int i = 0; i < kMaxRefinements; ++i) { + for (int j = 0; j < kNumActiveInputs; ++j) { + if (i < num_refinements_vect[j]) { + for (int k = 0; k < testv::params::G; ++k) { + xus_val[k] = xus[i][j][k]; + } + xus_axis.PushVector(xus_val); + } + } + } + std::cout << "[INFO] Pushing into V." << std::endl; + typename testv::params::VectTvType v_val; + for (int i = 0; i < kMaxRefinements; ++i) { + for (int k = 0; k < kNumTilesV; ++k) { + for (int j = 0; j < testv::params::G; ++j) { + for (int ii = 0; ii < testv::params::Tv; ++ii) { + v_val[ii] = v[i][k * testv::params::Tv + ii][j]; + } + v_axis.PushVector(v_val); + } + } + } + } + std::cout << "[INFO] Starting HlsKernelV." << std::endl; + std::cout << "[INFO] v_port.size(): " << v_port.size() << std::endl; + for (int t = 0; t < kNumTests; ++t) { + int tmp[testv::params::N]; + for (int i = 0; i < testv::params::N; ++i) { + tmp[i] = num_refinements_vect[i]; + } + HlsKernelV(kNumActiveInputs, kOutputSize, tmp, xus_port, v_port, y_port); + std::cout << "[INFO] v_port.size(): " << v_port.size() << std::endl; + } + int num_elems = 0; + for (int t = 0; t < kNumTests; ++t) { + std::cout << "[INFO] Checking results test n." << t << std::endl; + int test_errors = 0; + num_elems = 0; + for (int j = 0; j < kNumTilesV; ++j) { + for (int i = 0; i < kNumActiveInputs; ++i) { + const int kGTv = testv::params::G * testv::params::Tv; + auto y_val = y_axis.PopVector(); + for (int k = 0; k < testv::params::Tv; ++k) { + for (int ii = 0; ii < testv::params::G; ++ii) { + if (y_val[k * testv::params::G + ii] != y_gold[i][ii][j * testv::params::Tv + k]) { + std::cout << "N:" << i << "][NTv:" << j << "][Tv:" << k << "][G:" + << ii << "] test/gold: " + << y_val[k * testv::params::G + ii] << " / " + << y_gold[i][ii][j * testv::params::Tv + k] << std::endl; + ++test_errors; + } else { + // std::cout << "\tN:" << i << "][NTv:" << j << "][Tv:" << k << "][G:" + // << ii << "] test/gold: " + // << y_val[k * testv::params::G + ii] << " / " + // << y_gold[i][ii][j * testv::params::Tv + k] << std::endl; + } + ++num_elems; + } + } + } + } + std::cout << "[INFO] Number of mismatches per test / total: " << test_errors + << " / " << num_elems << std::endl; + num_errors += test_errors; + } + std::cout << "[INFO] Total number of mismatches / total: " << num_errors + << " / " << num_elems * kNumTests << std::endl; + return 0; // num_errors; +#endif // end __VITIS_HLS__ +} diff --git a/tcl/lstm_params.tcl b/tcl/lstm_params.tcl new file mode 100644 index 0000000..c56e150 --- /dev/null +++ b/tcl/lstm_params.tcl @@ -0,0 +1,28 @@ +proc append_lstm_params {&defines} { + dict set params NUM_GATES 4 + dict set params NUM_INPUTS 2 + dict set params NUM_SAMPLES 2 + dict set params INPUT_SIZE 256 + dict set params HIDDEN_SIZE 128 + dict set params NUM_ITERATIONS 32 + dict set params NUM_TILES_U 4 + dict set params NUM_ZERO_TILES_U 2 + dict set params NUM_TILES_V 16 + dict set params NUM_ZERO_TILES_V 4 + dict set params NUM_TIMESTEPS 28 + dict set params FIX_WIDTH 16 + dict set params FIX_FRACT_WIDTH 6 + + set tmp {} + append tmp " " + foreach key [dict keys $params] { + set value [dict get $params $key] + append tmp "-D${key}=${value} " + } + puts "================================================================" + puts "\[INFO\] LSTM parameters:" + puts $tmp + puts "================================================================" + upvar 1 ${&defines} defines ;# To have a "pass by reference" argument. + append defines $tmp +} \ No newline at end of file diff --git a/tcl/utils.tcl b/tcl/utils.tcl new file mode 100644 index 0000000..3793db7 --- /dev/null +++ b/tcl/utils.tcl @@ -0,0 +1,63 @@ +# +# @brief Find all files in a directory and return them in a list. +# +# @param basedir The directory to start looking in pattern. +# @param pattern A pattern, as defined by the glob command, that +# the files must match. +# @param exclude_dirs_list Ignore searching in specified directories +# +# @return The list of found files. +# +proc findFiles { basedir pattern exclude_dirs_list } { + # Fix the directory name, this ensures the directory name is in the + # native format for the platform and contains a final directory seperator + set basedir [string trimright [file join [file normalize $basedir] { }]] + set fileList {} + # Look in the current directory for matching files, -type {f r} + # means ony readable normal files are looked at, -nocomplain stops + # an error being thrown if the returned list is empty + foreach fileName [glob -nocomplain -type {f r} -path $basedir $pattern] { + lappend fileList $fileName + } + # Now look for any sub direcories in the current directory + foreach dirName [glob -nocomplain -type {d r} -path $basedir *] { + # Recusively call the routine on the sub directory and append any + # new files to the results + if {[lsearch -exact ${exclude_dirs_list} $dirName] == -1} { + set subDirList [findFiles $dirName $pattern $exclude_dirs_list] + if { [llength $subDirList] > 0 } { + foreach subDirFile $subDirList { + lappend fileList $subDirFile + } + } + } + } + return $fileList +} + +# +# @brief Greps a file content and writes matches to a file. +# +# @param re Regular expression +# @param lines Number of lines to report/include after the found match +# @param fin The fin pointer +# @param fout The fout pointer +# +proc grep {re lines fin fout} { + set cnt 0 + set match false + seek $fin 0 + while {[gets $fin line] >= 0} { + if [regexp -- $re $line] { + set cnt 0 + set match true + } + if {$match && ($cnt < $lines)} { + puts $line + puts $fout $line + set cnt [expr {$cnt +1}] + } else { + set match false + } + } +} \ No newline at end of file diff --git a/token b/token new file mode 100644 index 0000000..5cf751e --- /dev/null +++ b/token @@ -0,0 +1,5 @@ +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 + +git remote remove origin +git remote add origin https://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@github.com/ribesstefano/hls_svd.git +git pull https://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@github.com/ribesstefano/hls_svd.git \ No newline at end of file